diff --git a/fvdb/.gitignore b/fvdb/.gitignore index 92b270f6c4..e62d482baf 100644 --- a/fvdb/.gitignore +++ b/fvdb/.gitignore @@ -1,5 +1,4 @@ -build/* -build/ +/build/* *.creator *.includes *.files diff --git a/fvdb/README.md b/fvdb/README.md index 416349abc6..f9429145cc 100644 --- a/fvdb/README.md +++ b/fvdb/README.md @@ -93,7 +93,7 @@ pip install . To make sure that everything works by running tests: ```shell -python setup.py test +pytest tests/unit ``` ### Building Documentation @@ -118,7 +118,7 @@ docker run -it --gpus all --rm \ --mount type=bind,source="$HOME/.ssh",target=/root/.ssh \ --mount type=bind,source="$(pwd)",target=/fvdb \ fvdb-dev:latest \ - conda run -n fvdb_test --no-capture-output python setup.py test + conda run -n fvdb_test --no-capture-output python setup.py develop ``` diff --git a/fvdb/env/build_environment.yml b/fvdb/env/build_environment.yml index 5b072d3d86..f5fcff7320 100644 --- a/fvdb/env/build_environment.yml +++ b/fvdb/env/build_environment.yml @@ -2,18 +2,20 @@ name: fvdb_build channels: - nvidia/label/cuda-12.1.0 - pytorch - - conda-forge dependencies: - python=3.10 - - pytorch=2.2 - - pytorch-cuda=12.1 + - pytorch::pytorch=2.2 + - pytorch::pytorch-cuda=12.1 - git - gitpython - ca-certificates - certifi - openssl - - cuda - - cuda-nvcc + - nvidia/label/cuda-12.1.0::cuda + - nvidia/label/cuda-12.1.0::cuda-tools + - nvidia/label/cuda-12.1.0::cuda-nvcc + - nvidia/label/cuda-12.1.0::cuda-cccl + - nvidia/label/cuda-12.1.0::cuda-libraries-static - gcc_linux-64=11 - gxx_linux-64=11 - setuptools diff --git a/fvdb/env/cutlass.patch b/fvdb/env/cutlass.patch index 97828ceb63..7369fa7d20 100644 --- a/fvdb/env/cutlass.patch +++ b/fvdb/env/cutlass.patch @@ -7,7 +7,7 @@ index e22c8be3..a29e6067 100644 storage = reinterpret_cast(x); #else - __half_raw raw(x); -+ __half_raw raw(*(reinterpret_cast(&x))); ++ __half_raw raw(*(reinterpret_cast(&x))); std::memcpy(&storage, &raw.x, sizeof(storage)); #endif } @@ -16,7 +16,7 @@ index e22c8be3..a29e6067 100644 storage = reinterpret_cast(x); #else - __half_raw raw(x); -+ __half_raw raw(*(reinterpret_cast(&x))); ++ __half_raw raw(*(reinterpret_cast(&x))); std::memcpy(&storage, &raw.x, sizeof(storage)); #endif return *this; diff --git a/fvdb/env/test_environment.yml b/fvdb/env/test_environment.yml index 9eda44280c..c3175190b8 100644 --- a/fvdb/env/test_environment.yml +++ b/fvdb/env/test_environment.yml @@ -3,11 +3,10 @@ channels: - pyg - nvidia/label/cuda-12.1.0 - pytorch - - conda-forge dependencies: - python=3.10 - - pytorch=2.2 - - pytorch-cuda=12.1 + - pytorch::pytorch=2.2 + - pytorch::pytorch-cuda=12.1 - tensorboard - pip - git @@ -15,8 +14,11 @@ dependencies: - ca-certificates - certifi - openssl - - cuda - - cuda-nvcc + - nvidia/label/cuda-12.1.0::cuda + - nvidia/label/cuda-12.1.0::cuda-tools + - nvidia/label/cuda-12.1.0::cuda-nvcc + - nvidia/label/cuda-12.1.0::cuda-cccl + - nvidia/label/cuda-12.1.0::cuda-libraries-static - parameterized - gcc_linux-64=11 - gxx_linux-64=11 diff --git a/fvdb/fvdb/_Cpp.pyi b/fvdb/fvdb/_Cpp.pyi index 3eeca77700..30d2d9fea5 100644 --- a/fvdb/fvdb/_Cpp.pyi +++ b/fvdb/fvdb/_Cpp.pyi @@ -118,7 +118,9 @@ class JaggedTensor: @property def dtype(self) -> torch.dtype: ... @property - def jidx(self) -> torch.ShortTensor: ... + def jidx(self) -> torch.IntTensor: ... + @property + def jlidx(self) -> torch.IntTensor: ... @property def joffsets(self) -> torch.LongTensor: ... @property @@ -134,6 +136,19 @@ class JaggedTensor: @property def requires_grad(self) -> bool: ... + @staticmethod + def from_data_and_indices(data: torch.Tensor, indices: torch.Tensor, num_tensors: int) -> JaggedTensor: ... + + @staticmethod + def from_data_indices_and_list_ids(data: torch.Tensor, indices: torch.Tensor, list_ids: torch.Tensor, num_tensors: int) -> JaggedTensor: ... + + @staticmethod + def from_data_and_offsets(data: torch.Tensor, offsets: torch.Tensor) -> JaggedTensor: ... + + @staticmethod + def from_data_offsets_and_list_ids(data: torch.Tensor, offsets: torch.Tensor, list_ids: torch.Tensor) -> JaggedTensor: ... + + JaggedTensorOrTensor = Union[torch.Tensor, JaggedTensor] class GridBatch: @@ -243,8 +258,8 @@ class GridBatch: def cubes_in_grid(self, cube_centers: JaggedTensorOrTensor, cube_min: Vec3dOrScalar = 0.0, cube_max: Vec3dOrScalar = 0.0, ignore_disabled: bool = False) -> JaggedTensor: ... def cubes_intersect_grid(self, cube_centers: JaggedTensorOrTensor, cube_min: Vec3dOrScalar = 0.0, cube_max: Vec3dOrScalar = 0.0, ignore_disabled: bool = False) -> JaggedTensor: ... - def ijk_to_index(self, ijk: JaggedTensorOrTensor) -> JaggedTensor: ... - def ijk_to_inv_index(self, ijk: JaggedTensorOrTensor) -> JaggedTensor: ... + def ijk_to_index(self, ijk: JaggedTensorOrTensor, cumulative: bool = False) -> JaggedTensor: ... + def ijk_to_inv_index(self, ijk: JaggedTensorOrTensor, cumulative: bool = False) -> JaggedTensor: ... def neighbor_indexes(self, ijk: JaggedTensorOrTensor, extent: int, bitshift: int = 0) -> JaggedTensor: ... def splat_bezier(self, points: JaggedTensorOrTensor, points_data: JaggedTensorOrTensor) -> JaggedTensor: ... @@ -256,7 +271,7 @@ class GridBatch: def segments_along_rays(self, ray_origins: JaggedTensorOrTensor, ray_directions: JaggedTensorOrTensor, max_segments: int, eps: float = 0.0, ignore_masked: bool = False) -> JaggedTensor: ... - def voxels_along_rays(self, ray_origins: JaggedTensorOrTensor, ray_directions: JaggedTensorOrTensor, max_voxels: int, eps: float = 0.0, return_ijk: bool = True) -> Tuple[JaggedTensor, JaggedTensor]: ... + def voxels_along_rays(self, ray_origins: JaggedTensorOrTensor, ray_directions: JaggedTensorOrTensor, max_voxels: int, eps: float = 0.0, return_ijk: bool = True, cumulative: bool = False) -> Tuple[JaggedTensor, JaggedTensor]: ... def uniform_ray_samples(self, ray_origins: JaggedTensorOrTensor, ray_directions: JaggedTensorOrTensor, t_min: JaggedTensorOrTensor, t_max: JaggedTensorOrTensor, step_size: float, cone_angle: float = 0.0, include_end_segments : bool = True, return_midpoints: bool = False, eps: float = 0.0) -> JaggedTensor: ... def ray_implicit_intersection(self, ray_origins: JaggedTensorOrTensor, ray_directions: JaggedTensorOrTensor, grid_scalars: JaggedTensorOrTensor, eps: float = 0.0) -> JaggedTensor: ... diff --git a/fvdb/fvdb/nn/vdbtensor.py b/fvdb/fvdb/nn/vdbtensor.py index 7dd23ee823..4c0fd42ecf 100644 --- a/fvdb/fvdb/nn/vdbtensor.py +++ b/fvdb/fvdb/nn/vdbtensor.py @@ -71,7 +71,7 @@ def _feature_ops(op, other: List[Union["VDBTensor", JaggedTensor, Any]]): raw_features.append(o.feature.jdata) elif isinstance(o, JaggedTensor): assert pivot_tensor.total_voxels == o.jdata.size(0), "All tensors should have the same voxels" - assert pivot_tensor.grid.grid_count == len(o.joffsets), "All tensors should have the same batch size" + assert pivot_tensor.grid.grid_count == o.num_tensors, "All tensors should have the same batch size" raw_features.append(o.jdata) else: raw_features.append(o) diff --git a/fvdb/notebooks/00_intro.ipynb b/fvdb/notebooks/00_intro.ipynb new file mode 100644 index 0000000000..bc165a5481 --- /dev/null +++ b/fvdb/notebooks/00_intro.ipynb @@ -0,0 +1,309 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Welcome to ƒVDB! ##\n", + "\n", + "In this notebook, we hope to acquaint you with the basic concepts, motivations and functionality of the core objects in ƒVDB. By the end of the first notebook, we will train a basic network which we will take deeper dives into in subsequent notebooks.\n", + "\n", + "### What are *Sparse* Grids?\n", + "\n", + "In ƒVDB, we are fundamentally concerned with **sparse grids**. What do these words mean?\n", + "\n", + "When we refer to a **grid**, we're referring to a 3-dimensional space divided into uniformly sized voxels where there exists some interesting value in each voxel. \n", + "\n", + "When we refer to a **sparse** grid, we're referring to a grid where only a subset of the voxels which contain interesting or **active** values exist in the grid. This is in contrast to a **dense** grid where every voxel in the 3D space is occupied and contains a value (even if the value is 0 or some other null or default value).\n", + "\n", + "Here are some examples of data that can be useful to think of through the lens of sparsity:\n", + "\n", + "\n", + "
\n", + "
\n", + "
\"bunny\"
A volumetric cloud in the shape of a bunny
\n", + "\n", + "
\n", + "\n", + "
A 3D scan of a head
\n", + "
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "#### Sparse vs. Dense Grids\n", + "\n", + "Why is this a useful distinction? To start, let's think about images as 2D grids which are easy to visualize. We can think of an image as a 2D **dense** grid where each pixel/voxel in our grid contains a value such as this representation of a hand-drawn '2':\n", + "\n", + "\n", + "
\n", + "\n", + "\"two\"\n", + "\n", + "
\n", + "\n", + "In this image, every pixel, or 2D 'voxel' if you will, contains a value but some of these values exist at positions unoccupied by the '2' figure. If we were to visualize this image as a **sparse** 2D grid where only the pixels containing the '2' figure are **active**, we would have something like this:\n", + "\n", + "
\n", + "\n", + "\"two\"\n", + "\n", + "
\n", + "\n", + "Effectively we've reduced the amount of data by 58% in this case by only storing the **active** voxels that are of interest to us. This is the fundamental motivation behind sparse grids: to reduce the amount of data we need to store and process by only storing the **active** voxels we wish to track.\n", + "\n", + "In real-world applications it is often the case that we only have interesting values in a small subset of voxels within the **dense** grid representing a space. For example, for a LiDAR dataset we may only care about spaces where points exist along the surface of an object where the object is detected by the sensor. It is not uncommon in these realworld cases that the **sparse** grid would contain less than 10% of the voxels compared to the equivalent **dense** grid for the same data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Why ƒVDB?\n", + "\n", + "There is a problem if we naively move our deep learning networks from **dense** to **sparse** grids. If we think about our image usecase as a stand-in for 2D **dense** grids, our 2D **dense** grids can be expressed as a tensor of dimensions $[C, H, W]$. \n", + "\n", + "
\n", + "\"two\"\n", + "
\n", + "\n", + "Having a series of images of the same height, width and channel count concatenated together as a single tensor of a batch with dimensions $[N, C, H, W]$ is a well-supported practice for training a network with mini-batches (where $N$ is the number of grids in the batch). Many operators, like convolution, are effectively accelerated on GPUs for batches of these **dense** volumes since the operators can be very efficiently parallelized over lots of images in this format:\n", + "\n", + "\n", + "
\n", + "
\n", + "
\"two\"
Mini-batch of 'dense 2D grids'
\"two\"
Convolution over 'dense 2D grid' minibatch
\n", + "
\n", + "
\n", + "\n", + "\n", + "\n", + "With **sparse** grids, it is very unlikely we'll have multiple grids with the same topology of **active** voxels and therefore the same number of voxels in grids that we could batch together to use these same operators. It won't be as simple as cropping or scaling an image to fit a fixed size to create a $[N, C, H, W]$ tensor for sparse grids that have different topologies like these:\n", + "\n", + "
\n", + "\"two\"\n", + "
\n", + "\n", + "This is the fundamental problem that **ƒVDB** is designed to solve using novel data structures that marry technologies from [OpenVDB](https://www.openvdb.org/) and [PyTorch](https://pytorch.org/)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training a Simple Network\n", + "\n", + "To get going and show how easy it is to start working with sparse grids in ƒVDB, let's train a simple network to classify the voxels in a grid as being inside or outside of a sphere using fVDB and all the standard PyTorch functionality.\n", + "\n", + "💡 We will cover all the details of what is happening in the code below in subsequent notebooks. For now, just run the code and see the results!" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 9, batch 99, loss 0.03371221199631691: 100%|██████████| 10/10 [00:16<00:00, 1.69s/it]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "import tqdm\n", + "import torch\n", + "\n", + "import fvdb\n", + "from fvdb.nn import LeakyReLU, Sigmoid, Linear, VDBTensor\n", + "\n", + "# RandomGridsDataset produces a batch of sparse grids with a random number of randomly activated voxels in it\n", + "class RandomGridsDataset(torch.utils.data.Dataset):\n", + " def __init__(self, batch_size):\n", + " self.batch_size = batch_size\n", + " def __len__(self):\n", + " return 100\n", + " def __getitem__(self, idx) -> VDBTensor:\n", + " # create a random number of voxels in each grid with random voxel indexes (ijk's) between -200, 200 in each dimension\n", + " ijks = [torch.randint(-200, 200, (np.random.randint(5_000, 50_000), 3), device='cuda') for i in range(self.batch_size)]\n", + " # make a batch of sparse grids from the ijk's!\n", + " sparse_gridbatch = fvdb.sparse_grid_from_ijk(fvdb.JaggedTensor(ijks), voxel_sizes=0.005)\n", + " # features are just the world-space coordinates of each voxel\n", + " features = sparse_gridbatch.grid_to_world(sparse_gridbatch.ijk.float())\n", + " # produce a 'VDBTensor' which is a convenience for holding the sparse grid and its features\n", + " return VDBTensor(sparse_gridbatch, features)\n", + "\n", + "# Define a basic MLP-type model from ƒVDB modules\n", + "class Model(torch.nn.Module):\n", + " def __init__(self):\n", + " super(Model, self).__init__()\n", + " self.fc0 = Linear(3, 16)\n", + " self.fc1 = Linear(3, 16)\n", + " self.fc2 = Linear(32, 32)\n", + " self.fc3 = Linear(32, 1)\n", + " self.relu = LeakyReLU()\n", + " self.sigmoid = Sigmoid()\n", + " def forward(self, x):\n", + " # concatenate the features produced by two different linear layers\n", + " x = self.relu(VDBTensor.cat([self.fc0(x), self.fc1(x)], dim=1))\n", + " x = self.relu(self.fc2(x))\n", + " x = self.fc3(x)\n", + " x = self.sigmoid(x)\n", + " return x\n", + "\n", + "\n", + "# Data\n", + "batch_size = 8\n", + "dataset = RandomGridsDataset(batch_size)\n", + "dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, collate_fn=lambda x: x[0])\n", + "\n", + "# Model, Loss, Optimizer\n", + "model = Model().to('cuda')\n", + "loss = torch.nn.BCELoss()\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=.001)\n", + "\n", + "# Simple training loop for 10 epochs\n", + "epochs = 10\n", + "with tqdm.tqdm(total=epochs) as pbar:\n", + " for epoch in range(epochs):\n", + " for i, data in enumerate(dataloader):\n", + " optimizer.zero_grad()\n", + " output = model(data)\n", + " # whether each voxel is inside or outside of the unit sphere centered at the origin of the grid space\n", + " dist = torch.sqrt(torch.sum(data.grid.grid_to_world(data.grid.ijk.float()).jdata ** 2, dim=1))\n", + " target = (dist < 1).float()\n", + " l = loss(output.feature.jdata, target[:, None])\n", + " l.backward()\n", + " optimizer.step()\n", + " pbar.set_description(f\"Epoch {epoch}, batch {i}, loss {l.item()}\")\n", + " pbar.update(1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize a sample of predictions from the network to see how well we're doing!" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "test_data = next(iter(dataloader))\n", + "\n", + "fig = plt.figure(figsize=(10, 10))\n", + "ax = fig.add_subplot(2,2,1, projection='3d')\n", + "\n", + "# get predictions from the trained model\n", + "model.eval()\n", + "pred = model(test_data)\n", + "\n", + "ijks_0 = pred.grid.ijk.jdata[pred.grid.jidx==0].detach().cpu().numpy()\n", + "pred_0 = pred.feature.jdata[pred.feature.jidx==0].detach().cpu()\n", + "\n", + "preds_in_sphere = ijks_0[torch.round(pred_0)[:,-1] == 1]\n", + "\n", + "ax.scatter3D(ijks_0[:, 0], ijks_0[:, 1], ijks_0[:, 2], marker = 'o', c = torch.round(pred_0), cmap='coolwarm', alpha =0.25)\n", + "ax.set_title(\"Prediction of voxels inside/outside of a unit sphere\")\n", + "\n", + "# Also plot a 2D slice to make it easier to see\n", + "pred_0 = pred_0[((ijks_0[:, 2]>-20) & (ijks_0[:, 2]<20))]\n", + "\n", + "ijks_0 = ijks_0[((ijks_0[:, 2]>-20) & (ijks_0[:, 2]<20))]\n", + "\n", + "ax = fig.add_subplot(2,2,2)\n", + "ax.scatter(ijks_0[:, 0], ijks_0[:, 1], c=torch.round(pred_0), marker = 'o', cmap='coolwarm', alpha=0.25)\n", + "ax.set_title(\"Cross-section of predictions\")\n", + "\n", + "fig.show()\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fvdb_exec", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/fvdb/notebooks/01_api_basics.ipynb b/fvdb/notebooks/01_api_basics.ipynb new file mode 100644 index 0000000000..02bb307d77 --- /dev/null +++ b/fvdb/notebooks/01_api_basics.ipynb @@ -0,0 +1,525 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### GridBatch and JaggedTensor\n", + "There are two fundamental classes in fVDB you will encounter frequently: `GridBatch` and `JaggedTensor`.\n", + "\n", + "```python\n", + "fvdb.GridBatch\n", + "fvdb.JaggedTensor\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### GridBatch\n", + "\n", + "A `GridBatch` is an indexing structure which maps the 3D $ijk$ coordinates of a set of **sparse** grids to integer offsets which can be used to look up attributes in a tensor that correspond with each voxel.\n", + "\n", + "This mapping only exists for $ijk$ coordinates which are **active** in the space of a **sparse**, 3D grid.\n", + "\n", + "💡 We call these 3D grids **sparse** because of this arbitrary nature to the topology of **active** voxels in the grid compared to **dense** grids where all voxels exist inside some chosen extents in each dimension.\n", + "\n", + "The figure below illustrates this $ijk$ mapping process for a `GridBatch` containing only a single grid.\n", + "\n", + "\n", + "
\n", + "\n", + "\"Image\n", + "\n", + "
\n", + "\n", + "In practice, `GridBatch` is an ordered collection of 1 or more of these 3D grids. \n", + "\n", + "🔩\tAt the level of technical implementation, these 3D grids are **NanoVDB** grids of the special `IndexGrid` type which only stores a unique **index** integer value at each active voxel location. This **index** is an offset into some external data array, a tensor, (one that is not contained in the `IndexGrid`/`GridBatch` classes) where contiguous array members correspond to spatially nearby voxels. `IndexGrid` will allow us to reference into this 'sidecar' tensor of attribute data given a spatial $ijk$ set of coordinates.\n", + "\n", + "Each grid member in a `GridBatch` can have different topologies, different numbers of active voxels and different voxel dimensions and origins per-grid.\n", + "\n", + "
\n", + "\n", + "\"Image\n", + "\n", + "
\n", + "\n", + "##### Images as 2D GridBatch\n", + "\n", + "\n", + "To help explain these concepts, let's consider how we might treat image data with this framework (an image can be thought of as a dense 2D grid after all). \n", + "\n", + "If an image is a 2D grid of pixels, we could imagine the position of each pixel could be expressed as $i,j$ coordinates. For an RGB image, each pixel would contain 3 associated values $(R,G,B)$.\n", + "\n", + "In this way, we could decompose an image into:\n", + "\n", + "1. an `IndexGrid` of $i,j$ coordinates\n", + "2. a tensor of size $[NumberPixels, 3]$ (the flattened RGB features for our attribute tensor)\n", + "\n", + "The $i,j$ coordinates can be used with the `IndexGrid` to index into the list of RGB values to retrieve the RGB value for each pixel. \n", + "\n", + "
\n", + "\n", + "\"Image\n", + "\n", + "
\n", + "\n", + "If we had many images, each of different sizes, we can imagine constructing a `GridBatch` as an ordered set of their `IndexGrid`s.\n", + "\n", + "All the RGB values would go into a sidecar attribute tensor where each feature array would have to be of a different length corresponding to the image size. We call this attribute list of different-length features a **jagged tensor**.\n", + "\n", + "
\n", + "\n", + "\"Grid\n", + "\n", + "
\n", + "\n", + "This is the essence of the relationship between `GridBatch` and `JaggedTensor` in fVDB, but more on `JaggedTensor` later…\n", + "\n", + "Lastly, it is important to know that each grid in the `GridBatch` will be on the same device and processed together by operators in mini-batch-like fashion. \n", + "\n", + "Let's put together our first `GridBatch` to see how it works." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# import the usual suspects and fvdb\n", + "import numpy as np\n", + "import torch\n", + "import fvdb" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will make a `GridBatch` of 8 grids, each with a different number of active voxels and all of those voxels' positions being chosen randomly. Further, each grid will have a randomly chosen origin in the 3D world space and a randomly chosen voxel size." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "batch_size = 8\n", + "# Randomly generate different numbers of voxels we desire in each grid in our batch\n", + "num_voxels_per_grid = [np.random.randint(100, 1_000) for _ in range(batch_size)]\n", + "\n", + "# A list of randomly generated 3D indices for each grid in our batch in the range [-512, 512]\n", + "ijks = [torch.randint(-512, 512, (num_voxels_per_grid[i], 3), device='cuda') for i in range(batch_size)]\n", + "\n", + "# Create an fvdb.GridBatch from the list of indices!!\n", + "grid_batch = fvdb.sparse_grid_from_ijk(fvdb.JaggedTensor(ijks), # We'll explain JaggedTensor in a moment…\n", + " voxel_sizes = [np.random.rand(3).tolist() for _ in range(batch_size)], # Random, different voxel sizes for each grid in our batch\n", + " origins = [np.random.rand(3).tolist() for _ in range(batch_size)], # Random, different grid origins for each grid in our batch\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "There are many more convenient ways that fVDB provides to create a `GridBatch` besides building from lists of coordinate indexes such as building a `GridBatch` from **worldspace pointclouds, meshes or dense tensors**.\n", + "\n", + "💡 The fVDB documentation has more useful examples for these cases using functions like `sparse_grid_from_points`, `sparse_grid_from_dense` and `sparse_grid_from_mesh`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# This grid will be on the GPU because the `ijks` were on that device\n", + "assert(grid_batch.device == ijks[0].device == torch.device('cuda:0'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Each member of the batch has different voxel size dimensions, a different origin in space and different number of voxels" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grid 0 has 116 voxels,\n", + " voxel size of [0.9519320130348206, 0.9454407095909119, 0.36045560240745544]\n", + " and an origin of [0.49334126710891724, 0.26929008960723877, 0.4102530777454376]\n", + "Grid 1 has 768 voxels,\n", + " voxel size of [0.19912821054458618, 0.008141621947288513, 0.9990909695625305]\n", + " and an origin of [0.6951860189437866, 0.5513076782226562, 0.8320647478103638]\n", + "Grid 2 has 920 voxels,\n", + " voxel size of [0.6421335935592651, 0.47253838181495667, 0.9842809438705444]\n", + " and an origin of [0.43986809253692627, 0.8472382426261902, 0.4374838173389435]\n", + "Grid 3 has 930 voxels,\n", + " voxel size of [0.2742624282836914, 0.10442875325679779, 0.7849230766296387]\n", + " and an origin of [0.2953282296657562, 0.6793888807296753, 0.5144127011299133]\n", + "Grid 4 has 981 voxels,\n", + " voxel size of [0.9298512935638428, 0.5107961893081665, 0.08465440571308136]\n", + " and an origin of [0.6837033629417419, 0.9869440793991089, 0.8731261491775513]\n", + "Grid 5 has 627 voxels,\n", + " voxel size of [0.44863489270210266, 0.6608395576477051, 0.7873831987380981]\n", + " and an origin of [0.3249656856060028, 0.9829473495483398, 0.16377957165241241]\n", + "Grid 6 has 923 voxels,\n", + " voxel size of [0.9786439538002014, 0.43387871980667114, 0.7194949388504028]\n", + " and an origin of [0.8193762898445129, 0.9936668276786804, 0.31122133135795593]\n", + "Grid 7 has 840 voxels,\n", + " voxel size of [0.9930934309959412, 0.32834455370903015, 0.4128821790218353]\n", + " and an origin of [0.23459914326667786, 0.7528347373008728, 0.41168293356895447]\n" + ] + } + ], + "source": [ + "for i in range(grid_batch.grid_count):\n", + " print(f\"\"\"Grid {i} has {grid_batch.num_voxels_at(i)} voxels,\n", + " voxel size of {grid_batch.voxel_size_at(i).tolist()}\n", + " and an origin of {grid_batch.origin_at(i).tolist()}\"\"\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's examine some of the ways we can retrieve indices from a `GridBatch` based on $ijk$ coordinates." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Grid 0, feature Index at ijk [[-283, -242, -57]], world-space [[-268.9034118652344, -228.52735900878906, -20.13571548461914]] : 4\n", + "Grid 1, feature Index at ijk [[466, 245, 313]], world-space [[93.48892974853516, 2.5460050106048584, 313.5475158691406]] : 756\n", + "Grid 2, feature Index at ijk [[-151, 193, -299]], world-space [[-96.52230072021484, 92.0471420288086, -293.8625183105469]] : 286\n", + "Grid 3, feature Index at ijk [[302, -130, 70]], world-space [[83.12258911132812, -12.89634895324707, 55.45902633666992]] : 681\n", + "Grid 4, feature Index at ijk [[423, -340, -478]], world-space [[394.01080322265625, -172.6837615966797, -39.591678619384766]] : 590\n", + "Grid 5, feature Index at ijk [[-199, -45, -259]], world-space [[-88.95337677001953, -28.754833221435547, -203.76846313476562]] : 58\n", + "Grid 6, feature Index at ijk [[-163, 121, 189]], world-space [[-158.69960021972656, 53.49298858642578, 136.29576110839844]] : 403\n", + "Grid 7, feature Index at ijk [[493, -252, 261]], world-space [[489.8296813964844, -81.98999786376953, 108.17393493652344]] : 622\n" + ] + } + ], + "source": [ + "# Let's retrieve a random ijk coordinate from each of the lists we used to make the grids\n", + "ijk_queries = fvdb.JaggedTensor([ijks[n][np.random.randint(len(ijks[n]))][None,:] for n in range(grid_batch.grid_count)])\n", + "\n", + "# Use the GridBatch to get indices into the sidecar feature array from the `ijk` coordinate in each grid\n", + "feature_indices = grid_batch.ijk_to_index(ijk_queries)\n", + "world_positions = grid_batch.grid_to_world(ijk_queries.float())\n", + "for i, (ijk, world_p, i_f) in enumerate(zip(ijk_queries, world_positions, feature_indices)):\n", + " print(f\"Grid {i}, feature Index at ijk {ijk.jdata.tolist()}, world-space {world_p.jdata.tolist()} : {i_f.jdata.item()}\")\n", + "\n", + "# NOTE: This GridBatch (Batch of IndexGrids) just expresses the topology of the grids and can be used to reference a sidecar flat array of features but we won't create this sidecar in this example…\n", + "# We can get the index into this hypothetical sidecar feature array with any `ijk` coordinate (if we ask for an `ijk` not in the grid, -1 is given as the index)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### JaggedTensor\n", + "\n", + "`JaggedTensor` is the supporting feature data (i.e. the 'sidecar' of attributes) that is paired with a `GridBatch`. \n", + "\n", + "You can think of `JaggedTensor` as an ordered list of PyTorch Tensors, one for each grid in the `GridBatch`. Same as `GridBatch`, the Tensors are all on the same device and processed together in a mini-batch. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Here we create a list of Tensors, one for each grid in the batch with its number of active voxels and 8 random features per-voxel\n", + "list_of_features = [torch.randn(int(grid_batch.num_voxels[i]), 5, device=grid_batch.device) for i in range(grid_batch.grid_count)]\n", + "# Now we make a JaggedTensor out of this list of heterogeneous Tensors\n", + "features = fvdb.JaggedTensor(list_of_features)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the `JaggedTensor` above, you can see how we constructed it with a list of heterogeneously sized Tensors whose shapes were of the form:\n", + "\n", + "$$[ [B1, C], [B2, C], [B3, C], …] ]$$\n", + "\n", + "where the value of $Bn$ would be the number of active voxels in each grid of the `GridBatch` and $C$ is the number of feature channels (5 was chosen in this case).\n", + "\n", + "💡 Note how each Tensor element in our `JaggedTensor` can have different numbers of active voxels (similar to `GridBatch`) but the same number of per-voxel feature channels. This is distinctly different from the classic representation of 3D data in a PyTorch `Tensor` which is usually a homogeneously shaped Tensor of shape $[N, C, H, W, D]$ where $N$ would be the number of \"grids\" in our batch, $C$ is the number of feature channels, and $H, W, D$ are the 3 index dimensions of a **dense** grid." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can also directly use a `GridBatch` to derive a `JaggedTensor` to match the `GridBatch`'s specific sizing.\n", + "\n", + "This more concise line of code has the same effect as the previous example:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# From a GridBatch, a matching JaggedTensor can be created from a Tensor of shape `(total_voxels, feature_dim)`\n", + "features = grid_batch.jagged_like(torch.randn(grid_batch.total_voxels, 5, device=grid_batch.device))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have a `GridBatch` and a `JaggedTensor` of attributes that correspond to the batch of grids, we could use the $ijk$ offsets we can obtain from the `GridBatch` to index into the `JaggedTensor` to retrieve the feature data for the voxels at those $ijk$'s." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[-1.4529, 1.5827, -0.5729, -0.5724, -0.0612],\n", + " [-1.4506, -0.9575, 0.0528, -1.1230, 2.0563],\n", + " [-2.3013, 1.2390, 0.8193, 0.1099, 1.1040],\n", + " [-0.9724, -0.9775, -0.3134, 0.7936, -1.3263],\n", + " [ 2.7002, 0.3406, -0.3990, 2.0181, -0.1572],\n", + " [-1.1491, 0.8803, 0.1625, 1.7068, 0.4811],\n", + " [ 1.8915, 0.3565, -0.3147, 1.0703, -0.1139],\n", + " [-1.1003, -1.2272, 0.8648, -0.4511, -0.3558]], device='cuda:0')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "features[feature_indices].jdata" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "But beyond just looking up the features directly, we can use higher-level ƒVDB functionality like sampling what the feature values are at a given worldspace position.\n", + "\n", + "Let's get the feature values at the worldspace positions from earlier in the lesson:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "World position [-268.9, -228.5, -20.1] \n", + "\thas the feature values: [-1.453, 1.583, -0.573, -0.572, -0.061]\n", + "World position [93.5, 2.5, 313.5] \n", + "\thas the feature values: [-1.451, -0.957, 0.053, -1.123, 2.056]\n", + "World position [-96.5, 92.0, -293.9] \n", + "\thas the feature values: [-2.301, 1.239, 0.819, 0.11, 1.104]\n", + "World position [83.1, -12.9, 55.5] \n", + "\thas the feature values: [-0.972, -0.977, -0.313, 0.794, -1.326]\n", + "World position [394.0, -172.7, -39.6] \n", + "\thas the feature values: [2.7, 0.341, -0.399, 2.018, -0.157]\n", + "World position [-89.0, -28.8, -203.8] \n", + "\thas the feature values: [-1.149, 0.88, 0.162, 1.707, 0.481]\n", + "World position [-158.7, 53.5, 136.3] \n", + "\thas the feature values: [1.891, 0.356, -0.315, 1.07, -0.114]\n", + "World position [489.8, -82.0, 108.2] \n", + "\thas the feature values: [-1.1, -1.227, 0.865, -0.451, -0.356]\n" + ] + } + ], + "source": [ + "sampled_features = grid_batch.sample_trilinear(world_positions, features)\n", + "\n", + "\n", + "for xyz, value in zip(world_positions.jdata, sampled_features.jdata):\n", + " print(f\"World position {[round(num, 1) for num in xyz.tolist()]} \\n\\thas the feature values: {[round(num, 3) for num in value.tolist()]}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### JaggedTensor Implementation Details\n", + "\n", + "\n", + "Internally, `JaggedTensor` does not represent the list of features as a list of differently sized PyTorch tensors, but instead stores a single tensor of the features accompanied by a special index structure that allows us to access the feature data for each grid in the `GridBatch`. \n", + "\n", + "The `jdata` attribute of a `JaggedTensor` contains all the feature data values in this single list. `jdata` is a `Tensor` of shape $[N, C]$ where $N$ is the total number of active voxels in the batch and $C$ is the number of feature channels. \n", + "\n", + "`jdata`'s shape would be equivalent to the result of concatenating the list of heterogeneously sized Tensors, mentioned above, along their first axis into a single Tensor whose shape would be $[B1+B2+B3…+Bn, C]$.\n", + "\n", + "
\n", + "\n", + "\"jdata\"\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "size of features data for the entire GridBatch: torch.Size([6105, 5])\n" + ] + } + ], + "source": [ + "print(f\"size of features data for the entire GridBatch: {features.jdata.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To determine which grid each feature belongs to, `JaggedTensor` contains indexing information in its `jidx` attribute.\n", + "\n", + "`jidx` is a `Tensor` of shape $[N]$ where $N$ is again the total number of active voxels across the batch. Each element of `jidx` is an integer that tells us which grid in the `GridBatch` the corresponding feature in `jdata` belongs to. The grid membership in `jidx` is ordered starting from 0 and members of the same batch are contiguous.\n", + "\n", + "
\n", + "\n", + "\"jdata\"\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "per-feature membership for each voxel in the GridBatch: tensor([0, 0, 0, ..., 7, 7, 7], device='cuda:0', dtype=torch.int32)\n", + "\n", + "the size of the features of the 4th grid in this batch: torch.Size([930, 5])\n" + ] + } + ], + "source": [ + "print(f\"per-feature membership for each voxel in the GridBatch: {features.jidx}\")\n", + "print(f\"\\nthe size of the features of the 4th grid in this batch: {features.jdata[features.jidx==3].shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Additionally, `JaggedTensor` has a `joffsets` attribute that can also be used to index into `jdata` to get the feature data for each grid in the batch.\n", + "\n", + "The `joffsets` attribute is a `Tensor` of shape $[B]$, where $B$ is the number of grids in the batch. `joffset`'s values are the start offsets into `jdata` that corresponds to each grid in the batch. This is essentially the same information that can be found in `jidx` but expressed in a different form.\n", + "\n", + "
\n", + "\n", + "\"jdata\"\n", + "\n", + "
" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "per-grid offsets into the feature data:\n", + "tensor([ 0, 116, 884, 1804, 2734, 3715, 4342, 5265, 6105], device='cuda:0')\n", + "\n", + "the size of the features of the 4th grid in this batch: torch.Size([930, 5])\n" + ] + } + ], + "source": [ + "print(\"per-grid offsets into the feature data:\")\n", + "print(features.joffsets)\n", + "print(f\"\\nthe size of the features of the 4th grid in this batch: {features.jdata[features.joffsets[3]:features.joffsets[3+1]].shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The features stored in a `JaggedTensor` can be of any type that PyTorch supports, including float, float64, float16, bfloat16, int, etc., and we can have an arbitrary number of feature channels per voxel. \n", + "\n", + "For instance, there could be a `JaggedTensor` with 1 float feature that represents a signed distance field in each grid, or 3 float features that represent an RGB color in each voxel of the grids, or a 192 float feature that represents a learned feature vector of each voxel in each grids." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# A single scalar feature\n", + "features = grid_batch.jagged_like(torch.randn(grid_batch.total_voxels, 1, dtype=torch.float, device=grid_batch.device))\n", + "\n", + "# Cast to a double\n", + "features = features.double()\n", + "\n", + "# A JaggedTensor of 192 float features\n", + "features = grid_batch.jagged_like(torch.randn(grid_batch.total_voxels, 192, dtype=torch.float, device=grid_batch.device))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fvdb_exec", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/fvdb/notebooks/02_nn.ipynb b/fvdb/notebooks/02_nn.ipynb new file mode 100644 index 0000000000..8bed869183 --- /dev/null +++ b/fvdb/notebooks/02_nn.ipynb @@ -0,0 +1,351 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "import fvdb\n", + "import tqdm\n", + "\n", + "# A starting point from the previous notebook:\n", + "batch_size = 8\n", + "num_voxels_per_grid = [np.random.randint(1_000, 10_000) for _ in range(batch_size)]\n", + "\n", + "# A list of randomly generated 3D indices for each grid in our batch in the range [-512, 512]\n", + "ijks = [torch.randint(-512, 512, (num_voxels_per_grid[i], 3), device='cuda') for i in range(batch_size)]\n", + "\n", + "# Create an fvdb.GridBatch from the list of indices!!\n", + "grid_batch = fvdb.sparse_grid_from_ijk(fvdb.JaggedTensor(ijks),\n", + " voxel_sizes = [np.random.rand(3).tolist() for _ in range(batch_size)], # Random, different voxel sizes for each grid in our batch\n", + " origins = [np.random.rand(3).tolist() for _ in range(batch_size)], # Random, different grid origins for each grid in our batch\n", + " )\n", + "\n", + "# 32 random features in a JaggedTensor\n", + "features = grid_batch.jagged_like(torch.randn(grid_batch.total_voxels, 32, device=grid_batch.device))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### VDBTensor\n", + "\n", + "As you can tell from the previous notebook, the functionality for `GridBatch` and `JaggedTensor` are closely related to each other and it's often the case you want to perform operations that reference or affect both the grid and feature data at the same time. \n", + "\n", + "To that end, `VDBTensor` exists to wrap around a `GridBatch` and `JaggedTensor` and provides most of the higher level functionality you'll most often use for these operations.\n", + "\n", + "
\n", + "\n", + "\"VDB>\n", + "\n", + "
\n", + "\n", + "Creating a `VDBTensor` is as simple as:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from fvdb.nn import VDBTensor\n", + "\n", + "vdbtensor = VDBTensor(grid_batch, features)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`VDBTensor` has some common functionality to both `GridBatch` and `JaggedTensor` such as moving to a device:\n", + " \n", + "```python\n", + " vdbtensor = vdbtensor.to(device)\n", + " vdbtensor = vdbtensor.cuda()\n", + "```\n", + "\n", + "Or retrieving the number of grids in this batch or total number of active voxels:\n", + "\n", + "```python\n", + " num_grids = vdbtensor.grid_count\n", + " num_voxels = vdbtensor.total_voxels\n", + "```" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### VDBTensor Operations\n", + "\n", + "`VDBTensor` has a number of operations that are designed to work with both the `GridBatch` and `JaggedTensor` at the same time. Concatenation is a useful example.\n", + "\n", + "`VDBTensor` concatenation has two different definitions.\n", + "\n", + "1. Concatenating along **dimension 0** is a concatenation along the **batch** dimension. \n", + "If `J1` has **10** member grids in the batch and `J2` has **20** members in the batch, then `VDBTensor.cat([J1,J2], dim=0)` will have **30** members. \n", + "All input `VDBTensors` must have the same number of features.\n", + "\n", + "2. Concatenating along **dimension 1** concatenates the **features** of the `VDBTensors` together. \n", + "If `J1` has **3** features and `J2` has **4** features, then `VDBTensor.cat([J1,J2], dim=1)` will have **7** features. \n", + "All input `VDBTensors` must have the same number of grids in the batch and number of voxels in each grid." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Concatenating VDBTensor of batch size 8, feature size 32, total voxels 49465 with itself along…\n", + "\tdim 0 gives a VDBTensor of batch size 16, feature size 32, and total voxel count 98930.\n", + "\tdim 1 gives a VDBTensor of batch size 8, feature size 64, and total voxel count 49465.\n" + ] + } + ], + "source": [ + "print(f\"Concatenating VDBTensor of batch size {vdbtensor.batch_size}, feature size {vdbtensor.jdata.shape[1]}, total voxels {vdbtensor.total_voxels} with itself along…\")\n", + "print(f\"\\tdim 0 gives a VDBTensor of batch size {VDBTensor.cat([vdbtensor, vdbtensor]).batch_size}, feature size {VDBTensor.cat([vdbtensor, vdbtensor]).jdata.shape[1]}, and total voxel count {VDBTensor.cat([vdbtensor, vdbtensor]).total_voxels}.\")\n", + "print(f\"\\tdim 1 gives a VDBTensor of batch size {VDBTensor.cat([vdbtensor, vdbtensor], dim=1).batch_size}, feature size {VDBTensor.cat([vdbtensor, vdbtensor], dim=1).jdata.shape[1]}, and total voxel count {VDBTensor.cat([vdbtensor, vdbtensor], dim=1).total_voxels}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### NN Modules\n", + "\n", + "Many commonly used Neural Network Modules are available from `fvdb.nn`, operate on `VDBTensors` and return `VDBTensors`. For example:\n", + "\n", + "* `fvdb.nn.Linear`: fully connected layer\n", + "* `fvdb.nn.Conv3d`: 3D convolutional layer \n", + "* `fvdb.nn.BatchNorm`: batch normalization layer\n", + "* `fvdb.nn.ReLU`: ReLU activation function\n", + "\n", + "These Modules are designed to work with `VDBTensors`, are a drop-in replacement for the PyTorch equivalents and can be used in combination with other PyTorch Modules:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Linear layer took a VDBTensor input of feature size 32 and output feature size 64.\n" + ] + } + ], + "source": [ + "from fvdb.nn import LeakyReLU, Sigmoid, Linear\n", + "\n", + "linear = torch.nn.Sequential(Linear(32, 64), LeakyReLU()).to('cuda')\n", + "\n", + "out_vdbtensor = linear(vdbtensor)\n", + "\n", + "print(f\"Linear layer took a VDBTensor input of feature size {vdbtensor.jdata.shape[1]} and output feature size {out_vdbtensor.jdata.shape[1]}.\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this simple example we took a `VDBTensor` (a pair of a `GridBatch` and `JaggedTensor`) and ran it through a fully-connected layer to produce a new `VDBTensor` (another pair of a `GridBatch` and `JaggedTensor`).\n", + "\n", + "💡 It's worth noting that it would be wasteful to have two separate `GridBatch`s in this example because our `Linear` operation hasn't actually changed the topology of the grids in any way, it has only produced new features.\n", + "\n", + "In fact, the `fvdb.nn` Modules consider best-practice optimizations such as this, and you can see that the `GridBatch` of the input and output `VDBTensor` are in-fact the same objects on your device:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input and output VDBTensor's GridBatches are the same: True\n" + ] + } + ], + "source": [ + "print(\"Input and output VDBTensor's GridBatches are the same: \", VDBTensor.same_grid(out_vdbtensor.grid, vdbtensor.grid))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In practice, in the course of running grid operators in a deep neural network, it is often the case that there are several `JaggedTensors` which are produced that correspond to a single `GridBatch`. \n", + "\n", + "`fvdb.nn`'s Modules will automatically handle these types of optimizations for you such as ensuring that only the new feature data is created when operations are performed which don't alter the topology of the input grid." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training the Simple Network Again\n", + "\n", + "Let's return to the simple network which classifies the voxels in a grid as being inside or outside of a sphere. At this point, you should have a good understanding of how all the pieces fit together in this example to train the network." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 9, batch 99, loss 0.04092085361480713: 100%|██████████| 10/10 [00:16<00:00, 1.67s/it]\n" + ] + } + ], + "source": [ + "# DataSet that produces random grids centered at 0, 0, 0 worldspace with voxel sizes (0.005, 0.005, 0.005)\n", + "from torch.utils.data import Dataset\n", + "class RandomGridsDataset(Dataset):\n", + " def __init__(self, batch_size):\n", + " self.batch_size = batch_size\n", + " def __len__(self):\n", + " return 100\n", + " def __getitem__(self, idx) -> VDBTensor:\n", + " ijks = [torch.randint(-200, 200, (np.random.randint(5_000, 50_000), 3), device='cuda') for i in range(self.batch_size)]\n", + " grid = fvdb.sparse_grid_from_ijk(fvdb.JaggedTensor(ijks), voxel_sizes=0.005)\n", + " # features are the world-space coordinates of the voxels\n", + " features = grid.grid_to_world(grid.ijk.float())\n", + " return VDBTensor(grid, features)\n", + "\n", + "# Define model\n", + "class Model(torch.nn.Module):\n", + " def __init__(self):\n", + " super(Model, self).__init__()\n", + " self.fc0 = Linear(3, 16)\n", + " self.fc1 = Linear(3, 16)\n", + " self.fc2 = Linear(32, 32)\n", + " self.fc3 = Linear(32, 1)\n", + " self.relu = LeakyReLU()\n", + " self.sigmoid = Sigmoid()\n", + " def forward(self, x):\n", + " # concatenate the features produced by two different linear layers\n", + " x = self.relu(VDBTensor.cat([self.fc0(x), self.fc1(x)], dim=1))\n", + " x = self.relu(self.fc2(x))\n", + " x = self.fc3(x)\n", + " x = self.sigmoid(x)\n", + " return x\n", + "\n", + "\n", + "# Data\n", + "dataset = RandomGridsDataset(batch_size)\n", + "dataloader = torch.utils.data.DataLoader(dataset, batch_size=1, collate_fn=lambda x: x[0])\n", + "\n", + "# Model, Loss, Optimizer\n", + "model = Model().to('cuda')\n", + "\n", + "loss = torch.nn.BCELoss()\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=.001)\n", + "\n", + "epochs = 10\n", + "with tqdm.tqdm(total=epochs) as pbar:\n", + " for epoch in range(epochs):\n", + " for i, data in enumerate(dataloader):\n", + " optimizer.zero_grad()\n", + " output = model(data)\n", + " # JaggedTensor indicating whether each voxel is inside or outside of the unit sphere centered at the origin of the grid space\n", + " dist = torch.sqrt(torch.sum(data.grid.grid_to_world(data.grid.ijk.float()).jdata ** 2, dim=1))\n", + " target = (dist < 1).float()\n", + " l = loss(output.feature.jdata, target[:, None])\n", + " l.backward()\n", + " optimizer.step()\n", + " pbar.set_description(f\"Epoch {epoch}, batch {i}, loss {l.item()}\")\n", + " pbar.update(1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize a sample of predictions from the network to see how well it's doing." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "test_data = next(iter(dataloader))\n", + "\n", + "fig = plt.figure(figsize=(10, 10))\n", + "ax = fig.add_subplot(2,2,1, projection='3d')\n", + "\n", + "model.eval()\n", + "pred = model(test_data)\n", + "\n", + "ijks_0 = pred.grid.ijk.jdata[pred.grid.jidx==0].detach().cpu().numpy()\n", + "pred_0 = pred.feature.jdata[pred.feature.jidx==0].detach().cpu()\n", + "\n", + "preds_in_sphere = ijks_0[torch.round(pred_0)[:,-1] == 1]\n", + "\n", + "ax.scatter3D(ijks_0[:, 0], ijks_0[:, 1], ijks_0[:, 2], marker = 'o', c = torch.round(pred_0), cmap='coolwarm', alpha =0.25)\n", + "\n", + "# Also plot a 2D slice to make it easier to see\n", + "pred_0 = pred_0[((ijks_0[:, 2]>-20) & (ijks_0[:, 2]<20))]\n", + "\n", + "ijks_0 = ijks_0[((ijks_0[:, 2]>-20) & (ijks_0[:, 2]<20))]\n", + "\n", + "ax = fig.add_subplot(2,2,2)\n", + "ax.scatter(ijks_0[:, 0], ijks_0[:, 1], c=torch.round(pred_0), marker = 'o', cmap='coolwarm', alpha=0.25)\n", + "fig.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fvdb_exec", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/fvdb/notebooks/03_conv.ipynb b/fvdb/notebooks/03_conv.ipynb new file mode 100644 index 0000000000..2484b2bdef --- /dev/null +++ b/fvdb/notebooks/03_conv.ipynb @@ -0,0 +1,627 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Convolution\n", + "\n", + "As mentioned in the previous notebook, `fvdb.nn` contains the `VDBTensor` class and useful Modules such as the convolutional layer `SparseConv3d` as well as useful activation functions." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import torch\n", + "import fvdb\n", + "import tqdm\n", + "\n", + "from fvdb.nn import VDBTensor, SparseConv3d, LeakyReLU, Sigmoid\n", + "\n", + "batch_size = 8\n", + "num_voxels_per_grid = [np.random.randint(1_000, 10_000) for _ in range(batch_size)]\n", + "\n", + "# A list of randomly generated 3D indices for each grid in our batch in the range [-512, 512]\n", + "ijks = [torch.randint(-512, 512, (num_voxels_per_grid[i], 3), device=\"cuda\") for i in range(batch_size)]\n", + "grid_batch = fvdb.sparse_grid_from_ijk(fvdb.JaggedTensor(ijks))\n", + "\n", + "# Some random features of 8 channels for each voxel in the grid\n", + "features = grid_batch.jagged_like(torch.randn(grid_batch.total_voxels, 8, device=grid_batch.device))\n", + "\n", + "# Create a VDBTensor\n", + "vdbtensor = fvdb.nn.VDBTensor(grid_batch, features)\n", + "\n", + "# SparseConv3d of 8 -> 16 features\n", + "conv_layer = SparseConv3d(8, 16, kernel_size=3, stride=1).to(\"cuda\")\n", + "\n", + "conv_vdbtensor = conv_layer(vdbtensor)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Convolution on sparse volumes in ƒVDB is similar to the general convolution case on 3D data with one notable difference: for the `stride=1` case, the topology of the output grid is the same as the input grid. In effect, we only compute convolution at the active voxel locations in our sparse grid.\n", + "\n", + "The animations below contrast this difference between general convolution and this sparse convolution approach, visualized on 2D grids. (Image Credit: [Chris Choy](https://chrischoy.github.io/))\n", + "\n", + "
\n", + "\n", + "| Dense Convolution | Sparse Convolution \n", + "| :---: | :---: |\n", + "| \"dense\"| \"sparse\" |\n", + "\n", + "
\n", + "\n", + "This approach is similar to other spatially sparse convolution approaches used in previous works such as [Minkowski Engine](https://github.com/NVIDIA/MinkowskiEngine) and maintains spatial sparsity in the data as we progress through a deep convolutional network. Using a `stride != 1` results in an output grid with a different topology where striding has been applied; comparable to the general, dense convolution case.\n", + "\n", + "💡 See the [Minkowski Engine Documentation](https://nvidia.github.io/MinkowskiEngine/) for deeper discussions on sparse convolution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Given this feature of sparse 3D convolution, `SparseConv3d` will make sure that the output `VDBTensor` it produces will not unncessarily create new grids for a `GridBatch` if its operation doesn't change the topology of the incoming grids:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input and output VDBTensor's GridBatches the same: True\n" + ] + } + ], + "source": [ + "# A convolution that does not change the grid's spatial topology\n", + "conv_layer = SparseConv3d(8, 16, kernel_size=3, stride=1).to(\"cuda\")\n", + "\n", + "conv_vdbtensor = conv_layer(vdbtensor)\n", + "\n", + "print(\"Input and output VDBTensor's GridBatches the same: \", VDBTensor.same_grid(vdbtensor.grid, conv_vdbtensor.grid))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Contrast this with operations which must necessarily create a new grid topology as part of convolving the input, such as when striding over a grid:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Input and output VDBTensor's GridBatches the same when toplogy changes: False\n" + ] + } + ], + "source": [ + "# Let's try a convolutional layer that changes the topology of the grid\n", + "conv_layer = SparseConv3d(8, 16, stride=2).to(\"cuda\")\n", + "\n", + "conv_vdbtensor = conv_layer(vdbtensor)\n", + "print(\"Input and output VDBTensor's GridBatches the same when toplogy changes: \", VDBTensor.same_grid(vdbtensor.grid, conv_vdbtensor.grid))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Transposed Convolution\n", + "\n", + "When performing strided convolution on a grid, such as in the case above, it is often necessary to perform the transposed convolution in order to produce the **same toplogy** as the original grid at a later stage in the network. This often happens in UNet architectures. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unlike with dense, general convolution, naive subdivision of the sparse grid we coarsened with strided convolution won't produce the same topology as the original grid! This is an inherent characteristic of the sparse layout of voxels compared to a dense represenation.\n", + "\n", + "Take a look at the following diagram as an illustration of this point. In this illustration of a 2D sparse convolution, a 3x3 kernel coarsens the grid to 1 active voxel. When it comes time to perform the tranposed convolution to attempt to topologically invert this operation, it's entirely ambiguous which were the active voxels that contributed to the coarsened voxel (and its features) at the location of the downsampled grid.\n", + "\n", + "
\n", + "\n", + "\n", + "\"transposed_conv\"\n", + "\n", + "
\n", + "\n", + "Any combination of active voxels might be present in the grid we're trying to produce as the inverse of the strided convolution. To accurately invert a strided convolution, we need to upsample the grid to the original topology by explicitly providing the desired original grid topology." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To accomplish this, `SparseConv3d` can be provided the target output grid as an optional argument, `out_grid`, when performing this transpose convolution." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original grid batch voxel count we need to match: 49,431\n", + "Convolved grid batch voxel count: 166,878\n", + "Tranposed convolution grid batch voxel count: 49,431\n", + "Input and tranposed output VDBTensor's GridBatches the same after transpose convolution: True\n" + ] + } + ], + "source": [ + "# a transposed convolutional layer\n", + "tranpose_conv_layer = SparseConv3d(16, 8, stride=2, transposed=True).to(\"cuda\")\n", + "\n", + "# providing the original grid as the \"out_grid\" to the transposed convolutional layer\n", + "convtransposed_vdbtensor = tranpose_conv_layer(conv_vdbtensor, out_grid=vdbtensor.grid)\n", + "\n", + "print(f\"Original grid batch voxel count we need to match: {vdbtensor.total_voxels:,}\")\n", + "print(f\"Convolved grid batch voxel count: {conv_vdbtensor.total_voxels:,}\")\n", + "print(f\"Tranposed convolution grid batch voxel count: {convtransposed_vdbtensor.total_voxels:,}\")\n", + "\n", + "print(\"Input and tranposed output VDBTensor's GridBatches the same after transpose convolution: \", VDBTensor.same_grid(vdbtensor.grid, convtransposed_vdbtensor.grid))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's illustrate what happens if we were to naively coarsen the convolved grid to reproduce the same input topology. \n", + "\n", + "If we were to naively do the transposed convolution to target a 2x coarsened grid (to try to match the effect of convolution `stride=2`), this would have most likely given us a grid with a different topology than the original grid with a much larger number of active voxels." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total voxel counts\n", + "\tOriginal grids: 49,431\n", + "\tConvolved, upsampled grids: 166,878\n", + "\tTranposed convolution on grid : 96,630\n", + "Input and tranposed output VDBTensor's GridBatches the same after transpose convolution: False\n" + ] + } + ], + "source": [ + "# Let's attempt to do a transposed convolution and output the topology of the convolved grid subdivided once (to attempt to match the original grid we convolved with stride 2)\n", + "convtransposed_vdbtensor = tranpose_conv_layer(conv_vdbtensor, out_grid=conv_vdbtensor.grid.coarsened_grid(2))\n", + "\n", + "print(\"Total voxel counts\")\n", + "print(f\"\\tOriginal grids: {vdbtensor.total_voxels:,}\")\n", + "print(f\"\\tConvolved, upsampled grids: {conv_vdbtensor.total_voxels:,}\")\n", + "# this won't match the original grid shape we're after\n", + "print(f\"\\tTranposed convolution on grid : {convtransposed_vdbtensor.total_voxels:,}\")\n", + "\n", + "print(\"Input and tranposed output VDBTensor's GridBatches the same after transpose convolution: \", VDBTensor.same_grid(vdbtensor.grid, convtransposed_vdbtensor.grid))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Simple UNet\n", + "\n", + "Now that we understand the basics of convolution, concatenation and training networks with ƒVDB, let's evolve the sphere detection problem from the previous notebook to try our hands at semantic segmentation.\n", + "\n", + "We'll try to segment two different classes of shapes, spheres and cubes, that can be randomly placed in a 3D volume using a simple convolutional UNet architecture in ƒVDB." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### ShapeDataset\n", + "\n", + "We'll define a `ShapeDataset` class that randomly places a sphere and several cubes in a 3D volume. The dataset will return `VDBTensor`'s whose features will be 4 channels: 3 for the world-space coordinates of the voxels and 1 for the class label of the voxel (which we'll use as ground truth and not as input to the network)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# DataSet that produces randomly centered spheres in a noisy grids\n", + "import torch.types\n", + "from torch.utils.data import Dataset\n", + "from typing import Tuple\n", + "\n", + "radius = 0.12\n", + "\n", + "class ShapeDataset(Dataset):\n", + " def __len__(self):\n", + " return 800\n", + "\n", + " def __getitem__(self, idx) -> VDBTensor:\n", + " N = 100\n", + "\n", + " ii, jj, kk, = torch.meshgrid([torch.arange(N).cuda()]*3, indexing='ij')\n", + " # normalze ijks -> [ -1, 1 ]\n", + " xx, yy, zz = ii.float() / (float(N) - 1) * 2 - 1, jj.float() / (float(N) - 1) * 2 - 1, kk.float() / (float(N) - 1) * 2 - 1\n", + "\n", + " # pick random sphere origin\n", + " rand_sphere_origin = (torch.rand(3) - 0.5) * 2 * (1-radius/2)\n", + "\n", + " # create sphere mask with the random origin and radius\n", + " xx -= rand_sphere_origin[0]\n", + " yy -= rand_sphere_origin[1]\n", + " zz -= rand_sphere_origin[2]\n", + " sphere_mask = torch.sqrt(xx**2 + yy**2 + zz**2) < radius\n", + "\n", + " # create 3 random cubes\n", + " cube_centers = []\n", + "\n", + " def check_bbox_intersection(center_a, center_b):\n", + " bbox_min_a, bbox_max_a = center_a - radius, center_a + radius\n", + " bbox_min_b, bbox_max_b = center_b - radius, center_b + radius\n", + " return ((bbox_min_a >= bbox_min_b) & (bbox_min_a <= bbox_max_b)).any() or \\\n", + " ((bbox_max_a >= bbox_min_b) & (bbox_max_a <= bbox_max_b)).any()\n", + "\n", + " for i in range(3):\n", + " rand_box_origin = (torch.rand(3) - 0.5) * 2 * (1-radius/2)\n", + " # test that the bboxes don't intersect\n", + " while check_bbox_intersection(rand_box_origin, rand_sphere_origin) or \\\n", + " torch.tensor([check_bbox_intersection(rand_box_origin, center) for center in cube_centers]).any():\n", + " rand_box_origin = (torch.rand(3) - 0.5) * 2 * (1-radius/2)\n", + " cube_centers.append(rand_box_origin)\n", + "\n", + " xx, yy, zz = ii.float() / (float(N) - 1) * 2 - 1, jj.float() / (float(N) - 1) * 2 - 1, kk.float() / (float(N) - 1) * 2 - 1\n", + "\n", + " sphere_and_cubes_mask = sphere_mask\n", + " for box_center in cube_centers:\n", + " cube = ((xx > box_center[0] - radius) & (xx < box_center[0] + radius) \\\n", + " & (yy > box_center[1] - radius) & (yy < box_center[1] + radius) \\\n", + " & (zz > box_center[2] - radius) & (zz < box_center[2] + radius))\n", + " sphere_and_cubes_mask = sphere_and_cubes_mask | cube\n", + "\n", + " # create the grid from spheres and cubes\n", + " sphere_and_cubes_grid = fvdb.GridBatch(device=sphere_and_cubes_mask.device)\n", + " sphere_and_cubes_grid.set_from_dense_grid(1, [N]*3, voxel_sizes=0.01, mask = sphere_and_cubes_mask)\n", + "\n", + " # create the ground truth sphere-or-cube mask for the grid\n", + " sphere_gt = sphere_and_cubes_grid.read_from_dense(sphere_mask.unsqueeze(-1).unsqueeze(0).float())\n", + "\n", + " features = fvdb.jcat([sphere_and_cubes_grid.ijk.jdata, sphere_gt.jdata], dim=1)\n", + " return VDBTensor(sphere_and_cubes_grid, features)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize the output of the `ShapeDataset` class to understand the data our model will be trained on." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the ShapeDataset output\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "dataloader = torch.utils.data.DataLoader(ShapeDataset(), batch_size=4, collate_fn=VDBTensor.cat)\n", + "X = next(iter(dataloader))\n", + "# Ground truth\n", + "gt = X.feature.jdata[:,-1:]\n", + "\n", + "fig = plt.figure()\n", + "\n", + "for i in range(4):\n", + "\n", + " # ijks and ground truth for batch element i\n", + " X_ijks_0 = X.grid.ijk.jdata[X.grid.jidx == i].detach().cpu().numpy()\n", + " X_gt_0 = gt[X.grid.jidx == i].detach().cpu().numpy()\n", + "\n", + " dim = 100\n", + " ax = fig.add_subplot(2,2,i+1, projection=\"3d\")\n", + " ax.set_xlim(0, dim)\n", + " ax.set_ylim(0, dim)\n", + " ax.set_zlim(0, dim)\n", + " ax.scatter3D(X_ijks_0[:, 0], X_ijks_0[:, 1], X_ijks_0[:, 2], marker=\"o\", c=X_gt_0, cmap=\"coolwarm\", alpha=0.25)\n", + "\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Convolutional UNet\n", + "\n", + "Here's a simple UNet we'll use to segment the shapes in the 3D volume built from fVDB `SparseConv3d` layers and `LeakyReLU` activations." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Define model\n", + "class ConvClass(SparseConv3d):\n", + " def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, bias=False, transposed=False):\n", + " super(ConvClass, self).__init__(in_channels, out_channels, kernel_size=kernel_size, stride=stride, bias=bias, transposed=transposed)\n", + " self.relu = LeakyReLU()\n", + "\n", + " def forward(self, x, out_grid=None):\n", + " return self.relu(super(ConvClass, self).forward(x, out_grid=out_grid).type(torch.float))\n", + "\n", + "class UNet(torch.nn.Module):\n", + " def __init__(self, in_ch = 3, out_ch = 1, growth_rate = 16):\n", + " super(UNet, self).__init__()\n", + " depth = 0\n", + "\n", + " self.conv0_0 = ConvClass(in_ch, growth_rate * 2 ** (depth + 1))\n", + " self.conv0_1 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth += 1\n", + " self.conv1_0 = ConvClass(growth_rate * 2 ** (depth), growth_rate * 2 ** (depth + 1), stride=2)\n", + " self.conv1_1 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth += 1\n", + " self.conv2_0 = ConvClass(growth_rate * 2 ** (depth), growth_rate * 2 ** (depth + 1), stride=2)\n", + " self.conv2_1 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth += 1\n", + " self.conv3_0 = ConvClass(growth_rate * 2 ** (depth), growth_rate * 2 ** (depth + 1), stride=2)\n", + " self.conv3_1 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth += 1\n", + " self.conv4_0 = ConvClass(growth_rate * 2 ** (depth), growth_rate * 2 ** (depth + 1), stride=2)\n", + " self.conv4_1 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth -= 1\n", + " self.dconv3_0 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1), stride=2, transposed=True)\n", + " self.dconv3_1 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1))\n", + " self.dconv3_2 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth -= 1\n", + " self.dconv2_0 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1), stride=2, transposed=True)\n", + " self.dconv2_1 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1))\n", + " self.dconv2_2 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth -= 1\n", + " self.dconv1_0 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1), stride=2, transposed=True)\n", + " self.dconv1_1 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1))\n", + " self.dconv1_2 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + "\n", + " depth -= 1\n", + " self.dconv0_0 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1), stride=2, transposed=True)\n", + " self.dconv0_1 = ConvClass(growth_rate * 2 ** (depth + 2), growth_rate * 2 ** (depth + 1))\n", + " self.dconv0_2 = ConvClass(growth_rate * 2 ** (depth + 1), growth_rate * 2 ** (depth + 1))\n", + " self.output = SparseConv3d(growth_rate * 2 ** (depth + 1), out_ch, kernel_size=1, bias=False)\n", + "\n", + " def forward(self, x):\n", + " x = self.conv0_0(x)\n", + " conv0_output = self.conv0_1(x)\n", + "\n", + " x = self.conv1_0(conv0_output)\n", + " conv1_output = self.conv1_1(x)\n", + "\n", + " x = self.conv2_0(conv1_output)\n", + " conv2_output = self.conv2_1(x)\n", + "\n", + " x = self.conv3_0(x)\n", + " conv3_output = self.conv3_1(x)\n", + "\n", + " x = self.conv4_0(x)\n", + " x = self.conv4_1(x)\n", + "\n", + " x = self.dconv3_0(x, out_grid=conv3_output.grid)\n", + " x = VDBTensor.cat([x, conv3_output], dim=1)\n", + " x = self.dconv3_1(x)\n", + " x = self.dconv3_2(x)\n", + "\n", + " x = self.dconv2_0(x, out_grid=conv2_output.grid)\n", + " x = VDBTensor.cat([x, conv2_output], dim=1)\n", + " x = self.dconv2_1(x)\n", + " x = self.dconv2_2(x)\n", + "\n", + " x = self.dconv1_0(x, out_grid=conv1_output.grid)\n", + " x = VDBTensor.cat([x, conv1_output], dim=1)\n", + " x = self.dconv1_1(x)\n", + " x = self.dconv1_2(x)\n", + "\n", + " x = self.dconv0_0(x, out_grid=conv0_output.grid)\n", + " x = VDBTensor.cat([x, conv0_output], dim=1)\n", + " x = self.dconv0_1(x)\n", + " x = self.dconv0_2(x)\n", + " x = self.output(x)\n", + " return x" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's train this network in a simple training loop and visualize the output of the network. Each volume has about 5% occupancy of the total volume which, if it were 'dense', would contain one million voxels. In the 'dense' case, a batch size of 32 would mean we're training on 32 million voxels per batch!" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/5 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the results of the trained network\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Get a batch of data\n", + "X = next(iter(dataloader))\n", + "\n", + "# Remove the ground truth channel from the features for the model input\n", + "input = VDBTensor(X.grid, X.grid.jagged_like(X.feature.jdata[:,:-1].contiguous()))\n", + "# Ground truth\n", + "gt = X.feature.jdata[:,-1:]\n", + "\n", + "fig = plt.figure(figsize=(10, 20))\n", + "\n", + "# ijks and ground truth for batch element 0\n", + "X_ijks_0 = X.grid.ijk.jdata[X.grid.jidx == 0].detach().cpu().numpy()\n", + "X_gt_0 = gt[X.grid.jidx == 0].detach().cpu().numpy()\n", + "\n", + "\n", + "# plot input and ground truth values\n", + "dim = 100\n", + "ax = fig.add_subplot(1, 2, 1, projection=\"3d\")\n", + "ax.set_xlim(0, dim)\n", + "ax.set_ylim(0, dim)\n", + "ax.set_zlim(0, dim)\n", + "ax.scatter3D(X_ijks_0[:, 0], X_ijks_0[:, 1], X_ijks_0[:, 2], marker=\"o\", c=X_gt_0, cmap=\"coolwarm\", alpha=0.25)\n", + "ax.set_title(\"Ground Truth\")\n", + "\n", + "\n", + "# model inference\n", + "model.eval()\n", + "sigmoid = Sigmoid()\n", + "pred = sigmoid(model(input))\n", + "\n", + "# predicted values for batch element 0\n", + "pred_0 = np.round(pred.feature.jdata[pred.grid.jidx == 0].detach().cpu().numpy())\n", + "\n", + "ax = fig.add_subplot(1, 2, 2, projection=\"3d\")\n", + "ax.set_xlim(0, dim)\n", + "ax.set_ylim(0, dim)\n", + "ax.set_zlim(0, dim)\n", + "ax.scatter3D(X_ijks_0[:, 0], X_ijks_0[:, 1], X_ijks_0[:, 2], marker=\"o\", c=pred_0, cmap=\"coolwarm\", alpha=0.25)\n", + "ax.set_title(\"Prediction\")\n", + "\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fvdb_exec", + "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.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/fvdb/notebooks/img/2dconv.png b/fvdb/notebooks/img/2dconv.png new file mode 100644 index 0000000000..3acb8ba9b0 Binary files /dev/null and b/fvdb/notebooks/img/2dconv.png differ diff --git a/fvdb/notebooks/img/DenseConv.gif b/fvdb/notebooks/img/DenseConv.gif new file mode 100644 index 0000000000..6a10c31c5d Binary files /dev/null and b/fvdb/notebooks/img/DenseConv.gif differ diff --git a/fvdb/notebooks/img/SparseConv.gif b/fvdb/notebooks/img/SparseConv.gif new file mode 100644 index 0000000000..5237213117 Binary files /dev/null and b/fvdb/notebooks/img/SparseConv.gif differ diff --git a/fvdb/notebooks/img/blank_sparse_grids.png b/fvdb/notebooks/img/blank_sparse_grids.png new file mode 100644 index 0000000000..21aefd1d66 Binary files /dev/null and b/fvdb/notebooks/img/blank_sparse_grids.png differ diff --git a/fvdb/notebooks/img/bunny_volume.jpg b/fvdb/notebooks/img/bunny_volume.jpg new file mode 100644 index 0000000000..51fa7e617a Binary files /dev/null and b/fvdb/notebooks/img/bunny_volume.jpg differ diff --git a/fvdb/notebooks/img/first-3d-brain-reconstruction-strip.mp4 b/fvdb/notebooks/img/first-3d-brain-reconstruction-strip.mp4 new file mode 100644 index 0000000000..3c7b202ac4 Binary files /dev/null and b/fvdb/notebooks/img/first-3d-brain-reconstruction-strip.mp4 differ diff --git a/fvdb/notebooks/img/grid_batch_diagram.svg b/fvdb/notebooks/img/grid_batch_diagram.svg new file mode 100644 index 0000000000..ae3f45b0cb --- /dev/null +++ b/fvdb/notebooks/img/grid_batch_diagram.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/fvdb/notebooks/img/gridbatch.png b/fvdb/notebooks/img/gridbatch.png new file mode 100644 index 0000000000..65f06d3797 Binary files /dev/null and b/fvdb/notebooks/img/gridbatch.png differ diff --git a/fvdb/notebooks/img/gridbatch_concept.svg b/fvdb/notebooks/img/gridbatch_concept.svg new file mode 100644 index 0000000000..59d992e359 --- /dev/null +++ b/fvdb/notebooks/img/gridbatch_concept.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/fvdb/notebooks/img/image_index_grid_diagram.svg b/fvdb/notebooks/img/image_index_grid_diagram.svg new file mode 100644 index 0000000000..a6b253a4db --- /dev/null +++ b/fvdb/notebooks/img/image_index_grid_diagram.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/fvdb/notebooks/img/imagestack.png b/fvdb/notebooks/img/imagestack.png new file mode 100644 index 0000000000..09f810ad60 Binary files /dev/null and b/fvdb/notebooks/img/imagestack.png differ diff --git a/fvdb/notebooks/img/jdata.jpg b/fvdb/notebooks/img/jdata.jpg new file mode 100644 index 0000000000..bec762f0f3 Binary files /dev/null and b/fvdb/notebooks/img/jdata.jpg differ diff --git a/fvdb/notebooks/img/jidx.jpg b/fvdb/notebooks/img/jidx.jpg new file mode 100644 index 0000000000..e1c373e7b8 Binary files /dev/null and b/fvdb/notebooks/img/jidx.jpg differ diff --git a/fvdb/notebooks/img/joffsets.jpg b/fvdb/notebooks/img/joffsets.jpg new file mode 100644 index 0000000000..f6d92adbb1 Binary files /dev/null and b/fvdb/notebooks/img/joffsets.jpg differ diff --git a/fvdb/notebooks/img/numbers.png b/fvdb/notebooks/img/numbers.png new file mode 100644 index 0000000000..4211fe6202 Binary files /dev/null and b/fvdb/notebooks/img/numbers.png differ diff --git a/fvdb/notebooks/img/sparse_two.png b/fvdb/notebooks/img/sparse_two.png new file mode 100644 index 0000000000..dd4e917518 Binary files /dev/null and b/fvdb/notebooks/img/sparse_two.png differ diff --git a/fvdb/notebooks/img/transposed_sparse_convolution_diagram.svg b/fvdb/notebooks/img/transposed_sparse_convolution_diagram.svg new file mode 100644 index 0000000000..c9dfeedad2 --- /dev/null +++ b/fvdb/notebooks/img/transposed_sparse_convolution_diagram.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/fvdb/notebooks/img/two.png b/fvdb/notebooks/img/two.png new file mode 100644 index 0000000000..a2cdf248a4 Binary files /dev/null and b/fvdb/notebooks/img/two.png differ diff --git a/fvdb/notebooks/img/vdbtensor.svg b/fvdb/notebooks/img/vdbtensor.svg new file mode 100644 index 0000000000..b27295eca4 --- /dev/null +++ b/fvdb/notebooks/img/vdbtensor.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/fvdb/src/GridBatch.cpp b/fvdb/src/GridBatch.cpp index 4032a4aa7b..f40edb19ce 100644 --- a/fvdb/src/GridBatch.cpp +++ b/fvdb/src/GridBatch.cpp @@ -822,7 +822,8 @@ void GridBatch::buildDualFromPrimalGrid(const GridBatch& primalGrid, bool exclud std::vector GridBatch::voxels_along_rays(const JaggedTensor& ray_origins, const JaggedTensor& ray_directions, - int64_t max_vox, double eps, bool return_ijk) const { + int64_t max_vox, double eps, + bool return_ijk, bool cumulative) const { TORCH_CHECK_VALUE(ray_origins.ldim() == 1, "Expected ray_origins to have 1 list dimension, i.e. be a single list of coordinate values, but got", ray_origins.ldim(), "list dimensions" ); @@ -830,7 +831,7 @@ std::vector GridBatch::voxels_along_rays(const JaggedTensor& ray_o "Expected ray_directions to have 1 list dimension, i.e. be a single list of coordinate values, but got", ray_directions.ldim(), "list dimensions" ); return FVDB_DISPATCH_KERNEL_DEVICE(device(), [&]() { - return fvdb::detail::ops::dispatchVoxelsAlongRays(*impl(), ray_origins, ray_directions, max_vox, eps, return_ijk); + return fvdb::detail::ops::dispatchVoxelsAlongRays(*impl(), ray_origins, ray_directions, max_vox, eps, return_ijk, cumulative); }); } @@ -968,22 +969,22 @@ JaggedTensor GridBatch::coords_in_active_voxel(const JaggedTensor& ijk, bool ign } -JaggedTensor GridBatch::ijk_to_index(const JaggedTensor& ijk) const { +JaggedTensor GridBatch::ijk_to_index(const JaggedTensor& ijk, bool cumulative) const { TORCH_CHECK_VALUE(ijk.ldim() == 1, "Expected ijk to have 1 list dimension, i.e. be a single list of coordinate values, but got", ijk.ldim(), "list dimensions" ); return FVDB_DISPATCH_KERNEL_DEVICE(device(), [&]() { - return fvdb::detail::ops::dispatchIjkToIndex(*impl(), ijk); + return fvdb::detail::ops::dispatchIjkToIndex(*impl(), ijk, cumulative); }); } -JaggedTensor GridBatch::ijk_to_inv_index(const JaggedTensor& ijk) const { +JaggedTensor GridBatch::ijk_to_inv_index(const JaggedTensor& ijk, bool cumulative) const { TORCH_CHECK_VALUE(ijk.ldim() == 1, "Expected ijk to have 1 list dimension, i.e. be a single list of coordinate values, but got", ijk.ldim(), "list dimensions" ); return FVDB_DISPATCH_KERNEL_DEVICE(device(), [&]() { - return fvdb::detail::ops::dispatchIjkToInvIndex(*impl(), ijk); + return fvdb::detail::ops::dispatchIjkToInvIndex(*impl(), ijk, cumulative); }); } diff --git a/fvdb/src/GridBatch.h b/fvdb/src/GridBatch.h index 2cafd2e8d4..5743cabd4e 100644 --- a/fvdb/src/GridBatch.h +++ b/fvdb/src/GridBatch.h @@ -464,7 +464,8 @@ struct GridBatch : torch::CustomClassHolder { JaggedTensor disabled_mask() const; /// @brief Return whether each coordinate is in the grid batch or not - /// @param ijk A JaggedTensor of coordinates with shape [B, -1, 3] (one coordinate set per grid in the batch) + /// @param ijk A JaggedTensor of ijk coordinates with lshape [N_0, ..., N_B] and eshape (3,) + /// (one coordinate set per grid in the batch) /// @param ignore_disabled Whether to ignore voxels that have been disabled (only applicable to mutable grids) /// @return A JaggedTensor of booleans with shape [B, -1] (one boolean per coordinate) /// where the [bi, i]^th entry is true if coords[bi, i] lies inside the bi^th grid in the batch @@ -472,15 +473,19 @@ struct GridBatch : torch::CustomClassHolder { /// @brief Return the integer offset of each ijk value in the grid batch /// @param ijk A JaggedTensor of ijk coordinates with shape [B, -1, 3] (one coordinate set per grid in the batch) + /// @param cumulative Whether to return cumulative offsets in the batch or offsets relative to each grid /// @return A JaggedTensor of integer offsets with shape [B, -1] into the grid batch (one offset per coordinate) - JaggedTensor ijk_to_index(const JaggedTensor& ijk) const; + JaggedTensor ijk_to_index(const JaggedTensor& ijk, bool cumulative = false) const; /// @brief Return a JaggedTensor of integers such that if it is used as a permutation of the input IJK coordinates, /// it will re-order them to the indexing order of the grid batch. This effectively performs the inverse of - /// ijkToIndex if you pass in the ijk coordinates in the grid. - /// @param ijk A JaggedTensor of ijk coordinates with shape [B, -1, 3] (one coordinate set per grid in the batch) + /// ijk_to_index if you pass in the ijk coordinates in the grid. + /// i.e. output[ijk_to_index(ijk[i])] = i + /// @param ijk A JaggedTensor of ijk coordinates with lshape [N_0, ..., N_B] and eshape (3,) + /// (one coordinate set per grid in the batch) + /// @param cumulative Whether to return cumulative offsets in the batch or offsets relative to each grid /// @return A JaggedTensor of integers with shape [B, -1] (one integer per grids' ijk) which inverts ijkToIndex - JaggedTensor ijk_to_inv_index(const JaggedTensor& ijk) const; + JaggedTensor ijk_to_inv_index(const JaggedTensor& ijk, bool cumulative = false) const; /// @brief Return the set of active ijk coordinates indexed by this grid batch /// @return A JaggedTensor of voxel coordinates indexed by this grid batch (shape [B, -1, 3]) @@ -511,6 +516,8 @@ struct GridBatch : torch::CustomClassHolder { /// @param max_voxels The maximum number of voxels to return per ray /// @param eps Skip voxels where the ray intersects by less than this distance /// @param return_ijk Whether to return the voxel coordinates in the grid or world coordinates or the voxel index + /// @param cumulative Whether to return cumulative indices in the batch or indices relative to each grid + /// (only applicable to return_ijk = false, otherwise ignored) /// @return A pair of JaggedTensors containing the voxels (or voxel indices) intersected by the rays. i.e.: /// - voxels: A JaggedTensor with lshape [[V_{0,0}, ..., V_{0,N_0}], ..., [V_{B,0}, ..., V_{B,N_B}]] /// and eshape (3,) or (,) containing the ijk coordinates or indices of the voxels @@ -519,7 +526,8 @@ struct GridBatch : torch::CustomClassHolder { std::vector voxels_along_rays(const JaggedTensor& ray_origins, const JaggedTensor& ray_directions, int64_t max_voxels, double eps = 0.0, - bool return_ijk = true) const; + bool return_ijk = true, + bool cumulative = false) const; /// @brief Enumerate the continuous segments (regions which overlap active voxels) in this /// grid batch (in-sorted order) intersected by a collection of rays diff --git a/fvdb/src/JaggedTensor.cpp b/fvdb/src/JaggedTensor.cpp index 3d4ac07141..5486aa10e4 100644 --- a/fvdb/src/JaggedTensor.cpp +++ b/fvdb/src/JaggedTensor.cpp @@ -67,8 +67,8 @@ JaggedTensor::JaggedTensor(const std::vector& tensors) { torch::Device device = tensors[0].device(); std::vector jIdxs; - torch::Tensor elementCounts = torch::empty({(JOffsetsType) tensors.size() + 1}, torch::TensorOptions().dtype(JOffsetsScalarType).device(torch::kCPU)); - auto elementCountsAcc = elementCounts.accessor(); + mOffsets = torch::empty({(JOffsetsType) tensors.size() + 1}, torch::TensorOptions().dtype(JOffsetsScalarType).device(torch::kCPU)); + auto elementCountsAcc = mOffsets.accessor(); elementCountsAcc[0] = 0; jIdxs.reserve(tensors.size()); @@ -84,7 +84,8 @@ JaggedTensor::JaggedTensor(const std::vector& tensors) { jIdxs.push_back(torch::full({tensorsReshaped[i].size(0)}, (int) i, torch::TensorOptions().dtype(JIdxScalarType).device(tensorsReshaped[i].device()))); elementCountsAcc[i+1] = tensorsReshaped[i].size(0); } - mOffsets = torch::cumsum(elementCounts, 0).to(tensors[0].device()); + mOffsets = mOffsets.to(tensors[0].device()); + torch::cumsum_out(mOffsets, mOffsets, 0); mBatchIdx = torch::cat(jIdxs, 0); mData = torch::cat(tensorsReshaped, 0); mListIdx = torch::empty({0, 1}, torch::TensorOptions().dtype(JLIdxScalarType).device(device)); @@ -130,8 +131,8 @@ JaggedTensor::JaggedTensor(const std::vector>& tensor std::vector batchIdxs; batchIdxs.reserve(totalTensors); - torch::Tensor elementCounts = torch::empty({totalTensors + 1}, torch::TensorOptions().dtype(JOffsetsScalarType).device(torch::kCPU)); - auto elementCountsAcc = elementCounts.accessor(); + mOffsets = torch::empty({totalTensors + 1}, torch::TensorOptions().dtype(JOffsetsScalarType).device(torch::kCPU)); + auto elementCountsAcc = mOffsets.accessor(); elementCountsAcc[0] = 0; torch::Tensor listIndexes = torch::empty({totalTensors, (JLIdxType) 2}, torch::TensorOptions().dtype(JLIdxScalarType).device(torch::kCPU)); @@ -161,7 +162,8 @@ JaggedTensor::JaggedTensor(const std::vector>& tensor } } - mOffsets = torch::cumsum(elementCounts, 0).to(device);; + mOffsets = mOffsets.to(device); + torch::cumsum_out(mOffsets, mOffsets, 0); mBatchIdx = torch::cat(batchIdxs, 0); mData = torch::cat(tensorsReshaped, 0); mListIdx = listIndexes.to(device); @@ -472,60 +474,9 @@ JaggedTensor JaggedTensor::rmask(const torch::Tensor& mask) const { JaggedTensor JaggedTensor::index(JaggedTensorIndex idx) const { if (idx.is_integer()) { - auto idxVal = idx.integer(); - if (idxVal < 0) { - idxVal += mNumOuterLists; - } - TORCH_CHECK_INDEX(idxVal >= 0 && idxVal < mNumOuterLists, - "Index ", idx.integer(), " is out of bounds for JaggedTensor with ", - mNumOuterLists, " elements"); - - if (mListIdx.size(0) == 0) { - TORCH_CHECK(ldim() == 1, "bad list indexes. this should never happen"); - const JOffsetsType startIdx = mOffsets[idxVal].item(); - const JOffsetsType endIdx = mOffsets[idxVal+1].item(); - const torch::Tensor retJoffsets = torch::tensor({JOffsetsType(0), endIdx - startIdx}, torch::TensorOptions().dtype(JOffsetsScalarType).device(mData.device())); - const torch::Tensor retData = mData.index({torch::indexing::Slice(startIdx, endIdx)}); - const torch::Tensor retJidx = torch::empty({0}, torch::TensorOptions().dtype(JIdxScalarType)); - return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe( - retData, retJoffsets, retJidx, mListIdx, retJoffsets.size(0) - 1); - - } else { - TORCH_CHECK_VALUE(mListIdx.dim() == 2, "Corrupt list indices. This should never happen"); - TORCH_CHECK_VALUE(mListIdx.numel() == 0 || mListIdx.size(0) == (mOffsets.size(0) - 1), "Corrupt list indices. This should never happen"); - const torch::Tensor joffsetCat = torch::stack({ - mOffsets.index({torch::indexing::Slice(0, num_tensors())}), - mOffsets.index({torch::indexing::Slice(1, num_tensors()+1)}) - }, 1); - const torch::Tensor mask = mListIdx.index({torch::indexing::Slice(), 0}).eq(idxVal); - const torch::Tensor selectedOffsets = joffsetCat.index({mask}); - - const JOffsetsType startIdx = selectedOffsets[0][0].item(); - const JOffsetsType endIdx = selectedOffsets[-1][1].item(); - - const torch::Tensor retData = mData.index({torch::indexing::Slice(startIdx, endIdx)}); - - const torch::Tensor retOffsets = torch::cat({ - selectedOffsets.index({torch::indexing::Slice(), 0}), - selectedOffsets.index({-1, 1}).unsqueeze(0) - }) - startIdx; - torch::Tensor retListIdx; - int64_t retNumOuterLists; - if (mListIdx.size(1) > 1) { - retListIdx = mListIdx.index({mask, torch::indexing::Slice(1, mListIdx.size(1))}); - if (retListIdx.dim() == 0) { - retListIdx = retListIdx.unsqueeze(1); - } - retNumOuterLists = std::get<0>(torch::unique_dim(retListIdx, 0)).size(0); - } else { - retListIdx = torch::empty({0, 1}, torch::TensorOptions().dtype(JLIdxScalarType).device(mData.device())); - retNumOuterLists = retOffsets.size(0) - 1; - } - - const torch::Tensor retJidx = jidx_from_joffsets(retOffsets, retData.size(0)); - return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe(retData, retOffsets, retJidx, retListIdx, retNumOuterLists); - } - + return FVDB_DISPATCH_KERNEL_DEVICE(mData.device(), [&]() { + return detail::ops::dispatchJaggedTensorIndex(*this, idx.integer()); + }); } else if (idx.is_slice()) { int64_t start = idx.slice().start().as_int_unchecked(); int64_t end = idx.slice().stop().as_int_unchecked(); @@ -793,6 +744,7 @@ std::vector JaggedTensor::jmax(int64_t dim, bool keepdim) const { } JaggedTensor JaggedTensor::jcat(const std::vector& vec, c10::optional dimension) { + // Null dimension is just list concatenation if (!dimension.has_value()) { TORCH_CHECK_VALUE(vec.size() > 0, "Empty jagged tensor list"); @@ -835,50 +787,9 @@ JaggedTensor JaggedTensor::jcat(const std::vector& vec, c10::optio } if (dim == 0) { - const auto device = vec[0].device(); - const auto dtype = vec[0].scalar_type(); - - int64_t totalElements = 0; - for (const auto& jvec : vec) { - TORCH_CHECK_VALUE(jvec.joffsets().size(0) == vec[0].joffsets().size(0), - "All tensors must have the same number of lists"); - TORCH_CHECK_VALUE(jvec.jdata().dim() == vec[0].jdata().dim(), - "All tensors must have the same number of dimensions"); - TORCH_CHECK_VALUE(jvec.device() == device, "All tensors must be on the same device"); - TORCH_CHECK_VALUE(jvec.scalar_type() == dtype, "All tensors must have the same scalar type"); - totalElements += jvec.jdata().size(0); - } - const auto shape = fvdb::detail::spliceShape({totalElements}, vec[0].jdata()); - const JOffsetsType numOffsets = vec[0].joffsets().size(0); - - torch::Tensor outJdata = torch::empty(shape, torch::TensorOptions().device(device).dtype(dtype)); - torch::Tensor outJoffsets = torch::empty({numOffsets}, torch::TensorOptions().device(device).dtype(JOffsetsScalarType)); - torch::Tensor outJidx = torch::empty({totalElements}, torch::TensorOptions().device(device).dtype(JIdxScalarType)); - torch::Tensor outJLidx = vec[0].jlidx(); - const int64_t outNumOuterLists = vec[0].mNumOuterLists; - - JOffsetsType startOffset = 0; - for (JOffsetsType i = 0; i < numOffsets - 1; ++i) { - JOffsetsType numElements = 0; - - std::vector tensorsToCat; - tensorsToCat.reserve(vec.size()); - for (const auto& jvec : vec) { - const JOffsetsType startIdx = jvec.joffsets()[i].item(); - const JOffsetsType endIdx = jvec.joffsets()[i+1].item(); - torch::Tensor jdataSlice = jvec.jdata().index({torch::indexing::Slice(startIdx, endIdx)}); - tensorsToCat.push_back(jdataSlice); - numElements += (endIdx - startIdx); - } - - outJdata.index({torch::indexing::Slice(startOffset, startOffset + numElements)}).copy_(torch::cat(tensorsToCat, 0)); - outJidx.index({torch::indexing::Slice(startOffset, startOffset + numElements)}).copy_(torch::full({numElements}, i, torch::TensorOptions().dtype(JIdxScalarType).device(device))); - outJoffsets[i] = startOffset; - outJoffsets[i+1] = startOffset + numElements; - startOffset += numElements; - } - return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe(outJdata, outJoffsets, outJidx, outJLidx, outNumOuterLists); - + return FVDB_DISPATCH_KERNEL_DEVICE(vec[0].device(), [&]() { + return detail::ops::dispatchJCat0(vec); + }); } else { std::vector data; for (const auto& jvec : vec) { data.push_back(jvec.mData); } diff --git a/fvdb/src/JaggedTensor.h b/fvdb/src/JaggedTensor.h index 7bd6d0e4a9..eb94ed875d 100644 --- a/fvdb/src/JaggedTensor.h +++ b/fvdb/src/JaggedTensor.h @@ -129,13 +129,12 @@ class JaggedTensor : public torch::CustomClassHolder { void recompute_lsizes_if_dirty(); - static torch::Tensor joffsets_from_jidx_and_jdata(torch::Tensor jidx, torch::Tensor jdata, int64_t num_tensors); - static torch::Tensor jidx_from_joffsets(torch::Tensor joffsets, int64_t num_elements); - void binary_op_check(const JaggedTensor& other) const; public: + static torch::Tensor joffsets_from_jidx_and_jdata(torch::Tensor jidx, torch::Tensor jdata, int64_t num_tensors); + static torch::Tensor jidx_from_joffsets(torch::Tensor joffsets, int64_t num_elements); static JaggedTensor from_jdata_joffsets_jidx_and_lidx_unsafe(torch::Tensor jdata, torch::Tensor joffsets, torch::Tensor jidx, torch::Tensor jlidx, int64_t numOuterLists); @@ -222,8 +221,8 @@ class JaggedTensor : public torch::CustomClassHolder { /// @return The indices of this JaggedTensor const torch::Tensor& jidx() const { return mBatchIdx; } - /// @brief Get the offsets of each tensor indexed by this JaggedTensor. i.e. a tensor of size (num_tensors, 2) - /// where joffsets[i][0] is the start offset in jdata and joffsets[i][1] is the end offset in jdata + /// @brief Get the offsets of each tensor indexed by this JaggedTensor. i.e. a tensor of size (num_tensors + 1) + /// where joffsets[i] is the start offset in jdata and joffsets[i+1] is the end offset in jdata /// @return The offsets of each tensor indexed by this JaggedTensor const torch::Tensor& joffsets() const { return mOffsets; } diff --git a/fvdb/src/detail/GridBatchImpl.cu b/fvdb/src/detail/GridBatchImpl.cu index e5f860acb9..dd200f6aa2 100644 --- a/fvdb/src/detail/GridBatchImpl.cu +++ b/fvdb/src/detail/GridBatchImpl.cu @@ -154,6 +154,7 @@ void GridBatchImpl::syncMetadataToDeviceIfCUDA(bool blocking) { // We haven't allocated the cuda memory yet, so we need to do that now if (mDeviceGridMetadata == nullptr) { // We need to allocate the memory on the device + c10::cuda::CUDAGuard deviceGuard(device()); size_t metaDataByteSize = sizeof(GridMetadata) * mHostGridMetadata.size(); at::cuda::CUDAStream defaultStream = at::cuda::getCurrentCUDAStream(device().index()); mDeviceGridMetadata = static_cast(c10::cuda::CUDACachingAllocator::raw_alloc_with_stream(metaDataByteSize, defaultStream.stream())); @@ -293,6 +294,7 @@ void GridBatchImpl::setGrid(nanovdb::GridHandle&& gridHdl, // Allocate device memory for metadata GridBatchMetadata* deviceBatchMetadataPtr = nullptr; if constexpr (DeviceTag == torch::kCUDA) { + c10::cuda::CUDAGuard deviceGuard(device); const size_t metaDataByteSize = sizeof(GridMetadata) * gridHdl.gridCount(); at::cuda::CUDAStream defaultStream = at::cuda::getCurrentCUDAStream(device.index()); mDeviceGridMetadata = static_cast(c10::cuda::CUDACachingAllocator::raw_alloc_with_stream(metaDataByteSize, defaultStream.stream())); diff --git a/fvdb/src/detail/TorchDeviceBuffer.cpp b/fvdb/src/detail/TorchDeviceBuffer.cpp index 4ea4c8b4d0..0293050cbb 100644 --- a/fvdb/src/detail/TorchDeviceBuffer.cpp +++ b/fvdb/src/detail/TorchDeviceBuffer.cpp @@ -8,6 +8,7 @@ #include // for cudaMalloc/cudaMallocManaged/cudaFree #include +#include namespace nanovdb { @@ -164,16 +165,23 @@ void TorchDeviceBuffer::toCuda(torch::Device toDevice, bool blocking) { if (mDevice.is_cuda() && toDevice != mDevice) { // CUDA -> CUDA accross different devices std::unique_ptr buf(new uint8_t[mSize]); - at::cuda::CUDAStream currentStream = at::cuda::getCurrentCUDAStream(mDevice.index()); - at::cuda::CUDAStream toStream = at::cuda::getCurrentCUDAStream(toDevice.index()); - cudaCheck(cudaMemcpyAsync(buf.get(), mGpuData, mSize, cudaMemcpyDeviceToHost, currentStream.stream())); - cudaCheck(cudaStreamSynchronize(currentStream.stream())); - c10::cuda::CUDACachingAllocator::raw_delete(mGpuData); - mGpuData = reinterpret_cast(c10::cuda::CUDACachingAllocator::raw_alloc_with_stream(mSize, toStream.stream())); - cudaCheck(cudaMemcpyAsync(mGpuData, buf.get(), mSize, cudaMemcpyHostToDevice, toStream.stream())); + { + c10::cuda::CUDAGuard deviceGuard(mDevice); + at::cuda::CUDAStream currentStream = at::cuda::getCurrentCUDAStream(mDevice.index()); + cudaCheck(cudaMemcpyAsync(buf.get(), mGpuData, mSize, cudaMemcpyDeviceToHost, currentStream.stream())); + cudaCheck(cudaStreamSynchronize(currentStream.stream())); + c10::cuda::CUDACachingAllocator::raw_delete(mGpuData); + } + { + c10::cuda::CUDAGuard deviceGuard(toDevice); + at::cuda::CUDAStream toStream = at::cuda::getCurrentCUDAStream(toDevice.index()); + mGpuData = reinterpret_cast(c10::cuda::CUDACachingAllocator::raw_alloc_with_stream(mSize, toStream.stream())); + cudaCheck(cudaMemcpyAsync(mGpuData, buf.get(), mSize, cudaMemcpyHostToDevice, toStream.stream())); + } mDevice = toDevice; } else if (mDevice.is_cpu()) { // CPU -> CUDA TORCH_CHECK(toDevice.has_index(), "Invalid device must specify device index"); + c10::cuda::CUDAGuard deviceGuard(toDevice); at::cuda::CUDAStream stream = at::cuda::getCurrentCUDAStream(toDevice.index()); copyHostToDeviceAndFreeHost((void*) stream.stream(), blocking); mDevice = toDevice; @@ -212,6 +220,7 @@ void TorchDeviceBuffer::init(uint64_t size, void* data /* = nullptr */, bool hos if (data) { mGpuData = (uint8_t*) data; } else { + c10::cuda::CUDAGuard deviceGuard(mDevice); at::cuda::CUDAStream defaultStream = at::cuda::getCurrentCUDAStream(mDevice.index()); mGpuData = reinterpret_cast(c10::cuda::CUDACachingAllocator::raw_alloc_with_stream(size, defaultStream.stream())); checkPtr(mGpuData, "failed to allocate device data"); diff --git a/fvdb/src/detail/build/Build.h b/fvdb/src/detail/build/Build.h new file mode 100644 index 0000000000..f119f242ec --- /dev/null +++ b/fvdb/src/detail/build/Build.h @@ -0,0 +1,123 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#pragma once + +#include + +#include "detail/VoxelCoordTransform.h" +#include "detail/GridBatchImpl.h" + +#include "detail/utils/Utils.h" + + +namespace fvdb { +namespace detail { +namespace build { + +/// @brief Build an empty NanovVDB index grid or mutable index grid on the given device +/// @param device The device on which the grid will be allocated +/// @param isMutable Whether the grid should be mutable or not +/// @return A handle to the nanovdb grid +nanovdb::GridHandle buildEmptyGrid(torch::Device device, bool isMutable); + +/// @brief Build a NanoVDB grid encoding a dense 3D volume of voxels +/// @param device The device on which the grid will be allocated +/// @param isMutable Whether the grid should be mutable or not +/// @param batchSize The number of grids in the batch +/// @param size The size of the grid in voxels +/// @param ijkMin The coordinate of the bottom-back-left corner of the grid +/// @param mask An optional mask tensor that can be used to mask out some of the voxels (shape = size) +/// @return A handle to the nanovdb grid +nanovdb::GridHandle buildDenseGrid(torch::Device device, bool isMutable, + const uint32_t batchSize, + const nanovdb::Coord& size, + const nanovdb::Coord& ijkMin, + const torch::optional& mask); + +/// @brief Build a NanoVDB grid representing the coarse grid of a given fine grid +/// @param isMutable Whether the grid should be mutable or not +/// @param fineGridHdl The handle to the fine grid +/// @param branchingFactor The coarsening factor from the fine grid to the coarse grid (i.e. N = [2, 2, 2] for a 2x2x2 coarsening) +/// @return A handle to the nanovdb grid (the device will match fineGridHdl) +nanovdb::GridHandle buildCoarseGridFromFineGrid(bool isMutable, + const GridBatchImpl& fineGridHdl, + const nanovdb::Coord branchingFactor); + +/// @brief Build a NanoVDB grid representing the fine grid of a given coarse grid +/// @param isMutable Whether the grid should be mutable or not +/// @param coarseGridHdl The handle to the coarse grid +/// @param subdivMask An optional mask JaggedTensor that can be used to not refine certain voxels (shape = [B, -1] matching number of coarse voxels) +/// @param subdivisionFactor The refinement factor from the coarse grid to the fine grid (i.e. (2, 2, 2) for a 2x2x2 refinement) +/// @return A handle to the nanovdb grid (the device will match coarseGridHdl) +nanovdb::GridHandle buildFineGridFromCoarseGrid(bool isMutable, + const GridBatchImpl& coarseGridHdl, + const torch::optional& subdivMask, + const nanovdb::Coord subdivisionFactor); + +nanovdb::GridHandle buildConvGridFromGrid(bool isMutable, + const GridBatchImpl& baseGridHdl, + const nanovdb::Coord& kernelSize, const nanovdb::Coord& stride); + +/// @brief Build a NanoVDB grid which is a padded version of the given grid +/// @param isMutable Whether the grid should be mutable or not +/// @param baseGridHdl The handle to the base grid +/// @param bmin The padding in the negative direction +/// @param bmax The padding in the positive direction +/// @param excludeBorder Whether to exclude the border voxels from padding +/// @return A handle to the padded nanovdb grid (the device will match baseGridHdl) +nanovdb::GridHandle buildPaddedGridFromGrid(bool isMutable, + const GridBatchImpl& baseGridHdl, + int bmin, int bmax, bool excludeBorder); + +/// @brief Build a NanoVDB grid from a set of points and pad each voxel ijk which contains a point from ijk - bmin to ijk + bmax +/// @param device The device on which the grid will be allocated +/// @param isMutable Whether the grid should be mutable or not +/// @param points The points to be encoded in the grid (JaggedTensor of shape = (B, -1, 3)) +/// @param tx Transform from world to voxel coordinates +/// @param bmin The minimum padding (i.e. we pad ijk from ijk - bmin to ijk + bmax) +/// @param bmax The maximum padding (i.e. we pad ijk from ijk - bmin to ijk + bmax) +/// @return A handle to the nanovdb grid (the device will match points) +nanovdb::GridHandle buildPaddedGridFromPoints(bool isMutable, + const JaggedTensor& points, + const std::vector& tx, + const nanovdb::Coord& bmin, + const nanovdb::Coord& bmax); + +/// @brief Build a NanoVDB grid from a set of points where the 8 nearest voxels to each point are added to the grid +/// @param device The device on which the grid will be allocated +/// @param isMutable Whether the grid should be mutable or not +/// @param points The points to be encoded in the grid (JaggedTensor of shape = (B, -1, 3)) +/// @param tx Transform from world to voxel coordinates +/// @return A handle to the nanovdb grid (the device will match points) +nanovdb::GridHandle buildNearestNeighborGridFromPoints(bool isMutable, + const JaggedTensor& points, + const std::vector& tx); + +/// @brief Build a NanoVDB grid from a set of ijk coordinates pad each voxel from ijk - bmin to ijk + bmax +/// @param device The device on which the grid will be allocated +/// @param isMutable Whether the grid should be mutable or not +/// @param coords The ijk coordinates to be encoded in the grid (JaggedTensor of shape = (B, -1, 3)) +/// @param tx Transform from world to voxel coordinates +/// @param bmin The minimum padding (i.e. we pad ijk from ijk - bmin to ijk + bmax) +/// @param bmax The maximum padding (i.e. we pad ijk from ijk - bmin to ijk + bmax) +/// @return A handle to the nanovdb grid (the device will match coords) +nanovdb::GridHandle buildPaddedGridFromCoords(bool isMutable, + const JaggedTensor& coords, + const nanovdb::Coord& bmin, + const nanovdb::Coord& bmax); + + +/// @brief Build a NanoVDB grid by voxelizing a mesh (i.e. each voxel in the ouput grid intersects the mesh) +/// @param isMutable Whether the grid should be mutable or not +/// @param meshVertices A JaggedTensor of shape = (B, -1, 3) containing the vertices of each mesh to voxelize +/// @param meshFaces A JaggedTensor of shape = (B, -1, 3) containing the face indexes of each mesh to voxelize +/// @return A handle to the nanovdb grid (the device will match meshVertices and meshFaces) +nanovdb::GridHandle buildGridFromMesh(bool isMutable, + const JaggedTensor meshVertices, + const JaggedTensor meshFaces, + const std::vector& tx); + +} // namespace build +} // namespace detail +} // namespace fvdb \ No newline at end of file diff --git a/fvdb/src/detail/build/CoarseFromFine.cpp b/fvdb/src/detail/build/CoarseFromFine.cpp new file mode 100644 index 0000000000..6a403165b1 --- /dev/null +++ b/fvdb/src/detail/build/CoarseFromFine.cpp @@ -0,0 +1,75 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildCoarseGridFromFineGridCPU(const GridBatchImpl& fineBatchHdl, + const nanovdb::Coord branchingFactor) { + + using IndexTree = nanovdb::NanoTree; + + const nanovdb::GridHandle& fineGridHdl = fineBatchHdl.nanoGridHandle(); + + std::vector> batchHandles; + batchHandles.reserve(fineGridHdl.gridCount()); + for (uint32_t bidx = 0; bidx < fineGridHdl.gridCount(); bidx += 1) { + const nanovdb::NanoGrid* fineGrid = fineGridHdl.template grid(bidx); + if (!fineGrid) { + throw std::runtime_error("Failed to get pointer to nanovdb index grid"); + } + const IndexTree& fineTree = fineGrid->tree(); + + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + for (auto it = ActiveVoxelIterator(fineTree); it.isValid(); it++) { + const nanovdb::Coord coarseIjk = (it->first.asVec3d() / branchingFactor.asVec3d()).floor(); + proxyGridAccessor.setValue(coarseIjk, 1.0f); + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + +nanovdb::GridHandle buildCoarseGridFromFineGrid(bool isMutable, + const GridBatchImpl& fineBatchHdl, + const nanovdb::Coord branchingFactor) { + if (fineBatchHdl.device().is_cuda()) { + JaggedTensor coords = ops::dispatchCoarseIJKForFineGrid(fineBatchHdl, branchingFactor); + return ops::dispatchCreateNanoGridFromIJK(coords, isMutable); + } else { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return buildCoarseGridFromFineGridCPU(fineBatchHdl, branchingFactor); + }); + } +} + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/ConvGrid.cpp b/fvdb/src/detail/build/ConvGrid.cpp new file mode 100644 index 0000000000..455cfdf9a9 --- /dev/null +++ b/fvdb/src/detail/build/ConvGrid.cpp @@ -0,0 +1,145 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + +template +nanovdb::GridHandle buildCoarseGridFromFineGridCPU(const GridBatchImpl& fineBatchHdl, + const nanovdb::Coord branchingFactor) { + + using IndexTree = nanovdb::NanoTree; + + const nanovdb::GridHandle& fineGridHdl = fineBatchHdl.nanoGridHandle(); + + std::vector> batchHandles; + batchHandles.reserve(fineGridHdl.gridCount()); + for (uint32_t bidx = 0; bidx < fineGridHdl.gridCount(); bidx += 1) { + const nanovdb::NanoGrid* fineGrid = fineGridHdl.template grid(bidx); + if (!fineGrid) { + throw std::runtime_error("Failed to get pointer to nanovdb index grid"); + } + const IndexTree& fineTree = fineGrid->tree(); + + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + for (auto it = ActiveVoxelIterator(fineTree); it.isValid(); it++) { + const nanovdb::Coord coarseIjk = (it->first.asVec3d() / branchingFactor.asVec3d()).floor(); + proxyGridAccessor.setValue(coarseIjk, 1.0f); + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + +template +nanovdb::GridHandle buildConvGridFromGridCPU(const GridBatchImpl& baseBatchHdl, + const nanovdb::Coord& kernelSize, + const nanovdb::Coord& stride) { + + if (stride == nanovdb::Coord(1) || stride == kernelSize) { + return buildCoarseGridFromFineGridCPU(baseBatchHdl, stride); + } + + const nanovdb::GridHandle& baseGridHdl = baseBatchHdl.nanoGridHandle(); + std::vector> batchHandles; + batchHandles.reserve(baseGridHdl.gridCount()); + + int lower[3], upper[3]; + for (int i = 0; i < 3; i += 1) { + if (kernelSize[i] % 2 == 0) { + lower[i] = 0; upper[i] = kernelSize[i] - 1; + } else { + lower[i] = -(kernelSize[i] - 1) / 2; + upper[i] = (kernelSize[i] - 1) / 2; + } + } + + for (uint32_t bidx = 0; bidx < baseGridHdl.gridCount(); bidx += 1) { + + const nanovdb::NanoGrid* baseGrid = baseGridHdl.template grid(bidx); + if (!baseGrid) { + throw std::runtime_error("Failed to get pointer to nanovdb index grid"); + } + + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + for (auto it = ActiveVoxelIterator(baseGrid->tree()); it.isValid(); it++) { + const nanovdb::Coord& ijk0 = it->first; + + for (int di = lower[0]; di <= upper[0]; di += 1) { + for (int dj = lower[1]; dj <= upper[1]; dj += 1) { + for (int dk = lower[2]; dk <= upper[2]; dk += 1) { + const nanovdb::Coord dstIjk = ijk0 + nanovdb::Coord(dk, dj, di); + if (dstIjk[0] % stride[2] != 0 || dstIjk[1] % stride[1] != 0 || dstIjk[2] % stride[0] != 0) continue; + proxyGridAccessor.setValue(nanovdb::Coord( + dstIjk[0] / stride[2], dstIjk[1] / stride[1], dstIjk[2] / stride[0]), 1.0f); + } + } + } + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + +nanovdb::GridHandle buildConvGridFromGrid(bool isMutable, + const GridBatchImpl& baseGridHdl, + const nanovdb::Coord& kernelSize, + const nanovdb::Coord& stride) { + /** + * Logic for building the conv grid is the same as torchsparse 2.0.0b. + * However, torchsparse has a bug that creates excessive voxels in the void space, it is fixed in a customized + * branch - hence the additional URL for pre-built wheels. + */ + + if (baseGridHdl.device().is_cuda()) { + JaggedTensor coords = ops::dispatchConvIJKForGrid(baseGridHdl, kernelSize, stride); + return ops::dispatchCreateNanoGridFromIJK(coords, isMutable); + } else { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return buildConvGridFromGridCPU(baseGridHdl, kernelSize, stride); + }); + } +} + + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/DenseGrid.cpp b/fvdb/src/detail/build/DenseGrid.cpp new file mode 100644 index 0000000000..2a37717928 --- /dev/null +++ b/fvdb/src/detail/build/DenseGrid.cpp @@ -0,0 +1,104 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildDenseGridCPU(const uint32_t batchSize, + const nanovdb::Coord& size, + const nanovdb::Coord& ijkMin, + torch::optional mask) { + + torch::TensorAccessor maskAccessor(nullptr, nullptr, nullptr); + if (mask.has_value()) { + maskAccessor = mask.value().accessor(); + } + + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(0.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + for (int32_t i = 0; i < size[0]; i += 1) { + for (int32_t j = 0; j < size[1]; j += 1) { + for (int32_t k = 0; k < size[2]; k += 1) { + const nanovdb::Coord ijk = ijkMin + nanovdb::Coord(i, j, k); + if (mask.has_value()) { + if (maskAccessor[i][j][k] == false) { + continue; + } else { + proxyGridAccessor.setValue(ijk, 1.0f); + } + } else { + proxyGridAccessor.setValue(ijk, 1.0f); + } + } + } + } + + proxyGridAccessor.merge(); + nanovdb::GridHandle ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true /* sync */); + + TorchDeviceBuffer guide(0, nullptr); + guide.setDevice(torch::kCPU, true); + + std::vector> batchHandles; + batchHandles.reserve(batchSize); + batchHandles.push_back(std::move(ret)); + for (uint32_t i = 1; i < batchSize; i += 1) { + batchHandles.push_back(batchHandles[0].copy(guide)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + + +nanovdb::GridHandle buildDenseGrid(torch::Device device, bool isMutable, + const uint32_t batchSize, + const nanovdb::Coord& size, + const nanovdb::Coord& ijkMin, + const torch::optional& mask) { + + TORCH_CHECK(size[0] > 0 && size[1] > 0 && size[2] > 0, "Size must be greater than 0 in all dimensions"); + TORCH_CHECK((__uint128_t) size[0] * size[1] * size[2] <= std::numeric_limits::max(), + "Size of dense grid exceeds the number of voxels supported by a GridBatch"); + TORCH_CHECK((__uint128_t) size[0] * size[1] * size[2] * batchSize <= std::numeric_limits::max(), + "Size and batch size exceed the number of voxels supported by a GridBatch"); + if (mask.has_value()) { + TORCH_CHECK(mask.value().device() == device, "Mask device must match device of dense grid to build"); + TORCH_CHECK(mask.value().dtype() == torch::kBool, "Mask must be of type bool"); + TORCH_CHECK(mask.value().dim() == 3, "Mask must be 3D"); + TORCH_CHECK(mask.value().size(0) == size[0] && mask.value().size(1) == size[1] && mask.value().size(2) == size[2], + "Mask must have same size as dense grid to build"); + } + if (device.is_cuda()) { + return ops::dispatchCreateNanoGridFromDense(batchSize, ijkMin, size, isMutable, device, mask); + } else { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return buildDenseGridCPU(batchSize, size, ijkMin, mask); + }); + } +} + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/EmptyGrid.cpp b/fvdb/src/detail/build/EmptyGrid.cpp new file mode 100644 index 0000000000..b490125b84 --- /dev/null +++ b/fvdb/src/detail/build/EmptyGrid.cpp @@ -0,0 +1,34 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include "detail/utils/Utils.h" + +#include +#include +#include + + +namespace fvdb { +namespace detail { +namespace build { + + +nanovdb::GridHandle buildEmptyGrid(torch::Device device, bool isMutable) { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(0.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(device, true /* sync */); + return ret; + }); +} + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/FineFromCoarse.cpp b/fvdb/src/detail/build/FineFromCoarse.cpp new file mode 100644 index 0000000000..efa6c41ff4 --- /dev/null +++ b/fvdb/src/detail/build/FineFromCoarse.cpp @@ -0,0 +1,99 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildFineGridFromCoarseGridCPU(const GridBatchImpl& coarseBatchHdl, + const torch::Tensor& subdivMask, + const nanovdb::Coord subdivisionFactor) { + + using IndexTree = nanovdb::NanoTree; + + const nanovdb::GridHandle& coarseGridHdl = coarseBatchHdl.nanoGridHandle(); + const torch::TensorAccessor& subdivMaskAcc = subdivMask.accessor(); + + std::vector> batchHandles; + batchHandles.reserve(coarseGridHdl.gridCount()); + for (uint32_t bidx = 0; bidx < coarseGridHdl.gridCount(); bidx += 1) { + const nanovdb::NanoGrid* coarseGrid = coarseGridHdl.template grid(bidx); + if (!coarseGrid) { + throw std::runtime_error("Failed to get pointer to nanovdb index grid"); + } + const IndexTree& coarseTree = coarseGrid->tree(); + + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + for (auto it = ActiveVoxelIterator(coarseTree); it.isValid(); it++) { + const nanovdb::Coord baseIjk(it->first[0] * subdivisionFactor[0], + it->first[1] * subdivisionFactor[1], + it->first[2] * subdivisionFactor[2]); + + if (subdivMaskAcc.size(0) > 0 && !subdivMaskAcc[it->second]) { + continue; + } + + for (int i = 0; i < subdivisionFactor[0]; i += 1) { + for (int j = 0; j < subdivisionFactor[1]; j += 1) { + for (int k = 0; k < subdivisionFactor[2]; k += 1) { + const nanovdb::Coord fineIjk = baseIjk + nanovdb::Coord(i, j, k); + proxyGridAccessor.setValue(fineIjk, 1); + } + } + } + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + +nanovdb::GridHandle buildFineGridFromCoarseGrid(bool isMutable, + const GridBatchImpl& coarseBatchHdl, + const torch::optional& subdivMask, + const nanovdb::Coord subdivisionFactor) { + + if (coarseBatchHdl.device().is_cuda()) { + JaggedTensor coords = ops::dispatchFineIJKForCoarseGrid(coarseBatchHdl, subdivisionFactor, subdivMask); + return ops::dispatchCreateNanoGridFromIJK(coords, isMutable); + } else { + torch::Tensor subdivMaskTensor; + if (subdivMask.has_value()) { + subdivMaskTensor = subdivMask.value().jdata(); + } else { + subdivMaskTensor = torch::zeros(0, torch::TensorOptions().dtype(torch::kBool)); + } + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return buildFineGridFromCoarseGridCPU(coarseBatchHdl, subdivMaskTensor, subdivisionFactor); + }); + } +} + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/FromMesh.cpp b/fvdb/src/detail/build/FromMesh.cpp new file mode 100644 index 0000000000..cda2254ced --- /dev/null +++ b/fvdb/src/detail/build/FromMesh.cpp @@ -0,0 +1,110 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildGridFromMeshCPU(const JaggedTensor& vertices, + const JaggedTensor& triangles, + const std::vector& tx) { + + using Vec3T = nanovdb::math::Vec3; + using ProxyGridT = nanovdb::tools::build::Grid; + + + std::vector> batchHandles; + batchHandles.reserve(vertices.num_outer_lists()); + + for (int64_t bidx = 0; bidx < vertices.num_outer_lists(); bidx += 1) { + + const torch::Tensor ti = triangles.index({bidx}).jdata(); + const torch::Tensor vi = vertices.index({bidx}).jdata(); + const VoxelCoordTransform& txi = tx[bidx]; + + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + // int64_t numSearched = 0; + // int64_t numFound = 0; + // For eacjh face, compute thee min max voxels + for (int faceId = 0; faceId < ti.size(0); faceId += 1) { + const torch::Tensor face = ti.index({faceId}); // 3 + const torch::Tensor faceVertices = vi.index({face}); // [3, 3] + torch::TensorAccessor faceVerticesAcc = faceVertices.accessor(); + const Vec3T v1 = txi.apply(Vec3T(faceVerticesAcc[0][0], faceVerticesAcc[0][1], faceVerticesAcc[0][2])); + const Vec3T v2 = txi.apply(Vec3T(faceVerticesAcc[1][0], faceVerticesAcc[1][1], faceVerticesAcc[1][2])); + const Vec3T v3 = txi.apply(Vec3T(faceVerticesAcc[2][0], faceVerticesAcc[2][1], faceVerticesAcc[2][2])); + + const Vec3T e1 = v2 - v1; + const Vec3T e2 = v3 - v1; + const ScalarType spacing = sqrt(3.0) / 3.0; // This is very conservative spacing but fine for now + const int32_t numU = ceil((e1.length() + spacing) / spacing); + const int32_t numV = ceil((e2.length() + spacing) / spacing); + + // numSearched += (numU * numV); + for (int i = 0; i < numU; i += 1) { + for (int j = 0; j < numV; j += 1) { + ScalarType u = ScalarType(i) / (ScalarType(std::max(numU - 1, 1))); + ScalarType v = ScalarType(j) / (ScalarType(std::max(numV - 1, 1))); + if (u + v >= 1.0) { + u = 1.0 - u; + v = 1.0 - v; + } + const Vec3T p = v1 + e1 * u + e2 * v; + const nanovdb::Coord ijk = p.round(); + + proxyGridAccessor.setValue(ijk, 1.0f); + // numFound += 1; + } + } + } + + // std::cerr << "I searched over " << numSearched << " voxels" << std::endl; + // std::cerr << "I found " << numFound << " voxels" << std::endl; + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + +nanovdb::GridHandle buildGridFromMesh(bool isMutable, + const JaggedTensor meshVertices, + const JaggedTensor meshFaces, + const std::vector& tx) { + if (meshVertices.device().is_cuda()) { + JaggedTensor coords = ops::dispatchIJKForMesh(meshVertices, meshFaces, tx); + return ops::dispatchCreateNanoGridFromIJK(coords, isMutable); + } else { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return AT_DISPATCH_FLOATING_TYPES(meshVertices.scalar_type(), "buildGridFromMeshCPU", [&]() { + return buildGridFromMeshCPU(meshVertices, meshFaces, tx); + }); + }); + } +} + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/NearestNeighborGridFromPoints.cpp b/fvdb/src/detail/build/NearestNeighborGridFromPoints.cpp new file mode 100644 index 0000000000..d763990513 --- /dev/null +++ b/fvdb/src/detail/build/NearestNeighborGridFromPoints.cpp @@ -0,0 +1,103 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildNearestNeighborGridFromPointsCPU(const JaggedTensor& jaggedPoints, + const std::vector& txs) { + + return AT_DISPATCH_FLOATING_TYPES_AND_HALF(jaggedPoints.scalar_type(), "buildNearestNeighborGridFromPoints", [&]() { + using ScalarT = scalar_t; + using MathT = typename at::opmath_type; + using Vec3T = typename nanovdb::math::Vec3; + using ProxyGridT = nanovdb::tools::build::Grid; + + static_assert(is_floating_point_or_half::value, "Invalid type for points, must be floating point"); + + jaggedPoints.check_valid(); + + const torch::TensorAccessor& pointsAcc = jaggedPoints.jdata().accessor(); + const torch::TensorAccessor& pointsBOffsetsAcc = jaggedPoints.joffsets().accessor(); + + std::vector> batchHandles; + batchHandles.reserve(pointsBOffsetsAcc.size(0) - 1); + for (int bi = 0; bi < (pointsBOffsetsAcc.size(0) - 1); bi += 1) { + + const VoxelCoordTransform& tx = txs[bi]; + + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + const int64_t start = pointsBOffsetsAcc[bi]; + const int64_t end = pointsBOffsetsAcc[bi+1]; + + for (int64_t pi = start; pi < end; pi += 1) { + Vec3T ijk0 = tx.apply(static_cast(pointsAcc[pi][0]), + static_cast(pointsAcc[pi][1]), + static_cast(pointsAcc[pi][2])); + nanovdb::Coord ijk000 = ijk0.floor(); + nanovdb::Coord ijk001 = ijk000 + nanovdb::Coord(0, 0, 1); + nanovdb::Coord ijk010 = ijk000 + nanovdb::Coord(0, 1, 0); + nanovdb::Coord ijk011 = ijk000 + nanovdb::Coord(0, 1, 1); + nanovdb::Coord ijk100 = ijk000 + nanovdb::Coord(1, 0, 0); + nanovdb::Coord ijk101 = ijk000 + nanovdb::Coord(1, 0, 1); + nanovdb::Coord ijk110 = ijk000 + nanovdb::Coord(1, 1, 0); + nanovdb::Coord ijk111 = ijk000 + nanovdb::Coord(1, 1, 1); + + proxyGridAccessor.setValue(ijk000, 11.0f); + proxyGridAccessor.setValue(ijk001, 11.0f); + proxyGridAccessor.setValue(ijk010, 11.0f); + proxyGridAccessor.setValue(ijk011, 11.0f); + proxyGridAccessor.setValue(ijk100, 11.0f); + proxyGridAccessor.setValue(ijk101, 11.0f); + proxyGridAccessor.setValue(ijk110, 11.0f); + proxyGridAccessor.setValue(ijk111, 11.0f); + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } + }); +} + + +nanovdb::GridHandle buildNearestNeighborGridFromPoints(bool isMutable, + const JaggedTensor& points, + const std::vector& txs) { + if (points.device().is_cuda()) { + JaggedTensor coords = ops::dispatchNearestNeighborIJKForPoints(points, txs); + return ops::dispatchCreateNanoGridFromIJK(coords, isMutable); + } else { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return buildNearestNeighborGridFromPointsCPU(points, txs); + }); + } +} + + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/PaddedGridFromCoords.cpp b/fvdb/src/detail/build/PaddedGridFromCoords.cpp new file mode 100644 index 0000000000..c45554d361 --- /dev/null +++ b/fvdb/src/detail/build/PaddedGridFromCoords.cpp @@ -0,0 +1,91 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildPaddedGridFromCoordsCPU(const JaggedTensor& jaggedCoords, + const nanovdb::Coord& bmin, + const nanovdb::Coord& bmax) { + + return AT_DISPATCH_INTEGRAL_TYPES(jaggedCoords.scalar_type(), "buildPaddedGridFromCoords", [&]() { + using ScalarT = scalar_t; + jaggedCoords.check_valid(); + + static_assert(std::is_integral::value, "Invalid type for coords, must be integral"); + + using ProxyGridT = nanovdb::tools::build::Grid; + + const torch::TensorAccessor& coordsAcc = jaggedCoords.jdata().accessor(); + const torch::TensorAccessor& coordsBOffsetsAcc = jaggedCoords.joffsets().accessor(); + + std::vector> batchHandles; + batchHandles.reserve(coordsBOffsetsAcc.size(0) - 1); + for (int bi = 0; bi < (coordsBOffsetsAcc.size(0) - 1); bi += 1) { + + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + const int64_t start = coordsBOffsetsAcc[bi]; + const int64_t end = coordsBOffsetsAcc[bi+1]; + + for (unsigned ci = start; ci < end; ci += 1) { + nanovdb::Coord ijk0(coordsAcc[ci][0], coordsAcc[ci][1], coordsAcc[ci][2]); + + // Splat the normal to the 8 neighboring voxels + for (int di = bmin[0]; di <= bmax[0]; di += 1) { + for (int dj = bmin[1]; dj <= bmax[1]; dj += 1) { + for (int dk = bmin[2]; dk <= bmax[2]; dk += 1) { + const nanovdb::Coord ijk = ijk0 + nanovdb::Coord(di, dj, dk); + proxyGridAccessor.setValue(ijk, 11); + } + } + } + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } + }); +} + + +nanovdb::GridHandle buildPaddedGridFromCoords(bool isMutable, + const JaggedTensor& coords, + const nanovdb::Coord& bmin, + const nanovdb::Coord& bmax) { + if (coords.device().is_cuda()) { + JaggedTensor buildCoords = ops::dispatchPaddedIJKForCoords(coords, bmin, bmax); + return ops::dispatchCreateNanoGridFromIJK(buildCoords, isMutable); + } else { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return buildPaddedGridFromCoordsCPU(coords, bmin, bmax); + }); + } +} +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/PaddedGridFromGrid.cpp b/fvdb/src/detail/build/PaddedGridFromGrid.cpp new file mode 100644 index 0000000000..3108545806 --- /dev/null +++ b/fvdb/src/detail/build/PaddedGridFromGrid.cpp @@ -0,0 +1,144 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildPaddedGridFromGridWithoutBorderCPU(const GridBatchImpl& baseBatchHdl, int BMIN, int BMAX) { + TORCH_CHECK(BMIN <= BMAX, "BMIN must be less than BMAX"); + + const nanovdb::GridHandle& baseGridHdl = baseBatchHdl.nanoGridHandle(); + + std::vector> batchHandles; + batchHandles.reserve(baseGridHdl.gridCount()); + for (uint32_t bidx = 0; bidx < baseGridHdl.gridCount(); bidx += 1) { + + const nanovdb::NanoGrid* baseGrid = baseGridHdl.template grid(bidx); + if (!baseGrid) { + throw std::runtime_error("Failed to get pointer to nanovdb index grid"); + } + auto baseGridAccessor = baseGrid->getAccessor(); + + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + for (auto it = ActiveVoxelIterator(baseGrid->tree()); it.isValid(); it++) { + nanovdb::Coord ijk0 = it->first; + bool active = true; + for (int di = BMIN; di <= BMAX && active; di += 1) { + for (int dj = BMIN; dj <= BMAX && active; dj += 1) { + for (int dk = BMIN; dk <= BMAX && active; dk += 1) { + const nanovdb::Coord ijk = ijk0 + nanovdb::Coord(di, dj, dk); + if (ijk != ijk0) { + active = active && baseGridAccessor.isActive(ijk); // if any surrounding is off, turn it off. + } + } + } + } + if (active) { + proxyGridAccessor.setValue(ijk0, 1.0f); + } + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + + +template +nanovdb::GridHandle buildPaddedGridFromGridCPU(const GridBatchImpl& baseBatchHdl, int BMIN, int BMAX) { + TORCH_CHECK(BMIN <= BMAX, "BMIN must be less than BMAX"); + + const nanovdb::GridHandle& baseGridHdl = baseBatchHdl.nanoGridHandle(); + + std::vector> batchHandles; + batchHandles.reserve(baseGridHdl.gridCount()); + for (uint32_t bidx = 0; bidx < baseGridHdl.gridCount(); bidx += 1) { + + const nanovdb::NanoGrid* baseGrid = baseGridHdl.template grid(bidx); + if (!baseGrid) { + throw std::runtime_error("Failed to get pointer to nanovdb index grid"); + } + + using ProxyGridT = nanovdb::tools::build::Grid; + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + for (auto it = ActiveVoxelIterator(baseGrid->tree()); it.isValid(); it++) { + nanovdb::Coord ijk0 = it->first; + for (int di = BMIN; di <= BMAX; di += 1) { + for (int dj = BMIN; dj <= BMAX; dj += 1) { + for (int dk = BMIN; dk <= BMAX; dk += 1) { + const nanovdb::Coord ijk = ijk0 + nanovdb::Coord(di, dj, dk); + proxyGridAccessor.setValue(ijk, 1.0f); + } + } + } + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } +} + + +nanovdb::GridHandle buildPaddedGridFromGrid(bool isMutable, + const GridBatchImpl& baseBatchHdl, + int bmin, int bmax, bool excludeBorder) { + if (baseBatchHdl.device().is_cuda()) { + JaggedTensor coords; + if (excludeBorder) { + coords = ops::dispatchPaddedIJKForGridWithoutBorder(baseBatchHdl, nanovdb::Coord(bmin), nanovdb::Coord(bmax)); + } else { + coords = ops::dispatchPaddedIJKForGrid(baseBatchHdl, nanovdb::Coord(bmin), nanovdb::Coord(bmax)); + } + return ops::dispatchCreateNanoGridFromIJK(coords, isMutable); + } else { + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + if (excludeBorder) { + return buildPaddedGridFromGridWithoutBorderCPU(baseBatchHdl, bmin, bmax); + } else { + return buildPaddedGridFromGridCPU(baseBatchHdl, bmin, bmax); + } + }); + } +} + + + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/build/PaddedGridFromPoints.cpp b/fvdb/src/detail/build/PaddedGridFromPoints.cpp new file mode 100644 index 0000000000..55a0871686 --- /dev/null +++ b/fvdb/src/detail/build/PaddedGridFromPoints.cpp @@ -0,0 +1,99 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// +#include "Build.h" + +#include +#include +#include + +#include "detail/utils/Utils.h" +#include "detail/ops/Ops.h" + + +namespace fvdb { +namespace detail { +namespace build { + + +template +nanovdb::GridHandle buildPaddedGridFromPointsCPU(const JaggedTensor& pointsJagged, + const std::vector& txs, + const nanovdb::Coord& bmin, + const nanovdb::Coord& bmax) { + return AT_DISPATCH_FLOATING_TYPES_AND_HALF(pointsJagged.scalar_type(), "buildPaddedGridFromPoints", [&](){ + using ScalarT = scalar_t; + static_assert(is_floating_point_or_half::value, "Invalid type for points, must be floating point"); + using MathT = typename at::opmath_type; + using ProxyGridT = nanovdb::tools::build::Grid; + + pointsJagged.check_valid(); + + const torch::TensorAccessor& pointsAcc = pointsJagged.jdata().accessor(); + const torch::TensorAccessor& pointsBOffsetsAcc = pointsJagged.joffsets().accessor(); + + std::vector> batchHandles; + batchHandles.reserve(pointsBOffsetsAcc.size(0) - 1); + for (int bi = 0; bi < (pointsBOffsetsAcc.size(0) - 1); bi += 1) { + VoxelCoordTransform tx = txs[bi]; + + auto proxyGrid = std::make_shared(-1.0f); + auto proxyGridAccessor = proxyGrid->getWriteAccessor(); + + const int64_t start = pointsBOffsetsAcc[bi]; + const int64_t end = pointsBOffsetsAcc[bi+1]; + + for (int64_t pi = start; pi < end; pi += 1) { + + nanovdb::Coord ijk0 = tx.apply(static_cast(pointsAcc[pi][0]), + static_cast(pointsAcc[pi][1]), + static_cast(pointsAcc[pi][2])).round(); + + // Splat the normal to the 8 neighboring voxels + for (int di = bmin[0]; di <= bmax[0]; di += 1) { + for (int dj = bmin[1]; dj <= bmax[1]; dj += 1) { + for (int dk = bmin[2]; dk <= bmax[2]; dk += 1) { + const nanovdb::Coord ijk = ijk0 + nanovdb::Coord(di, dj, dk); + proxyGridAccessor.setValue(ijk, 1.0f); + } + } + } + } + + proxyGridAccessor.merge(); + auto ret = nanovdb::tools::createNanoGrid(*proxyGrid, 0u, false, false); + ret.buffer().setDevice(torch::kCPU, true); + batchHandles.push_back(std::move(ret)); + } + + if (batchHandles.size() == 1) { + return std::move(batchHandles[0]); + } else { + return nanovdb::mergeGrids(batchHandles); + } + }); +} + + +nanovdb::GridHandle buildPaddedGridFromPoints(bool isMutable, + const JaggedTensor& points, + const std::vector& txs, + const nanovdb::Coord& bmin, + const nanovdb::Coord& bmax) { + if (points.device().is_cuda()) { + JaggedTensor coords = ops::dispatchPaddedIJKForPoints(points, bmin, bmax, txs); + return ops::dispatchCreateNanoGridFromIJK(coords, isMutable); + + } else { + + return FVDB_DISPATCH_GRID_TYPES_MUTABLE(isMutable, [&]() { + return buildPaddedGridFromPointsCPU(points, txs, bmin, bmax); + }); + } +} + + + +} // namespace build +} // namespace detail +} // namespace fvdb diff --git a/fvdb/src/detail/ops/IjkToIndex.cu b/fvdb/src/detail/ops/IjkToIndex.cu index 078dfe649e..6a05afa7ea 100644 --- a/fvdb/src/detail/ops/IjkToIndex.cu +++ b/fvdb/src/detail/ops/IjkToIndex.cu @@ -31,7 +31,7 @@ __hostdev__ inline void ijkToIndexCallback(int32_t bidx, int32_t eidx, template -JaggedTensor IjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) { +JaggedTensor IjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative) { batchHdl.checkNonEmptyGrid(); batchHdl.checkDevice(ijk); TORCH_CHECK_TYPE(at::isIntegralType(ijk.scalar_type(), false), "ijk must have an integer type"); @@ -51,12 +51,12 @@ JaggedTensor IjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) auto outIndexAcc = tensorAccessor(outIndex); if constexpr (DeviceTag == torch::kCUDA) { auto cb = [=] __device__ (int32_t bidx, int32_t eidx, int32_t cidx, JaggedRAcc32 ijkAcc) { - ijkToIndexCallback(bidx, eidx, batchAcc, ijkAcc, outIndexAcc, true); + ijkToIndexCallback(bidx, eidx, batchAcc, ijkAcc, outIndexAcc, cumulative); }; forEachJaggedElementChannelCUDA(512, 1, ijk, cb); } else { auto cb = [=] (int32_t bidx, int32_t eidx, int32_t cidx, JaggedAcc ijkAcc) { - ijkToIndexCallback(bidx, eidx, batchAcc, ijkAcc, outIndexAcc, true); + ijkToIndexCallback(bidx, eidx, batchAcc, ijkAcc, outIndexAcc, cumulative); }; forEachJaggedElementChannelCPU(1, ijk, cb); } @@ -68,13 +68,13 @@ JaggedTensor IjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) template <> -JaggedTensor dispatchIjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) { - return IjkToIndex(batchHdl, ijk); +JaggedTensor dispatchIjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative) { + return IjkToIndex(batchHdl, ijk, cumulative); } template <> -JaggedTensor dispatchIjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) { - return IjkToIndex(batchHdl, ijk); +JaggedTensor dispatchIjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative) { + return IjkToIndex(batchHdl, ijk, cumulative); } diff --git a/fvdb/src/detail/ops/IjkToInvIndex.cu b/fvdb/src/detail/ops/IjkToInvIndex.cu index a9bc6586ee..1945bc372c 100644 --- a/fvdb/src/detail/ops/IjkToInvIndex.cu +++ b/fvdb/src/detail/ops/IjkToInvIndex.cu @@ -14,21 +14,23 @@ template batchAccessor, const JaggedAccessor ijk, - TensorAccessor outInvIndex) { + TensorAccessor outInvIndex, + bool cumulative) { const nanovdb::NanoGrid* grid = batchAccessor.grid(bidx); const auto acc = grid->getAccessor(); const auto ijkCoord = ijk.data()[eidx]; const nanovdb::Coord vox(ijkCoord[0], ijkCoord[1], ijkCoord[2]); if (acc.isActive(vox)) { + const int64_t baseOffset = cumulative ? 0 : batchAccessor.voxelOffset(bidx); const int64_t index = (int64_t) acc.getValue(vox) - 1 + batchAccessor.voxelOffset(bidx); - outInvIndex[index] = eidx; + outInvIndex[index] = eidx - baseOffset; } } template -JaggedTensor IjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) { +JaggedTensor IjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative) { batchHdl.checkNonEmptyGrid(); batchHdl.checkDevice(ijk); TORCH_CHECK_TYPE(at::isIntegralType(ijk.scalar_type(), false), "ijk must have an integer type"); @@ -50,12 +52,12 @@ JaggedTensor IjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ij if constexpr (DeviceTag == torch::kCUDA) { auto cb = [=] __device__ (int32_t bidx, int32_t eidx, int32_t cidx, JaggedRAcc32 ijkAcc) { - ijkToInvIndexCallback(bidx, eidx, batchAcc, ijkAcc, outInvIndexAcc); + ijkToInvIndexCallback(bidx, eidx, batchAcc, ijkAcc, outInvIndexAcc, cumulative); }; - forEachJaggedElementChannelCUDA(1024, 1, ijk, cb); + forEachJaggedElementChannelCUDA(512, 1, ijk, cb); } else { auto cb = [=] (int32_t bidx, int32_t eidx, int32_t cidx, JaggedAcc ijkAcc) { - ijkToInvIndexCallback(bidx, eidx, batchAcc, ijkAcc, outInvIndexAcc); + ijkToInvIndexCallback(bidx, eidx, batchAcc, ijkAcc, outInvIndexAcc, cumulative); }; forEachJaggedElementChannelCPU(1, ijk, cb); } @@ -67,13 +69,13 @@ JaggedTensor IjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ij template <> -JaggedTensor dispatchIjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) { - return IjkToInvIndex(batchHdl, ijk); +JaggedTensor dispatchIjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative) { + return IjkToInvIndex(batchHdl, ijk, cumulative); } template <> -JaggedTensor dispatchIjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk) { - return IjkToInvIndex(batchHdl, ijk); +JaggedTensor dispatchIjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative) { + return IjkToInvIndex(batchHdl, ijk, cumulative); } } // namespace ops diff --git a/fvdb/src/detail/ops/JCat0.cu b/fvdb/src/detail/ops/JCat0.cu new file mode 100644 index 0000000000..9054e6d443 --- /dev/null +++ b/fvdb/src/detail/ops/JCat0.cu @@ -0,0 +1,193 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// + + +#include +#include +#include + +#include "detail/ops/Ops.h" +#include "detail/utils/Utils.h" +#include "detail/utils/cuda/Utils.cuh" + +namespace fvdb { +namespace detail { +namespace ops { + +__global__ void computeTensorSizes(const JOffsetsType* __restrict__ const* __restrict__ offsets, + const size_t numOffsets, TorchRAcc32 outTensorSizes) { + int32_t idx = blockIdx.x * blockDim.x + threadIdx.x; + + if (idx > outTensorSizes.size(0) - 1) { + return; + } + + // Calculate the size of the concatenated output tensor + JOffsetsType tensorSize = 0; + for (size_t i = 0; i < numOffsets; ++i) { + tensorSize += offsets[i][idx + 1] - offsets[i][idx]; + } + outTensorSizes[idx+1] = tensorSize; + + // One thread will write out the zero in the begining + if (idx == 0) { + outTensorSizes[0] = 0; + } +} + +template +__global__ void computeIndexPutArg(const size_t jti, const JOffsetsType* __restrict__ const* __restrict__ offsets, const size_t numOffsets, + const TorchRAcc32 inJIdxI, // Jidx of the i^th input tensor + const TorchRAcc32 inJoffsetsI, // JOffsets of the i^th input tensor + const TorchRAcc32 outJOffsets, // Output JOffsets (already computed earlier) + TorchRAcc32 outSelIdx, // Output selection indices + TorchRAcc32 outJIdx) { // Output Jidx + int32_t idx = blockIdx.x * blockDim.x + threadIdx.x; + const int64_t numElements = inJIdxI.size(0); + + if (idx >= numElements) { + return; + } + + const JIdxType jidx = inJIdxI[idx]; // Which tensor this element belongs to + + // Where in the output tensor we're going to write to + JOffsetsType tensorWriteOffset = 0; + for (size_t i = 0; i < jti; ++i){ + tensorWriteOffset += offsets[i][jidx + 1] - offsets[i][jidx]; + } + + const JOffsetsType writeBaseOffset = outJOffsets[jidx]; // Start of the concatenated tensor in the output + const JOffsetsType tensorOffsetOut = writeBaseOffset + tensorWriteOffset; // Start of where we're copying the input tensor to in the output + const JOffsetsType tensorOffsetIn = inJoffsetsI[jidx]; // Start of the tensor in the input + const JOffsetsType elementOffsetInTensor = idx - tensorOffsetIn; // Which element in the tensor we are copying + + outSelIdx[idx] = elementOffsetInTensor + tensorOffsetOut; // Which element in the output the current input element will go to + outJIdx[elementOffsetInTensor] = jidx; // Which tensor the current element belongs to in the output +} + + +template <> +JaggedTensor dispatchJCat0(const std::vector& vec) { + int64_t totalElements = 0; + int64_t maxElements = 0; + thrust::host_vector offsets; + offsets.reserve(vec.size()); + + auto size_0 = vec[0].jdata().sizes(); + auto dtype_0 = vec[0].jdata().dtype(); + for (auto& jt : vec) { + totalElements += jt.jdata().size(0); + maxElements = std::max(maxElements, jt.jdata().size(0)); + offsets.push_back(jt.joffsets().data_ptr()); + TORCH_CHECK_VALUE(jt.joffsets().size(0) == vec[0].joffsets().size(0), "All jagged tensors must have the same number of tensors"); + TORCH_CHECK_VALUE(jt.joffsets().is_contiguous(), "All jagged tensors must have contiguous offsets"); + TORCH_CHECK_VALUE(jt.device().is_cuda(), "All jagged tensors must be on the same device"); + TORCH_CHECK(jt.jdata().dtype() == dtype_0, "All jagged tensors must have the same dtype"); + auto sizes_i = jt.jdata().sizes(); + for (size_t i = 1; i < sizes_i.size(); ++i) { + TORCH_CHECK_VALUE(sizes_i[i] == size_0[i], "All jagged tensors must have the same eshape"); + } + } + + thrust::device_vector offsets_d = offsets; + torch::Tensor outJOffsets = torch::empty({vec[0].joffsets().size(0)}, torch::TensorOptions().dtype(JOffsetsScalarType).device(torch::kCUDA)); + const int64_t numThreadsCalcTensorSizes = 1024; + const int64_t numBlocksCalcTensorSizes = GET_BLOCKS(outJOffsets.size(0), numThreadsCalcTensorSizes); + computeTensorSizes<<>>( + thrust::raw_pointer_cast(offsets_d.data()), offsets_d.size(), outJOffsets.packed_accessor32()); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + torch::cumsum_out(outJOffsets, outJOffsets, 0); + + auto outShape = spliceShape({totalElements}, vec[0].jdata()); + torch::Tensor outJData = torch::empty(outShape, torch::TensorOptions().dtype(vec[0].scalar_type()).device(torch::kCUDA)); + torch::Tensor outJIdx = torch::empty({totalElements}, torch::TensorOptions().dtype(JIdxScalarType).device(torch::kCUDA)); + + c10::ScalarType idxType = torch::kInt32; + if (maxElements < std::numeric_limits::max()) { + idxType = torch::kInt32; + } else if (maxElements < std::numeric_limits::max()) { + idxType = torch::kInt64; + } else { + TORCH_CHECK(false, "Cannot handle more than ", std::numeric_limits::max(), " elements"); + } + + torch::Tensor selectIndices = torch::zeros({maxElements}, torch::TensorOptions().dtype(idxType).device(torch::kCUDA)); + for (size_t jti = 0; jti < vec.size(); ++jti) { + const JaggedTensor& jt = vec[jti]; + AT_DISPATCH_INTEGRAL_TYPES(selectIndices.scalar_type(), "computeIndexPutArg", [&] { + const int64_t numElements = jt.jdata().size(0); + const int64_t numThreadsComputeIndexPutArg = 1024; + const int64_t numBlocksComputeIndexPutArg = GET_BLOCKS(numElements, numThreadsComputeIndexPutArg); + computeIndexPutArg<<>>( + jti, thrust::raw_pointer_cast(offsets_d.data()), offsets_d.size(), + jt.jidx().packed_accessor32(), + jt.joffsets().packed_accessor32(), + outJOffsets.packed_accessor32(), + selectIndices.packed_accessor32(), + outJIdx.packed_accessor32()); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + + torch::Tensor selIdxI = selectIndices.index({torch::indexing::Slice(0, numElements)}); + + outJData.index_put_({selIdxI, torch::indexing::Ellipsis}, jt.jdata()); + }); + } + + return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe( + outJData, outJOffsets, outJIdx, vec[0].jlidx(), vec[0].num_outer_lists()); +} + +template <> +JaggedTensor dispatchJCat0(const std::vector& vec) { + const auto device = vec[0].device(); + const auto dtype = vec[0].scalar_type(); + + int64_t totalElements = 0; + for (const auto& jvec : vec) { + TORCH_CHECK_VALUE(jvec.joffsets().size(0) == vec[0].joffsets().size(0), + "All tensors must have the same number of lists"); + TORCH_CHECK_VALUE(jvec.jdata().dim() == vec[0].jdata().dim(), + "All tensors must have the same number of dimensions"); + TORCH_CHECK_VALUE(jvec.device() == device, "All tensors must be on the same device"); + TORCH_CHECK_VALUE(jvec.scalar_type() == dtype, "All tensors must have the same scalar type"); + totalElements += jvec.jdata().size(0); + } + const auto shape = fvdb::detail::spliceShape({totalElements}, vec[0].jdata()); + const JOffsetsType numOffsets = vec[0].joffsets().size(0); + + torch::Tensor outJdata = torch::empty(shape, torch::TensorOptions().device(device).dtype(dtype)); + torch::Tensor outJoffsets = torch::empty({numOffsets}, torch::TensorOptions().device(device).dtype(JOffsetsScalarType)); + torch::Tensor outJidx = torch::empty({totalElements}, torch::TensorOptions().device(device).dtype(JIdxScalarType)); + torch::Tensor outJLidx = vec[0].jlidx(); + const int64_t outNumOuterLists = vec[0].num_outer_lists(); + + JOffsetsType startOffset = 0; + for (JOffsetsType i = 0; i < numOffsets - 1; ++i) { + JOffsetsType numElements = 0; + + std::vector tensorsToCat; + tensorsToCat.reserve(vec.size()); + for (const auto& jvec : vec) { + const JOffsetsType startIdx = jvec.joffsets()[i].item(); + const JOffsetsType endIdx = jvec.joffsets()[i+1].item(); + torch::Tensor jdataSlice = jvec.jdata().index({torch::indexing::Slice(startIdx, endIdx)}); + tensorsToCat.push_back(jdataSlice); + numElements += (endIdx - startIdx); + } + + outJdata.index({torch::indexing::Slice(startOffset, startOffset + numElements)}).copy_(torch::cat(tensorsToCat, 0)); + outJidx.index({torch::indexing::Slice(startOffset, startOffset + numElements)}).copy_(torch::full({numElements}, i, torch::TensorOptions().dtype(JIdxScalarType).device(device))); + outJoffsets[i] = startOffset; + outJoffsets[i+1] = startOffset + numElements; + startOffset += numElements; + } + return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe(outJdata, outJoffsets, outJidx, outJLidx, outNumOuterLists); +} + + + +} // namespace ops +} // namespace detail +} // namespace fvdb \ No newline at end of file diff --git a/fvdb/src/detail/ops/JOffsetsFromJIdx.cu b/fvdb/src/detail/ops/JOffsetsFromJIdx.cu index 70ff9a0230..557bf57837 100644 --- a/fvdb/src/detail/ops/JOffsetsFromJIdx.cu +++ b/fvdb/src/detail/ops/JOffsetsFromJIdx.cu @@ -21,6 +21,7 @@ __global__ void setZero(T* thingToSet) { template <> torch::Tensor dispatchJOffsetsForJIdx(torch::Tensor jidx, torch::Tensor jdata, int64_t numTensors) { TORCH_CHECK_VALUE(jdata.device().is_cuda(), "Invalid device for jdata"); + c10::cuda::CUDAGuard deviceGuard(jdata.device()); if (jidx.size(0) == 0 && numTensors == 1) { torch::Tensor ret = torch::empty({2}, JOffsetsScalarType); diff --git a/fvdb/src/detail/ops/JaggedTensorIndex.cu b/fvdb/src/detail/ops/JaggedTensorIndex.cu new file mode 100644 index 0000000000..f50d100bfe --- /dev/null +++ b/fvdb/src/detail/ops/JaggedTensorIndex.cu @@ -0,0 +1,226 @@ +// Copyright Contributors to the OpenVDB Project +// SPDX-License-Identifier: MPL-2.0 +// + + +#include +#include +#include + +#include "detail/ops/Ops.h" +#include "detail/utils/Utils.h" +#include "detail/utils/cuda/Utils.cuh" + +namespace fvdb { +namespace detail { +namespace ops { + +// __global__ void makeJOffsetsForListJt(const TorchRAcc32 inJoffsets, int64_t idxVal, +// TorchRAcc32 outJoffsets) { +// JOffsetsType startIdx = inJoffsets[idxVal]; +// JOffsetsType endIdx = inJoffsets[idxVal + 1]; +// outJoffsets[0] = 0; +// outJoffsets[1] = endIdx - startIdx; +// } + + +__global__ void getJOffsetsMask(const int64_t idxVal, + const TorchRAcc32 jlidx, + const TorchRAcc32 inJoffsets, + TorchRAcc32 offsetsAndRange) { + int32_t idx = threadIdx.x + blockIdx.x * blockDim.x; + + if (idx >= jlidx.size(0)) { + return; + } + + JLIdxType lid = jlidx[idx][0]; + JLIdxType prevLid = -1; + if (idx - 1 >= 0) { + prevLid = jlidx[idx - 1][0]; + } + const bool lidMatches = lid == idxVal; + const bool prevLidMatches = prevLid == idxVal; + const bool isLastIdx = idx == (jlidx.size(0) - 1); + + if (lidMatches && !prevLidMatches) { + offsetsAndRange[0] = inJoffsets[idx]; + offsetsAndRange[2] = idx; + } + + if (!lidMatches && prevLidMatches) { + offsetsAndRange[1] = inJoffsets[idx]; + offsetsAndRange[3] = idx; + } else if (lidMatches && isLastIdx) { + offsetsAndRange[1] = inJoffsets[idx + 1]; + offsetsAndRange[3] = idx + 1; + } +} + + +// __global__ void computeJLidx(const int64_t startIdx, const int64_t idxVal, +// const TorchRAcc32 inJLIdx, +// TorchRAcc32 outJLidx) { +// int32_t idx = threadIdx.x + blockIdx.x * blockDim.x; + +// if (idx >= outJLidx.size(0)) { +// return; +// } +// outJLidx[idx][0] = inJLIdx[idx + startIdx][0] - idxVal; +// outJLidx[idx][1] = inJLIdx[idx + startIdx][1]; +// } + + +JaggedTensor jaggedTensorIndexMultiListCuda(const JaggedTensor& jt, int64_t idxVal) { + if (idxVal < 0) { + idxVal += jt.num_outer_lists(); + } + TORCH_CHECK_INDEX(idxVal >= 0 && idxVal < jt.num_outer_lists(), + "Index ", idxVal, " is out of bounds for JaggedTensor with ", + jt.num_outer_lists(), " elements"); + + torch::Tensor joffsets = jt.joffsets(); + torch::Tensor jdata = jt.jdata(); + torch::Tensor jlidx = jt.jlidx(); + + TORCH_CHECK_VALUE(jlidx.dim() == 2, "Corrupt list indices. This should never happen"); + TORCH_CHECK_VALUE(jlidx.numel() == 0 || jlidx.size(0) == (joffsets.size(0) - 1), "Corrupt list indices. This should never happen"); + + torch::Tensor offsetsAndRange = torch::empty({4}, torch::TensorOptions().dtype(JOffsetsScalarType).device(torch::kCPU).pinned_memory(true)); + offsetsAndRange = offsetsAndRange.to(jt.device()); + auto inJLidxAcc = jlidx.packed_accessor32(); + auto inJOffsetsAcc = joffsets.packed_accessor32(); + auto offsetsAndRangeAcc = offsetsAndRange.packed_accessor32(); + const int numBlocks = GET_BLOCKS(joffsets.size(0), 1024); + getJOffsetsMask<<>>(idxVal, inJLidxAcc, inJOffsetsAcc, offsetsAndRangeAcc); + C10_CUDA_KERNEL_LAUNCH_CHECK(); + + offsetsAndRange = offsetsAndRange.cpu(); + const JOffsetsType elementStartOffset = offsetsAndRange[0].item(); + const JOffsetsType elementEndOffset = offsetsAndRange[1].item(); + const JOffsetsType startIdx = offsetsAndRange[2].item(); + const JOffsetsType endIdx = offsetsAndRange[3].item(); + torch::Tensor retOffsets = joffsets.index({torch::indexing::Slice(startIdx, endIdx+1)}) - elementStartOffset; + const torch::Tensor retData = jdata.index({torch::indexing::Slice(elementStartOffset, elementEndOffset)}); + + torch::Tensor retListIdx; + int64_t retNumOuterLists; + if (jlidx.size(1) > 1 && jlidx.size(1) > 2) { + TORCH_CHECK(false, "We don't support ldim > 2."); + // const auto lidxOpts = torch::TensorOptions().dtype(JLIdxScalarType).device(jdata.device()); + // retListIdx = torch::empty({retOffsets.size(0)-1, 2}, lidxOpts); + // auto outJLidxAcc = retListIdx.packed_accessor32(); + // const int numBlocksJLidx = GET_BLOCKS(retListIdx.size(0), 1024); + // computeJLidx<<>>(startIdx, idxVal, inJLidxAcc, outJLidxAcc); + // C10_CUDA_KERNEL_LAUNCH_CHECK(); + // retNumOuterLists = std::get<0>(torch::unique_dim(retListIdx, 0)).size(0); + } else { + retListIdx = torch::empty({0, 1}, torch::TensorOptions().dtype(JLIdxScalarType).device(jdata.device())); + retNumOuterLists = retOffsets.size(0) - 1; + } + + const torch::Tensor retJidx = JaggedTensor::jidx_from_joffsets(retOffsets, retData.size(0)); + return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe(retData, retOffsets, retJidx, retListIdx, retNumOuterLists); +} + + + + + +JaggedTensor jaggedTensorIndexMultiListCpu(const JaggedTensor& jt, int64_t idxVal) { + if (idxVal < 0) { + idxVal += jt.num_outer_lists(); + } + TORCH_CHECK_INDEX(idxVal >= 0 && idxVal < jt.num_outer_lists(), + "Index ", idxVal, " is out of bounds for JaggedTensor with ", + jt.num_outer_lists(), " elements"); + + torch::Tensor joffsets = jt.joffsets(); + torch::Tensor jdata = jt.jdata(); + torch::Tensor jlidx = jt.jlidx(); + + TORCH_CHECK_VALUE(jlidx.dim() == 2, "Corrupt list indices. This should never happen"); + TORCH_CHECK_VALUE(jlidx.numel() == 0 || jlidx.size(0) == (joffsets.size(0) - 1), "Corrupt list indices. This should never happen"); + const torch::Tensor joffsetCat = torch::stack({ + joffsets.index({torch::indexing::Slice(0, jt.num_tensors())}), + joffsets.index({torch::indexing::Slice(1, jt.num_tensors()+1)}) + }, 1); + const torch::Tensor mask = jlidx.index({torch::indexing::Slice(), 0}).eq(idxVal); + const torch::Tensor selectedOffsets = joffsetCat.index({mask}); + + const JOffsetsType startIdx = selectedOffsets[0][0].item(); + const JOffsetsType endIdx = selectedOffsets[-1][1].item(); + + const torch::Tensor retData = jdata.index({torch::indexing::Slice(startIdx, endIdx)}); + + const torch::Tensor retOffsets = torch::cat({ + selectedOffsets.index({torch::indexing::Slice(), 0}), + selectedOffsets.index({-1, 1}).unsqueeze(0) + }) - startIdx; + torch::Tensor retListIdx; + int64_t retNumOuterLists; + if (jlidx.size(1) > 1 && jlidx.size(1) > 2) { + TORCH_CHECK(false, "We don't support ldim > 2."); + // retListIdx = jlidx.index({mask, torch::indexing::Slice(1, jlidx.size(1))}); + // if (retListIdx.dim() == 0) { + // retListIdx = retListIdx.unsqueeze(1); + // } + // retNumOuterLists = std::get<0>(torch::unique_dim(retListIdx, 0)).size(0); + } else { + retListIdx = torch::empty({0, 1}, torch::TensorOptions().dtype(JLIdxScalarType).device(jdata.device())); + retNumOuterLists = retOffsets.size(0) - 1; + } + + const torch::Tensor retJidx = JaggedTensor::jidx_from_joffsets(retOffsets, retData.size(0)); + return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe(retData, retOffsets, retJidx, retListIdx, retNumOuterLists); +} + + +JaggedTensor jaggedTensorIndexOneList(const JaggedTensor& jt, int64_t idxVal) { + if (idxVal < 0) { + idxVal += jt.num_outer_lists(); + } + TORCH_CHECK_INDEX(idxVal >= 0 && idxVal < jt.num_outer_lists(), + "Index ", idxVal, " is out of bounds for JaggedTensor with ", + jt.num_outer_lists(), " elements"); + + torch::Tensor joffsets = jt.joffsets(); + torch::Tensor jdata = jt.jdata(); + torch::Tensor jlidx = jt.jlidx(); + + TORCH_CHECK(jt.ldim() == 1, "bad list indexes. this should never happen"); + const JOffsetsType startIdx = joffsets[idxVal].item(); + const JOffsetsType endIdx = joffsets[idxVal+1].item(); + const torch::Tensor retJoffsets = torch::tensor({JOffsetsType(0), endIdx - startIdx}, torch::TensorOptions().dtype(JOffsetsScalarType).device(jdata.device())); + const torch::Tensor retData = jdata.index({torch::indexing::Slice(startIdx, endIdx)}); + const torch::Tensor retJidx = torch::empty({0}, torch::TensorOptions().dtype(JIdxScalarType)); + return JaggedTensor::from_jdata_joffsets_jidx_and_lidx_unsafe( + retData, retJoffsets, retJidx, jlidx, retJoffsets.size(0) - 1); +} + + + +template <> +JaggedTensor dispatchJaggedTensorIndex(const JaggedTensor& jt, int64_t idxVal) { + if (jt.jlidx().size(0) == 0) { + return jaggedTensorIndexOneList(jt, idxVal); + } else { + return jaggedTensorIndexMultiListCpu(jt, idxVal); + } +} + + +template <> +JaggedTensor dispatchJaggedTensorIndex(const JaggedTensor& jt, int64_t idxVal) { + if (jt.jlidx().size(0) == 0) { + return jaggedTensorIndexOneList(jt, idxVal); + } else { + return jaggedTensorIndexMultiListCuda(jt, idxVal); + } +} + + + +} // namespace ops +} // namespace detail +} // namespace fvdb \ No newline at end of file diff --git a/fvdb/src/detail/ops/Ops.h b/fvdb/src/detail/ops/Ops.h index c10a7e5a94..0596c373b0 100644 --- a/fvdb/src/detail/ops/Ops.h +++ b/fvdb/src/detail/ops/Ops.h @@ -14,6 +14,12 @@ namespace fvdb { namespace detail { namespace ops { +template +JaggedTensor dispatchJaggedTensorIndex(const JaggedTensor& jt, int64_t idxVal); + +template +JaggedTensor dispatchJCat0(const std::vector& tensors); + template torch::Tensor dispatchJOffsetsForJIdx(torch::Tensor jidx, torch::Tensor jdata, int64_t numTensors); @@ -74,7 +80,7 @@ void dispatchFillToGrid(const GridBatchImpl& fromGrid, torch::Tensor& toFeatures); template -JaggedTensor dispatchIjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk); +JaggedTensor dispatchIjkToInvIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative); template @@ -180,7 +186,7 @@ JaggedTensor dispatchVoxelNeighborhood(const GridBatchImpl& batchHdl, template -JaggedTensor dispatchIjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk); +JaggedTensor dispatchIjkToIndex(const GridBatchImpl& batchHdl, const JaggedTensor& ijk, bool cumulative); template @@ -261,7 +267,8 @@ std::vector dispatchVoxelsAlongRays(const GridBatchImpl& batchHdl, const JaggedTensor& rayDirections, int64_t maxVox, float eps, - bool returnIjk); + bool returnIjk, + bool cumulative); diff --git a/fvdb/src/detail/ops/SampleRaysUniform.cu b/fvdb/src/detail/ops/SampleRaysUniform.cu index 94bf849648..28795e7c4f 100644 --- a/fvdb/src/detail/ops/SampleRaysUniform.cu +++ b/fvdb/src/detail/ops/SampleRaysUniform.cu @@ -282,8 +282,8 @@ JaggedTensor UniformRaySamples(const GridBatchImpl& batchHdl, TORCH_CHECK_VALUE(batchHdl.batchSize() == rayOrigins.num_outer_lists(), "ray_origins must have the same batch size as the grid batch"); TORCH_CHECK_VALUE(batchHdl.batchSize() == rayDirections.num_outer_lists(), "ray_directions must have the same batch size as the grid batch"); - TORCH_CHECK_VALUE(batchHdl.batchSize() == tMin.num_outer_lists(), "ray_directions must have the same batch size as the grid batch"); - TORCH_CHECK_VALUE(batchHdl.batchSize() == tMax.num_outer_lists(), "ray_directions must have the same batch size as the grid batch"); + TORCH_CHECK_VALUE(batchHdl.batchSize() == tMin.num_outer_lists(), "t_min must have the same batch size as the grid batch"); + TORCH_CHECK_VALUE(batchHdl.batchSize() == tMax.num_outer_lists(), "t_max must have the same batch size as the grid batch"); TORCH_CHECK_TYPE(rayOrigins.dtype() == rayDirections.dtype(), "all tensors must have the same type"); TORCH_CHECK_TYPE(tMin.dtype() == tMin.dtype(), "all tensors must have the same type"); diff --git a/fvdb/src/detail/ops/ScaledDotProductAttention.cu b/fvdb/src/detail/ops/ScaledDotProductAttention.cu index 4c269f7128..ed6d3c45c6 100644 --- a/fvdb/src/detail/ops/ScaledDotProductAttention.cu +++ b/fvdb/src/detail/ops/ScaledDotProductAttention.cu @@ -3,10 +3,12 @@ // #include #include -#include +#if (defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ >= 12) +#include #define JSON_HAS_RANGES 0 #include +#endif #include "detail/utils/cuda/Utils.cuh" #include "detail/utils/BezierInterpolationIterator.h" @@ -29,6 +31,7 @@ torch::Tensor dispatchScaledDotProductAttention(const torch::Tenso bool training, float scale) { +#if (defined(__CUDACC_VER_MAJOR__) && __CUDACC_VER_MAJOR__ >= 12) // TODO: Cache built execution graph and plans! // Get dimensions: query (B*Sq, H, D), key (B*Skv, H, D), value (B*Skv, H, T) // https://github.com/NVIDIA/cudnn-frontend/blob/main/docs/operations/Attention.md @@ -175,6 +178,11 @@ torch::Tensor dispatchScaledDotProductAttention(const torch::Tenso cudnnDestroy(handle); return output; + +#else + TORCH_CHECK(false, "CUDNN frontend not available for CUDA < 12.0"); + +#endif } diff --git a/fvdb/src/detail/ops/VoxelsAlongRays.cu b/fvdb/src/detail/ops/VoxelsAlongRays.cu index 9c79b36d3f..29b327c8bd 100644 --- a/fvdb/src/detail/ops/VoxelsAlongRays.cu +++ b/fvdb/src/detail/ops/VoxelsAlongRays.cu @@ -23,7 +23,8 @@ __hostdev__ void voxelsAlongRaysCallback(int32_t bidx, int32_t rayIdx, TensorAccessor outTimes, // [B*M*S, 2] GridBatchImpl::Accessor batchAccessor, int64_t maxVox, - ScalarType eps) { + ScalarType eps, + bool cumulative) { const nanovdb::NanoGrid* gpuGrid = batchAccessor.grid(bidx); const VoxelCoordTransform& transform = batchAccessor.dualTransform(bidx); @@ -54,26 +55,29 @@ __hostdev__ void voxelsAlongRaysCallback(int32_t bidx, int32_t rayIdx, int32_t ijkIdx = -1; if constexpr (!returnIjk) { - ijkIdx = primalAcc.getValue(ijk) + batchAccessor.voxelOffset(bidx) - 1; + const int64_t baseOffset = cumulative ? batchAccessor.voxelOffset(bidx) : 0; + ijkIdx = primalAcc.getValue(ijk) - 1 + baseOffset; } if (deltaT < eps) { continue; } // This check handles numerical errors where we can accidentally add the same voxel twice - bool lastMatch = false; - if constexpr (returnIjk) { - lastMatch = (ijk[0] == outVoxels[startIdx + numVox - 1][0] && - ijk[1] == outVoxels[startIdx + numVox - 1][1] && - ijk[2] == outVoxels[startIdx + numVox - 1][2]); - } else { - lastMatch = (ijkIdx == outVoxels[startIdx + numVox - 1][0]); - } - if (numVox > 0 && lastMatch) { - outTimes[startIdx + numVox - 1][0] = c10::cuda::compat::min(t0, outTimes[startIdx + numVox - 1][0]); - outTimes[startIdx + numVox - 1][1] = c10::cuda::compat::max(t1, outTimes[startIdx + numVox - 1][1]); - outJIdx[startIdx + numVox - 1] = rayIdx; - continue; + if (numVox > 0) { + bool lastMatch = false; + if constexpr (returnIjk) { + lastMatch = (ijk[0] == outVoxels[startIdx + numVox - 1][0] && + ijk[1] == outVoxels[startIdx + numVox - 1][1] && + ijk[2] == outVoxels[startIdx + numVox - 1][2]); + } else { + lastMatch = (ijkIdx == outVoxels[startIdx + numVox - 1][0]); + } + if (lastMatch) { + outTimes[startIdx + numVox - 1][0] = c10::cuda::compat::min(t0, outTimes[startIdx + numVox - 1][0]); + outTimes[startIdx + numVox - 1][1] = c10::cuda::compat::max(t1, outTimes[startIdx + numVox - 1][1]); + outJIdx[startIdx + numVox - 1] = rayIdx; + continue; + } } if constexpr (returnIjk) { @@ -146,7 +150,7 @@ std::vector VoxelsAlongRays(const GridBatchImpl& batchHdl, const JaggedTensor& rayOrigins, const JaggedTensor& rayDirections, int64_t maxVox, float eps, - bool returnIjk) { + bool returnIjk, bool cumulative) { batchHdl.checkNonEmptyGrid(); batchHdl.checkDevice(rayOrigins); batchHdl.checkDevice(rayDirections); @@ -228,7 +232,7 @@ std::vector VoxelsAlongRays(const GridBatchImpl& batchHdl, rayOriginsAcc, rayDirectionsAcc, outJOffsetsAcc, outJIdxAcc, outJLIdxAcc, outVoxelsAcc, outTimesAcc, - batchAcc, maxVox, eps); + batchAcc, maxVox, eps, cumulative); }; auto cbIdx = [=] __device__ (int32_t bidx, int32_t eidx, int32_t cidx, JaggedRAcc32 rayOriginsAcc) { voxelsAlongRaysCallback( @@ -236,7 +240,7 @@ std::vector VoxelsAlongRays(const GridBatchImpl& batchHdl, rayOriginsAcc, rayDirectionsAcc, outJOffsetsAcc, outJIdxAcc, outJLIdxAcc, outVoxelsAcc, outTimesAcc, - batchAcc, maxVox, eps); + batchAcc, maxVox, eps, cumulative); }; if (returnIjk) { @@ -251,7 +255,7 @@ std::vector VoxelsAlongRays(const GridBatchImpl& batchHdl, rayOriginsAcc, rayDirectionsAcc, outJOffsetsAcc, outJIdxAcc, outJLIdxAcc, outVoxelsAcc, outTimesAcc, - batchAcc, maxVox, eps); + batchAcc, maxVox, eps, cumulative); }; auto cbIdx = [=] (int32_t bidx, int32_t eidx, int32_t cidx, JaggedAcc rayOriginsAcc) { voxelsAlongRaysCallback( @@ -259,7 +263,7 @@ std::vector VoxelsAlongRays(const GridBatchImpl& batchHdl, rayOriginsAcc, rayDirectionsAcc, outJOffsetsAcc, outJIdxAcc, outJLIdxAcc, outVoxelsAcc, outTimesAcc, - batchAcc, maxVox, eps); + batchAcc, maxVox, eps, cumulative); }; if (returnIjk) { forEachJaggedElementChannelCPU(1, rayOrigins, cbIjk); @@ -289,8 +293,9 @@ std::vector dispatchVoxelsAlongRays(const GridBatchI const JaggedTensor& rayDirections, int64_t maxVox, float eps, - bool returnIjk) { - return VoxelsAlongRays(batchHdl, rayOrigins, rayDirections, maxVox, eps, returnIjk); + bool returnIjk, + bool cumulative) { + return VoxelsAlongRays(batchHdl, rayOrigins, rayDirections, maxVox, eps, returnIjk, cumulative); } template <> @@ -299,8 +304,9 @@ std::vector dispatchVoxelsAlongRays(const GridBatchIm const JaggedTensor& rayDirections, int64_t maxVox, float eps, - bool returnIjk) { - return VoxelsAlongRays(batchHdl, rayOrigins, rayDirections, maxVox, eps, returnIjk); + bool returnIjk, + bool cumulative) { + return VoxelsAlongRays(batchHdl, rayOrigins, rayDirections, maxVox, eps, returnIjk, cumulative); } diff --git a/fvdb/src/detail/utils/cuda/Utils.cuh b/fvdb/src/detail/utils/cuda/Utils.cuh index 94f6c6e1ba..8ecb4591fa 100644 --- a/fvdb/src/detail/utils/cuda/Utils.cuh +++ b/fvdb/src/detail/utils/cuda/Utils.cuh @@ -724,6 +724,7 @@ struct RAIIRawDeviceBuffer { /// @param device The device to allocate the buffer on RAIIRawDeviceBuffer(size_t size, torch::Device device) { TORCH_CHECK(device.has_index(), "Device must specify an index"); + c10::cuda::CUDAGuard deviceGuard(device); stream = at::cuda::getCurrentCUDAStream(device.index()).stream(); bufferSize = size * sizeof(T); devicePtr = reinterpret_cast(c10::cuda::CUDACachingAllocator::raw_alloc_with_stream(bufferSize, stream)); diff --git a/fvdb/src/python/GridBatchBinding.cpp b/fvdb/src/python/GridBatchBinding.cpp index b3ccfa71b2..0c7b8a2370 100644 --- a/fvdb/src/python/GridBatchBinding.cpp +++ b/fvdb/src/python/GridBatchBinding.cpp @@ -516,14 +516,14 @@ void bind_grid_batch(py::module& m) { )_FVDB_") // Indexing functions - .def("ijk_to_index", &fvdb::GridBatch::ijk_to_index, py::arg("ijk")) - .def("ijk_to_inv_index", &fvdb::GridBatch::ijk_to_inv_index, py::arg("ijk")) + .def("ijk_to_index", &fvdb::GridBatch::ijk_to_index, py::arg("ijk"), py::arg("cumulative") = false) + .def("ijk_to_inv_index", &fvdb::GridBatch::ijk_to_inv_index, py::arg("ijk"), py::arg("cumulative") = false) .def("neighbor_indexes", &fvdb::GridBatch::neighbor_indexes, py::arg("ijk"), py::arg("extent"), py::arg("bitshift") = 0) // Ray tracing .def("voxels_along_rays", &fvdb::GridBatch::voxels_along_rays, - py::arg("ray_origins"), py::arg("ray_directions"), py::arg("max_voxels"), py::arg("eps") = 0.0, py::arg("return_ijk") = true) + py::arg("ray_origins"), py::arg("ray_directions"), py::arg("max_voxels"), py::arg("eps") = 0.0, py::arg("return_ijk") = true, py::arg("cumulative") = false) .def("segments_along_rays", &fvdb::GridBatch::segments_along_rays, py::arg("ray_origins"), py::arg("ray_directions"), py::arg("max_segments"), py::arg("eps") = 0.0, py::arg("ignore_masked") = false) .def("uniform_ray_samples", &fvdb::GridBatch::uniform_ray_samples, diff --git a/fvdb/src/python/JaggedTensorBinding.cpp b/fvdb/src/python/JaggedTensorBinding.cpp index 82bf34ba88..e6b3de5d7d 100644 --- a/fvdb/src/python/JaggedTensorBinding.cpp +++ b/fvdb/src/python/JaggedTensorBinding.cpp @@ -40,9 +40,45 @@ void bind_jagged_tensor(py::module& m) { return self.jidx(); } }, "The indices indicating the batch index where the element belong to.") - .def_property_readonly("joffsets", &fvdb::JaggedTensor::joffsets, "A [batch_size, 2] array where each row contains the start and end row index in jdata.") + .def_property_readonly("joffsets", &fvdb::JaggedTensor::joffsets, "A [num_tensors + 1] array where each row contains the start and end row index in jdata.") .def_property_readonly("num_tensors", &fvdb::JaggedTensor::num_tensors, "The number of tensors in the JaggedTensor.") + .def_property_readonly("jlidx", &fvdb::JaggedTensor::jlidx, "The list index of the JaggedTensor with size [num_tensors, ldim].") + + .def_static("from_data_and_indices", [](const torch::Tensor& data, const torch::Tensor& indices, int num_tensors) { + return fvdb::JaggedTensor::from_data_indices_and_list_ids( + data, indices, + torch::empty({0, 1}, torch::TensorOptions().dtype(fvdb::JLIdxScalarType).device(data.device())), + num_tensors + ); + }, R"_FVDB_( + Initialize jagged tensor with ldim=1 from data and indices. + + Args: + data (torch.Tensor): The data of the JaggedTensor. + indices (torch.Tensor): The indices indicating the batch index where the element belong to. + num_tensors (int): The batch size of the JaggedTensor. + + Returns: + jt (JaggedTensor): The JaggedTensor with the given data and indices.)_FVDB_") + + .def_static("from_data_and_offsets", [](const torch::Tensor& data, const torch::Tensor& offsets) { + return fvdb::JaggedTensor::from_data_offsets_and_list_ids( + data, offsets, + torch::empty({0, 1}, torch::TensorOptions().dtype(fvdb::JLIdxScalarType).device(data.device())) + ); + }, R"_FVDB_( + Initialize jagged tensor with ldim=1 from data and offsets. + + Args: + data (torch.Tensor): The data of the JaggedTensor. + offsets (torch.Tensor): The 1-dimensional offsets indicating the start and end of each tensor in data. + + Returns: + jt (JaggedTensor): The JaggedTensor with the given data and offsets.)_FVDB_") + + .def_static("from_data_indices_and_list_ids", &fvdb::JaggedTensor::from_data_indices_and_list_ids, py::arg("data"), py::arg("indices"), py::arg("list_ids"), py::arg("num_tensors")) + .def_static("from_data_offsets_and_list_ids", &fvdb::JaggedTensor::from_data_offsets_and_list_ids, py::arg("data"), py::arg("offsets"), py::arg("list_ids")) .def_property_readonly("is_cuda", &fvdb::JaggedTensor::is_cuda, "Whether the JaggedTensor is on a CUDA device.") .def_property_readonly("is_cpu", &fvdb::JaggedTensor::is_cpu, "Whether the JaggedTensor is on a CPU device.") @@ -258,9 +294,6 @@ void bind_jagged_tensor(py::module& m) { return fvdb::JaggedTensor::from_data_indices_and_list_ids(data, jidx, jlidx, batchSize); } - if (t.size() > 0) { - TORCH_CHECK(false, "Invalid pickle format"); - } int version = t[0].cast(); if (version == 1 || version == 2) { const torch::Tensor jdata = THPVariable_Unpack(t[1].ptr()); @@ -282,8 +315,10 @@ void bind_jagged_tensor(py::module& m) { const torch::Tensor jlidx = THPVariable_Unpack(t[3].ptr()); const int64_t numOuterLists = t[4].cast(); - TORCH_CHECK(numOuterLists == joffsets.size(0), "Invalid pickle format: numOuterLists does not match joffsets size"); - TORCH_CHECK(jlidx.size(0) == 0 || jlidx.size(0) == joffsets.size(0), "Invalid pickle format: jlidx size does not match joffsets size"); + if (jlidx.numel() != 0 && jlidx.size(1) == 1) { + TORCH_CHECK(numOuterLists == joffsets.size(0), "Invalid pickle format: numOuterLists does not match joffsets size"); + } + TORCH_CHECK(jlidx.size(0) == 0 || jlidx.size(0) == (joffsets.size(0) - 1), "Invalid pickle format: jlidx size does not match joffsets size"); return fvdb::JaggedTensor::from_data_offsets_and_list_ids(jdata, joffsets, jlidx); } else { TORCH_CHECK(false, "Invalid JaggedTensor pickle version (got version = ", version, ")"); diff --git a/fvdb/src/python/TypeCasters.h b/fvdb/src/python/TypeCasters.h index 5d0e7c3e9c..070d610bea 100644 --- a/fvdb/src/python/TypeCasters.h +++ b/fvdb/src/python/TypeCasters.h @@ -38,6 +38,9 @@ template <> struct type_caster : public type_caster_base= 2 && TORCH_VERSION_MINOR < 4)) template <> struct type_caster : public type_caster_base { using base = type_caster_base; public: @@ -59,6 +62,7 @@ template <> struct type_caster : public type_caster_base struct type_caster : public type_caster_base { diff --git a/fvdb/tests/unit/test_basic_ops.py b/fvdb/tests/unit/test_basic_ops.py index 7c17ee6952..9885c47165 100644 --- a/fvdb/tests/unit/test_basic_ops.py +++ b/fvdb/tests/unit/test_basic_ops.py @@ -331,6 +331,43 @@ def test_ijk_to_index(self, device, dtype, mutable): self.assertTrue(torch.all(pidx == target_pidx[ppmt])) self.assertTrue(torch.all(didx == target_didx[dpmt])) + @parameterized.expand(all_device_dtype_combos) + def test_ijk_to_index_batched(self, device, dtype, mutable): + gsize = 7 + + grid_p1, grid_d1, _ = make_dense_grid_and_point_data(gsize, device, dtype, mutable) + grid_p2, grid_d2, _ = make_dense_grid_and_point_data(gsize-2, device, dtype, mutable) + + grid_p, grid_d = fvdb.jcat([grid_p1, grid_p2]), fvdb.jcat([grid_d1, grid_d2]) + + pijk = grid_p.ijk + dijk = grid_d.ijk + + for in_dtype in [torch.int8, torch.int16, torch.int32, torch.int64]: + pijk, dijk = pijk.to(in_dtype), dijk.to(in_dtype) + pidx = grid_p.ijk_to_index(grid_p.ijk) + didx = grid_d.ijk_to_index(grid_d.ijk) + + target_pidx = fvdb.JaggedTensor([torch.arange(n.item()).to(device=pidx.device, dtype=pidx.dtype) for n in grid_p.num_voxels]) + target_didx = fvdb.JaggedTensor([torch.arange(n.item()).to(device=pidx.device, dtype=didx.dtype) for n in grid_d.num_voxels]) + + self.assertTrue(torch.all(pidx.jdata == target_pidx.jdata)) + self.assertTrue(torch.all(didx.jdata == target_didx.jdata)) + + ppmt = fvdb.JaggedTensor([torch.randperm(pidx_i.rshape[0]).to(pidx.device) for pidx_i in pidx]) + dpmt = fvdb.JaggedTensor([torch.randperm(didx_i.rshape[0]).to(pidx.device) for didx_i in didx]) + + pidx = grid_p.ijk_to_index(pijk[ppmt]) + didx = grid_d.ijk_to_index(dijk[dpmt]) + # target_pidx = torch.arange(pidx.shape[0]).to(pidx) + # target_didx = torch.arange(didx.shape[0]).to(didx) + target_pidx = fvdb.JaggedTensor([torch.arange(n.item()).to(device=pidx.device, dtype=pidx.dtype) for n in grid_p.num_voxels]) + target_didx = fvdb.JaggedTensor([torch.arange(n.item()).to(device=pidx.device, dtype=didx.dtype) for n in grid_d.num_voxels]) + + self.assertTrue(torch.all(pidx.jdata == target_pidx[ppmt].jdata)) + self.assertTrue(torch.all(didx.jdata == target_didx[dpmt].jdata)) + + @parameterized.expand(all_device_dtype_combos) def test_coords_in_grid(self, device, _, mutable): num_inside = 1000 if device == 'cpu' else 100_000 @@ -380,7 +417,7 @@ def test_points_in_grid(self, device, dtype, mutable): def test_cubes_intersect_grid(self, device, dtype, mutable): # TODO: (@Caenorst) tests are a bit too light, should test on more variety of range #import random - #torch.random.manual_seed(0) + torch.random.manual_seed(0) #random.seed(0) #np.random.seed(0) @@ -1146,6 +1183,74 @@ def check_order(t1: torch.Tensor, t2: torch.Tensor): # ensure output of ijk_to_inv_index appears in ascending order in ijks assert check_order(grid.ijk.jdata[grid.ijk.jidx == i], inv_ijks.jdata) + @parameterized.expand(all_device_dtype_combos) + def test_ijk_to_inv_index_batched(self, device, dtype, mutable): + vox_size = 0.1 + + # Unique IJK since for duplicates the permutation is non-bijective + ijk = [list( + set( + [tuple([a for a in (np.random.randn(3) / vox_size).astype(np.int32)]) for _ in range(100 + np.random.randint(10))] + ) + ) for _ in range(3)] + ijk = [torch.from_numpy(np.array([list(a) for a in ijk_i])).to(torch.int32).to(device) for ijk_i in ijk] + ijk = fvdb.JaggedTensor(ijk) + + grid = GridBatch(mutable=mutable, device=device) + grid.set_from_ijk(ijk, voxel_sizes=vox_size, origins=[0.]*3) + + inv_index = grid.ijk_to_inv_index(ijk).jdata + + target_inv_index = torch.full_like(grid.ijk.jdata[:, 0], -1) + idx = grid.ijk_to_index(ijk, cumulative=True) + + for i, ijk_i in enumerate(ijk): + for j in range(ijk_i.rshape[0]): + target_inv_index[idx[i].jdata[j]] = j + + self.assertTrue(torch.all(inv_index == target_inv_index)) + + # Test functionality where size of ijk_to_inv_index's argument != len(grid.ijk) + # Pick random ijk subset + rand_ijks = [] + for i in range(grid.grid_count): + ijks = grid[i].ijk.jdata + rand_ijks.append(torch.unique(ijks[torch.randint(len(ijks), (50,), device = ijks.device)], dim=0)) + + rand_ijks = fvdb.JaggedTensor(rand_ijks) + + rand_ijk_inv_indices = grid.ijk_to_inv_index(rand_ijks) + + # # valid ijk indices + inv_rand_ijk = grid.ijk[rand_ijk_inv_indices!= -1] + assert(len(inv_rand_ijk.jdata) == len(rand_ijks.jdata)) + + def check_order(t1: torch.Tensor, t2: torch.Tensor): + t1_list = t1.tolist() + t2_list = t2.tolist() + + last_index = -1 + for elem in t2_list: + try: + current_index = t1_list.index(elem) + # Check if the current index is greater than the last index + if current_index > last_index: + last_index = current_index + else: + return False + except ValueError: + return False + return True + + for i, (inv_ijks, ijks) in enumerate(zip(inv_rand_ijk, rand_ijks)): + # ensure output of ijk_to_inv_index is a permutation of the input + inv_ijks_sorted, _ = torch.sort(inv_ijks.jdata, dim=0) + ijks_sorted, _ = torch.sort(ijks.jdata, dim=0) + assert torch.equal(inv_ijks_sorted, ijks_sorted) + + # ensure output of ijk_to_inv_index appears in ascending order in ijks + assert check_order(grid.ijk.jdata[grid.ijk.jidx == i], inv_ijks.jdata) + @parameterized.expand(all_device_dtype_combos) def test_no_use_after_free_on_backward(self, device, dtype, mutable): diff --git a/fvdb/tests/unit/test_conv.py b/fvdb/tests/unit/test_conv.py index 6940ffd9cf..bc57b50ba1 100644 --- a/fvdb/tests/unit/test_conv.py +++ b/fvdb/tests/unit/test_conv.py @@ -177,7 +177,7 @@ def test_conv_halo(self, in_channel, out_channel, batch_size, variant): out_ts_tensor.coords[out_ts_tensor.coords[:, -1] == b, :3] for b in range(batch_size)]) - ts_features = out_ts_tensor.feats[grid.ijk_to_inv_index(ts_target_grid_ijk).jdata] + ts_features = out_ts_tensor.feats[grid.ijk_to_inv_index(ts_target_grid_ijk, cumulative=True).jdata] ts_features.backward(grad_out) ts_features_grad = torch.clone(vdb_features.jdata.grad) @@ -228,12 +228,12 @@ def test_special_conv(self, dtype, batch_size, backend): ts_target_grid_ijk = JaggedTensor([ torch.div(out_ts_tensor.coords[out_ts_tensor.coords[:, -1] == b, :3], stride, rounding_mode='floor') for b in range(batch_size)]) - idx_map = vdb_target_grid.ijk_to_index(ts_target_grid_ijk) + idx_map = vdb_target_grid.ijk_to_index(ts_target_grid_ijk, cumulative=True) assert idx_map.jdata.shape[0] == vdb_target_grid.total_voxels assert torch.all(torch.sort(idx_map.jdata).values == torch.arange(vdb_target_grid.total_voxels, device=device)) - ts_features = out_ts_tensor.feats[vdb_target_grid.ijk_to_inv_index(ts_target_grid_ijk).jdata] + ts_features = out_ts_tensor.feats[vdb_target_grid.ijk_to_inv_index(ts_target_grid_ijk, cumulative=True).jdata] self.assertTrue(torch.allclose(out_vdb_features.jdata, ts_features, atol=0.1), f"Max dist is {torch.max(out_vdb_features.jdata - ts_features)}") @@ -299,7 +299,7 @@ def test_conv_vs_torchsparse(self, device, dtype, batch_size, kernel_size, strid torch.div(out_ts_tensor.coords[out_ts_tensor.coords[:, -1] == b, :3], stride, rounding_mode='floor') for b in range(batch_size) ]) - idx_map = vdb_target_grid.ijk_to_index(ts_target_grid_ijk) + idx_map = vdb_target_grid.ijk_to_index(ts_target_grid_ijk, cumulative=True) # (Optionally: visualize) # from pycg import vis @@ -316,7 +316,7 @@ def test_conv_vs_torchsparse(self, device, dtype, batch_size, kernel_size, strid assert idx_map.jdata.shape[0] == vdb_target_grid.total_voxels assert torch.all(torch.sort(idx_map.jdata).values == torch.arange(vdb_target_grid.total_voxels, device=device)) - ts_features = out_ts_tensor.feats[vdb_target_grid.ijk_to_inv_index(ts_target_grid_ijk).jdata] + ts_features = out_ts_tensor.feats[vdb_target_grid.ijk_to_inv_index(ts_target_grid_ijk, cumulative=True).jdata] ts_features.backward(grad_out) dense_features_grad = torch.clone(vdb_features.jdata.grad) diff --git a/fvdb/tests/unit/test_jagged_tensor.py b/fvdb/tests/unit/test_jagged_tensor.py index 0d66041e4b..1644f0da53 100644 --- a/fvdb/tests/unit/test_jagged_tensor.py +++ b/fvdb/tests/unit/test_jagged_tensor.py @@ -3,6 +3,7 @@ # import itertools import os +import tempfile import unittest from typing import List @@ -27,13 +28,16 @@ class TestJaggedTensor(unittest.TestCase): def setUp(self): pass - def mklol(self, num_outer, num_inner_min, num_inner_max, device, dtype, last_dims=(3, 4)): + def mklol(self, num_outer, num_inner_min, num_inner_max, device, dtype, last_dims=(3, 4), base_num=1000, vary_num=10, empty_prob=0.0): pts_list = [] for _ in range(num_outer): pts_list_i = [] while len(pts_list_i) == 0: + size = base_num + (np.random.randint(vary_num) if vary_num > 0 else 0) + if np.random.rand() < empty_prob: + size = 0 pts_list_i = [ - torch.rand(1000 + np.random.randint(10), *last_dims, device=device, dtype=dtype) + torch.rand(size, *last_dims, device=device, dtype=dtype) for _ in range(np.random.randint(num_inner_min, num_inner_max))] pts_list.append(pts_list_i) ret = fvdb.JaggedTensor(pts_list), pts_list @@ -67,6 +71,41 @@ def check_lshape(self, jt: fvdb.JaggedTensor, lt: List[torch.Tensor] | List[List else: assert False, "jagged tensor ldim should be 1 or 2" + @parameterized.expand(all_device_dtype_combos) + def test_pickle(self, device, dtype): + jt, _ = self.mklol(7, 4, 8, device, dtype) + with tempfile.NamedTemporaryFile() as tmp: + torch.save(jt, tmp.name) + jt2: fvdb.JaggedTensor = torch.load(tmp.name) + self.assertTrue(torch.all(jt.jdata == jt2.jdata)) + self.assertTrue(torch.all(jt.joffsets == jt2.joffsets)) + self.assertTrue(torch.all(jt.jidx == jt2.jidx)) + self.assertTrue(jt.device == jt2.device) + self.assertTrue(jt.dtype == jt2.dtype) + self.assertEqual(jt.lshape, jt2.lshape) + + jt = fvdb.JaggedTensor([torch.randn(100 + np.random.randint(10), 3, 2).to(device).to(dtype) for _ in range(10)]) + with tempfile.NamedTemporaryFile() as tmp: + torch.save(jt, tmp.name) + jt2: fvdb.JaggedTensor = torch.load(tmp.name) + self.assertTrue(torch.all(jt.jdata == jt2.jdata)) + self.assertTrue(torch.all(jt.joffsets == jt2.joffsets)) + self.assertTrue(torch.all(jt.jidx == jt2.jidx)) + self.assertTrue(jt.device == jt2.device) + self.assertTrue(jt.dtype == jt2.dtype) + self.assertEqual(jt.lshape, jt2.lshape) + + jt = fvdb.JaggedTensor([torch.rand(1024, 9, 9, 9)]) + with tempfile.NamedTemporaryFile() as tmp: + torch.save(jt, tmp.name) + jt2: fvdb.JaggedTensor = torch.load(tmp.name) + self.assertTrue(torch.all(jt.jdata == jt2.jdata)) + self.assertTrue(torch.all(jt.joffsets == jt2.joffsets)) + self.assertTrue(torch.all(jt.jidx == jt2.jidx)) + self.assertTrue(jt.device == jt2.device) + self.assertTrue(jt.dtype == jt2.dtype) + self.assertEqual(jt.lshape, jt2.lshape) + @parameterized.expand(all_device_dtype_combos) def test_jflatten_list_of_lists(self, device, dtype): jt1, l1 = self.mklol(7, 4, 8, device, dtype) @@ -145,8 +184,8 @@ def test_jflatten_list(self, device, dtype): @parameterized.expand(all_device_dtype_combos) def test_concatenation(self, device, dtype): - jt1, l1 = self.mklol(7, 4, 8, device, dtype, last_dims=(3,)) - jt2, _ = self.mklol(3, 7, 11, device, dtype, last_dims=(3,)) + jt1, l1 = self.mklol(7, 2, 5, device, dtype, last_dims=(3,), base_num=1_000_000 if device == 'cuda' else 1000, vary_num=100, empty_prob=0.0) + jt2, _ = self.mklol(3, 3, 5, device, dtype, last_dims=(3,), base_num=1_000_000 if device == 'cuda' else 1000, vary_num=100, empty_prob=0.0) jt3, l3 = self.mklol_like(l1, vary_dim_1=True, vary_dim_2=False) jt4, l4 = self.mklol_like(l1, vary_dim_1=False, vary_dim_2=True) @@ -169,6 +208,19 @@ def test_concatenation(self, device, dtype): cat_ij = torch.cat([l1[i][j], l1[i][j]], dim=dim) # meow lcatted[-1].append(cat_ij) self.assertTrue(torch.all(jtcatij.jdata == cat_ij)) + + jt_to_cat = jt3 if dim == 0 else jt4 + jtcat = fvdb.jcat([jt1, jt1, jt_to_cat, jt1, jt_to_cat, jt1], dim=dim) + lcatted = [] + for i, jtcati in enumerate(jtcat): + lcatted.append([]) + for j, jtcatij in enumerate(jtcati): + t_test = (l3 if dim == 0 else l4)[i][j] + t1ij = l1[i][j] + cat_ij = torch.cat([t1ij, t1ij, t_test, t1ij, t_test, t1ij], dim=dim) # meow + lcatted[-1].append(cat_ij) + self.assertTrue(torch.all(jtcatij.jdata == cat_ij)) + jtcat = fvdb.jcat([jt1, jt3 if dim == 0 else jt4, jt1], dim=dim) lcatted = [] for i, jtcati in enumerate(jtcat): @@ -1015,7 +1067,7 @@ def test_batch_size_one(self, device, dtype): @parameterized.expand(all_device_dtype_combos) def test_jsum(self, device, dtype): - torch.random.manual_seed(0) + torch.random.manual_seed(111) if dtype == torch.float16: min_num = 100 else: diff --git a/fvdb/tests/unit/test_nn.py b/fvdb/tests/unit/test_nn.py index 0928f443a5..87d0e98d22 100644 --- a/fvdb/tests/unit/test_nn.py +++ b/fvdb/tests/unit/test_nn.py @@ -245,6 +245,9 @@ def test_vdbtensor_arithmetic(self): v = v1 + v2 self.assertTrue(torch.allclose(v.feature.jdata, v1.feature.jdata + v2.feature.jdata)) + v = v1 + v2.feature + self.assertTrue(torch.allclose(v.feature.jdata, v1.feature.jdata + v2.feature.jdata)) + v = v1 + 1.0 self.assertTrue(torch.allclose(v.feature.jdata, v1.feature.jdata + 1.0))