diff --git a/docs/api/nn.rst b/docs/api/nn.rst index b45981c54..86a401fc3 100644 --- a/docs/api/nn.rst +++ b/docs/api/nn.rst @@ -4,6 +4,7 @@ Neural Network Layers and Blocks .. autoclass:: fvdb.nn.MaxPool .. autoclass:: fvdb.nn.AvgPool .. autoclass:: fvdb.nn.UpsamplingNearest +.. autoclass:: fvdb.nn.Prune .. autoclass:: fvdb.nn.SparseConv3d .. autoclass:: fvdb.nn.SparseConvTranspose3d .. autoclass:: fvdb.nn.BatchNorm diff --git a/env/learn_environment.yml b/env/learn_environment.yml index 6b73819c3..5aa907e38 100644 --- a/env/learn_environment.yml +++ b/env/learn_environment.yml @@ -10,6 +10,7 @@ dependencies: - fvdb-core - git - ipython + - ipywidgets - jupyterlab - linkify-it-py - matplotlib diff --git a/examples/shape_completion.py b/examples/shape_completion.py new file mode 100644 index 000000000..fabfc04de --- /dev/null +++ b/examples/shape_completion.py @@ -0,0 +1,233 @@ +# Copyright Contributors to the OpenVDB Project +# SPDX-License-Identifier: Apache-2.0 +# +"""Sparse 3D shape completion with generative transposed convolutions. + +A sparse encoder-decoder network is given a partial shape (a slab cropped along x) +and learns to generate the voxel topology of the complete shape. The decoder grows +topology with *generative* transposed convolutions and trims it with per-level +occupancy classifiers. +""" + +import logging + +import fvdb.nn as fvnn +import polyscope as ps +import torch +import torch.nn as nn +import torch.nn.functional as F +import tqdm +from fvdb.utils.examples import load_dragon_mesh, load_happy_mesh + +import fvdb +from fvdb import ConvolutionPlan, GridBatch, JaggedTensor + +RESOLUTION = 64 # voxels along the longest axis of each shape +NUM_LEVELS = 5 # stride-2 pyramid depth; coarsest lattice is RESOLUTION / 2**NUM_LEVELS = 2^3 +CHANNELS = [16, 32, 64, 128, 256, 256] # CHANNELS[0] = full resolution, CHANNELS[NUM_LEVELS] = coarsest +CROP_FRACTION = 0.55 # keep voxels with x below this fraction of the shape's x-extent +NUM_ITERATIONS = 500 +LEARNING_RATE = 1e-2 +LOG_EVERY = 50 + + +def normalize_vertices(vertices: torch.Tensor) -> torch.Tensor: + """Uniformly scale vertices into [0.02, 0.98]^3 so all voxel ijk are in [0, RESOLUTION).""" + vertices = vertices - vertices.amin(dim=0) + vertices = vertices / vertices.amax() + return vertices * 0.96 + 0.02 + + +def prepare_shapes(device: torch.device) -> tuple[GridBatch, GridBatch]: + """Voxelize the bundled meshes and slab-crop them along x. + + Returns: + gt_grid (GridBatch): Complete (ground-truth) shape topologies. + partial_grid (GridBatch): The cropped, partial input topologies. + """ + voxel_size = 1.0 / RESOLUTION + meshes = [load_dragon_mesh(mode="vf", device=device), load_happy_mesh(mode="vf", device=device)] + vertices = JaggedTensor([normalize_vertices(v) for v, _ in meshes]) + faces = JaggedTensor([f.int() for _, f in meshes]) + gt_grid = GridBatch.from_mesh(vertices, faces, voxel_sizes=voxel_size, origins=0.0) + + # Crop away the top (1 - CROP_FRACTION) of each shape along x, in voxel space. + ijk = gt_grid.ijk + keep = torch.zeros(gt_grid.total_voxels, dtype=torch.bool, device=device) + for b in range(gt_grid.grid_count): + in_b = ijk.jidx == b + x = ijk.jdata[in_b, 0].float() + keep[in_b] = x < x.min() + CROP_FRACTION * (x.max() - x.min()) + partial_grid = gt_grid.pruned_grid(gt_grid.jagged_like(keep)) + return gt_grid, partial_grid + + +def build_gt_pyramid(gt_grid: GridBatch) -> list[GridBatch]: + """Ground-truth topology at every pyramid level; level d has voxel size 2^d / RESOLUTION.""" + pyramid = [gt_grid] + for _ in range(NUM_LEVELS): + pyramid.append(pyramid[-1].conv_grid(2, 2)) + return pyramid + + +class ConvBnElu(nn.Module): + """A sparse convolution followed by batch norm and ELU, building its plan per call.""" + + def __init__(self, in_channels: int, out_channels: int, kernel_size: int, stride: int): + super().__init__() + self.conv = fvnn.SparseConv3d(in_channels, out_channels, kernel_size, stride) + self.norm = fvnn.BatchNorm(out_channels) + self.kernel_size = kernel_size + self.stride = stride + + def forward(self, data: JaggedTensor, grid: GridBatch) -> tuple[JaggedTensor, GridBatch]: + if self.stride == 1: + plan = ConvolutionPlan.from_grid_batch(self.kernel_size, 1, grid, grid) + else: + plan = ConvolutionPlan.from_grid_batch(self.kernel_size, self.stride, grid) + data = self.conv(data, plan) + out_grid = plan.target_grid_batch + return out_grid.jagged_like(F.elu(self.norm(data, out_grid).jdata)), out_grid + + +class GenerativeUpBlock(nn.Module): + """Generative transposed conv (uncropped support) + BN + ELU + k3 conv + BN + ELU.""" + + def __init__(self, in_channels: int, out_channels: int, kernel_size: int): + super().__init__() + self.up = fvnn.SparseConvTranspose3d(in_channels, out_channels, kernel_size, stride=2) + self.up_norm = fvnn.BatchNorm(out_channels) + self.conv = ConvBnElu(out_channels, out_channels, kernel_size=3, stride=1) + self.kernel_size = kernel_size + + def forward(self, data: JaggedTensor, grid: GridBatch) -> tuple[JaggedTensor, GridBatch]: + # target_grid=None -> COMPLETE topology policy: the plan *generates* new coordinates + plan = ConvolutionPlan.from_grid_batch_transposed(self.kernel_size, 2, grid) + data = self.up(data, plan) + out_grid = plan.target_grid_batch + data = out_grid.jagged_like(F.elu(self.up_norm(data, out_grid).jdata)) + return self.conv(data, out_grid) + + +class CompletionNet(nn.Module): + """Sparse encoder-decoder that completes a partial shape.""" + + def __init__(self): + super().__init__() + self.stem = ConvBnElu(1, CHANNELS[0], kernel_size=3, stride=1) + self.enc_down = nn.ModuleList( + ConvBnElu(CHANNELS[i], CHANNELS[i + 1], kernel_size=2, stride=2) for i in range(NUM_LEVELS) + ) + self.enc_conv = nn.ModuleList( + ConvBnElu(CHANNELS[i + 1], CHANNELS[i + 1], kernel_size=3, stride=1) for i in range(NUM_LEVELS) + ) + # Decoder level i produces the level-i grid from level i+1. The coarsest transpose + # uses kernel size 4; the rest use kernel size 2. + self.dec_up = nn.ModuleList( + GenerativeUpBlock(CHANNELS[i + 1], CHANNELS[i], kernel_size=4 if i == NUM_LEVELS - 1 else 2) + for i in range(NUM_LEVELS) + ) + self.dec_head = nn.ModuleList( + fvnn.SparseConv3d(CHANNELS[i], 1, kernel_size=1, stride=1) for i in range(NUM_LEVELS) + ) + self.prune = fvnn.Prune() + + def forward( + self, data: JaggedTensor, grid: GridBatch, gt_pyramid: list[GridBatch] + ) -> tuple[list[JaggedTensor], list[JaggedTensor], JaggedTensor, GridBatch]: + """Run completion. Returns per-level (logits, targets) plus the final features and grid.""" + # Encoder: store per-level features for the additive U-Net skip connections. + data, grid = self.stem(data, grid) + skips: list[tuple[JaggedTensor, GridBatch]] = [(data, grid)] + for i in range(NUM_LEVELS): + data, grid = self.enc_down[i](data, grid) + data, grid = self.enc_conv[i](data, grid) + skips.append((data, grid)) + + # Decoder: generate, classify, and prune one level at a time. + logits_per_level: list[JaggedTensor] = [] + targets_per_level: list[JaggedTensor] = [] + for i in reversed(range(NUM_LEVELS)): + if grid.total_voxels == 0: + break # everything was pruned (possible when not teacher-forced) + data, grid = self.dec_up[i](data, grid) + # Additive skip: gather encoder features onto the generated decoder topology + # (voxels absent from the encoder grid contribute zero) + skip_data, skip_grid = skips[i] + data = grid.jagged_like(data.jdata + grid.inject_from(skip_grid, skip_data).jdata) + + head_plan = ConvolutionPlan.from_grid_batch(1, 1, grid, grid) + logits = self.dec_head[i](data, head_plan) + target = gt_pyramid[i].coords_in_grid(grid.ijk) + logits_per_level.append(logits) + targets_per_level.append(target) + + keep = logits.jdata.squeeze(-1) > 0 + if self.training: + keep |= target.jdata # teacher forcing + data, grid = self.prune(data, grid, grid.jagged_like(keep)) + return logits_per_level, targets_per_level, data, grid + + +def occupancy_loss(logits_per_level: list[JaggedTensor], targets_per_level: list[JaggedTensor]) -> torch.Tensor: + losses = [ + F.binary_cross_entropy_with_logits(logits.jdata.squeeze(-1), target.jdata.float()) + for logits, target in zip(logits_per_level, targets_per_level) + ] + return torch.stack(losses).mean() + + +def grid_iou(predicted: GridBatch, gt: GridBatch) -> float: + intersection = int(gt.coords_in_grid(predicted.ijk).jdata.sum().item()) + union = predicted.total_voxels + gt.total_voxels - intersection + return intersection / max(union, 1) + + +def visualize(partial_grid: GridBatch, predicted_grid: GridBatch, gt_grid: GridBatch) -> None: + ps.init() + for name, grid, offset in (("input", partial_grid, -1.2), ("predicted", predicted_grid, 0.0), ("gt", gt_grid, 1.2)): + centers = grid.voxel_to_world(grid.ijk.float()) + for b in range(grid.grid_count): + points = centers[b].jdata.cpu().numpy() + points = points + [offset, 1.2 * b, 0.0] + ps.register_point_cloud(f"{name}_{b}", points, radius=0.0025) + ps.show() + + +def main() -> None: + logging.basicConfig(level=logging.INFO) + logging.addLevelName(logging.INFO, "\033[1;32m%s\033[1;0m" % logging.getLevelName(logging.INFO)) + torch.random.manual_seed(0) + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + gt_grid, partial_grid = prepare_shapes(device) + gt_pyramid = build_gt_pyramid(gt_grid) + input_features = partial_grid.jagged_like(torch.ones(partial_grid.total_voxels, 1, device=device)) + logging.info(f"GT voxels: {gt_grid.total_voxels}, partial-input voxels: {partial_grid.total_voxels}") + + model = CompletionNet().to(device) + optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=0.9, weight_decay=1e-4) + scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=0.995) + + model.train() + for iteration in tqdm.trange(NUM_ITERATIONS, desc="training"): + logits, targets, _, _ = model(input_features, partial_grid, gt_pyramid) + loss = occupancy_loss(logits, targets) + optimizer.zero_grad() + loss.backward() + optimizer.step() + scheduler.step() + if iteration % LOG_EVERY == 0 or iteration == NUM_ITERATIONS - 1: + logging.info(f"iteration {iteration}: loss = {loss.item():.4f}") + + # Evaluation: no teacher forcing - the decoder keeps only what it predicts. + model.eval() + with torch.no_grad(): + _, _, _, predicted_grid = model(input_features, partial_grid, gt_pyramid) + logging.info(f"completed-shape IoU vs ground truth: {grid_iou(predicted_grid, gt_grid):.3f}") + + visualize(partial_grid, predicted_grid, gt_grid) + + +if __name__ == "__main__": + main() diff --git a/examples/shape_vae.py b/examples/shape_vae.py new file mode 100644 index 000000000..b5c440c60 --- /dev/null +++ b/examples/shape_vae.py @@ -0,0 +1,282 @@ +# Copyright Contributors to the OpenVDB Project +# SPDX-License-Identifier: Apache-2.0 +# +"""Sparse 3D shape variational autoencoder with generative transposed convolutions. + +An encoder compresses each sparse voxelized shape into a single latent vector; the +decoder generates the shape's voxel topology back from the latent alone, growing +coordinates with *generative* transposed convolutions and trimming them with +per-level occupancy classifiers and :class:`fvdb.nn.Prune`. Because the decoder +sees only the latent (no skip connections), sampling ``z ~ N(0, I)`` generates +novel shapes - demonstrated at the end of the script. + + +The dataset is the 254-shoe "Shoe" category of Scanned Objects by Google Research +(CC-BY 4.0), bundled with fvdb-example-data — a single object category with real +intra-class variation (runners, boat shoes, ballet flats, cleats, boots). Training +runs small random minibatches over the pre-voxelized dataset. +""" + +import logging + +import fvdb.nn as fvnn +import polyscope as ps +import torch +import torch.nn as nn +import torch.nn.functional as F +import tqdm +from fvdb.utils.examples import load_gso_shoes + +import fvdb +from fvdb import ConvolutionPlan, GridBatch, JaggedTensor + +RESOLUTION = 64 # voxels along the longest axis of each shape +NUM_LEVELS = 4 # stride-2 pyramid depth; the decoder neck lattice is (RESOLUTION / 2**NUM_LEVELS)^3 = 4^3 +CHANNELS = [16, 32, 64, 128, 256] # CHANNELS[0] = full resolution, CHANNELS[NUM_LEVELS] = coarsest +LATENT_DIM = 128 +KLD_WEIGHT = 1e-2 +NUM_ITERATIONS = 1500 +BATCH_SIZE = 16 +LEARNING_RATE = 1e-3 +LOG_EVERY = 100 +NUM_PRIOR_SAMPLES = 4 +NUM_EVAL_SHAPES = 8 # reconstruction / visualization subset + + +def normalize_vertices(vertices: torch.Tensor) -> torch.Tensor: + """Uniformly scale vertices into [0.02, 0.98]^3 so all voxel ijk are in [0, RESOLUTION).""" + vertices = vertices - vertices.amin(dim=0) + vertices = vertices / vertices.amax() + return vertices * 0.96 + 0.02 + + +def prepare_shapes(device: torch.device) -> GridBatch: + """Voxelize the GSO shoe meshes (CC-BY 4.0) into a single GridBatch 'dataset'.""" + meshes = load_gso_shoes(device=device) + vertices = JaggedTensor([normalize_vertices(v) for v, _ in meshes]) + faces = JaggedTensor([f.int() for _, f in meshes]) + return GridBatch.from_mesh(vertices, faces, voxel_sizes=1.0 / RESOLUTION, origins=0.0) + + +def build_gt_pyramid(gt_grid: GridBatch) -> list[GridBatch]: + """Ground-truth topology at every pyramid level; level d has voxel size 2^d / RESOLUTION.""" + pyramid = [gt_grid] + for _ in range(NUM_LEVELS): + pyramid.append(pyramid[-1].conv_grid(2, 2)) + return pyramid + + +class ConvBnElu(nn.Module): + """A sparse convolution followed by batch norm and ELU, building its plan per call.""" + + def __init__(self, in_channels: int, out_channels: int, kernel_size: int, stride: int): + super().__init__() + self.conv = fvnn.SparseConv3d(in_channels, out_channels, kernel_size, stride) + self.norm = fvnn.BatchNorm(out_channels) + self.kernel_size = kernel_size + self.stride = stride + + def forward(self, data: JaggedTensor, grid: GridBatch) -> tuple[JaggedTensor, GridBatch]: + if self.stride == 1: + plan = ConvolutionPlan.from_grid_batch(self.kernel_size, 1, grid, grid) + else: + plan = ConvolutionPlan.from_grid_batch(self.kernel_size, self.stride, grid) + data = self.conv(data, plan) + out_grid = plan.target_grid_batch + return out_grid.jagged_like(F.elu(self.norm(data, out_grid).jdata)), out_grid + + +class GenerativeUpBlock(nn.Module): + """Generative transposed conv (uncropped support) + BN + ELU + k3 conv + BN + ELU.""" + + def __init__(self, in_channels: int, out_channels: int): + super().__init__() + self.up = fvnn.SparseConvTranspose3d(in_channels, out_channels, kernel_size=2, stride=2) + self.up_norm = fvnn.BatchNorm(out_channels) + self.conv = ConvBnElu(out_channels, out_channels, kernel_size=3, stride=1) + + def forward(self, data: JaggedTensor, grid: GridBatch) -> tuple[JaggedTensor, GridBatch]: + # target_grid=None -> COMPLETE topology policy: the plan *generates* new coordinates + plan = ConvolutionPlan.from_grid_batch_transposed(2, 2, grid) + data = self.up(data, plan) + out_grid = plan.target_grid_batch + data = out_grid.jagged_like(F.elu(self.up_norm(data, out_grid).jdata)) + return self.conv(data, out_grid) + + +class Encoder(nn.Module): + """Strided sparse convolutions to the coarsest level, then a global average pool and mu/logvar heads.""" + + def __init__(self): + super().__init__() + self.stem = ConvBnElu(1, CHANNELS[0], kernel_size=3, stride=1) + self.down = nn.ModuleList( + ConvBnElu(CHANNELS[i], CHANNELS[i + 1], kernel_size=2, stride=2) for i in range(NUM_LEVELS) + ) + self.conv = nn.ModuleList( + ConvBnElu(CHANNELS[i + 1], CHANNELS[i + 1], kernel_size=3, stride=1) for i in range(NUM_LEVELS) + ) + self.fc_mu = nn.Linear(CHANNELS[NUM_LEVELS], LATENT_DIM) + self.fc_logvar = nn.Linear(CHANNELS[NUM_LEVELS], LATENT_DIM) + + def forward(self, data: JaggedTensor, grid: GridBatch) -> tuple[torch.Tensor, torch.Tensor]: + data, grid = self.stem(data, grid) + for i in range(NUM_LEVELS): + data, grid = self.down[i](data, grid) + data, grid = self.conv[i](data, grid) + # Global average pool over each grid's voxels. + counts = grid.num_voxels.to(data.jdata.dtype).clamp_min(1).unsqueeze(1) + pooled = data.jsum(0).jdata / counts + return self.fc_mu(pooled), self.fc_logvar(pooled) + + +class Decoder(nn.Module): + """Generates shape topology from a latent vector alone (no skip connections).""" + + def __init__(self): + super().__init__() + neck_extent = RESOLUTION // 2**NUM_LEVELS + self.fc_seed = nn.Linear(LATENT_DIM, CHANNELS[NUM_LEVELS]) + # Learned per-voxel positional embedding for the dense neck. This breaks spatial + # symmetry: with only the broadcast latent, every neck voxel would carry identical + # features and the decoder could not distinguish positions. + self.neck_position = nn.Parameter(0.02 * torch.randn(neck_extent**3, CHANNELS[NUM_LEVELS])) + self.up = nn.ModuleList(GenerativeUpBlock(CHANNELS[i + 1], CHANNELS[i]) for i in range(NUM_LEVELS)) + self.head = nn.ModuleList(fvnn.SparseConv3d(CHANNELS[i], 1, kernel_size=1, stride=1) for i in range(NUM_LEVELS)) + self.prune = fvnn.Prune() + + def make_seed_grid(self, batch_size: int, device: torch.device) -> GridBatch: + neck_extent = RESOLUTION // 2**NUM_LEVELS + return GridBatch.from_dense( + batch_size, [neck_extent] * 3, voxel_sizes=float(2**NUM_LEVELS) / RESOLUTION, origins=0.0, device=device + ) + + def forward( + self, z: torch.Tensor, gt_pyramid: list[GridBatch] | None + ) -> tuple[list[JaggedTensor], list[JaggedTensor], JaggedTensor, GridBatch]: + """Decode latents. ``gt_pyramid`` supplies per-level targets (and teacher forcing while + training); pass ``None`` for pure generation. Returns per-level (logits, targets) plus + the final features and grid.""" + grid = self.make_seed_grid(z.shape[0], z.device) + voxels_per_grid = grid.total_voxels // z.shape[0] + seed = torch.repeat_interleave(F.elu(self.fc_seed(z)), voxels_per_grid, dim=0) + data = grid.jagged_like(seed + self.neck_position.tile(z.shape[0], 1)) + + logits_per_level: list[JaggedTensor] = [] + targets_per_level: list[JaggedTensor] = [] + for i in reversed(range(NUM_LEVELS)): + if grid.total_voxels == 0: + break # every voxel was pruned (possible when generating from the prior) + data, grid = self.up[i](data, grid) + head_plan = ConvolutionPlan.from_grid_batch(1, 1, grid, grid) + logits = self.head[i](data, head_plan) + keep = logits.jdata.squeeze(-1) > 0 + if gt_pyramid is not None: + target = gt_pyramid[i].coords_in_grid(grid.ijk) + logits_per_level.append(logits) + targets_per_level.append(target) + if self.training: + keep |= target.jdata # teacher forcing + data, grid = self.prune(data, grid, grid.jagged_like(keep)) + return logits_per_level, targets_per_level, data, grid + + +class ShapeVAE(nn.Module): + def __init__(self): + super().__init__() + self.encoder = Encoder() + self.decoder = Decoder() + + def forward(self, data: JaggedTensor, grid: GridBatch, gt_pyramid: list[GridBatch] | None): + mu, logvar = self.encoder(data, grid) + z = mu + torch.exp(0.5 * logvar) * torch.randn_like(mu) if self.training else mu + logits, targets, out_data, out_grid = self.decoder(z, gt_pyramid) + return logits, targets, out_data, out_grid, mu, logvar + + +def vae_loss( + logits_per_level: list[JaggedTensor], + targets_per_level: list[JaggedTensor], + mu: torch.Tensor, + logvar: torch.Tensor, +) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + bce = torch.stack( + [ + F.binary_cross_entropy_with_logits(logits.jdata.squeeze(-1), target.jdata.float()) + for logits, target in zip(logits_per_level, targets_per_level) + ] + ).mean() + kld = -0.5 * torch.mean(1.0 + logvar - mu.pow(2) - logvar.exp()) + return bce + KLD_WEIGHT * kld, bce, kld + + +def grid_iou(predicted: GridBatch, gt: GridBatch) -> float: + intersection = int(gt.coords_in_grid(predicted.ijk).jdata.sum().item()) + union = predicted.total_voxels + gt.total_voxels - intersection + return intersection / max(union, 1) + + +def visualize(gt_grid: GridBatch, recon_grid: GridBatch, sample_grid: GridBatch) -> None: + ps.init() + for name, grid, offset in ( + ("gt", gt_grid, -1.2), + ("reconstruction", recon_grid, 0.0), + ("sample", sample_grid, 1.2), + ): + centers = grid.voxel_to_world(grid.ijk.float()) + for b in range(grid.grid_count): + points = centers[b].jdata.cpu().numpy() + points = points + [offset, 1.2 * b, 0.0] + ps.register_point_cloud(f"{name}_{b}", points, radius=0.0025) + ps.show() + + +def main() -> None: + logging.basicConfig(level=logging.INFO) + logging.addLevelName(logging.INFO, "\033[1;32m%s\033[1;0m" % logging.getLevelName(logging.INFO)) + torch.random.manual_seed(0) + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + gt_grid = prepare_shapes(device) + # Build the ground-truth pyramid ONCE for the whole dataset; minibatches sub-index each + # level (GridBatch indexing is cheap, rebuilding conv_grid pyramids per iteration is not). + gt_pyramid = build_gt_pyramid(gt_grid) + logging.info(f"dataset: {gt_grid.grid_count} shapes, {gt_grid.total_voxels} voxels total") + + model = ShapeVAE().to(device) + optimizer = torch.optim.Adam(model.parameters(), lr=LEARNING_RATE) + + model.train() + for iteration in tqdm.trange(NUM_ITERATIONS, desc="training"): + idx = torch.randperm(gt_grid.grid_count)[:BATCH_SIZE] + batch_gt = gt_grid[idx] + batch_pyramid = [level[idx] for level in gt_pyramid] + batch_features = batch_gt.jagged_like(torch.ones(batch_gt.total_voxels, 1, device=device)) + + logits, targets, _, _, mu, logvar = model(batch_features, batch_gt, batch_pyramid) + loss, bce, kld = vae_loss(logits, targets, mu, logvar) + optimizer.zero_grad() + loss.backward() + optimizer.step() + if iteration % LOG_EVERY == 0 or iteration == NUM_ITERATIONS - 1: + logging.info( + f"iteration {iteration}: loss = {loss.item():.4f} (bce {bce.item():.4f}, kld {kld.item():.4f})" + ) + + model.eval() + with torch.no_grad(): + # Reconstructions: encode a fixed subset of shapes and decode from z = mu. + eval_gt = gt_grid[list(range(NUM_EVAL_SHAPES))] + eval_features = eval_gt.jagged_like(torch.ones(eval_gt.total_voxels, 1, device=device)) + _, _, _, recon_grid, _, _ = model(eval_features, eval_gt, None) + logging.info(f"reconstruction IoU on {NUM_EVAL_SHAPES} shapes: {grid_iou(recon_grid, eval_gt):.3f}") + + # Generation: decode novel shapes from the prior. + z = torch.randn(NUM_PRIOR_SAMPLES, LATENT_DIM, device=device) + _, _, _, sample_grid = model.decoder(z, None) + logging.info(f"prior samples decoded to {sample_grid.num_voxels.tolist()} voxels") + visualize(eval_gt, recon_grid, sample_grid) + + +if __name__ == "__main__": + main() diff --git a/examples/wip/structure_prediction_net.py b/examples/wip/structure_prediction_net.py deleted file mode 100644 index cabbe5cca..000000000 --- a/examples/wip/structure_prediction_net.py +++ /dev/null @@ -1,189 +0,0 @@ -# Copyright Contributors to the OpenVDB Project -# SPDX-License-Identifier: Apache-2.0 -# - -import os - -import fvdb.nn as fvnn -import numpy as np -import point_cloud_utils as pcu -import polyscope as ps -import torch -import torch.nn as nn -import torch.nn.functional as F -import torch_cudamanaged - -import fvdb - -torch.backends.cudnn.deterministic = True -np.random.seed(42) -torch.manual_seed(42) - - -class ConvBlock(nn.Sequential): - def __init__(self, in_channels: int, out_channels: int, order: str, num_groups: int): - super().__init__() - for i, char in enumerate(order): - if char == "r": - self.add_module("ReLU", fvnn.ReLU(inplace=True)) - elif char == "c": - conv = fvnn.SparseConv3d(in_channels, out_channels, 3, 1, bias="g" not in order) - conv.backend = "halo" - self.add_module("Conv", conv) - elif char == "g": - num_channels = in_channels if i < order.index("c") else out_channels - if num_channels < num_groups: - num_groups = 1 - self.add_module("GroupNorm", fvnn.GroupNorm(num_groups=num_groups, num_channels=num_channels)) - else: - raise NotImplementedError - - -class SparseDoubleConv(nn.Sequential): - def __init__(self, in_channels: int, out_channels: int, order: str, num_groups: int, encoder: bool): - super().__init__() - if encoder: - conv1_in_channels = in_channels - conv1_out_channels = out_channels // 2 - if conv1_out_channels < in_channels: - conv1_out_channels = in_channels - conv2_in_channels, conv2_out_channels = conv1_out_channels, out_channels - else: - conv1_in_channels, conv1_out_channels = in_channels, out_channels - conv2_in_channels, conv2_out_channels = out_channels, out_channels - - self.add_module("SingleConv1", ConvBlock(conv1_in_channels, conv1_out_channels, order, num_groups)) - self.add_module("SingleConv2", ConvBlock(conv2_in_channels, conv2_out_channels, order, num_groups)) - - -class StructPredictionNet(nn.Module): - def __init__(self): - super().__init__() - self.pre_conv = fvnn.SparseConv3d(3, 32, 3, 1) - self.pre_conv.backend = "halo" - self.dconv1 = SparseDoubleConv(32, 32, "gcr", 8, True) - self.dconv2 = SparseDoubleConv(32, 64, "gcr", 8, True) - self.dconv3 = SparseDoubleConv(64, 128, "gcr", 8, True) - - self.max_pool = fvnn.MaxPool(2) - self.up_sample = fvnn.UpsamplingNearest(2) - self.up_sample0 = fvnn.UpsamplingNearest(1) - - self.pad = fvnn.FillFromGrid() - - self.dconvd2 = SparseDoubleConv(192, 64, "gcr", 8, False) - self.dconvd1 = SparseDoubleConv(96, 32, "gcr", 8, False) - - self.struct_conv3 = fvnn.SparseConv3d(128, 2, 3, 1) - self.struct_conv3.backend = "halo" - self.struct_conv2 = fvnn.SparseConv3d(64, 2, 3, 1) - self.struct_conv2.backend = "halo" - self.struct_conv1 = fvnn.SparseConv3d(32, 2, 3, 1) - self.struct_conv1.backend = "halo" - - @classmethod - def struct_to_mask(cls, struct_pred: fvnn.VDBTensor): - # 0 is exist, 1 is non-exist - mask = struct_pred.jdata[:, 0] > struct_pred.jdata[:, 1] - return struct_pred.grid.jagged_like(mask) - - def forward(self, x: fvnn.VDBTensor): - x = self.pre_conv(x) - enc1 = x = self.dconv1(x) - x = self.max_pool(x) - enc2 = x = self.dconv2(x) - x = self.max_pool(x) - x = self.dconv3(x) - - x = self.pad(x, neck_grid) - struct2 = self.struct_conv3(x) - - x = self.up_sample(x, self.struct_to_mask(struct2)) - x = fvdb.jcat([x, self.pad(enc2, x)], dim=1) - x = self.dconvd2(x) - struct1 = self.struct_conv2(x) - - x = self.up_sample(x, self.struct_to_mask(struct1)) - x = fvdb.jcat([x, self.pad(enc1, x)], dim=1) - x = self.dconvd1(x) - struct0 = self.struct_conv1(x) - - x = self.up_sample0(x, self.struct_to_mask(struct0)) - - return x, struct0, struct1, struct2 - - -def normalize_pts(xyz: np.ndarray): - xyz_min = np.min(xyz, axis=0) - xyz_max = np.max(xyz, axis=0) - xyz_center = (xyz_min + xyz_max) / 2 - xyz_scale = np.max(xyz_max - xyz_min) * 1.2 - return (xyz - xyz_center) / xyz_scale + 0.5 - - -def visualize_grid(grid: fvdb.GridBatch): - ps.init() - xyz = grid.voxel_to_world(grid.ijk.float()) - for batch_idx in range(grid.grid_count): - pts = xyz[batch_idx].jdata.cpu().numpy() - ps.register_point_cloud(f"grid_{batch_idx}", pts, radius=0.0025) - ps.show() - - -def compute_loss(pd_struct: fvnn.VDBTensor, gt_grid: fvdb.GridBatch): - assert torch.allclose(pd_struct.grid.origins, gt_grid.origins) - assert torch.allclose(pd_struct.grid.voxel_sizes, gt_grid.voxel_sizes) - idx_mask = gt_grid.ijk_to_index(pd_struct.grid.ijk).jdata == -1 - idx_mask = idx_mask.long() - loss = F.cross_entropy(pd_struct.jdata, idx_mask) - return 0.0 if idx_mask.size(0) == 0 else loss - - -if __name__ == "__main__": - grid_resolution = 256 - device = "cudamanaged:0" - - voxel_size = 1 / grid_resolution - dragon_pts = pcu.load_mesh_v("/home/mcong/voxel-foundation/fvdb-example-data/meshes/dragon.ply") - dragon_pts = normalize_pts(dragon_pts) - dragon_pts = torch.from_numpy(dragon_pts).to(device).to(torch.float32) - - bunny_pts = pcu.load_mesh_v("/home/mcong/voxel-foundation/fvdb-example-data/meshes/bunny.ply") - bunny_pts = normalize_pts(bunny_pts) - bunny_pts = torch.from_numpy(bunny_pts).to(device).to(torch.float32) - - gt_grid = fvdb.GridBatch.from_points( - fvdb.JaggedTensor([dragon_pts, bunny_pts]), voxel_sizes=voxel_size, origins=[voxel_size / 2.0] * 3 - ) - # visualize_grid(gt_grid) - - gt_grid0 = gt_grid - gt_grid1 = gt_grid.coarsened_grid(2) - gt_grid2 = gt_grid.coarsened_grid(4) - - neck_grid = fvdb.GridBatch.from_dense( - gt_grid.grid_count, - [grid_resolution // 2 // 2] * 3, - device=device, - voxel_sizes=voxel_size * 4, - origins=[voxel_size * 2.0] * 3, - ) - assert torch.allclose(gt_grid.coarsened_grid(4).origins, neck_grid.origins) - # visualize_grid(neck_grid) - - input_x = fvnn.VDBTensor(gt_grid, gt_grid.ijk.float()) - net = StructPredictionNet().to(device) - - optimizer = torch.optim.Adam(net.parameters(), lr=0.001) - for i in range(1000): - output_x, pd_struct0, pd_struct1, pd_struct2 = net(input_x) - if i % 100 == 0: - visualize_grid(output_x.grid) - - loss = ( - compute_loss(pd_struct0, gt_grid0) + compute_loss(pd_struct1, gt_grid1) + compute_loss(pd_struct2, gt_grid2) - ) - print(f"step = {i}, loss: {loss.item()}") - optimizer.zero_grad() - loss.backward() - optimizer.step() diff --git a/fvdb/nn/__init__.py b/fvdb/nn/__init__.py index aae736736..ee3e85a88 100644 --- a/fvdb/nn/__init__.py +++ b/fvdb/nn/__init__.py @@ -6,6 +6,7 @@ BatchNorm, GroupNorm, MaxPool, + Prune, SparseConv3d, SparseConvTranspose3d, SyncBatchNorm, @@ -28,6 +29,7 @@ "BatchNorm", "GroupNorm", "MaxPool", + "Prune", "SimpleUNet", "SimpleUNetBasicBlock", "SimpleUNetBottleneck", diff --git a/fvdb/nn/modules.py b/fvdb/nn/modules.py index bb92a01a0..8452b171f 100644 --- a/fvdb/nn/modules.py +++ b/fvdb/nn/modules.py @@ -261,6 +261,58 @@ def forward( return coarse_grid.refine(self.scale_factor, coarse_data, mask, fine_grid=fine_grid) +@_trace_fvdb_nn_forward +class Prune(nn.Module): + """ + Prunes the topology of a :class:`fvdb.GridBatch` and its associated :class:`JaggedTensor` + features according to a boolean keep-mask with one entry per active voxel. Voxels where the + mask is ``False`` are removed from the output grid, and the corresponding feature rows are + removed from the output features. + + This module prunes *grid topology* (voxels), not network parameters — it is unrelated to + weight pruning as in :mod:`torch.nn.utils.prune`. It is typically used in generative + sparse decoders, where a classifier predicts which voxels of a generated topology to keep + (*e.g.* after a generative transposed convolution built with + :meth:`fvdb.ConvolutionPlan.from_grid_batch_transposed`). + + .. note:: + + Pruning preserves the canonical voxel order of the surviving voxels, so the returned + features remain aligned with the returned grid. Feature selection is differentiable + (gradients flow to the kept rows of ``data``); the mask itself is not differentiable. + + .. seealso:: + + :meth:`fvdb.GridBatch.pruned_grid` and :meth:`fvdb.JaggedTensor.rmask` for the + underlying operations. + """ + + def forward( + self, + data: JaggedTensor, + grid: GridBatch, + mask: JaggedTensor, + ) -> tuple[JaggedTensor, GridBatch]: + """ + Prune ``grid`` and ``data`` down to the voxels where ``mask`` is ``True``. + + Args: + data (JaggedTensor): Input features associated with ``grid``. + Shape: ``(batch_size, num_voxels_b, channels)``. + grid (GridBatch): The grid batch corresponding to ``data``. + mask (JaggedTensor): Boolean keep-mask with one entry per active voxel of ``grid``. + Shape: ``(batch_size, num_voxels_b)``. + + Returns: + pruned_data (JaggedTensor): Features of the surviving voxels, aligned with ``pruned_grid``. + pruned_grid (GridBatch): A new :class:`fvdb.GridBatch` containing only the voxels + where ``mask`` is ``True``. + """ + pruned_grid = grid.pruned_grid(mask) + pruned_data = data.rmask(mask.jdata) + return pruned_data, pruned_grid + + class _SparseConv3dBase(nn.Module): def __init__( self, diff --git a/fvdb/utils/examples/__init__.py b/fvdb/utils/examples/__init__.py index 87dfac22f..84b6d114a 100644 --- a/fvdb/utils/examples/__init__.py +++ b/fvdb/utils/examples/__init__.py @@ -3,6 +3,7 @@ # import hashlib import importlib +import json import logging import timeit from pathlib import Path @@ -17,7 +18,7 @@ from fvdb import GridBatch, JaggedTensor _EXAMPLE_DATA_REPO = "voxel-foundation/fvdb-example-data" -_EXAMPLE_DATA_REVISION = "613c3a4e220eb45b9ae0271dca4808ab484ee134" +_EXAMPLE_DATA_REVISION = "42ea11a3210677f7c010f93a2febf9760faa1641" def _import_optional(module_name: str) -> ModuleType: @@ -218,6 +219,41 @@ def load_car_4_mesh(skip_every=1, mode="vf", device=torch.device("cuda"), dtype= ) +def load_gso_shoes( + limit: Union[int, None] = None, device=torch.device("cuda"), dtype=torch.float32 +) -> List[List[torch.Tensor]]: + """Load the Google Scanned Objects "Shoe" meshes (254 scans, CC-BY 4.0). + + The subset lives in ``meshes/gso_shoes`` of the example-data snapshot; per-model + attribution and source URLs are recorded in its ``ATTRIBUTION.json`` manifest + (individual files are integrity-protected by the pinned data-repo revision, so + no per-file checksums are kept here). + + Args: + limit: Load only the first ``limit`` meshes in manifest order, or ``None`` for all 254. + device: Device for the returned tensors. + dtype: Floating dtype for the vertex tensors. + + Returns: + meshes: A list of ``[vertices, faces]`` tensor pairs, one per shoe. + """ + pcu = _import_optional("point_cloud_utils") + + shoes_dir = get_fvdb_example_data_path() / "meshes" / "gso_shoes" + with open(shoes_dir / "ATTRIBUTION.json") as fp: + entries = json.load(fp)["models"] + if limit is not None: + entries = entries[:limit] + logging.info(f"Loading {len(entries)} GSO shoe meshes...") + start = timeit.default_timer() + meshes = [] + for entry in entries: + v, f = pcu.load_mesh_vf(str(shoes_dir / entry["file"])) + meshes.append([torch.from_numpy(v).to(device=device, dtype=dtype), torch.from_numpy(f).to(device)]) + logging.info(f"Done in {timeit.default_timer() - start}s") + return meshes + + def plot_ray_segments(ray_o, ray_d, times, plot_every=1): ps = _import_optional("polyscope") @@ -248,5 +284,6 @@ def plot_ray_segments(ray_o, ray_d, times, plot_every=1): "load_bunny_mesh", "load_car_1_mesh", "load_car_2_mesh", + "load_gso_shoes", "plot_ray_segments", ] diff --git a/notebooks/04_shape_vae.ipynb b/notebooks/04_shape_vae.ipynb new file mode 100644 index 000000000..79179c9b5 --- /dev/null +++ b/notebooks/04_shape_vae.ipynb @@ -0,0 +1,519 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8ea3da0a", + "metadata": {}, + "source": [ + "# Generative Shape VAE: Interactive Sampling Demo\n", + "\n", + "This notebook trains the sparse voxel shape VAE from [`examples/shape_vae.py`](../examples/shape_vae.py) and then explores its latent space interactively:\n", + "reconstructing shapes, sampling novel shapes from the prior, and interpolating between shapes.\n", + "\n", + "The model is built from three fvdb pieces:\n", + "\n", + "- **Generative transposed convolutions** — `fvdb.ConvolutionPlan.from_grid_batch_transposed(..., target_grid=None)`\n", + " generates the complete (uncropped) transposed support, so the decoder can *create new voxel coordinates*.\n", + "- **`fvdb.nn.Prune`** — trims the generated topology with a per-voxel keep mask predicted by a classifier at\n", + " each level.\n", + "- A **ground-truth pyramid** built with `GridBatch.conv_grid(2, 2)` supplies per-level occupancy targets.\n", + "\n", + "Training takes about 1–2 minutes on a GPU." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0ea4bd79", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:36:59.092409Z", + "iopub.status.busy": "2026-09-01T06:36:59.092302Z", + "iopub.status.idle": "2026-09-01T06:37:00.598532Z", + "shell.execute_reply": "2026-09-01T06:37:00.597923Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using device: cuda\n" + ] + } + ], + "source": [ + "import pathlib\n", + "import sys\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "import tqdm\n", + "\n", + "# Reuse the data pipeline, model, and losses from examples/shape_vae.py.\n", + "repo_root = next(p for p in (pathlib.Path.cwd() / \"..\", pathlib.Path.cwd()) if (p / \"examples\" / \"shape_vae.py\").exists())\n", + "sys.path.insert(0, str((repo_root / \"examples\").resolve()))\n", + "import shape_vae as sv\n", + "\n", + "torch.random.manual_seed(0)\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "print(f\"Using device: {device}\")" + ] + }, + { + "cell_type": "markdown", + "id": "42288e91", + "metadata": {}, + "source": [ + "## The dataset\n", + "\n", + "The 254-model \"Shoe\" category of [Scanned Objects by Google Research](https://app.gazebosim.org/GoogleResearch)\n", + "(CC-BY 4.0, bundled with fvdb-example-data — see its `ATTRIBUTION.json` for per-model attribution). Each mesh is\n", + "voxelized to a sparse grid at resolution 64 inside the unit cube; the whole dataset is one pre-voxelized\n", + "`GridBatch`, and the input features are just a constant 1 per voxel — the network learns *topology*, not\n", + "appearance. One object category with real intra-class variation (runners, boat shoes, ballet flats, boots)\n", + "is exactly what makes latent-space interpolation and sampling interesting." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d685310c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:37:00.600302Z", + "iopub.status.busy": "2026-09-01T06:37:00.600092Z", + "iopub.status.idle": "2026-09-01T06:37:01.823394Z", + "shell.execute_reply": "2026-09-01T06:37:01.822707Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "254 shapes, 1737209 voxels total\n" + ] + } + ], + "source": [ + "import json\n", + "\n", + "from fvdb.utils.examples import get_fvdb_example_data_path\n", + "\n", + "gt_grid = sv.prepare_shapes(device)\n", + "with open(get_fvdb_example_data_path() / \"meshes\" / \"gso_shoes\" / \"ATTRIBUTION.json\") as fp:\n", + " shape_names = [m[\"name\"] for m in json.load(fp)[\"models\"]]\n", + "print(f\"{gt_grid.grid_count} shapes, {gt_grid.total_voxels} voxels total\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "20730e01", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:37:01.824892Z", + "iopub.status.busy": "2026-09-01T06:37:01.824685Z", + "iopub.status.idle": "2026-09-01T06:37:04.362407Z", + "shell.execute_reply": "2026-09-01T06:37:04.361810Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import point_cloud_utils as pcu\n", + "from mpl_toolkits.mplot3d.art3d import Poly3DCollection\n", + "\n", + "\n", + "def voxel_surface(ijk: np.ndarray, voxel_size: float) -> np.ndarray:\n", + " \"\"\"Triangles of the exposed voxel-cube faces (interior faces between adjacent voxels culled).\"\"\"\n", + " v, f = pcu.voxel_grid_geometry(ijk, voxel_size)\n", + " tris = v[f]\n", + " centroids = np.round(tris.mean(axis=1) / (voxel_size * 0.25)).astype(np.int64)\n", + " _, inverse, counts = np.unique(centroids, axis=0, return_inverse=True, return_counts=True)\n", + " return tris[counts[inverse] == 1]\n", + "\n", + "\n", + "def lambert_colors(tris: np.ndarray, base_rgb=(0.45, 0.62, 0.95), light=(0.4, 0.6, 1.0)) -> np.ndarray:\n", + " normals = np.cross(tris[:, 1] - tris[:, 0], tris[:, 2] - tris[:, 0])\n", + " normals /= np.linalg.norm(normals, axis=1, keepdims=True) + 1e-12\n", + " light_dir = np.asarray(light) / np.linalg.norm(light)\n", + " lambert = 0.35 + 0.65 * np.clip(normals @ light_dir, 0.0, 1.0)\n", + " return np.clip(lambert[:, None] * np.asarray(base_rgb)[None, :], 0.0, 1.0)\n", + "\n", + "\n", + "def plot_grids(grids_and_titles, panel_size=2.8):\n", + " \"\"\"Render each (GridBatch, batch_index, title) triple as a lit voxel surface in a row of 3D axes.\n", + "\n", + " The GSO scans follow the Gazebo z-up convention, so axes are plotted unswapped.\n", + " \"\"\"\n", + " n = len(grids_and_titles)\n", + " fig = plt.figure(figsize=(panel_size * n, panel_size))\n", + " for i, (grid, b, title) in enumerate(grids_and_titles):\n", + " ax = fig.add_subplot(1, n, i + 1, projection=\"3d\")\n", + " if grid.num_voxels_at(b) > 0:\n", + " ijk = grid.ijk[b].jdata.cpu().numpy()\n", + " tris = voxel_surface(ijk, 1.0 / sv.RESOLUTION)\n", + " ax.add_collection3d(Poly3DCollection(tris, facecolors=lambert_colors(tris), edgecolors=\"none\"))\n", + " lo, hi = tris.reshape(-1, 3).min(axis=0), tris.reshape(-1, 3).max(axis=0)\n", + " center, half = (lo + hi) / 2, (hi - lo).max() / 2 * 1.05\n", + " ax.set_xlim(center[0] - half, center[0] + half)\n", + " ax.set_ylim(center[1] - half, center[1] + half)\n", + " ax.set_zlim(center[2] - half, center[2] + half)\n", + " ax.set_box_aspect((1, 1, 1))\n", + " ax.view_init(elev=18, azim=-60)\n", + " ax.set_title(title, fontsize=9)\n", + " ax.set_axis_off()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "plot_grids([(gt_grid, b, shape_names[b][:24]) for b in range(8)])" + ] + }, + { + "cell_type": "markdown", + "id": "13b87532", + "metadata": {}, + "source": [ + "## Training\n", + "\n", + "The encoder strides each shape down four levels and global-average-pools into a 128-dimensional latent\n", + "(`mu`, `logvar`). The decoder broadcasts a latent over a dense $4^3$ \"neck\" grid (plus a learned positional\n", + "embedding) and then alternates generative transposed convolution → occupancy classifier → `Prune` for four\n", + "levels back to full resolution. While training, the keep mask is teacher-forced with the ground truth\n", + "(`keep |= target`). The loss is per-level binary cross-entropy plus a\n", + "down-weighted KL term.\n", + "\n", + "Each iteration trains on a random minibatch: the ground-truth `conv_grid(2, 2)` pyramid is built once for\n", + "the whole dataset, and a minibatch just sub-indexes every level (`GridBatch` indexing is cheap; per-iteration\n", + "CPU work — notably `ConvolutionPlan` construction for the changing generated topologies — is what bounds\n", + "throughput here)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "97a43a18", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:37:04.364309Z", + "iopub.status.busy": "2026-09-01T06:37:04.364175Z", + "iopub.status.idle": "2026-09-01T06:40:30.414043Z", + "shell.execute_reply": "2026-09-01T06:40:30.413305Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "training: 100%|██████████| 1500/1500 [02:15<00:00, 11.07it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "final loss 0.2523 (bce 0.2471, kld 0.5176)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "model = sv.ShapeVAE().to(device)\n", + "optimizer = torch.optim.Adam(model.parameters(), lr=sv.LEARNING_RATE)\n", + "gt_pyramid = sv.build_gt_pyramid(gt_grid)\n", + "\n", + "model.train()\n", + "for iteration in tqdm.trange(sv.NUM_ITERATIONS, desc=\"training\"):\n", + " idx = torch.randperm(gt_grid.grid_count)[: sv.BATCH_SIZE]\n", + " batch_gt = gt_grid[idx]\n", + " batch_pyramid = [level[idx] for level in gt_pyramid]\n", + " batch_features = batch_gt.jagged_like(torch.ones(batch_gt.total_voxels, 1, device=device))\n", + "\n", + " logits, targets, _, _, mu, logvar = model(batch_features, batch_gt, batch_pyramid)\n", + " loss, bce, kld = sv.vae_loss(logits, targets, mu, logvar)\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "print(f\"final loss {loss.item():.4f} (bce {bce.item():.4f}, kld {kld.item():.4f})\")" + ] + }, + { + "cell_type": "markdown", + "id": "5d487c75", + "metadata": {}, + "source": [ + "## Reconstructions\n", + "\n", + "Encode the training shapes and decode from `z = mu` with **no teacher forcing** — the decoder keeps only\n", + "the voxels its classifiers predict. We keep the full dataset's latents (`mu`) around for the interpolation\n", + "and interactive cells below." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "710021f2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:40:30.415727Z", + "iopub.status.busy": "2026-09-01T06:40:30.415517Z", + "iopub.status.idle": "2026-09-01T06:40:32.042307Z", + "shell.execute_reply": "2026-09-01T06:40:32.041617Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reconstruction IoU on 4 shapes: 0.458\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.eval()\n", + "with torch.no_grad():\n", + " all_features = gt_grid.jagged_like(torch.ones(gt_grid.total_voxels, 1, device=device))\n", + " mu, _ = model.encoder(all_features, gt_grid)\n", + "\n", + " eval_gt = gt_grid[list(range(4))]\n", + " _, _, _, recon_grid = model.decoder(mu[:4], None)\n", + "print(f\"reconstruction IoU on 4 shapes: {sv.grid_iou(recon_grid, eval_gt):.3f}\")\n", + "\n", + "plot_grids(\n", + " [(gt_grid, 0, \"gt\"), (recon_grid, 0, \"recon\"), (gt_grid, 1, \"gt\"), (recon_grid, 1, \"recon\")]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b5320053", + "metadata": {}, + "source": [ + "## Sampling novel shapes from the prior\n", + "\n", + "Because the decoder never sees the encoder's topology (no skip connections), we can decode latents drawn\n", + "from the prior, $z \\sim \\mathcal{N}(0, I)$, and get novel shoes that are not in the training set." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "4059d86d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:40:32.043883Z", + "iopub.status.busy": "2026-09-01T06:40:32.043740Z", + "iopub.status.idle": "2026-09-01T06:40:33.237405Z", + "shell.execute_reply": "2026-09-01T06:40:33.236812Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def decode_latents(z: torch.Tensor):\n", + " \"\"\"Decode a (batch, LATENT_DIM) tensor of latents into a GridBatch of generated topologies.\"\"\"\n", + " with torch.no_grad():\n", + " _, _, _, grid = model.decoder(z, None)\n", + " return grid\n", + "\n", + "\n", + "z = torch.randn(4, sv.LATENT_DIM, device=device)\n", + "samples = decode_latents(z)\n", + "plot_grids([(samples, b, f\"prior sample {b}\") for b in range(samples.grid_count)])" + ] + }, + { + "cell_type": "markdown", + "id": "89ac16cd", + "metadata": {}, + "source": [ + "## Latent interpolation\n", + "\n", + "Walk a straight line between two shapes' latents and decode each step. All the steps are decoded in one\n", + "batched call — the generated `GridBatch` simply has one grid per interpolation step." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "972eaa9d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:40:33.238798Z", + "iopub.status.busy": "2026-09-01T06:40:33.238683Z", + "iopub.status.idle": "2026-09-01T06:40:34.273130Z", + "shell.execute_reply": "2026-09-01T06:40:34.272599Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def interpolate(source: int, target: int, num_steps: int = 5):\n", + " t = torch.linspace(0.0, 1.0, num_steps, device=device).unsqueeze(1)\n", + " grids = decode_latents((1.0 - t) * mu[source] + t * mu[target])\n", + " plot_grids([(grids, i, f\"t = {t[i].item():.2f}\") for i in range(num_steps)])\n", + "\n", + "\n", + "def find_shape(substring: str) -> int:\n", + " return next(i for i, n in enumerate(shape_names) if substring in n)\n", + "\n", + "\n", + "flat_idx = find_shape(\"Tieks\") # a ballet flat\n", + "boot_idx = find_shape(\"UGG_Classic_Tall\") # a tall boot\n", + "interpolate(source=flat_idx, target=boot_idx)" + ] + }, + { + "cell_type": "markdown", + "id": "ebafa729", + "metadata": {}, + "source": [ + "## Interactive latent explorer\n", + "\n", + "If `ipywidgets` is installed (it ships with the `fvdb_learn` environment), the cell below gives you live\n", + "controls: pick two shapes, blend between them, and add prior noise. Each slider move decodes a fresh\n", + "topology through the generative decoder. Without `ipywidgets` (e.g. in CI), a single static frame is shown\n", + "instead." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd5f79c7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-01T06:40:34.274757Z", + "iopub.status.busy": "2026-09-01T06:40:34.274642Z", + "iopub.status.idle": "2026-09-01T06:40:35.059880Z", + "shell.execute_reply": "2026-09-01T06:40:35.059275Z" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "876ca5b1d970457aab116164c4fe87db", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=17, description='from', max=253), IntSlider(value=199, description='to',…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def explore(source: int, target: int, t: float, noise: float):\n", + " z = (1.0 - t) * mu[source] + t * mu[target] + noise * torch.randn(sv.LATENT_DIM, device=device)\n", + " decoded = decode_latents(z.unsqueeze(0))\n", + " plot_grids(\n", + " [\n", + " (gt_grid, source, shape_names[source][:24]),\n", + " (decoded, 0, f\"decoded (t={t:.2f}, noise={noise:.1f})\"),\n", + " (gt_grid, target, shape_names[target][:24]),\n", + " ]\n", + " )\n", + "\n", + "\n", + "try:\n", + " import ipywidgets\n", + "\n", + " n = gt_grid.grid_count\n", + " ipywidgets.interact(\n", + " explore,\n", + " source=ipywidgets.IntSlider(min=0, max=n - 1, value=flat_idx, description=\"from\"),\n", + " target=ipywidgets.IntSlider(min=0, max=n - 1, value=boot_idx, description=\"to\"),\n", + " t=ipywidgets.FloatSlider(min=0.0, max=1.0, step=0.05, value=0.5, description=\"blend\"),\n", + " noise=ipywidgets.FloatSlider(min=0.0, max=2.0, step=0.1, value=0.0, description=\"noise\"),\n", + " )\n", + "except ImportError:\n", + " print(\"ipywidgets is not installed - showing a single static frame instead.\")\n", + " print(\"Install it (`pip install ipywidgets`) and re-run this cell for live sliders.\")\n", + " explore(source=flat_idx, target=boot_idx, t=0.5, noise=0.0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "902a6b9f", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "fvdb", + "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.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/unit/test_nn_modules.py b/tests/unit/test_nn_modules.py index 50de6e349..c4e3ba482 100644 --- a/tests/unit/test_nn_modules.py +++ b/tests/unit/test_nn_modules.py @@ -154,6 +154,73 @@ def test_upsampling_forward(self, device, dtype): self.assertTrue(torch.equal(fine_data.jdata, expected_data.jdata)) self.assertEqual(fine_grid.total_voxels, expected_grid.total_voxels) + # ========================================================================= + # Prune + # ========================================================================= + + def test_prune_construction(self): + prune = fvnn.Prune() + self.assertEqual(len(list(prune.parameters())), 0) + self.assertIn("Prune", repr(prune)) + + @expand_tests(all_device_dtype_combos) + def test_prune_forward(self, device, dtype): + grid = self._make_dense_grid(device, batch_size=2, shape=(6, 6, 6)) + features = self._make_features(grid, 4, device, dtype) + mask = torch.rand(grid.total_voxels, device=device) > 0.5 + jmask = grid.jagged_like(mask) + + prune = fvnn.Prune() + pruned_data, pruned_grid = prune(features, grid, jmask) + + # Topology matches the underlying pruned_grid op and preserves canonical voxel order. + self.assertEqual(pruned_grid.total_voxels, int(mask.sum().item())) + self.assertTrue(torch.equal(pruned_grid.ijk.jdata, grid.ijk.jdata[mask])) + + # Features are the kept rows, aligned with the pruned grid. + self.assertTrue(torch.equal(pruned_data.jdata, features.jdata[mask])) + + # Per-batch row counts are consistent with per-batch mask sums. + for b in range(grid.grid_count): + kept_b = int(mask[grid.ijk.jidx == b].sum().item()) + self.assertEqual(pruned_grid.num_voxels_at(b), kept_b) + self.assertEqual(pruned_data[b].jdata.shape[0], kept_b) + + @expand_tests(all_device_dtype_combos) + def test_prune_forward_all_false_all_true(self, device, dtype): + grid = self._make_dense_grid(device, batch_size=2, shape=(4, 4, 4)) + features = self._make_features(grid, 3, device, dtype) + prune = fvnn.Prune() + + all_false = grid.jagged_like(torch.zeros(grid.total_voxels, dtype=torch.bool, device=device)) + pruned_data, pruned_grid = prune(features, grid, all_false) + self.assertEqual(pruned_grid.total_voxels, 0) + # The batch still contains grid_count grids; they just have no active voxels. + self.assertEqual(pruned_grid.grid_count, grid.grid_count) + for b in range(pruned_grid.grid_count): + self.assertEqual(pruned_grid.num_voxels_at(b), 0) + self.assertEqual(pruned_data.jdata.shape[0], 0) + + all_true = grid.jagged_like(torch.ones(grid.total_voxels, dtype=torch.bool, device=device)) + pruned_data, pruned_grid = prune(features, grid, all_true) + self.assertTrue(torch.equal(pruned_grid.ijk.jdata, grid.ijk.jdata)) + self.assertTrue(torch.equal(pruned_data.jdata, features.jdata)) + + @expand_tests(all_device_dtype_combos) + def test_prune_gradient(self, device, dtype): + grid = self._make_dense_grid(device, batch_size=2, shape=(4, 4, 4)) + data = torch.randn(grid.total_voxels, 3, device=device, dtype=dtype, requires_grad=True) + features = grid.jagged_like(data) + mask = torch.rand(grid.total_voxels, device=device) > 0.5 + + pruned_data, _ = fvnn.Prune()(features, grid, grid.jagged_like(mask)) + pruned_data.jdata.sum().backward() + + assert data.grad is not None + expected_grad = torch.zeros_like(data) + expected_grad[mask] = 1.0 + self.assertTrue(torch.equal(data.grad, expected_grad)) + # ========================================================================= # SparseConv3d # =========================================================================