From f6eab9d5fe49f7b1e967379f31b02e17affd86f4 Mon Sep 17 00:00:00 2001 From: Jonathan Swartz Date: Tue, 1 Sep 2026 11:18:54 +1200 Subject: [PATCH 1/7] Add fvdb.nn.Prune and generative shape completion / VAE examples Add a Prune module to fvdb.nn (the MinkowskiPruning analog): prunes grid topology and its aligned features by a per-voxel boolean mask, built on GridBatch.pruned_grid + JaggedTensor.rmask, differentiable through the kept feature rows. Add two examples mapping one-to-one onto MinkowskiEngine's canonical generative examples, built on the generative transposed convolution semantics from #726 (ConvolutionPlan.from_grid_batch_transposed with target_grid=None): - examples/shape_completion.py (analog of ME examples/completion.py): sparse encoder-decoder completing a slab-cropped shape, per-level occupancy classifiers, teacher-forced pruning, additive U-Net skips via inject_from. GT level targets come from a conv_grid(2, 2) pyramid queried with coords_in_grid. - examples/shape_vae.py (analog of ME examples/vae.py): shape VAE with a jagged global-pooling latent bottleneck, dense-neck decoder seeded from the latent plus a learned positional embedding, KL + per-level BCE loss, and prior-sampling demo. Both examples train on bundled fvdb-example-data meshes in ~1-2 minutes and run headlessly under tests/test_examples.py. Addresses #741. Signed-off-by: Jonathan Swartz --- docs/api/nn.rst | 1 + examples/shape_completion.py | 263 +++++++++++++++++++++++++++++ examples/shape_vae.py | 309 ++++++++++++++++++++++++++++++++++ fvdb/nn/__init__.py | 2 + fvdb/nn/modules.py | 53 ++++++ tests/unit/test_nn_modules.py | 67 ++++++++ 6 files changed, 695 insertions(+) create mode 100644 examples/shape_completion.py create mode 100644 examples/shape_vae.py 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/examples/shape_completion.py b/examples/shape_completion.py new file mode 100644 index 000000000..0799e4b9d --- /dev/null +++ b/examples/shape_completion.py @@ -0,0 +1,263 @@ +# Copyright Contributors to the OpenVDB Project +# SPDX-License-Identifier: Apache-2.0 +# +"""Sparse 3D shape completion with generative transposed convolutions. + +This example is the fvdb analog of MinkowskiEngine's ``examples/completion.py``. +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, exactly like MinkowskiEngine's completion network. + +MinkowskiEngine to fvdb mapping: + +- ``MinkowskiGenerativeConvolutionTranspose`` -> + :class:`fvdb.nn.SparseConvTranspose3d` executed with a plan from + :meth:`fvdb.ConvolutionPlan.from_grid_batch_transposed` with ``target_grid=None``, + which generates the complete (uncropped) transposed support. +- ``MinkowskiPruning`` -> :class:`fvdb.nn.Prune`. +- ``get_target`` (per-level occupancy labels via strided coordinate keys) -> + a ground-truth pyramid built with :meth:`fvdb.GridBatch.conv_grid` (kernel 2, + stride 2) queried with :meth:`fvdb.GridBatch.coords_in_grid`. ``conv_grid(2, 2)`` + maps ``coarse = floor(fine / 2)``, the same lattice relation MinkowskiEngine uses + for its stride-2 pyramid (do NOT use ``coarsened_grid`` here - it has different, + block-centroid semantics). +- Teacher forcing (``keep += target`` while training) is reproduced verbatim. + +Kernel-anchoring note: MinkowskiEngine anchors even kernels at the corner of the +``[0, K)`` window, while fvdb centers kernels via ``padding = floor((K - 1) / 2)`` +(see fvdb-core PR #726). MinkowskiEngine's completion decoder relies on a +kernel-size-4 first transpose to reach coordinates beyond the partial input's +coarse support. Here shapes are normalized into ``[0, 1)`` (all-positive ijk, like +MinkowskiEngine's quantized coordinates) and the crop keeps enough of the shape +that its coarsest support matches the full shape's, so completion is structurally +reachable; we keep a kernel-size-4 first transpose to mirror MinkowskiEngine. + +Unlike the MinkowskiEngine example (ModelNet40, 30k iterations), this example +overfits two bundled meshes for a few hundred iterations so it runs in a couple of +minutes; crank up the constants below for a real experiment. +""" + +import logging + +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 +import fvdb.nn as fvnn +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, + # the fvdb equivalent of MinkowskiGenerativeConvolutionTranspose. + 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, mirroring MinkowskiEngine's CompletionNet.""" + + 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 (as in MinkowskiEngine); 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) - MinkowskiEngine's `dec + enc`. + 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, as in MinkowskiEngine + 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..2029f2e36 --- /dev/null +++ b/examples/shape_vae.py @@ -0,0 +1,309 @@ +# Copyright Contributors to the OpenVDB Project +# SPDX-License-Identifier: Apache-2.0 +# +"""Sparse 3D shape variational autoencoder with generative transposed convolutions. + +This example is the fvdb analog of MinkowskiEngine's ``examples/vae.py``. 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. + +MinkowskiEngine to fvdb mapping (see ``shape_completion.py`` for the shared +decoder pattern and lattice/anchoring notes): + +- ``MinkowskiGenerativeConvolutionTranspose`` -> + :meth:`fvdb.ConvolutionPlan.from_grid_batch_transposed` with ``target_grid=None``. +- ``MinkowskiPruning`` -> :class:`fvdb.nn.Prune`. +- ``MinkowskiGlobalPooling`` -> a jagged global average pool + (:meth:`fvdb.JaggedTensor.jsum` divided by voxel counts). MinkowskiEngine + instead strides all the way down to a single voxel per shape at + ``tensor_stride = resolution``; global pooling over the jagged batch is the + idiomatic fvdb equivalent. +- MinkowskiEngine seeds its decoder with one voxel per shape at the coarsest + stride; here the decoder starts from a small dense "neck" grid (4^3 voxels at + stride 16) built with :meth:`fvdb.GridBatch.from_dense`. The latent vector is + broadcast to every neck voxel and combined with a learned per-voxel positional + embedding (without it the broadcast features would be spatially identical and + the decoder could not tell neck positions apart). The first decoder level then + learns which neck children to keep. + +Deviations from MinkowskiEngine, chosen so the example trains in minutes on the +bundled meshes instead of hours on ModelNet40: a 6-shape dataset (4 cars, dragon, +happy Buddha), Adam instead of SGD, and a down-weighted KL term (``KLD_WEIGHT``) +since a 6-shape "dataset" is an overfit regime. +""" + +import logging + +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_car_1_mesh, + load_car_2_mesh, + load_car_3_mesh, + load_car_4_mesh, + load_dragon_mesh, + load_happy_mesh, +) + +import fvdb +import fvdb.nn as fvnn +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 = 1000 +LEARNING_RATE = 1e-3 +LOG_EVERY = 50 +NUM_PRIOR_SAMPLES = 4 + + +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 six bundled triangle meshes into a single GridBatch 'dataset'.""" + loaders = ( + load_car_1_mesh, + load_car_2_mesh, + load_car_3_mesh, + load_car_4_mesh, + load_dragon_mesh, + load_happy_mesh, + ) + meshes = [loader(mode="vf", device=device) for loader in loaders] + 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, + # the fvdb equivalent of MinkowskiGenerativeConvolutionTranspose. + 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 (MinkowskiGlobalPooling analog). + 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. (MinkowskiEngine's + # single-voxel seed gets this for free - every descendant has a unique kernel-tap + # path from the root.) + 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, as in MinkowskiEngine + 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) + gt_pyramid = build_gt_pyramid(gt_grid) + input_features = gt_grid.jagged_like(torch.ones(gt_grid.total_voxels, 1, device=device)) + 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"): + logits, targets, _, _, mu, logvar = model(input_features, gt_grid, gt_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 each training shape and decode from z = mu. + _, _, _, recon_grid, _, _ = model(input_features, gt_grid, None) + logging.info(f"reconstruction IoU vs ground truth: {grid_iou(recon_grid, gt_grid):.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(gt_grid, recon_grid, sample_grid) + + +if __name__ == "__main__": + main() 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..fb70b62ed 100644 --- a/fvdb/nn/modules.py +++ b/fvdb/nn/modules.py @@ -261,6 +261,59 @@ 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 the fvdb analog of + ``MinkowskiPruning`` from the MinkowskiEngine library and 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/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 # ========================================================================= From aa562d08285a707c20f8e36f3a76067d4d19ceda Mon Sep 17 00:00:00 2001 From: Jonathan Swartz Date: Tue, 1 Sep 2026 11:47:25 +1200 Subject: [PATCH 2/7] Add interactive shape VAE sampling notebook notebooks/04_shape_vae.ipynb trains the shape VAE from examples/shape_vae.py and explores its latent space: reconstructions, prior sampling, batched latent interpolation, and an ipywidgets-based interactive latent explorer (blend between shapes, add prior noise) with a static fallback when ipywidgets is unavailable (e.g. in CI). Executed outputs are stored so the notebook renders on GitHub (reconstruction IoU 0.999; tqdm progress spam stripped). Runs under pytest --nbmake in ~87 s on GPU. Adds ipywidgets to the fvdb_learn environment for the interactive path. Signed-off-by: Jonathan Swartz --- env/learn_environment.yml | 1 + notebooks/04_shape_vae.ipynb | 453 +++++++++++++++++++++++++++++++++++ 2 files changed, 454 insertions(+) create mode 100644 notebooks/04_shape_vae.ipynb 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/notebooks/04_shape_vae.ipynb b/notebooks/04_shape_vae.ipynb new file mode 100644 index 000000000..00d46f959 --- /dev/null +++ b/notebooks/04_shape_vae.ipynb @@ -0,0 +1,453 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "2dab3eeb", + "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)\n", + "(the fvdb analog of MinkowskiEngine's `examples/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", + " (the `MinkowskiGenerativeConvolutionTranspose` analog).\n", + "- **`fvdb.nn.Prune`** — trims the generated topology with a per-voxel keep mask predicted by a classifier at\n", + " each level (the `MinkowskiPruning` analog).\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. See the module docstring of `examples/shape_vae.py` for the full\n", + "MinkowskiEngine-to-fvdb mapping and design notes." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "6f2e6704", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:44:57.925181Z", + "iopub.status.busy": "2026-08-31T23:44:57.925078Z", + "iopub.status.idle": "2026-08-31T23:44:59.371305Z", + "shell.execute_reply": "2026-08-31T23:44:59.370717Z" + } + }, + "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": "7c1be16e", + "metadata": {}, + "source": [ + "## The dataset\n", + "\n", + "Six bundled meshes (four cars, the dragon, and the happy Buddha), each voxelized to a sparse grid at\n", + "resolution 64 inside the unit cube. The whole \"dataset\" is one `GridBatch`, and the input features are\n", + "just a constant 1 per voxel — the network learns *topology*, not appearance." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "662fbeb6", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:44:59.372891Z", + "iopub.status.busy": "2026-08-31T23:44:59.372711Z", + "iopub.status.idle": "2026-08-31T23:45:00.801439Z", + "shell.execute_reply": "2026-08-31T23:45:00.800778Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6 shapes, per-shape voxel counts: [8031, 9048, 8119, 5854, 8559, 6782]\n" + ] + } + ], + "source": [ + "gt_grid = sv.prepare_shapes(device)\n", + "gt_pyramid = sv.build_gt_pyramid(gt_grid)\n", + "input_features = gt_grid.jagged_like(torch.ones(gt_grid.total_voxels, 1, device=device))\n", + "shape_names = [\"car 1\", \"car 2\", \"car 3\", \"car 4\", \"dragon\", \"happy\"]\n", + "print(f\"{gt_grid.grid_count} shapes, per-shape voxel counts: {gt_grid.num_voxels.tolist()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6e874a5e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:45:00.803406Z", + "iopub.status.busy": "2026-08-31T23:45:00.803166Z", + "iopub.status.idle": "2026-08-31T23:45:01.522881Z", + "shell.execute_reply": "2026-08-31T23:45:01.522196Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_grids(grids_and_titles, point_size=1.0, panel_size=2.6):\n", + " \"\"\"Scatter the voxel centers of each (GridBatch, batch_index, title) triple in a row of 3D axes.\"\"\"\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", + " pts = grid.voxel_to_world(grid.ijk.float())[b].jdata.cpu().numpy()\n", + " ax.scatter(pts[:, 0], pts[:, 2], pts[:, 1], s=point_size)\n", + " ax.set_title(title, fontsize=9)\n", + " ax.set_xlim(0, 1), ax.set_ylim(0, 1), ax.set_zlim(0, 1)\n", + " ax.set_axis_off()\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "plot_grids([(gt_grid, b, shape_names[b]) for b in range(gt_grid.grid_count)])" + ] + }, + { + "cell_type": "markdown", + "id": "f0653dbe", + "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`), exactly as in MinkowskiEngine. The loss is per-level binary cross-entropy plus a\n", + "down-weighted KL term." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "47907ec9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:45:01.524625Z", + "iopub.status.busy": "2026-08-31T23:45:01.524482Z", + "iopub.status.idle": "2026-08-31T23:46:20.716367Z", + "shell.execute_reply": "2026-08-31T23:46:20.715830Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "final loss 0.0058 (bce 0.0034, kld 0.2453)\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", + "\n", + "model.train()\n", + "for iteration in tqdm.trange(sv.NUM_ITERATIONS, desc=\"training\"):\n", + " logits, targets, _, _, mu, logvar = model(input_features, gt_grid, gt_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": "9d87281e", + "metadata": {}, + "source": [ + "## Reconstructions\n", + "\n", + "Encode every training shape and decode from `z = mu` with **no teacher forcing** — the decoder keeps only\n", + "the voxels its classifiers predict." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "333f0aa5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:46:20.718058Z", + "iopub.status.busy": "2026-08-31T23:46:20.717845Z", + "iopub.status.idle": "2026-08-31T23:46:21.199579Z", + "shell.execute_reply": "2026-08-31T23:46:21.198922Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "reconstruction IoU vs ground truth: 0.999\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/MAAAEGCAYAAAApPMUgAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUSZJREFUeJzt3Qd4nNWV//Gfem+WLEtyl3sv2Bjb9N4JkNAJEBZISDZl8w/JkrbJJqRDAgECIUAoIQkECL2DaS7g3rtluahYvY00kub/nGvLKxsXyZY0846+n+cR2CqjV2Pdd+6599xzIgKBQEAAAAAAAMAzIoN9AQAAAAAAoHMI5gEAAAAA8BiCeQAAAAAAPIZgHgAAAAAAjyGYBwAAAADAYwjmAQAAAADwGIJ5AAAAAAA8hmAeAAAAAACPIZgPA3PmzNFzzz0X7MsA4AG///3vtWXLlmBfBgAAAI4SwXwYePPNN/WPf/wj2JcBwAN++ctfasOGDcG+DAAAAByl6KN9AHSd7du368knn9Rtt93G0woAAEJmbvCzn/1s759nzJihM844I6jXAyA0LVmyRC+99NLev99yyy3q27dvUK8pnLEzH0IKCwv105/+NNiXAQAAQkSozA18Pp97e+SRR/Tyyy8H+3IAhKiWlhZ3rygtLdUPf/hDFRcXB/uSwho78z3MfrlfeOEF9ws+a9YsVVdXq7y8XGeffbYeffRR+f3+vavfn/vc5zR+/PjPPEZjY6P+/e9/u8eYPXv2Z170LeX+pptu0uuvv66dO3fq+uuv1z333OM+npSUpEmTJunUU0/t0HVdfPHF7uOtra167bXXtG7dOg0ePFjnnnuu4uLi9vmeN998s1599VU3aE855RRNmDCh255HIBSsWrVKH374oS666CK99dZbbhzdeOONbvzY+LMdtYkTJ35mvNXU1LiP79ixQyeccIKmTJmy92M2Zu3ojH2O7X5NmzZt78defPFFJSYmKjc319XKSEhI0KWXXqqUlJSDXuOmTZvc90pNTdU555yzz8faHq9fv37u5xg1apQiIyP1wQcfKCIiQjk5OTrttNM0ZMiQfb7O0vTtGu0x7d71+OOPu/tV2+d19c8AhLuumBuYjz76yO2KZWdnu8+LiYlRVVXVIecAB5o3fOMb3/jMY7d9/08//bSbngUgPHhhbnCw72Vff6g5wIHmDTbnb++YY45xb9u2bdPdd9/dJc8pDo6d+R5kg/n444/XL37xC61fv15f+tKXXOqJvYgGAgEXpNv/21a/bWVrf/Y5J554on7+85+7wNoC9WeeeWbvxwsKCvSDH/xAJ510kruB1NfX7/OY9nG7oXzlK1/p0HUZm0TYQP32t7+tzZs3u+9tN5HKysp9vqcN+HfffVcLFy7Uscceq/fee69HnlcgWJYtW6bbb79dp59+uubOnevG0ooVK9xE2ybgNjZuvfVWN07bf82YMWN07733auPGjW4R7Iknntg7ER87dqyef/55rVy5UmeeeaZ+/OMf7/3af/3rX/rqV7/qxqiN1fvvv99N/Jubmw94ffaiPHnyZPf/999/371g19bWfubxrrvuOnctNtbtzX6OhoYGvfPOO+4F3r62Tdv77MXe3ux+ZOO/7Rx+V/8MQLjrirmBLbh//vOf1+WXX+7Gnc0Lzj//fPexw80BDjRvABC+c4NDfa/DzQEONG9AkAXQY+65557AqFGjAk1NTe7vPp8vkJ+fH7j88svd3+fOnRtISko65GPce++9geHDh7uvNQ0NDYGhQ4fufYwPPvggYP+sb7/99kEfY9euXYHU1NTAxo0bO3Rd9913X2DAgAGBuro693e/3x+YOnVq4Lvf/e4+33PevHl7v8dNN90UuOGGG47i2QJC31NPPRWIjIwMrFq1au/7TjzxxMDtt9++9+/V1dWB7OxsN07MrFmzArfeeuvej7e0tARWrFjh/mzj6jvf+c7ej9mYioqKCqxdu9b9/brrrgtMnjw50Nzc7P5uYzI5OTnw0UcfHfD6pkyZEvjJT36y9+8vv/yyG6tvvvnm3scbOXLk3rF/IH/84x8Dp5566t6/T5o0KXDHHXfs/furr766z2N29c8AhLuumBs8/PDDgZycnEB5efne9y1btqxDc4COzBvaO+usswLf+MY3OvzzAb1NqM8NDvW9DjcH6Mi8oU1hYaG7tyxfvvywn4sjR5p9D1qwYIFLc7W0N2Np6pZCV1ZW1uHHmD9/vs4777y9Ke7x8fHuMds/hn1s/5QXS6N54403VFRU5FbqLEXG0oDy8/MPe13z5s1zafX2NSY6OtqlDtmKXRv7mKX9tBkxYsQ+HwfClR07sRVuYyvUH3/8sUaPHr1Psai0tDSXmmoZKzbe7rzzzr0fs7T2cePGud03S4/905/+tPdjNqby8vLc14wcOdK9z3bCo6Ki9o47+7il3+3PHm/p0qV67LHH9r7PxrndM9qzjJq2sd/GUufsay37xtLkbCeg7TGXL1/uinG1Oeuss/Y+Zlf/DEBv0BVzA9s5s534jIyMve9rf9TtUHOAg80bAITf3KCpqemg3+twc4BDzRsQPKTZ9zA7g7LPP0Bk5/4JLF3ucI9hE+v2n2Pp7jbY7cy7TQ4sfcYepy1N/nDXZZ+7//ewv9v72+w/qO3x2n8cCFdti1zG0l/t995SXtvSWu3tsssuc+fj7GMHGsOmbbx01Vg70PeyP+//vdtfv7E0vS9+8YsuJbCurs698LfdKw73mF39MwC9RXfMDTozB9h/3gCg98wNOjoHONDPhuAjmO9BVgzCik20nXezlTr7e/vBYYPmUJNaO6tuL8ht52D2f4wDefrpp3XVVVfp73//u37zm9/o61//uhugHb2u6dOnu7/b6qCxm5EV6rGVRADaZ0Js48l2u2z1ve3NzqfaqrftftnHn3rqqb1fY+Pd6l/Y19p5Oitu2WbRokVuVbx9oZuOans8K1bTxs7D2jm4g7Fr+dvf/ubuFXbm7o477nDFsto/pv0c7StZv/3223sfs6t/BqA36Iq5gRXDtXFpBbbarFmzpkNzAAC9Z25wqO91uDkAQhNp9j3IKsU+9NBD7kX35JNPdmnoFhi3rbYNHz7cVYe2ohK2in6girX2GH/5y1/cY1hKXNtjHIoVvbKvs+qWsbGxrvdjW5p+R67LCmNYtWpL67HUPyt6VVFRoe9973vd8jwBXvbAAw+4dFc7nmLjd8uWLe6F1zo9GCs4Y8dWbKJtL5I2nmwM2pi/66673Li3ojJWKdZS5L/1rW/tTdXrrN/+9re65JJLtHbtWndvsUq4h1pRt5V6K8RlY/6CCy5w127Fe9r79a9/7QptrV692j2mpe7aY7bdL7r6ZwDCXVfMDWw37dlnn3X3FBvztgNvFbNtzB9uDtBRdo2Wpm8dMmzRwIIRC0Taut4A8Mbc4FDf63BzgI6w9H6LVdoWFx988EHXYeOaa675THccHD2C+R5kE14bxFZl1trPWLsG69fa9oJtH7cz8bbrbS1pDlSx1l6MbWDZSrs9hrWbsfYS9vlm0KBB+s53vrPP11xxxRXu7IydgbHv8corr7jd/bbzdIe7LnvRt7M+tipoK3dWgdNevNuCggN9z5kzZ7qBC4Qzm8ha1en2rHq8Bbo2YbYXQntB/POf/7x3vNhKetvHrY2jnVtrqzdhbWostc1e3G1cW+Vae2Ftc+GFF34mGLeV/YO9oFvF208++cQ9ngUD3//+993YHjp06EEfz+4///znP7V161a3eGcTdqu+28bO9tpj2j3EHvO2225zL8529q87fgYg3HXF3MDOytqYs8U1O+s6depUfeELX+jQHOBAr+EHYtl5banBxv5MJWvAe3ODQ32vw80BDvS99tfWQcMWD23e0Xa/ONC9C0cvwqrgdcHjoINsRbut4Iy1f7FiGD/5yU90ww03BPU5DNXrAhBaSkpKXK9qezPPPfecrr32WheE2GIjgM7jNRgAcCQI5nuYpb/Z+ZcBAwa41a8+ffq4lLr9K0xzXQBCkfWwvfTSS101W9shsHN31h/bzuECCK+5AQAgtBHM9zBLSbN09Q0bNrizKZauYq3egi1UrwtA6LH0O0vPs/uGtcOZMmVKsC8J8DRegwEAR4JgHgAAAAAAj6E1HQAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeEyvDOabmlsVCASCfRkAgqClNaDmllaeewAAAHhatHqZeRvL9OD7G5WXnqDjhmVqbG6q8vsmB/uyAPSA7RUN+tVrq9XaGtDpY3PUPyNB04f04bkHAACA50QEeskWte3GPfrRJj02t0CltY2KiYxUWmKMRvVL0f3XHKPoqF6ZpAD0Cnabm7O2VL97Y60276pTRISUlhCj3PQE/erSiSzoAQAAwHPCOph/edlObSyt1XkTcvS7N9bpzVXF8rfu++MmxUbpphPz9fljBmhARmLQrhVA11pSWKl3Vhfr5FF99dHGXfrTuxtV729V+ztATKR09oRc3XRCviYOSOefAAAAAJ4RNsG8/RjLtlUpKS5aAzISdN97G/Svhdvlb25RRGSEiqsbD/q1iTGROn1sP9195dQevWYAXcd23CvqmzRlYLpeWLpD9727UaW1PiVER6q4plHNBzkmHx0pHTO4j/5wxRTlpMXzTwIAAABPCItg3udv0V8/3qLnFm9XXEykMpNitWRrhRqaWtXU0qqWDvyEibFRunrGIE0emK6zxuWQdg94hN3C3lpdorvfXidLvBmSmahPt1Soxtckf0tA/g7UurOA/oKJuZo2JFMXTM5TanxMT1w6AAAA0LuD+Uc+2qwH39+kkhqfIiTFRkeqwd+qiIDUmZrVdmo+ITZSY/PS9KXZQ5WdGqcJ/dPd4wEITXM3luknL67UxpIal0Jv49XX9H/p9B29wbl7R1SEBmYm6apjB7q0++HZyUpPjO3GqwcAAAB6cTX7XTVNLr22rdtUq23FdTKQd18nqa6pVcsKK11w0CcpVlfPGKyrjxvcHZcNoAs0NDVrZ5XPpdFb4N7a1NrpsW/saxtbAtqyq1b3vrtBWclxmjIoQ7+8dCL/TgAAAAg5nt9yfm7RNr20bLua2uXSWqpt4Ch+WJvQl9Y0aktZnVbvrNbSwko1NLWoqMpHf3oghNjY/MPb69XQ5N875o+2g7wtCpTX+bVlV502lNRqYYGl7Pu1o7KB/vQAAAAIGZ5Ps7/5sU81Z12pGg9W3eooxUdHqE9ijCIjo+RrbtE3Txuha2YO6ZbvBaBzHpizUfe8s0G1jc3d8tRZtXtLs0+Oj1ZVvV8njuyr318xhX8mAAAABJ3nd+ajIu2ka/etR/iaA9pR3aRtlQ3aVdukhz7crJ2V9fK35fQDCOr4j+jG8W8JP6W1Tdq8q17l9X69tqJIq3dWydfUPYsHAAAAQK85Mx8XHalAoHsD+va2lNVr5i/fdbv1p4zO1rnjc3TqmH6KiLBrANCTEmKjOtStoqv4mlt1zh8+VEJMpOtff1x+lq6YPlBxMVE9dxEAAABAOKTZ/+9LK/WPT7epobG5Ryf17cVERWhWfqbuuWqqUhN2t7TaVFqrvy8o1LQhGZo0IE2JcdFKod0V0OU1M3756hpV1DWqKUjJMpYcNDQrUfdcdYzG5qa699kZ+798sNndDy6anCe7y2Ymx7LoBwAAgC7j+WB+2bZKfeWJRSqpbuhQP+nulJYQo/uvnurO8S4prHTneJNiI11BrcjISN168jBXIfvsCTn0sQa6gJ1jv+6R+Vqzs8btmgdTdGSEfn/FZH2wrlTvri1ReV2TEmKi3FEAa5V54aRcTR3cR7OGZWpwZlJQrxUAAADe5/lg3udv1hl3vq/CigaFgpjICPmtnP4BWGquHQu4YXa+vnH6iB6/NiAc3fTXT/TW6pIeOmhzaNGRu6vhH4j1sI+PidKkgel6/MYZPX1pAAAACDOeL4AnRewpghUaDhbIG5+/VXalWSmxPXpNQDiz8+qhUrLiUMkBTS0BNbcElJ0S15OXBAAAgDDl+WDedrrOn5jrzq2GOgvzbzh+iK6cPijYlwKEjWtnDlJslDduZTPy++jnF08I9mUAAAAgDHi+mn1pTaM+3VyhQ2yIhxQriBXphZUHwAOsReRbq0rU5JFWkYkxUW4BEkDoenHJDi3cWq7Tx+SoqaVF4/PSlJYYo1eW73RzjckD0jWwT6Ji7VwNgLBiNa+eXbRNxwzOUJ+kWOWkxmt4drLmrCvVjsoGTeifpqFZSUqmqDVChKfPzK/YXqXfvLZG8zaVqTFYpew7KSs5Rl85aYRLtT9tTD8lx3l+PQUIil21jfr1a2v06ooi1fi80fc9KTZKnz9mgKYOztDUQRkuIAAQOouDv3t9rZ6YX6CWllalJkSrtrHFdaGw4zF1jc1q8LcoKiJC04b00bkT8jQyJ9l1saA9LeB9zy/epjteWaPqBr+S46PU6G9VS+vu43FNzQHVNfnd5w3NStYVxw5S/4wEzR6W6cY/9wAEi6eD+T++s14Pvr9J1R6ZyJuIPb2x46Mjde3MIfrWGSODfUmAJ729ulg/fmGFdlT45I19+d3ioiOUEBvtdvue+A8K4QGhsjj4naeX6MP1uzrUGccK2lp3muyUWGUmx2v6kAyNyknV+P5pbjcPgHfY4t1v31yrRz/a4rrPdKQltY3/fimxykiKczv1J47sqyGZSRqSRbca9CxPbwtbMSlbJfcSWzmpb2pxb88sLNQVxw5UblpCsC8L8JyYqEjXms5LgbxpbA6osdmvhVvKXFbRcfmZwb4koFdbuaNKtz65UFvLGjrcFcMm/NZFZ3tlg2KiqrVwa4VS46Pl87coOyVe54zvp/ED0jUzP8sV6QUQmsrqGvXNpxbr441l6miSr78loJ1VPhVX+RQdZan5FXp3TYm7L1hGz0kjszRtSKaOH56lJDJw0c08vTP/wpId+u/nlqm+sSUk2lIdiYzEGH3vnNG6nKJ4QKesLarR9Q8vUHGNzzM1M/aXHBelCybl6Y6LJ5CiB/Qwm/68tmKnvvfsclU1dG2Gn+3cJURHKi8jQeP6p+nc8bkan5eqfizeAyFj1Y4qfe1vi7RpV32XPm5UxO7snb6p8RrWN1nnTcjV+AFpGt43mdd6dDlPB/P+5lZd9sBcrSuqVlNrq1pb5Sb1XvuBbNB/47QRuua4wUqMi6ZAFtBBP3huuV5cukP1/mbPjn9zxths/fSi8W4FP5WiOkC3sfOv76wpUXRkhBZu3qUHPtzidtk6wvbXj+T+Yl8XHxOp9IQYjclL1axhWTp7fI4rrBXtkU4cQLhYWFDhCtkFWlv1w3+vUJWvpUPj/kjHf9vxOquRZUdxJg5I10WTcjW0b5LiYzydII0Q4elg3jzy0SY9MGeTKuqb1NoacAPtUL2eQ5ml6A3OTNIFk3I1sl+KTh6VHexLAkLawoJyffufS1VS7XMV7W38e6Sw/WckxkS6s7ZXzhisvslxumRqfyb6QBeq9vn14JxNenXFTu2qaXT1djoyAWpLku+KyZKF7ha/W1eLQX0SXSG9c8bnaPrQTNLxgW5eyHt+8Xb9+YNNKqmuV1VDS4fT6o8mkN//cewekBAbqcyUeM0Y2kczh2XqnPG5bOSh9wbzy7ZV6pbHF6qkxif7SdybvMvO1sVGRbgWds9/dTbn6YFDsPOpl9z3sdaX1LgaGl4e+9rzIm/trqxI5i8umeh27wAcvcLyetf94uONu1Re5w+Ze4V1t4uLjlJKfLSOGZKhmfmZOnNsjrJT44N9aUDYqG1s1r3vrNcLS3e4c+7NIXIDsHIacVERSoqP0ch+yTppZF+dODJbY3JTg31p8BDP53dERkS4tNQ6n18NzZZqH+jwSluorhw2BgLKTIqlbR3QwXPndjbVatq3eHz8W1JBY3Orm9jnpTOZB7rC4q0V+smLK7WssCrkCmZaJmFzU4vqmlr06rIivbWyWHe9uV4DMxJ09oQcHTO4jyYNSKenPXCEtlXYQt5avbGySL4QS921o4ENzQE11DaprLZcn24u1/3vbXRFNI8fkaWTRmZryuB0jt8hvHfmbWfu4Y82a0tpnTaU1qq0ptFVmGz2akUsSX1TYvX2t09m8AId8MKS7Zq/uUzrS+q0q9annZW+DrWWCVVWOOvJG2foWKrcA0fFpjcvL9+pn7+82s0LvCbadu1iIjUgI9G1svzc1P4am5eqzKS4YF8a4AlLCiv10xdXasnWypBbyOtIPS3r2pOVEqdR/VLcEVzrftMvNZ4iegivYL6N/RjLtlW5XrG/e2OtS6mz9m9e3KXLTYvTnP93imJjooJ9KYBnbNlVp60V9Xrs4y36ZEu56hubO9QvOtRYW5uHr5vuztIC6Jz5m8r04YZdOnZIH72xqtgVyKxs8Hv+aYzYU0QrKS5G0wana/KgDFdXo18qrW2BNgVldXpu8XaN6Juk4tpGPfj+JhVVNYbFExQTGeEKaVoRvamD0/X5qQM1oh/V8RFGwXx79iNZQawr/jxP28rrPTWht5W4lIRojcxO1cM3TCfVHjgCtb5mfesfi/XBhl1q9O8ujOcVaQnRrhDevVcd43bhAHTsdd8m8Q99sElFlQ1qbA14um3tYYtoRch1v7BdutNHZ2t6fqY7b0tPe/RWCzaX64/vrNPaomr5/K2qbfTmhl5Hx78V0UxLiNHJI/tq6pA+OmtcP6XQDadXCstgvs2db6x1K/Rby+q0q87vqYFq54Cf+costwIHoPNeW1Gkv3y4SWW1jV3eQ7a7x39sdIR+dME4XT1jcLAvBwh5DU0tuuPVVXpxyQ63kBcqxa16chPACuf2SY7TuLw0nTchR1MGZ2hQn6RgXxrQ7SyM+dv8rbr77XUqr2vy1AZeVxXOjY6KUEZSrIbs6Yg1eWCGxuWlko7fS4R1MG8/Wk1jsz5av0s/fH65pwL6FIJ5oEtaUW0vr9e3/rFEa4trPbNLFxMpF8xfO3NIsC8FCGk7qxp02zNLNX9TuZrCcRvuCO8f1tN6eL8UzcrP1EVT8jSwT5I7fwuEE6ub9YtXVuvpTwtV39ui+EN2yIhUft9kTeyfrkuP6e+q4yfEer7mOXpjMN/eH99Zr0c/3qJdtU3yws7c6NwU/e0/jnMrbQCOzrtrSlw164Ky+pAP6G38ZyXH6k/XHuMqWQM4eHGr37y2Rp9sLleTh4vedn+7ywhlp8TpuGFZOn1MP506OlvRBPbwuOJqn3716hq9uapINY0twb6ckBW3p931jPxM19f+4ikDlBxPYB9Oek0wb6t3NqH/6UsrtTNEi2HYJN7Ou00amK6Hr5/uzsIAOHp2m7OieFYcc/7mipBOl7X+0n/+4jSN758W7MsBQrqLxW/fWOt6RjeyI9+pIzyJsdFup+76WUNccB9pB3ABD1laWKkf/XuF1hfXuO41vSKQ6aIOGYlx0RrYJ1GXTRuozx8zwNXegLf1mmC+zY//vUKPzS0IyYHfLyVW507M1X+dPkopBPJAl3tp2Q59+x+LFYqL+FYn45RR2fr6aSM0ol9KsC8HCEnNLa26++3dmXbVvuZgX45nWfiemx6vif3T3Fn7K6cPdLt3gzM5Z4/Q9tLS7frVa2u1raIhJOfyXpGeEKPpQzOUEBOlK48dpLSEWI3JTeGcvQf1umB+a3mdzr/7w5CcBFgBG3sx/eNVU10vSQBdq6U1oPP+8L7WFNeGZNuZmOgIffP0kbr5xGHBvhwg5Fgxyx88v0LvrClWY2+rctdNKfh2z4mNjlRqfIzSE2P1689PdEX0gFB8/f7DW+v06Nwtqm4IvTm8Fxf0rHCeZQT2SYpzO/RfPmmYLj1mQLAvDZ3U66qhDEhPdLtfthIVaj+8Fe+p8fkVx1k2oFvYMZarjxuslLho9wIWSvytATU2t6qpmSI+wIGsLapxfeQJ5LuG3WnsuazxtWhHpU8bS2r114+3aEdlA7+ACDlldY16eflOAvkuYsuh/paAfM0B7azyafOuOv19QYGWbqt0RxPhHaEWz3Y7Oxv2+ysm6w+XT1ZSbGTQilFER0a47x8bFen6RZqIPWkvgYMEGTa4Gpv/Lz94UUGFSxv2t3sfgEOzCvHPfXWmBmUkBK3SrI3/xNgoxcdEukWFtiGfGBN1yD6xVvujzbbyej29sFCVdaFf1BM4Wva7v7CgwrWhQ9ezqbuvuVXPLtquGx5ZoI2loZe9hN7L5r/LCytVWc/rXbc8v3aEqTWgTwsq9eXHF7rWvvCO6N543u7vn2zVL15epTp/cFaeLIV24oB0xURF6IH3N7nduM2lu9tmnTqmn4b13X1m7Yl5Ba5o180n5CslIUo/en6lVu2s0YWT87S+qEZz1u9yn5eTGueK2Hxh2kDVNTbr7nfWKynWzt/205nj+rmCWgB2W7C5TP/1j8XaVhmcQphW2O6/zhjlAvq/Ldiq7ZUNrn1eY0urJg1I18xhu4/YzN1YpifnF+iCSXkam5uqZxcW6q/ztuq00X3VEgjohSU7ZJv4cdEROmd8rs4Zn6OhWUn6w9vrXdeOk0dm6eTR/VyhK8Dr3lpd7M7JN5C50q1sQl9U7dO6ohr1SYylow5CwtriGv3q9bUq81CLaS+yOKS8rkkrd1Rr4sB09U8PzqYHOqfXnZl/Yt4W/c8LK90kOFj+58Kxun7W0L1/r29q1h/f2aB/fFLodh/G5CRrR1WjSmsb1dwSUEp8lKp9R7YbER8doQEZSbpgUq4umJinQZmJtKRBr7Vka4Wuf2SBKoN43u7EEVl67MYZe/9ut2AL6h/5cLNLdbMWUhGRESqt9qm2sUXJcZGqbTyyar2265+TFq/Zw7N01YxBGp2TqviYqC79eYCeYH2kb39uuUsLRfdKjIl0mwCZyXH6wxWTNSAjkaccQbW+pEaX3v8xKfY9VPG+f0aiO0N/29mjdPKo7J74tjgKvWpnfltFnX792tqgBvKWYnvGmH7uzx+u3+V2G04YkamnP92msj3psp9urdrna440kDd2FmZDaa3uemu9e8tOidX0IX1c5cqZw7LcGWKgN2htDei7/1oW1EDefG5Kf/f/Lbvq9Pi8Ak0fkqG/zd+qzWX1rsCP/b+9msYjv2FZ3LO90qd/frrNvSXHRWva4AydObafK3ITR2APj1hXXOPGMLpfvb9VheX1qvb5VVTlI5hH0FkLumaycnqE1RYtrKh3C/923yWYD329JpjfVFqrLz0yP+hV7Idnp7gVr38v2a7/fWmVO//z6vIdKq3tmXNAJTVNenl5kXuLj47U5IHpuuXkfJeSD4SrWp9f/++fS7U2yFXsrV7GuRNytXhrhX74/AqXOvivhYXuvtQTcUptY7PeW1fq3n70wgrXhuq6WUN0xfRBrqI1EIqsVszHG8rc4hR6hj3XdiyxqbnFFcbaWl6v4/L7KC6azB70vI837JLPT3HYnmLzkebmFvmbW1VR16TFhRWaPDBDfZJie+wa0HG9IphfsLlcX3li4d6d72AalZOsLWV1LtW/on732Z/imuBclxW7mbe5XMu3V2rKoAyXUvezz40/ZAEuwGt2VjXoxkc/cfUmgs3av1jRy/9+dvnuncaAgpYpYJscG0vr9L8vrtTrK4sUFRGh288b41LxgVBr29jgpxVVT7Mq99/8xxJXODg5Nko3nzRcl00b2OPXAdgRVEL5ntXUKj34wSZXZ8wqc588Olv/+7nx/DKGoLAP5i0t7y8fbgqJQN4JROgHzy3bG8iHgrqmVn24ocwdATh5ZLYunro7DRgIB/9evEOrQyCQN7HREfrFq2tcymCoZAzbZsdHG8rcn/M+2qJfXjox2JcE7OPdtaUqrglOwcreLLAnm89Y3s5fP9ri2nqeOS6HI3roMXYkbf7mCp7xIKhqaHZvdiD3jZVFGpadrEum9lcqm34hJawL4FnP9l+9ukb//GSrW2EKBZaiUt3QFNRz+4dLAx6Tl6qLp/R3b6kJpNTAm+zW9tSCAncPqDqKuhNdybpMWBDf0K7FXCixEhojs5N1wsi+Lv2ewlcIBQ9/uFk/f3kVafZBZgF9Tlqcbj9vrM6fmBfsy0Ev8cnmct341wVHVT8KXSMtIVpXHTtY3z1nNE9pCAnrQ5LWk/b5JdtDJpA3dvYkVAN509gS0JLCKv34hVU65bdz3A4i4EXW8u3P728OmUDe1DW1hGwgb2yhYU1xrf78wWadceccPbd4W7AvCVAChRpDgk1diqsb9dSCraoKoexChDfLaLOsVgRfdUOzXlmxk9ggxIR1MB8dFSFfU2hNnL2UBmFHE6wdkBXBAbwmKTZatU2csz1SDf5WPT63wLXOBILJijPSeCV0CuMtK6zUvM27j+YA3c1apEVGemn2HL7sX2F7Rb1eXrYz2JeC3nJmPjoy0p0Dbw6teN5THvxgsx6dW6BR/ZJ184nDdP7EXEVEsEKK0BcZaYWzwnq9stst2lqpif/zunLTEnT1cYN07XFD3MQK6Ekrd1SRYh9CrKo4bW3RU7aV16s+lFJseznLLraChAgdYTvTtR6pf3hrnUIow9azmppbtXx7tb7zzFK9sao42JcDHJbtJv/qtTUqq6VoVle8cBdWNOjXr67V3W+v57cPPc52gkKlYCRsoTTCtbYFesLWigY105cyZFiWVAzjP6SE7d14weYyLSqg+mVXr8Y/NncLK3IIeRtL6vTGiiJXAwJdw/ZFXly6wy2UAj2pf0YiT3gITeZioyJc//lG0h7RA3LT4hURttFK1+jJY0hREfYW4YqMIzSE7fCwKXxTBybyJIx3zryNZZq36dBn5awwztay/5vwL99W5RYBGPjoKQkxke7M9+Ew/jtnR5VP//ik8JCfYxP8ddZ6b89Wakm1T498tNm1FwI6y2q2tLAtf1itPTjRr2ls0a1PLtItjy1kcR/drtFSulmXP6TD3SK78hZgU6t731uvS+77WJtKa7vwkXGkosO5+m1Hxj73h86x9RFLtR2bl6rslPjPfHx7RYM+d9+HruLlF2cOVnRkhB6fZ0W0WvTcou2ukvft547RiSP7dvI7Ax0XHxvVoQCA8d95zywq1Mmj+mrakD4HPJJz3cOfuKyos8b3U15aghZsKdfSwko9MGeT0hJidPHU/vryScOO4DujN7p/zka9spxiS0ejO9ZCfM0BfbqlXK+u2KELJw3gDD26xTtrinXnm+upmXGUuvoWYOsrBWV1evSjza5VZTwdR4IqbPvMv7mySDc/vvCQv8CWlhCuJTVsFa47/2FvPmGoG8Dt2W78+fd8oGpf8z7XYLsC7ScTJ4zI0uM3znB/tt27TbvqNKhPoqtYDHQFSwU/9w/vux2kYI6TcDV1YJqe/erxn9lBvejej7RyR7X7uxXIsgWV+JhId0Sn7bmOi47U2p+ds08LweS4aBfoA/v7yhML9faaYjU1M1JDkY3r4X2TdNywTF0xfZDG9U8L9iUhjDz0wSbd9eY619YVoTn+s5JjNWtYls6bmKszxvajSHYQhO3OvBVniLIJpnqnQA9Uub9wcp7G90/f+771JTV7A/n217D/rsDcjWU66/dz9PmpA7ShuFbPLNqmyYPSNWNopo4fnqVZw7O6+eoR7ixgtJXiwwXzODKLCqv0u9fX6Ntnjd77Psu6WVtcs/fvbZkRFsibtttAY3OrZv/ybZ03MU85qXH6+curXSB/9XGD1T89QZdPH8hkAHvFR0cpPLccwoP906wvrXOL8osKKvXPL8+k4wW6NMuWBkqhPf5La5v0wtIdLguvb0qcpgzKCPZl9TphuzM/f3OZrv3zPNHNovtkJ8fo+tn5un7WEPf37z+3Qs8t2X5Ej9W2e29BWEp8tI4d2kf3XjWVST2OSHWDX2fcOUfFNVSz7y62437p1AG69ZThyk2N198WbNUPn19xVAuJtsqfl57g7gGWvWMTA/Ru//3sMv1r4bYO1cDBbq4lbxDSDq0w1uzhmbp8+iB3FCcpjmwbHJ1nF21zryvszHdcbKSCFvvkZyXpP04cqlNGZis3PSE4F9ELRYdzj/kYq7hK4ZxuU1Lr193vrNPba0pUXOVz6bJHqu2fyXbtGmub9NqKIpXVNSkrmck8Os9W8mNjInrlEZueYjvuTy3YqjU7q1XV4Hc7c0cbbtnXt91HFmwud2l76N1278z17IEYC0q9vHYQjEDe2HP2/voy9xYXHaER2Sk6e3yOrps1RCnxBPboPNvgsSNbPcnr84NgbmLaPOD2Z1e4e+jAPomakd9H3zxthHLT6UjSncI2mLdAfvcN4LOvyPZemxscLs5vf9abs7UH5vMHtLAbWgBa2ws7Rwsc0e+P64NsB20OzLW5OcwLXvsxz/g/MLs/Ltxa2S2/pCnxB//3Q+8RjNcBLwfyoaKxOaAVO6rd218/LtC4vBSdMyFXp4zOVt/kOLLu0CHxe4L5nnwN9nIgHyrsHrqlrN69vbRkh0bkpOi0Mf104aRcDchIomBmFwvbaGlIVpIykmJV3ej7zMfshtD+cEHbmp+9q/0NI+ogAT8T++5n/3aRHJTCUezmjeiXqvUlB26H1tK63+Lenhdw+7/F+XbSvi3e3/8WwPjvfvbcZyV/tlsGep/oqEi3uAvvKq1t1HvrGvX+ul2u08jw7GSXjn/xlP5u93535gXwWYmxMW4uyPqad9X5W7WksEpLC6t0z9vrlZsW72pjXTAxVzPyswjsu0DYBvOp8TEakJGogvLPBvPt2UtIYkyk+2Vrz03kD7Arb+/32k3Fa8FHv9Q4vfi146lujyNmk8NxuamHbWllY8PSQW0Xydh/994JIvZd9Gv7fK+NJ6+xwO2RG6a59peAFbIMMOLCgt1brU3tsm1VWrGtSg9/uEXZKXG66YShblI/ICOB4nnYR2JclFrDs7RXr2P/ilb7pKC8QQULCl0tlNSEGJ09bvdRnLTEmAO2vEYvDubb0nMOx1ojNrQL5NtuGTlpcSqtaXSpIu7s/Z68O7er787kR6jZI+fxvXGVUv/0eJ00KlvXzBik7FQGNI5OvFWBOQwbxza2248R+3NKXJQ7ZlPla1HMfsWkAmFwpjYURUdIV84YpOPyM3XiyOxgXw5CxMaSGvkPMdi8fr61t2rdUyOnsKJBd765TinxmzUqJ0UPXjtNkT18Rhqha11xtRqbD96Vhtdi77K5167aJj27uFDvrC1RRmKsHrpumnLTKJzXWWFbzd7c8fIq10LtSM7FJsdFqa6x5aCBMLtzXS82KlL+llaXgmdVMC+alKdLjxnQDd8JvcGHG0p17UMLDrmYtX/WTVtQkBC9u3impeMfaKwTQHQPlykRE6nZw7I0LDtZ3zt7NBP7XqqpuVUPf7hJ98/ZqKqGzzaZbSuJQyB/4CODXpQUG6Xvnz/GdcmIO0TNE/QOVgj5N6+t1sZd9Z/5WOSe2jftj8xh96L4nkRDz4mNitDnjxmg754zxrWrRceFdTD/9KeF+u4zyzr0Yn+w1b0DTeRtsNimfCjdQ7z+In6gwoNJcVFa+ZOzg3058PCK/iX3fqjapsOPirb6GB05H2+fa0c8bRIRSuMt3HYo7D7wwteO1/j+acG+FATB0sJKffvpJdpcWtfh1+beLlwWGWMiIzQkK9FVwrc2d3ZkEr1LQ1OLrn5onpZvq9R+p2Adxn/4Pic2l0lPjNH5E3N1waQ8TRuSGexLCnlhlWZv7ZGWb6vS8OwklyL/4rIdRz0A9t+1byuUFR0VoRbbuQuBkdMnKUbP3zrbpab8de4WvbBku5Ztr/bs4G87vZBoZyCADmpuadWnBRWunaGlyf/lg82HTM9tr+34zIHev//4t+VPK8gTFREIiRVwOyrwx6um6OzxuXpzZZH++Wmh3lpd0qFxbSPs4AmMwWXPc5/E2GBfBoKkvK5J5bX+g3adCYGhF3LCIZA3/taAK166/p2Nuu+9jbpxdr5OHNnXZe3lpHEErzeorG9UZT3jvzPC5Z5o07ayOr/+OnerHpu7VTOGZOhrp49UVnKsRudQSyesg/niap/ueGWVK6xiK3oN/hb3/468uMVHR6ihOdChoN79OWBnaAOHbW3XU249abgGZSa5P//HCfnaXlHf4WA+RH6EA4ojmEcH1TU2609zNuqNlUVuAmDHNRqamtXUgUg1LsrObh06u6X9+9w9JRA643/qgDSdMTbH/fmMcTmu+vebq0s69LWhGshr78JpiDzJ6FHzN5Xpt6+vVW1jE78BvZxlQD02d4ueW7JNQzKT9NRNx7l7HMJXSY1P/+/pZdpZ1RAyr7MIDvvn/6SgQt94arFLvf/zddM0rG8y/xzhFswXltfrleU79NqKYi3bVnlEO+VWhOFQVarbv3/v/0PoBvPC0h360vFD3Z9//MIKPT5vq7zOWlc8fP30YF8GQlyNz68Xl+7QnHWl+mBdqeoPlI93GPYlgUOkqB5o/IfSBGPDrjoVlNUpv2+yqw77vWeXyevsOb/3mqmk1/ZSdW4hrpXzsHB8za3y1TSpobFFf/lwk86dkKf+6QnU0wjjehlWHPFAR9/Q++zeqW9SdYNfD7y30cU7Nt+J7UCR897C82fmb//XMj23ZLsb/N2V8h6KqejtTRmYqu+fN06/e2Ot5m4ql9dlJsXqbzcd5yrbAofy7KJC/eSFVW7y377ifLiP+faykmP0wDXT9LcFW/X84u0hcfTnaNjL891XTdH5E/OCfSkIEjvCZlk2tz2zVDWNoZw/4o3xFLlfRw4v291ONFIXTsrTr78wKdiXg26yYnuVvvn3xdpQWsdzfJSsI88R7HOELKtbNjYvTY/deKzSOYrneH5Zw1ZrrLVcd05gQ31uXONr0VefXBgWgbxVs/3pReMJ5NHh9Praxq4N5L0w5ttrbQ3oB8+v0L8WeTeQt8mGsf99+eRhBPK9XFRkhE4Zna387GRX4RhHzm6N4RLIm8CenfqPNpa5RR+EJyt8euzQPq7FdLjcAYL1c4RTIG+sVtGm0lqXmY0wSLMvq23Uyh0dOxt+tJXVQ9nG0jpPBR8HY6vtd10+WWeO233+FzgUm8jNWburWwNYL1SIr6xvVnl9jbzMJht2r/3S7KG67ezRwb4chID4mCj95YvT9fLyHXr6021aXVRN2j32WfCxN4SvH10wVtOG9NHbq4v1xqriDhe0DVXevvrQYvV0rI0tPB7Mry+u0R2vrNaOyoZu/T6hHsgbD1xih8THRGr6kD7Bvgx4QFW9X795fY0+3LirW7+PF+YO4bLobi/LM4cx/vF/slLidN2soS6wf2DORpXX+11hW7+dp+WJ6tWsfR3CW3xMtC6ZOkBDs5JUUF6v0hqfqn3N8vutk1QgbOa+OLKMxOQ4z4awXc6Tz4Qd83/w/U2au7GsV7+gx0RI/jC6m1U1NOuWxz915+WpVotD+feS7Xpp2Q41hlv+WC8+B2epc9/713L96yupGpRJX2n8nwsn9VdKfIy2ltXrjVVFrg2ttZ+19qVxsVGKUED1jS0u2LdOM+EgmHU77ExqKLTdPBR/axjd/HBIkwem67azRmtbRb0reGsda4prfIqIiFBybJRa3O9ChHbVNrkjGDg61kjKH+qlSgIBMrW8XADPCt09Ob9A976zTrvqmtVbWTutcKwLZIvt91091fXMBg7k/XWl+t+XVml9SW2vfYLCdfybq2cM0M8vprAVDp6VY90b3lpdrFPH9NOE/mlaV1yje9/Z4AJ9606DI3ewrh6hJi46QmNy03T2+Bx9+aRhwb4c9GCdnIr6Jj23eLvys5J13sRcbd5Vp1eW7dT9cza6GjoI/00CW+wcn5emETnJuuPiCS57qzfz3M78p1vK9dyi7fI1eeC3rZvkpMaouNqvcGSbKl9/arEW/7CvkuI99+uJHug/a1k5ZXWNvfa5TouP2h2wWAPmMPTk/G2aNSzbTdKA/aUlxmhiYromDkzf+74xualKJOWyS3jlrtLYHHAVzxuamgnme5GkuGj39p+njtj7PkvDz06Nc1m7ODpeCOSN/Uuv3FHl5oSF5fUa0a93d7/yXPWAgX0SlZeRoJG5KUdU5dZ+4AgPr5hNHZim6KiosD4rtLvISTj/hDhSqfExGpyZqOF9k5WWEN3psWzpo14d/2ZMTrLrr2odPMJZU3OYph2g2yTHWbq9l0d3z/P6s2VHKmh2gLYCytH8MvQqNgtq9LcoMZaNP08G87+/fLL+dM00nTshV4P6JCgxNkrRkRFuMFuAb+PZfrDoSGlCXqpyUuPUNzlW1xw3SLeenK8Ed8bOW/LS4vXif56gb54xStsrfApnFsbXNpEqhc+yVKqfXDhOf7l+uq6bNUT5fZOUGh/tiiHZ2E+IiVRU5O7xb/eBvLQ4jchOVkZijE4e2VffP3+s+qbEueMcXroH2LnAP1w+WU/fMkurd3q7cn1HWBol0Bn2+h8THeG5sR1M4bBkbn3IX1tRFOzLQJBZZXObB9i8n/Hfe1T5mvXXjzf3+qyMaK9O6O3t91dMce2pXlm+U0sLK7WzukEVtU3aUeVTVnKspg3uo+tmD3G7eVY4Y1jfZNX4mvVpQaW2V9SrpLbRpWqFusumDdCPLxjnUose+mBJWLwAH44Vwnr4+umuwAnQnhVHTImK1H+dMcq9fbKlXHPWlmjLrno1NrdoU2mdW6GfOjhDl00bqAl5adpYWqv+fRJd9dPVO6s1f1OZK5ZT1xT6O8BTBqbprsunaEhWkl5aur1XFPj58/ubXK/57NT4YF8KPGLyoAwt2FzujuBsr/R5vo0VOsaOHD0xr8CdnUfvNaxvikbmpGpXrU/bKnyq98BrO46e3eVfWVGkLx2fr5y03jtf8FwBvMPZXtmgxVsrdOzQPspOOfA/7Kod1Vq2rcIV0aoL4bP3ttN40eT++sUlE1wAYz/X1Q/N7xU3qXF5qXrxa8crkvYz6AQrfmMF8mzhblTOgc9QFVX53Fj65WurVVDWva0tj9axQzL0x6ununtZtc+v8//wgbZWhPY1d4Ws5Bj9/eaZGp7du8/BoXOswv1db67Vv5fsUIO/pctbywazwjwOLCU2Wj+7ZLybK6F3sy4XLy/bod+8vlY1DX7XWjbQC4tD9iYWInxp9lDdfu6YXh0veHJn/lD6pye4t0MZm5eq9MQYZSRtUF3TgVPW234lgvXCnZMSq0e/NEOjc1P3vq+4qlG+XhDI23P/60sn9uqBiSNjO+92/OZQbPX2nAm5LjWrsLzhoBN++/ULVperuKgI/e6yyTp/Ut7e9zU2tWhXbe8o/HfdcUMI5NFpdoTmmMF9tGpnjXbV+FRU3dilreoI5EPPscP6EMjDSUuI0YT+6a4YWlmNT9urfPJ1YX0ZAvnQk50Sp++dM7rXxwueOzPfVfLSE3TuhDwl2hnbg5yxC9YL9/C+SXrm1tn7BPK7ryeg3pB1HhMV4RZcgO500wn57giOnbHbf93I/hqsQN7O91tNgPaBvPG3BhQZYnfs7rodHTO0Tzc9MsLdJVP7u/amUwZluNcS1oTDV1REhIZkJgX7MhBCJgxIc+P/8mMHKS7q4PP73iSc74EDMhKDfQkhIex25jvjrHH9tKigQlUNTdpZ5VNtu8bNPT2Ptzm6tdaYOSxTPzp/nDKSYj/zObHRkSG7M9CV6YeWHs1ZeXS3SYMyNGlgunZW1qu83q/y2qa9K+/BGGcZCTEak5eq7583RuPy0j7zcSv0GQiE1qtyoBvGf2pclCtaCBwJe+2wxXqrmVFQXq/y2kZ3jt4aJNgufai+hqLzjhvWR988/f9alAEmKznO7dAP75esijq/y2hram5VU0tr0Bbpgylcf2Yrbn7X5ZPdMeTerlcH85aOd/81x6istlGPfLRFr6/coWpf15+zOxibAKclRCk/K1knj87WDbOHKiU+5qCfHxkR/o13slNi9dyts4N9GeglL/j3XDVFNQ3N+vsnW/Xsom1uUa8nX/iSYiKUm56oE0Zm6Yszh7p+uQeze+yH6avyHraL8so3T1Dfg9Q7ATrqizOH6NTR2VpfXKu3VxdrfUmt1hZVq6bdov3hZCREKzoyUqV1B++uwDn64BnVL+WQcyb0XrYxds+VU10djacXFrr/2+adFb7t6KtoXHSEhmYmaV1JbdgGxF6uJ5CZHOc6nKGXB/NtZ+zs7Vefn+gq4D8+t0A+f7O6si6evdhnJkYrJy1B60trZSUHrcDbLSfmq1URbsJh1fkPpzWEahXa1bafEgX2DOaj7RA/JjeFVTb0GEuzt7dvnzlK4/JS9ON/r1JNo18NTa1dGjZb0G6VdtcV17qK+wMzEvSVk4crLiZKM/MzO1S13ao224JeKAp0UZ0BW8xLjGVyjqMXFRmhwZlJ7u30sf1ccdxXlu3QH95er/rGFvc769rYRkaouSWwz0TURtnY3BRXfPL6Rz5RZN3uACBwiBRW+70PnVfo8JcSF+VqnwAHYxk69mYZeFYc981VRbrzjXXuXhDYM16tnZ11xdp//Ntr0Z2XT9GT8wu0cVedAi0Hzuqxox42N7eX5t4c8Pd0IG/33atnDOrh7xq6en0w395FU/qrosGvosoGvb9+11EXzomPjtSjN0xXTVOzspLiNHlguksBLCyvV0p8tNITP5tKfyh203Dp5yEQ1LccZDBHHCDQ76ghmQn69pmju+DqgM6bmd9Xn5vSXzsqG/TOmpKjbltnLzY/On+MRvZLlb+lVTOHZbmjMpYJ1Njc6iYZnWG7BKEazLexW9ORrtAnxUbqv88dqz4HOGIEHC0rjHvdrKGas65UBWV1rtXjmJxUfbKlwo1J61ds49TO2U8ckK57r5rqXqenDExXpCJU5fOr1teklla5Ktlt9u+AF9FWc4N/sm5j95ifXjRe04dQWwMdL4578ZQBWr2zRq8t36n0pBj3+7OhpNbNySvq/W4jLzoqSnlpCbrr8kkam5em9cU1WltUowZ/s8pq/WppbVX77rAte+bj7aflwS6g3RtcMX2QrpoxONiXETLCrjVdV7DzNRfc/aGKqn1HPBj7JMXolhOH6ZaThnXZda3cXqWr/jzPTTrCTVJslJ686Ti34AEEU3NLqxtni7ZW7POi3RkJ0RE6fUyO7r5qSpfVf6iqb9JlD3ystcV1Cke/+fxEfWHawGBfBsLcxtJaN4E/YUSWEmOj3eKdpeDaURtbMP/P00a4BaWYPecwLcC3OcG7a0r0aUGFlm2rUmVdo1vsa/K3HnbhmjT8rmXP5++vmEwFexyR8romzd9UpsmD0pWbluDa2RWW1+nt1SUunf6rJw/T0KxkJcTuzpa1EMmO320qrXUtL20h0Gpx1Pia1bBnwZ8gqmddNX2Q7rh0Qg9/19BGMH8ANni/9+xyvbmySJX1/k6tsLuU+qRYfe3U4e7MXle1V/vt62v1z08L3apgWZ1f4SQ6QvrO2aO7dOEDOBpPzNuiB+Zs0s7KBjUHOr8wdcGkPP34gnF7JwRH642VRfqfF1eptbXVtdtSmAUQ54zPcRWIKXyJULehpEYbS2r1zMJt2lJmO3pNqm9slq/54MW13G79nqlAW3ovjszt547SzScO5+lDUNjCnp29/2RLud5bW6JqX7Oq6hplHfD2z9Jpz470uLEfGsm1njVjaIb+ccusYF9GyCGYP8Tu3OZdtfrr3AItLqjQmuJad67mcC2lbj93tMb3T9foLq7IfuZdc9x5247w0kQ+LT5av71sss4Y2y/YlwLss6BXVOXTMwsL9fGGMi0qrFDjYaJ6S4O/fuYQnTcpz3VkiIvumkDe/OD5FXpyXoFnxnVHxUZF6GunDNfXTx8Z7EsBOqW1NeDmCf9avN3NFZ75dJtL1T3cGG0L7AnqOy8xNkIPXXesZg3L4rcVQWdZO3M3lmnB5nK9snyntpTVdejcvO3x2X3gUME/Dvy8feesUa7eEPZFMN8Bdp7m2r/MV0l1gyyrxoL6iPZnxCOlAekJ+vklEzV7ePe8yJxx53taXxJe6bVpCdG667LJOnUMgTxC2+UPfKylWytcwUr/nlfgQLuJeUZirL56yjDXkaI7dpd/8PxyPTFvq8ItkP/PU0e4tGbA61btqNZzi7fphSXbVVxz8Or3B5ukEtwfWmyk9J+nj9RXTx7eZRmPQFfu2NuCuxXZW7mjplML723ziN5cQO9w7NDTORNy9MtLJ9LB4gAogNcBAzISdN3MIVqxo0ortlep0d+icf3TVN3QLKtv+Y3TRiq/b5Jrk9Bdjh3aR5tK6/cW2/AyVyk0NU4/v3gCgTw84csnDXep7muLa1RS7dPw7BTX97242qerjxvs2uDkpMZ3W5q4FeqxnT8rnOf9O8DujJwbjh/qjiMB4WBsXqrG5o1VUmy0Hvpgk1vktxaLdr62bQHwYNom8QT1BxZjgfxpI10WD0dxEKqtbr9x+khXPPM7Ty9VY0uL+ibHq7jKpzr/oStruE4Zgd0BvdsoDIcX+S4O5M8a349A/hDYme8kC+atYMasYZk9+qJiKX3zNpXpjdVFemJuwREX5gq2wZmJuufKKeqXGu/eAC+xYlmrd1bruPxMJcX17FqoVdR9a3Wx/jRnoyu+40Wp8dHuBXlC/zRXXZwdNoQbK6b3j0+2uuD+1NH99LUnF+nVlUXu6A6T9M6xGdaxQ9N1xthc3Xh892Q9AV2pqblVTy3Y6lpjXnnsID0+b4t++eoa+ZtbSas/AvmZiTp5dLa+dcZIduQPgWDeY6p9fs3+xduqaTy6tlldobNn84f0SdBjNx6nQZmJ3XhVQHi78I8fuoraXgzkrQq1BThAb/Hxxl26++318vlbXBV9O2frb963rzUO7BcXT9CV9JKGh1lP+x89v8LN3W38W/u7puYAgX0HnDU2W/dfM41F/w4gmPcIW9X/7+eW6/XlRS4zoNWD592e/sosTRqYEexLATzJdvt+98Y6VTU0HbYYX6ixhT8rXHPrKaTVo3cqqfHp9RVF2lhap9dWFKk1YJ1pmtzY8GqmXXf6nwvH6fpZQ4J9GUCXaGxuca3tLHPnyfkFamlpVUV9s1oCrWph/H/G2WOzdR+BfIdxZt4DbEX/tmeW6aVlOzybppeeFKuoyN19ewF0jp3B/d0ba9Vg/W88KCEmShlJscG+DCBoslPide3MIW5h/uYT890unaXjllQ3an1JjTtXb6/1nXmJtzP2NifwUgebjrj9nNEE8ggr1t3msmkD3Z/t/5X1TbrvvY3u/0sKK+VrblGjv7XThTDbDp6E0/g/e1yO7r+GVrWdwc68BywtrNTlD86Vz6MTeduVv+2cMZx5A46wXsb0n7+psjq/J58/W8K7aEqefva5CT1eZwAIdWW1jfpwwy4t316ll5bucJP5XXWNilCEmju5eh8OQf1tZPCgl52xf3t1sUprG/XAnE2uH/3Oap9b9Otsxk44jP/Tx2TroeumB/syPIeZlQdY1eyWVm8G8iYpLkYXTMqleA1wBKzm05EktfTEC3tHvkdMVITOHNuPQB44AOuCc9Hk/u7t22eMcrt0Ly/f4VrduTP2za3y7ZnVH26seX4iPzabozjoVWKjI3XOhNy9O/ZW/f6Rj7e4VncfrN+l5tZWNTS1dGjH3uvjv29yLIH8ESKY94Dk+Gilxse683VeY2mAo3JTlJZAii1wpPLSE1Va07midz3xwt6R79EvNU4j+qX0wNUA3pYQG+XaXNpbVb1fS7ZV6tMt5Xp+8XZ35raizu/G3P479m3p9l4WHRmh2cOygn0ZQNDEx0RpcFaSqxfR3NKqeZvKXfvbu99Zr9ioCBWU7W5PbXt7gTDbkbdNi2OG9An2ZXgWafYesa6oWo9+XKAP1pe69liHaVsbVOkJ0YqOinQ9scfkpurR66crkfRa4IhV1DXpzx9scpWxV2yv7nT6bXdrP5lIiIlUWkKMa5+XnRKn+645xt0HABw5C+rfXlOiTzaXa11xjU4YkaW89ATXsrLB36JPt1QccEJvQYB93pay+pB9+m86caimDe6j00Znu7kDgM9WxX9q/lYVVfv05qpi5aXH69zxuVpYUO5ege2ozoHmBdERUn52stYV14bsUzozv4+umjFYJ47oq7TEmGBfjicRzHvQhuIa3fXWOr2yvKhDq3G2am+fZy+R9qIeHRWh8jq/zhyb7Vb6PtlS4T6vs4V37M2qcNpqok3gq3x+5aTG69efn6SZ+ZlaW1yjARkJ9IYEulBJtU/PLt6u37y+pkNVcG3Fu61Ijp1Zt/7uO6saNCQzURMHpLsiXPY4nV0esCDBinZFRkSoX2qsSmqaXMqgVa23KtRby+td0Z+ctPgj+TEBHEB9U7ML4Cf0T9sb+Npi351vrtPcTWXu/pAcF6WiqkaX1ffbL0xyabtzN5aF3PMZGyX97+fG6/Lpg4N9KYAntLQGtGJ7lYZkJblFc2O7+A99sNkdz7E5vb3OW5q+zdFvPD5fcdGR+v1b60Nu996u77JpA3THxRNpP3eUCOY96ulPC/XdZ5Z1qEXdlccO1IyhmSooq9PFUwa4Pu9WdCcjMVZvri7W/7ywUqNzUnT2+BzN31ymBZvKVVTdqNZAQDGRu9vm2IKf7bhbR6xGf4umDc5Qpc/vKvFeeewgDeub7KrtXz9rqI4fQaoc0J22VzTo1N+926EWdWNyk3XbWWO0dFuFZuZnaUZ+pmtvGR8TqR2VPv3HXz9RdGSkvn7qMH28qUxLC6vcQpyt8tuqvi0F2J9t0c7qd1Q2NGlQn0SNzknVgs3lmjggTV87dbgr3jNrWKaunz2Uf3wgSGobm7WuqEaPzyvQOeNzdOa4HF314Dw3tkMtkL/z8ik6f2JesC8FCKvFPjuic887G9xc/5YT83Xfexv02zfWuXP3ocLWIa+bOUTfP2+soiyqx1EhmPegNUXV+vpTizuUNmO7Z18/bYS+duqIg35Ojc+vxNjofQaUrfy/u7bE3RieXbTdBfZ3XjbZpfRsq2jQt04f6XYFbIHAdvcYjEDPqPb59a2/L9G7a0oOu5hnQ3r28Cw9fuOMg36OtcMyFqy3Kary6Z01JSqva9LrK3equLpRt5yUr7y0BL2+qkhfnDlEY3NT3Q6BpdBTpR4IXdc8NN+l4YYKu9PcfeUUnTeJQB7obve/t0G/fm1tyOzMW6Rx/ewh+v65YzhW00UogOdBzy7c5qrcdiSQv3BSf91wmJ2ylPjPnlEZlZPi3oztvNvOvKXnHpefuc/n9aF3NNCjPt5Qpo827DpsIG8tbiYPTNcdF0845Oe1D+LbWGr8VTMGuT9/cdZgV2F3eHay60jRVnnXTKNgDRDyrHZFqBTJi460QH6qzm13HwHQfdITY1080BgCxbYskP/izMEE8l2MYN6DDlf8Kj46QmeM7acxeWn60uyhB5ysd0ZuWsJRfT2ArhMXE3nIe4AdjZk+NFOTB6a5ojIDMhKP6vulxse4NwDe9P3zxmhwVqIe+XCzKhuag3INQ7MSNbpfis4an0sgD/SgLxwzwAXRVkR3Y2ldUJ57W0ywApfD+6Xom6ePJJu3ixHMe9DAPoluN725pUUN/tY9xe0iFFDAFaL71hkj9aXZ+RSUAMKQ1bqwwjcNTc1qagm4gjhtu26x0RHuDOpPLxpP6juAvb3sv3HaSG0sqdOLS3f0aLqtbSxMGpCmS48ZwMYAEAR2JPaKYwfJ39Kqn760yhWu7anuNkMzk3Tx1DwdP6Kvpg7K6Nbv25txZt6DbPJuLerKapv0uzfXanxeqlvpmr+5XFnJcTp/Yq5LhwUQnhZvrVBpTePuCrWBgH556QR39Ka2sUWXTRvo+lUDQHvbKup1/3sb9dyibar3d6R8buflZyVqW4VPza2truDuLy6Z4LpcAAiuhqYWtzv/twUFrttFd+iTFKPEmGhtr2rQqH4p+vvNx7k0f3QvgvkwCOwpPgf0Tq170u0jqQYLoIO++uRCvbZid2vbrjhHP31Qhur8La5Q7mNfOlYF5fXaWFKri6f2d+0pAYSOv368RT9/eZWLH2z8H+0tICMhWjOHZ2lhQYXuumyyyx62Atpnj8tRdiqtaXsCwTwAAEAvsaGkRo/NLXDZPXPWlbpDenVNR7ZTf9qYbN1/9VTFErQDnumIc9+7G1VR16RXVuxUc3OLK453JAt7w7OT9MSNM5RDba2gIpgHAADoZewM7YLN5dpR2aCfv7xaVQ3+Du/S2UG+a2cO1g/PH6sYaxoNwJNH9qob/PrRv1eqsKK+UwH9zGGZuufKKe54L4KLYB4AAKAXs9obb68u0bOLtrme9HWNLa6gbl1Ti/u4leGxiX50hHRsfqZm5mfqKycPo080ECbWFlXrkY+2uGyd4mqfoiMjXCq+1cuz9bqW1t0tb0fnpGrakAz952kjCORDBME8AAAA9tbiWFxYqfK6Rv3s5dWaNjhDt501Sh9tLFPflDidMKIvzxQQxtYV17gdexv/FsD/7rLJ2lha67J3LpiURzZOiCGYBwAAAADAYzjoBAAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAA4DEE8wAAAAAAeAzBPAAAAAAAHkMwDwAAAACAxxDMAwAAAADgMQTzAAAAAAB4DME8AAAAAAAeQzAPAAAAAIDHEMwDAAAAAOAxBPMAAAAAAHgMwTwAAAAAAB5DMA8AAAAAgMcQzAMAAAAAIG/5/+BaLAwv5skfAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "model.eval()\n", + "with torch.no_grad():\n", + " mu, _ = model.encoder(input_features, gt_grid)\n", + " _, _, _, recon_grid = model.decoder(mu, None)\n", + "print(f\"reconstruction IoU vs ground truth: {sv.grid_iou(recon_grid, gt_grid):.3f}\")\n", + "\n", + "plot_grids(\n", + " [(gt_grid, 4, \"gt dragon\"), (recon_grid, 4, \"recon dragon\"), (gt_grid, 0, \"gt car 1\"), (recon_grid, 0, \"recon car 1\")]\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "4183dbc3", + "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 shapes. With only six training shapes the prior\n", + "samples land between memorized modes — with a real dataset (e.g. ModelNet40 chairs, as in MinkowskiEngine's\n", + "`vae.py`) this is where genuinely new shapes appear." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a0423a93", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:46:21.201202Z", + "iopub.status.busy": "2026-08-31T23:46:21.201035Z", + "iopub.status.idle": "2026-08-31T23:46:21.509657Z", + "shell.execute_reply": "2026-08-31T23:46:21.509039Z" + } + }, + "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": "9e98c580", + "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": "983987a5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:46:21.511228Z", + "iopub.status.busy": "2026-08-31T23:46:21.511064Z", + "iopub.status.idle": "2026-08-31T23:46:22.100917Z", + "shell.execute_reply": "2026-08-31T23:46:22.100317Z" + } + }, + "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", + "interpolate(source=0, target=4) # car 1 -> dragon" + ] + }, + { + "cell_type": "markdown", + "id": "097f0e40", + "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": 8, + "id": "d7a056e9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-08-31T23:46:22.122077Z", + "iopub.status.busy": "2026-08-31T23:46:22.121912Z", + "iopub.status.idle": "2026-08-31T23:46:22.496068Z", + "shell.execute_reply": "2026-08-31T23:46:22.495526Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "ipywidgets is not installed - showing a single static frame instead.\nInstall it (`pip install ipywidgets`) and re-run this cell for live sliders.\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu8AAAEFCAYAAABTtAkoAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQAAUHBJREFUeJzt3Qd4XOWVN/D/FPXeLMmS5d57pTiATQ8tlIS6BDaQwBIgC8kHbEgghMCSCiEsSyCEBEKoazqhmWZT3HuvsmT1XqbP3O85ZzSyLEtWsaSZK/1/PEKWNOVqNO+95773vOdYDMMwQEREREREEc8a7g0gIiIiIqLuYfBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IgqbvXv3oqSkxJTP3Z37FxYWorKystfPQZGvrKwMxcXF4d4MGkTCuV8kc2DwTkRh89Of/hSPP/64KZ+7q/s7nU6ccsopaGho6PVzDGa1tbXYsmULzE5Ozk499VR4vd5wbwoNEuHcL5I5MHgntW/fPqxevVo/NmzYwFeF6Bg9+eSTWLBgAcaOHatf19TUYOvWrcf8ujY1NWHTpk0a/B6Ny+VqHdOhD7lfbx+vr61atQr3338/wqWnv3dnt58+fTrGjBmDZ599tp+2lIjocAzeST3zzDO48cYbcemll+K0007jq0LUB8H7VVdd1fr1u+++iyuvvPKYHvOJJ55AdnY2LrroIuTm5uLuu+/u9Lb79+/H/PnzdVyHPtrfvieP19fOPPNMvPjiiwiHnv7eXd3+iiuuwFNPPdXPW01EFMTg3WQqKir0oNzWjh07dFZt3bp1Hc4iyWxRfX29Xtbdtm1bh5fxf/nLX+pjyGei/k4zOHDgQKc/93g8+p5ubGzs9Oc7d+6Ew+HocHZ0+/btcLvd/fLcXd0/RMaojDVJmxHNzc16dUtSaUKz4PK9npBZ+5tvvhmvvfYadu/erTPXjzzyiJ4UHM3XX3/d+pxvvvnmMT9eSHV1tf6Oof3Snj17EAgEuv036ShtJvT6d7ZOoKu/T3f09Pfuzu0XL16MFStWoKqqqtfbRUNbZ/uWtuNMbhN6/4fG9K5du+D3+zt8TBmXocfsKI++s7HZ3bFNYWSQKWzatMmYM2eOkZ6ebowePdpYuHChUV5erj+77rrrjLlz5xqzZs0yEhMTjSuuuMLwer2t9x05cqRx9dVXGzk5Ocbs2bONL7/8stPnee6554yMjIwB+Z1oaPF4PMaVV15pxMfHG+PHjzdmzpxpnHjiicbdd9/depv77rvPSEpKMiZNmqSfb7nlFiMQCLT+/N577zUSEhL0/vI+ffrpp/X78n6/8cYbjbi4OGPChAn6HL/+9a/77Lm7c/+2Xn31VSM/P/+w8SvjVrZPxqp8yPccDoexatWqTj/Wrl3b+hj33HOP7gPauvTSS42rrrqqw23Ytm2bIbv4Xbt2GTt37tTfoa2ePl57zzzzjL4WZ511VuvfQ36vxsbGbv1NXnjhBWPq1KmtX7/33ntGZmamMW7cOGP48OHGRRdd1PpYXf19+vN17O7tU1JS9Hcg6omu9i2hcXb66afr2Lj22muNFStWtO5HxowZY2RnZxsff/xx62O63W7jsssu032ljL0ZM2YYJ5xwQutjdjU2uxrbFH4M3k1ABqIMsFtvvdXw+Xz6veXLlx92QAqpq6vTA00oqAkF78cff7zR0NDQ5XMxeKf+8sc//lEPNGVlZfr10qVLDYvF0npAefbZZ40RI0YY+/fv16+rqqo0UJPvhw4oEtxt3bpVv3Y6ncaTTz6p/3700UeNvLw8o6ioSL9evXq1ER0dbXz00Ud98txd3b+9xx9/XA+Y7ceWHJjb2rFjR+tBuKOPk0466agBowSW8+bN63Ab5HcJPU5BQYGRnJxsPPbYY71+vPbk7yGvwTvvvNMaQMtrFnqOrv4m7YP3RYsWGQ8++GDr12+++aaxe/fubv19+vN17O7t5eRM/sZEPdHVvkXGmZyEv/zyy50+hrzvRo0a1RofPPzwwxp0V1RU6NeffPLJYY/Z1djsamxT+NnDOetP3SPpMHLZ6qGHHoLNZtPvLVy48IjLX0VFRXop/vjjj8eyZcvwve99r/XnN9xwA5KSkviSU9i89dZb+P73v6+5w0IqdJxwwgmtP5f857POOksvDYfSJiTt5L333sPVV1+Nl156CT/4wQ8wefJk/VlsbKw+Xuix5f2en5+vX8+dOxfnnnuuponIGo5jfe6u7t9eTEyMpnh0ZcKECXrpuzvk0nZqauph30tISNCFqR0ZOXLkYY8tr8Ull1yCadOm6e/W08frbPvPOecc/XdcXJzulyS1pDt/k/YmTpyIr776SlNppkyZgvPPP7/bf5/+fB27e3u5nfzdiXqiO/sWGcvf+c53DvueTL5KiVJJ1ZKxc/DgQf1abvv222/juuuuQ1ZWlt520aJFOPHEEw97zq7G5tHGNoUfg3cTkINVcnKyDqD2ZADfeuutuuBUBmJiYqLmqMkBuq3MzMwB3GKiI0m1lYyMjE7fl+Xl5Rq4yclqW/PmzWsdB6EDXHuSoxk6ULV9bPl+Xzx3V/dvTw6gpaWl6IrkwB+tXKKcrM+ePVv/Lc/fPqdavm6/XZ254IILtPrNRx99pIHvsT6ekP1NW3a7vbVkYld/k/Yee+wx/OMf/8ADDzyAzZs367b+4Q9/0H1fV3+f/nwdu3N7+Z3le/J3J+qJ7uxb2n+9du1aXHbZZZr7LvvEqKgozUmXcSLvQVlP0v4x237dnbF5tLFN4cfg3QRkFkoGoywgCc06hmZ65ID19NNP62K4UGBz2223tS42IYoU48eP14NOiCyykrKkUmov9D6XQE2CuLZCM5zy8y+++EJPVtvPdsos0Zo1aw67n8zEXnjhhX3y3F3dv73jjjtOF9TKTNW4ceNaD37tF33J1TKpAtOZ+Ph4fP755/pvuaImVU58Pp8+lvjkk09aZ8pkWyXolRN3uSohX8vnttssDYXS0tK69XgyMSCvqfzuKSkp6Kmu/ibtyXZce+21+iHbKtvxxz/+ET//+c+7/Pv05+vY1e2FvBfkZ6ETBKLu6um+RfziF7/Qk/Hf//73+rXEBxJ8h/Yvss9pe6Irj7lx48bWx+zp2KTIw+DdBKSGsBzQZGDdd999egb93HPP6WWvgoICPai8+uqrmDlzplY8+Mtf/nJEWk1X5IxdDoByEiCPF7oEHZrZIjpW//mf/6mXhOXAMmfOHL1a1HZ2+mc/+5mWNpTgUgKjuro6LFmyRL93yy23aOMSubx7++23a0qFpJItXboUL7zwgn7vpJNO0oOSXHJ++eWX9b0s6WJ98dxd3b89mbU677zz9DK0bJuQ+8o2/+tf/9JZLzkR70m6h5SZfPDBBzVNRC6Jy6VxqTQh2ynkREG2V6pLSeApt5XKUmeffbb+/M9//rOm10lZw+48npwYyeO98847rZfPe6Krv0l78hySGiMnPjIDKBWFvvvd73br79Ofr2NXtw+lIXz729/WGVCinujpvkVIDLBy5Up8/PHHerL529/+9rCfywTHGWecoY85a9Ys/O1vf9NKMxaLpVdjkyIPS0WahMyuyyCXQEUuJctBTvLYJLCXgScHlLvuuksHvQxkGZQhM2bMOCJns70PP/xQZ67eeOMNHfChutCdlaAi6imZwZT36fLly/Gb3/xG0yJ+/OMfIy8vT38u71mZHZKyptK8R05QJfCUMn1i0qRJWL9+va7rCJU2ffjhh/VnEmzJzKqU9ZMTXHnfymxW6GrUsT53V/fvyI9+9CP89a9/1Rns0ImwbJuMTxlbcrDsCcmz/uyzz/TzPffcoyfcsrZlxIgR+nNJq5OTm1B63b333qsnCDJbLfsMaRYls21Sp7w7jyevR05Oju5nOiIzfTIj3pZcsg+ljnT1N0lPTz8sve+VV17R119uKwGM/I1D63a6+vv05+vY1e1lskPSfeQkgqinutq3dDTOfve73+lknbwfpQfBHXfcgZNPPrk11UUm7+RYLuNPHlP2Paeffnrre7qrsdnV2Kbws8iq1XBvBBHRYCQL0a6//nqdTTYbCUhDqSzUOUmhef311zXFhyhSSH566EqQXEUbPXq0nshffPHF4d406gMM3omIiIgGEUkvu+mmm3Q2/vHHH9c0MFkj11HhCzIfBu9EREREg4jkxMvVIEmlldRZWTfCqnODB4N3IiIiIiKT4IJVIiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiIiKTYPBORERERGQSDN6JiIiIiEyCwTsRERERkUkweCciIiIiMgkG70REREREJsHgnYiIiIjIJBi8ExERERGZBIN3IiIiGrScHj82H6yHy+sP96YQ9Ql73zwMERERUWSpaHDhN+/twK6KRowdloi81DhcODsPY7MSw71pRL3G4J2IiIgGBcMw9LPFYsHq/dW4540tKKxuhscXwM7yRsTabXB4fPj5eVPDvalEvWYxQu90IiIiIpMqrnXgoX9tg91qxYTsRDy1bC9qHb4jbpcSa8cFs4bjhlPGIj8tPizbSnQsGLwTERGR6ZTWO/HupjJMz0uGyxvAr9/bhuIaJ2AJ5rl7/J3PTcZFWfEfi8bi1tMmDOg2E/UFBu9ERERkKmsKa/HwhzuwtaQeSbFRkDi9otEFI2DovwPdyClIjrVhcm4yTpucjQtn5WFYcuxAbDrRMWPwTkRERKZy/d9XYdmuSnh8BiwWwGaxwNudiL0dC4AYuxWTcpNw2qRs5KfH4fwZw2G3sRgfRS4uWCUiIiLTqHN4UN3khtdnQMJ1XbnXy+V7ci+XL4DtpY04UO1EdnIMCtITMHdkWp9vN1FfYfBOREREpuD2+XHHqxuxs7wJgTbfb/vv9jPr3QnrJYB3+zzw+X34aGsZyuqdOiOfEBOFE8Zm9NHWE/UNBu9ERERkCj6/gX1Vzd1uuNST+Xi5bYM7gCc+24sYm0VPCOKibXj2e8dh5ojUXm8zUV9jUhcRERGZgs1qgdXa6yyZ7qfS+A2tVlPv9OGe1zfhr8v2aqoOUSTgglUiIiIyhUAggPP+tBw7yxrhG+AuNfFRVgxPi8NFM4dj1sh0LBidjqg2C1ulbY4vYBz2PaL+wOCdiIiITEEC5Bv+sRor9tag0eXrVknI/jKnIBX/c9UcZCXGaJnKX72zDQdqHLh8/ghUNrq1es0MpttQP2DwTkRERKbx/pZS/Oy1zahq8vQop70/FKTFYUR6PFbsq4avZdWs3Qr4A0BafDRmF6Ricm4Sbj9jIqxWWT5LdOx4bYeIiIhMIz81Hg6PP+yBuzhQ68QXew4F7kL+LdtW4/Bg+e4qLFl7EPurm8O5mTTIMHgnIiIi00iMtSMxxq5lICNdwDBwysQsnZ0n6isM3jvg8QWwt7IJXrnu1UYgYOgHERERhUdBejym5iVHxMx7V1Ljo/DAhdO5iJX6FOu8t9Pg8uJ37+/ArvJGTM5JgtMbQE5KLM6YnI1/rjqAsnoXxg5LxKKJw3DCGDZuICIiGsgmTc99WYhV+2pNMxm4tbQB0/JSwr0pNIhwwWobRdXNuPP/NmLV/hrNWbNZ5JJXsHNblBWwWCzwBwzYbBaMSIvH9LwUTMxOwvzR6RiZkYCspJjw/SWJiIgGud9/sAOvri5CWYPbFDPvktozPDVWg3eJF350+gStVU90LBi8t5Se+mpPNe59czN2VzR3a4cg+UbRdgtS4qKQkRSLnOQYjMtK1BqwU4cnY/aINNhZ65WIiKjPXPe3lfh8VxW8fjOE7ofIBGBSXBT+/r0FmJ7Hbq10bIZ88O7zB/DPFYX4/Qc7Ue/y9e5FlIFps8BmsejilNgoGwoy4jFteArOm5mLiTnJyEzkrDwREdGxuOavK7BsV1VY67sfi7kj0/C778zE6MyEcG8KmdiQDt4lv/3hD3fi+a8LtQ1yX7O0dGRLiY/GzBGpmD8qHefPyEFmUqym4BAREVH3vbCiEL98eyvc3oBeJTdjABNtt+Kv18zDN8ZnhXtTyKSGXPAui0ceXboLe6uaUNHgwprCugEZ/NaWxg1x0XaMSI/DiWMzcfqUHG2vTERERF0rrXfiP19Yhx3lDVpQQirAeQ8vDGcKEhN8/6QxyE+PwwUz85ASHxXuTSITGVLBuwTr9765BV/tqdK2yuFKmZM5d0mHj4u2ac783II0LByfhUUTsjAsOTY8G0U0iMlurjtXu2qaPXrbDKa5EUWsRz7agb9/WYh6pzf4jZbCEmYUa7dgfHay7nfuvWCqXqEn6sqQKRW5sbgO/++VjdhX1dQvKTI9Ic8u1WwaXX79KKktxftbypAcG6WNHM6dnoN5ozMwOTeZtWGJ+mDs/2npLkzKTcZtp0/otEX5ugO1+PtX+/XkemZ+KkZmJugJNVPciCJLTnKcVn4LMWvgLlw+A1tK6mG3WvDR1nIG79Qtgz54l7PZtzaU4IF3tqG80Y1IFGgZwK4mDyqaPNhQXIdYu1XLT0p5qYtn52FqXgoSY3lZjagnY//tjSX41TvbUNPkxrbSRnxr1nCMG5Z02O12VzTqz15dU4QNRfWwwMCa/TUYmZmIMZkJOg6JKHJIAYjRmfGoaPDo2jWXxw8/zEvyH8ZmJeKiOXnh3hQyiUGXNiO/TnGtUwd3tM2C332wE89+tR/NHnMObZkFjLFbNHCX/Pg5BWm4eE4e0hNYvYaoM35/AL//cKfOpDe7D4399PgoHDc2AzcvHoepw1NQVOPQutEHa50ornOiqtHVWsUiNsqKmSNSMKcgA/92fIGOOVlodrDOiRV7q7UkrFSSIqKBJbPuK/ZVo6LBjbc2lqCqwYVtZY1hv6reWzLrft8FU3HV8SPDvSlkEoMqeJfFqNK8Yen2CiTG2LCzvBE7yppMfUntiFx5C5AQa8fw1Djt+ir5cQvHZXaaCkA02MkubGd5E+JaSrQ2u334ySvr8eHWck1Pa0tGiewbLl8wEnefO1ln3W94djVK6l064+7xGfAZ7damRNkwa0Qq4mPsyE6KxeaD9dhX3axrVk4Zn4lbTpug45GIBp4sWC1vcOGJz/diw4FabC6pP2LcR7r4aBsunZeP286YqOvgiIZM8C4LVx75cCc+2V6OsgYX3D7DlCWkekICeZmVz0iMxYz8FJw7IxdzCtKRk8JFrzQ0yAn76+uK8eaGEkTbrJiUk4xqhxtvrCuBq4MjuDRKibJbkZ8WrzPneyqaUFjTjHqnX4N1YXRQFSI1Pgp+w4DbF9BZfZngk9vLFb6bFo/DNSeOGpDfl4g6t7u8ET/851oN5uudPtPEANInRlJl/+2EUbjz7Enh3hwygUERvBdWNeGuJZuwen+NKUtG9XUHt/HDknSh3XkzcpGbGsdOrzRoPffVfjzx6W6U1rs1mpZUOVk/0hH5mVyelp9K4RmpEx1oCcIDbU6IO7rybrfI7JhVJwUCLbN9enurRQP7vNQ4nDIhCxfOzsOozMT+/JWJqBMSzryxvkSvqC1ZW4wS2S+YhOyHLpmbrw2ciAZ18C6b/vXeal2Muq20IWylHyORzBZG2y16Of+4MRk4Z1ouThyXqcEGkdmFxv7tL61HaYO7m1eprDAkajcM7azc0Ym+9GLwBzpu/CJjKibKgji7TXNrpZuyxx/QxWZWi0XTauQK2LS8ZIzPSsS8UenITIpBfHT/1QWQnH2pDy2VqkLcPj/sVtla4NMdFUhqWS9DNJTsKGvA1U+vREWEFqpoTw7NVywowAMXTQ/3ppAJmDZ4l8vlS9YW4cVVRdhS0gAvI/dOyWE8ym5BQowdM/NTsHjiMJw2ORt5afED+Scj6jNrC2tx15KNmuveXRLA68mrBfB2klYnPw4F8LJL6WgmPsoCSGwsJwMObRITzI2PjbJpR+W42CjE221IS4xGbkosclPiNM/+3BnDMTwlFtaWwLo39lY24Zkv9mHa8GRYLFb9d1pCtK57kTSghGg7HvrXNuSkxOnVgH9tLtXtyk+L02oWd5w9SRfdEg12Eto88dkePL/igBaxiGQypSbrah66ZAYm5hxeDYto0ATvkt/+5Gd78MKqA6ht9g5oXpsMMtO9YB2kAEj1mnNn5OCy+QWat8sFd2SmShN3L9mAV9Yc7NXVtp6MYQnehyVF60x7k8sHd5snlJ+FKtNISk5cjD04u9/SEMrScjJQ5/RqnryMOQnkT5qQidkj0nD65GE9CuTXFNbivre2aAAvnZplyr/R7UOU1QKbzYrkWDu8/gDqHF49WbdZrHB4fLotNotchYvFE1fP0yCeaKiQ6lDn/PFzzYGPRHJCP2dkGu45bwqbNNLgrfNeXOvAg+9swyc7KrQ18kAze+AuJCVYAgpZ5Pf5zirN2T1udAbGZyfi0nkj2JSGIla9w4N739iMdzeX9jpNrid3k+docPmRlRQNn88Pb0DSZYI/k8/yTwm/5cqf3+lFs0zsW4K59TLLb7cYcHoCejt3sxfVzV5sLWnQnHtJdzl5QrCz8gljMpF9lIXmUjnnv9/dhpI6h26Tz+/R0xB5XEndCXj9cLj98AcCWnnK8ElevgTu8jkAu92GUycOw8h0Xm2joUWC4+PHZOCDLeURd/yOi7LqfmRSThIDdxq8wbvT48fPX9+MZTsrW8u5Ue9Jd9cmlxOldU7srWzW/Nz5I9MxZhhn5ijySOnXu17dgA0H6zWtZaA4vX40ewKau263B1DX7GttCKMrSIJp9MF9ku6XJBe+8x2UbroB1DR78faGEny4pVxTXy6YmYsLZ+UhNSFaa9NXNroxb2QaXlx1AA9/tAt1ze7WE2s9gZATBUNODCyaQiOBuzyt3y85/TL7H6wfLTeUzzUOLxev05AjY+aq40biiz1VaHJFVr8XlzcAj9+lV9WIBm3wDiOgl4wZuPfhS9oyE+/z+OGoduDG59do6TsJIogigaShLN1Whnvf2KLVI4w+SmXr7v10zYjmwVt0Ft5oc/+4aAsChgUeb6BXHR6lmqXf44fL69QeFZ/vrERKXDR2lDfC7fVrh+VNB+vR5PZrCo4RaJurb+j3ZP7dagmm6uhZRMvvJf+0tAkSVhfWYntZg5bTJBpKThybgR+dNgEfbCnT9TLhXCLXdr8jn2XNjCx+J+oJ06xcksYrv3hrK0rrXeHelEFLdh+7K5rwPx/vQkUjX2cKP6kK8+Tne3H7yxtxsF3gbgnVbbdZdEfWk52Z5Kt3h9wsLc4mc9vITok5rKykfHZ6DU3fO5b5PPmdJJiQlJqdZY1Yua8aVU0eNLr9+GpvjQbubdN02pLvyX0lg9AXyudpIetSZRslppd1AiV1Tjz/deExbCmROdltViwcm4k6hycsgbtNFqTmp2BidiIK0uORHGPTvhRy8p0Ya8OZU3NaJyqkzKWs6xP1Dq8uSl97IDgz/+jSnZj3qw/xw+fXwOk5lMO/r6pZq2+ZcAkjDfYFq3LJ/Jq/rmTwPgAy4qO0WYSUvZOqNEThIAGnVE55bV0xqpuOXJguBz5ZKCpkRtpi7bzGe+t9dLbcirFZ8dhT6USzp+uwWxNPLEBOcgxqHd5+W2vTl4vhQwVlbFar5rzLJsvrJbm/UtXikjn5ulC9tMGJdzeWYkxWAs6YkqMVqYgGm6Vby/CTVzagNkyLVqOtwJp7ztSyrRLLbCyuw0dby7HpYINWf5IqcBfPycPyXVV4ZU2xjk3Jg5egXdLnJO1N1ra07TsnQzwpzo6c5FhdlOv1+XUh+9ThKbhi/gjMH5OB7GQ2bBysTBO876tswsX/+wVqHZG5YnwwkR1NtLSaT0/ACz84nu2aKSxcXj+ufnoFNhTVoqMYW4Jdqe4iZRotBuDwBZsutb9NYrRFq7rIrk5mp7OT43DraePw1LJ92FPRiJaJ7bBXmpLzEHmOY00LlIO6HOMlWJf686EZeblCIVVnJMUmNyUeblnoahioaHDBbrEgJzUO31s4ClefMIqL1mnQqGpy4Yw/fK4n3uGSnxqLz+44VRexVzW5EWWzYl1hLe5cshEVDcGvZdR2Yy6h2+SkQGb6Txqfhe+eMIqd1wcZ00yzfLazQi8jU//zBACv2486h1uDI6JwkMvKMuNkOdp6jUBAb+c1DpVtDJF3bnKcHYmxdtQ0yeVyQw+SCbE2Xfwul6TbzmS1Lf/YV3n1PdFXl/Nb03r0NWnpBGuRFCQDcv1CSsUW1jj0ZCb0nNJIvrDagaeW7cWpk7ORzx4QNAjUNntw8z/XhTVwF9eeOFoDd1nTcvdrm7T3gpxcl7c0mJNZ9f7ohSMz+/LxxKd7dFH8GVOytc/LmVOzeYJucqaZeb//rS14+ov94d6MISU1zo6fnjMZ64vq9es7zp6I1PjocG8WDSFPL9+H577cj/01jg5/LgfEGJukyxw+6y4BqpRAjY+WbqgBNLp8GqjL4s7hKXHaZGlfVbDsYlsz8pKxrbRRS0L2VG8C/GAtmEMB90CQQD4UPLSfEJFtyU2JwfUnj8EJYzLwwsoiTV+6aHaeHvxZI57MorC6GXe8uhEr9tWEe1Ow/M5F2FjcgP9asgkNTm9w8bmcXIdhW+S5JdXm5+dP0avqC0alswqVCZli5l0aj8hMEQ2sOqcPdy3ZpAd0CYQWjE7DhbPz+WegATM6M15n1zsjue4u41DtdRFtk8ZKsS3fkzKKFm2Q5NKGRTZUNrm1FGP7R02KtuLyBQX43093o6i25wu2ezMLYoQ6v1osiLIYcAzAxUV5XeKibXrS0z54l+2Rij4Pvr1NA/yAEUCM3YbluyuRmRiL33x7BgN4MoU7Xt2AFfvCX4JRLl5XNnrw6NJdGriHFqiHi4z/knoXbn9xnTZ3k+pyNy0aF74Nol4xRU7E9tJGbD4YnP2lgRWqZiGVMH7x5lbc+X8b0OTmugMaGC+tKjrqIvVAy3s0VHkmJdams0oyqyUpMpLvLf+WCQAJ2OXg2dgucJf7psfb8e25+chKjMGwpBidnRookuMuM/2hEtQSzPdkx9zTbZXcd6niIwtvLUfZpiYpH+s19CS+qNqJrSX1WLKmmBUtKKLJlaLX1x7ExqLwB+7KAO5/e6suVI2kNAenz9BKVi+sOIAvd1fBweO6qZgieJcuZNLmm8JLurIu3VaBr/ZU809BA+Li2flIje/eBcKxwxKxeHK2XgKOibKiID0OaQlROvMlpWYlIG0/2x6ljYyCAfzS7RW4580t2FPZfET+/EA4LFe9B/frTuKj/J6yfiXabkGsnOW0NJ+S9CFxtPhfa1FLh1hvAG9vLEVxrbMHW0c0sF5fW4yfv7EZYSoscwTZ72wsrg/LPqU7imqduPIvKzD7/g9x8z/XauUainymCN5lBi3YKZDCrabZg8c+3tVah5aoP43MiNfmSN2ZTT5Y68Ka/cH8Vilx+tAlMzAmM6HThVkxNim1FqUz9vVOHw7WuVDZ6NL8+IHUfuuMHt43VC7zaGRBr+T7x9slFUZmJ4P71YQoKxKjrYiRRQJdkABerrpJyg1RpNpR3oTGCJtFbt+DIRK5fcGT8z9/ujvcm0KDJefdDG/8oULz5bSmbDiW2tBQs3JfDRpdXZ8oSmqXXJ2TmuajsxJx1tQc5KXF44Sxmdpd1B9o0PSbUI65LNTKSIhCtcOrNdDb7mIGenfT26eT+Yxpw5Oxq6KpyyRaCc3dPgMen09n26UyndSAl9l4n9fQyZH4KANWqwWODtYDhEijKik/SRSppOkR9Z4sUq9xeHDqpGx8a1aeFgWgyGOKmXdpFS5tySkyyLG7P0pbEbWXHBfVreA2EDA0XcZus+js8Je7g90GvzNvBO4+dwomZCfp7LzMss8akYL/vmQ6zpmRh8Rouz5+6MNM8wSyrZtLGrpsGiW/s912KP1Fhq7XJ3X0A2hw+uD1+2FYWk6AjhK4yyH89MnZSE9gxSmKTA0ur/aEod6T9TdvbyzD7S9v0G6un+yo4MsZgUwRvCfEyKVeEx1Vw2Ag5xpi7cFFgUT9TfLduzPytc14jE27rEp++5oDNVq3XFJDRmUm4Pgx6Rg3LFHft5NyU3DmlBzcetp4nDQhExkJ0YiLlgZGocZGJtkxtjnZONr2SlAuAXuoLKXk+MvvGFqMLrG/1L2XutBdnZKv2h8hiwCJOvC/n+zGu5vL+dr0EamP/8zyfVykHoFMkTaTGGNvaQ/MAL4zR7suIUFJX750snD15hfWanmpaXkpfffARO3IJVtJx5ac7a40uYJNlyRAlepUd/zfBlz/jTHISorBtQtH4fixGRrQT85N1jx4GRffmpWP7KRYrDlQi60lDa2VaSQFxwgEZ6sHokHTsTpa0B2qxqN57bJA12LR39PvDbT+Xt294uCSKXuiCHWgxqG520NZX++vvthTrVW/pIxuT8iVz87WG9EQCN6rm9x4ceUBnvkdg74+52lw+fCvTWXweAP4y7Xz+/bBidqM/bfWl8JutcIbCJY1DB2YjA66ooZai8uVOq/fwJaDDfjZ65v16+l5KShIT8DNp47T+uUhC0an68eBmmatpCSP9YcPd+lJQOg5Ij1wP5rQoTPKbkG03abBt0/qyktFHltw1l0C+favaUesLfXoV+ytxpyRaS0t3YkiBwtb9P3+Skpvfry9HBfOzjts39nWq2uK8cHWMty0aKw2wfvbl/u1wd73Tx6NMZmJOHlCFjITY/p4y4a2iO+w+uqaIvz3u9u1yklEb+gQJIHO7II03LR4rHZpk0Y4RH099uscnuDscUvkLp8lt31cViLOm5GrDYSkC7DbbyA1LgrHj07Hsl1VcPv8SIqN0tl7CeblwPPb78zAiWMzO3w+SRvZVdGIG59b01oOsa/2OeGYvZeJ9mi7Ff5AAPExdjR7AvD5grPtEuTIa+j3B2C1WfQqgxQGkNdZ0mrk5/JvrZPfsv3SrVZm0uS1HJ4Sgxkj0nD+zFx8Y1yWPg9RuP10yQb8c2XxUW9jhitpkeiHi8fi/5016YjvP/fVfvzira0a5GcmROvknqwvavb4W3pKGJg1IhWv/XBhWLZ7sIr4mXebxar1iDnYInNGf3VhLW74+2qkJETjv745GZfMZQdW6rux7/L6D6V0GIc+SSrdT86aqDXZax0+REfZkBRrxcLxmVi9rxYun1+roozOTMB13xiNl1cX60zx5JzkTp/vt+9v11Jp8pySYhKczTf65GAfur+1ZQGpu5+u7GvDqYTo4AmPpLn4AvqcjU7fYfXjZVFaKDCXH8ht4qIkoLdpJRr5vaOtweDeAgsk5JeTIDkwy+PsqXJgX7UDS7eV44wp2ZiUk6zrB2SWjYE8hYusx0I3riAxA7fnnvh0D86Znoupww+lypY3uPDLt4OBu6hq9ujnUOaSnOiLfVVNeHV1Ec6enouyeid++/4OHDc6Q2fzZV/OfcYgDN6loQgvhfWMHIgHMutP8pGrmjz425f7cPqkYRrIE/XF2A+VKQsFv5o605K3LXmYmw7Wo7bZG9z52y2oanBrHfK0+BgNwssa3Foy8ulupHeVNbh0okBqwx83Ol0XZ0pXxJyUGJTUONDUncT7Lmizo24Mzp6eMEjgLSktkh4knVFdXi+k1LUcVKWSjBxb2z9e26/lZZa0muDtLLDK/1tebCkpKUG8XqRtV1JTauK/t7kMH22rwGvrihBls+Gy+SNw5XEje7D1RH1DrrR1hYF778jr9v9eWY8/XDYbE7OT9Cqc328g0MEL2n4NjXRp/smrG3H365v1Cqj0iflgSzkeeGcr8tPjcdVxBVpQQMpT0iAJ3qUBiRyUqPvCtVxn08EGzHvgIwxLjsF5M4fjvOm5uqCVi1aoN3Tst6kx3BrAG0Ct04OPtpbrQm253bDkOOSmxOKsqbk4eUImah0e/P3LQq0kI2Uiu/LWhhKdqb90Xr6WmvtwWzkm5yQFc8T9BtITY9E0gJ1Fe3OaYFgsmh4zMScZGQkxqG52o7rRjQa3T9ugdyZO8uGjbFrjXdJq5MgrjyX/ScBuGAEN7mUcR0dZ9fUI9d6Q/zt0sYFfFwxLLv0n2ytw+fwCfTyigSSzuNR/tpY24conv8a/HT9Sg/A/f773qMUy2pPFxKEFxbLvkLhfigg8+O523cd8+pPFKMiI77ftH0wi/p2eEBMVnAEiU5DL8dKp8s+f7cVTn+/FiLR4XLFgBE4cl4lpw1N4QKcej/32gayWOGw5YsiuQQLV7y0crYG3VToQAchPi8fvvpPareeR2enff7ADJfUuDEuMRmWjW/PnD1Q5YLFIaokFafE9v5o0aVgCdlQ0H1PKTWK0BU2erh/B6ZWt9OPrPVXYnhCNOQWpKMhIQ25yrC4k23ywQQNuyUFtX7VLF+dKLrzVoq+fpM0YLbcJLVKV+8ZH21GQEYMmt1e72cqaFzkQh+rj6138Aa34cckTX+LiOfkYnhKrC4K7MyNKdKxkHUdnQlftuqqsxJz4o6txePHEZ3u0t4avD/OZ5cJeN7KeyCzBu1wCN1PjFDpE/m6FNQ78+r0diIvapekL80el4YKZw3Wha0wnK9eJRFyMTXfobbXfFeSmxuC+86fgjKm5vX7RZHZf+kj4/AGUN7j1BFR42iTblze6e/y4uyp7F7jnJEXD4Q1ouqAE0n7Dp8F5V+QWzV4DzXVulNaXI8Zm0dkxaRUfKqHZUbld+X0DLQtS5UGskuMus+2hKjQtK4Xjoqw4cWwGNhXX6+sUbZPkGuhaAsmFF/LwuyubNbAvrGpGQoxdS3NKOlJBepyO/VkjOPapf8gxRjLoOqsW2TaWCIX57UeEvHdDQSkD+Y51t2x3T14/uZ00jqNBErzLzI/kvmLgrlhTH9NL616p5NGkH6+sLkJyXDSOG5OOk8dnHbUEFQ1dMocee5QqJlJNJT7Kjs93V+HrfTW4bF4BJuR0nSLTnqSG5KTEoarRre/TvtLb3FoJhGOjbRq8e2VmWwLqbswYtiW3dfoMOH2H6rIf7e6yQFdeawl+3F4/9lc1t6bGyAZI/C55qi+vKtJt0ZMqSalpOfkJlevU3ztg6KV06QchH7JALRRMvbq6WGfhdexPyMK503NZpYr6zKmThiHGboXPc+Q4br/GQxeO+w/tS0IBe9tx1nahOcPKnuvJLvA/ThmrBQZo0ATvltaZMBocJD6qbvbg3U1l+GxHpebIxkTbcPPicd3KT6ahQYLCQ7PfR5If7a+WqifNOsfz9oYSzC5I1/KRHn8A507P0QWUH2+v0MdaNDHriPUXz3yxD1/vrcY5U7NR7/BgV3lTpwfpgTqAywmEU2fegwe/zmYRQ7/JsKRoDfbrHN5gVZkePp88T5TVqpVm/vvi6Xh/Sxn+9PFuzW2XHOLMpBhUNLh0OyRlJnQyYYVNPyMUwCNYatISSsVpmblv+yeUdCR3swfvbCrT5/nVO9swNTcZv7xwGsc+HTO7zaoxw9EEuwwfnj4m/5Tvy0RhaPZXUsxC1VLM0qzNbGSfOiIjHhfOysNtZ0wI9+aYSkQH77XNHjy9fC/qWsoPtSezPXKA4BmxeUktWFkcKDvTjPho3HvB1HBvEkWIN9YfRE1Tx2NfyLiXvMsgQysefbKjHB9tK5PUazzw7lZMyk5GYXWzVlL56xdxGJeVgDOn5mj+9jsbS/DmhlL4An5sK23QplBy3E+wW+DwHqpv3tqFtM1zH+3SfF+Q5+zqIoDcRoJnyfeXYLikzqUNqUTjURaotqdBucen991e2oDV+2uRHGPXfHaptFPd7IXfMFpf61B+u19K+Eo5TV9AX2+dhZfXT+/rg9ViPSwnvqPnlWo1q/bX6InX7WdO7OGrRHQkCcCP9v7XseU/fHyH/j0sMQZFtc7W27S9j7WbOfPUfTFRVp10kMkBKUAweXgy8lLj+BKauUmTbNbtL2/Qzl71ziNbcuu5dejyLSm5DGjmlDHZMeanxmHmiFT8cNFYTG5TT5aGFmnKdsGflqG4ztVnjylhbUp8lM7KSyBqkeoqfpnhtsLj8/do7HQ0CxcfZdP68u3TXNqWudSUk5avOwsCpHqOpp50Y2Gd1Fi/7fQJuPh/v9S8cikZOX9UBjYU16Le2ZM6EFJ1xorEuCjUNbuREh+tM5Cy/rehZf8rgbmkt0kJztC2tX8d5PfTBk8BAzFRFrhkIa0l+LUsJgwFTe0lxtgwIz9V02i+MS4TI3n5nHrp35/5Gp/sqO7WbeU93XacHW12nakz/Sf0umckRuOru05j3Xezz7zLjFmzFCvugA4wBu6HMXPgLiTokVkP+XhnU6k23JAOjnefOwUpcaxWMZTIugip+tKX/C2VEtpz96jYWZBWwWm3//EGpKSi1FQ8FMjmJAVLNmpDpLa3Nzp+jGDKSTD9pCvy+D8+cwJ2lDXqSYiQha1bSup7HLjrfX0BOFte8+qmIztaS5AjkyqSIiP1nUNXINrud0KNrYQvVCWn5Zc82iI3KWX55Z5qfLWnWhfpSroTxz51h7wn5aRQej0U1zrg7kE/hvbjzOgkqNSqS1KNSRa2R8hxdlRGPG47fTye+Gwvdlc0dTu9OBJPQkJb3uTyoePTezJF8C6zTo9/shtFNQ69HEtDjxzvZSZRFrjtLm/Ucn0/O28K5o5MC/emUT+P/f/9dDee+7rwiGAv1m6Bqy9rkx2Djo6TEkDIrLMG4IahC0DPnpajQenuyib93UKLPW22YLlLzRkPBfItwUL7ihid/cZyOxkf/1hx4NDiUr1qceQJSkcH8Pz0OK0aE6q73JZxlHz8aGv/TRiEcvwllUnHfkWTfu/n503BnAKOfTpcIBDQ9RlrCmsxLCkG28sadNKvO9ousj7a+1E/G9A1IMG+E+HfBw1PjsZ7PzoJsdF2fGt2PpweP2b/8j20FH06qvBvfee8LR2dyaTBe0WjC0u3V6DB6Y3oNxr1P4kN1hfVa7Dz0qoDWr+aTZ8GLxn70q2zznH4zK8caI9Swjki6Boc/ZehwbEE1M+vPBA88AeM1pKUwRl3bYEUDM5l8WdLLfXWx7JKYAJNW5HPGtS3ez659VPL9+m/pcLGqROzdL/Z9qQnFGfLfeUxQq+hLEL9x/XHay+GV1YHg//uzih2UMij/8b+gTqt/fzSyiLMHsGxT0GSulVc48CjH+/CB1vK4PEF52u7Gy/IuJAmYh11B+1I6FZtx2g4yRXEPVXNmDo8BQ0uL254dk23AncRGb/BkWTX9O8LRzNlxszBe3ZSLM6fORxldQ6UNXa+YI26J0pKzkXITqc3dGGiH1iytlir03xjfCbu/OYkDEuKDfemUX+N/XoHyhoOjX05xsoi0kgWmj2XoabpM0awiZEudGtzu2A+fEsQ3/K9zKRoXXArZIa+9fFCueVdTPhJ8P7+1vLDZhIlUJdqMQ6vXzdK6r5LrfVGTwCZidE6yzV1eBI+T47VKjUOrxf+gEWrbEhgI51TD3s8K/QxJI99oC6IyvNIA9f/W1uET3dU4KTxWbjjmxM59ocwSRG7a8lGfL6jUqsfaYPfXh1TInt/clSGoRMcstj7gbe3Yn1xPczuByePwX+dMzncm2EaERm8y4Hjum+MxqaiWry1sbTX9ZIpGDT0VeAe7guGMjMozXLeXF+ijV+uP2lMGLeG+nPsby6uw5sbSg4b+5G+G5AUP5klNloWaAbLKbYJvNuUtpCgXBbMGgEDqXFRuHh2vq71kNn5pdvK9f5NHn/w0v6htPFOhZokhVhaGtzJLLwMf1nMnp4Qg/Nm5ml6T2p8NEamx8MIAKnxRXr/6Ci7fi0NmuKi7PAH/HC2ZOBMyk7E9BGpqGpwY3dFI4r6cCFxT8a+VCCalJvEsT+Eyft3Q1Edah1D98q8lMR8f3MZXlt/EI2uXpy9RIC2kxMnjc9k4D4YgveQm04dj3qXT/PYyuvdEbfIwgz6cucWKTtKuXQZmp2kwemmxeNQ5/JiR2kDyhrcPSrPJkGzNB2ShWsDuc8I5bMHq8pIUkwwmV0OUlJq0Rr6JVqOWqHZeCnTKOkvybF2XZh95pRs7K1swobi+l5NXISqwsg2SMUXKfcoC0zl8vqXe2vw93+fr6UzS+udePDdrThY59RFf8ErBX4Njhwe92HjXU4sfEYA+6scmrYWrhN5jn1yenwtCxs71hfvzZ42RRvohaJSMeufstbFzIfBln3lCWMz8NR354V7a0yn8/aFEUAa9jzz7wvwyGWzkJ0Sq6XYIj3vlQaGlJ2jwWu8jP1rF+CRy2chJzk49rv7F5eD7kCmdrR9XjmWhk4sNYCXLqQtBylhafm5TsC33E5+Lp1UpYPp3spmLFl3EGuLDg/cAz0YFzLjrqcOhoG0hGicNjFbzxekc2plgws/eHYN3tl4ELe9tB7rDtRqacrkuKhDFTUsHfdj2F3h0Bnwzso9DpQoyd+hIams3oVfv7+9NcWsI33x3uyPuaG+3B9JqpCpA/eWv1N8jA0PXDidHdYH28x7yIz8NHxrVh72VjbqzE+tw4Mmt09Xf8tldqvOccmCr0DElHGi/iVlwWjwm57XMvarGrGvyoGqRrfmYru6GOh9fVyTc0WJaSXVRYJXWUcieesSoEswrqktLWXrgrnshlaTCX2vo+0JtEwRhlptyOMda+8K2RdKyo3NatXHk5KPb2w8qI3uJK3nQI0DJXVO7ChvRHWTS7+XlRSLq08YiQ3FdThQ7UBJvUtnNuVkIhLjgyjpZU9D0q//tU07Jkfi+3KghDt9tS81u/14atke/OrC6RrL0SBo0tQROSgt312Fg7UOvLG+BLmpsbhyfgG2lTVic0k93tpQom3FqfcisQZsR06bnIVvjMvCpfNGaEdHGtxCY18CzxdXFeFAVROio2zISYnFloMN/b4gO3QZXU4a/dLYSRop+YONnmTbersuJ1QBJtAy9kJt2o9lDEp+e2JslC5IlVlq6YDavrFS2+dIjrXhnvOn4dtz8zV4lzTFZbuqsKawBtvLGiOuo+TpLWP/Oxz7Q4aEKZLjfdeSDajrRQ+DwaK/OzuHQ5zdgiU3LWRTxsEcvLclByM5MAXrrkoZwULc//Z2nZGnwS90qf+ub07WoIOGDhn7W0sasK+qGS+sPIANB2oxUIVoWid9W/LWZbZI89kR/NydQLftzJkG7/IYMlve0u1RdmnHskhfHkf3jRZdFavPZbNYdN/YvjO1lKKckpuMRy6fjbFZia2PIYeFlftqcNPza1HdHFkVv2Jaxv6dHPtDxvtbyvDo0l3YWSYn6hhyZNymJ0Shuhs9HMxIOix/cedp2gGbuse0uQeyICsUuIsYu/2wr6lrZn61pIpGncPb2lmShg4Z+3NGpmFiTpIu3LJIBDpAZLGm5JpqXXSjJb89EEqPaXfbdv9um/eudaZD32xJyQnd/Vira8n9Ja1ISmtKozNpZOMNBCvXxMXYEBtl1YZXkjoeH23HraeOPyxwD/2er607qCmKWi0ngrj9hlYa8UsBfBoSHB6fHt9T44beVVaZMJiel4A65+CdmJQOy/uqm8K9GaZi2uC9vbgomx6kqPtMecmlDQmc5NI+K88MTVOHJ+PucyZj8cTMDhdZ9sfOUuqptw+U5SK+BPPtx1Pbr0MNZEIz3/KhC1xDheEt/VMdShfv+ozWBbw+X0Bn1aXUnMzOx9mtWiNaUn/aO2/GcIwblqgz89I5tu1rrK+FDWEjY341x/6Q8c1pubjjrEm4afF4ZCREa/dieT+G0s7ajkr5flKMTa/QxEdZMG14MnJTYkxZ7GJidiJe+MFx8Aesg/44J5MyNATSZtr7ak817n9ni9YhlvKSHbX8psEnIdqGx66cg8WThoV7UyhMPtlRgR+/tF67DvYnObRER1nhluv2fVhKLtRNdaB2xFpK02ZBlF2q0liQlxaHP1w2E5Nykju8fU2zBy+vLkJtswfPrziAnOQYLBybgW2lDbreqNHtD9/Yv2oOFk/k2B9KyuqdWL2/Rte+FNc6tRKVjH2n14dom1UrVf3igin4dEelNim7eE6+dmF98N1taHT5dMG7YYK00B8uHoebF49Ds9eP+b/6aNDHNP923Ajcf+F0dlDvpkFzDeq40em48+zJ+Gp3FZ77uhDucG8QDYiEGBsyE2P4ag9h0hE0PtqmVWA8fj/cbWqoySXnviqpJodOlzcQPPD34dG/PzO/OqxM0ZL24/cGYLcayEmJRm5KnDaHqmx045K5+YeVY0xPiMaNp4zVf3/3xFE683nTP9ZgVWEdwkkCs8wEjv2hJiclTpuNyYek08gi9uW7qlBY48A1J4xCflqcXlmakH3oZFQ68148p1EbjH20reKYKjr1N1lw/uMzJ2rHUUlfe/idbYM+cBdLt1XgtjM8yODxfGgF77Jw7JQJWVovWUpJySIraUoiB3QanCQwu/f8qZienxLuTaEwmp6XitOnZOss8plTs/GTVzZoECo5slIy0eH29UkFJcNkJzTBhbCSJiNldEO156VihUXXjARPRyzYXd6MF1YU4g8f7mrNb798QUGHj5uXGofnvtqPZburwvp6yNi/5/wpHPtDnKzZGDcsST+ORvod3HH2JLy6pkiv1AUitGDN1OFJeOSy2ZquJoG7eG9LGYaCC2fn6UQBDbHgPeSUiVl6UPl8Z6UOVAbv5in/2FPSjIaz7iRdSX9xwTR9IaQ8ogSeO8oaUVgtTYUCyEqM0bURUjKxpZHoMS8KjXTSA0NyZLUpVJtpRqlL3zb1V4J46Z76m/d3tKYBPb+iUINiyXUPBRAhT32+F499skuT9eUEQWvch+G15Nin3pASo9lJsThY5+rw5DOcNdRPHpeBp66Zj5h2ud+RlqvfH6+RPOYPF49lysxQDt7lcu8ZU7LR7Pbhi91VWi1BctzkoB46cA81gzFwt7Scqc8uSAv3plCEjf9bTh3fWupQAsvjx6Trz8754zLN0R4KOqp+I7RKThe33XSwAf/+zErNFZaT4+/MHYHkODse+3g3/vz5Hj0JGpmZqGkrxbUOLd0p1SIGcjLiIo596gXpC3Hq5Gy9Ot/g9KDJ5T/s+BiO+CA5xoaLZufj7vOmmKL5YH+8RlIBq/1EAQ2x4D3k7Gk5eiAvqnXoYpUGpxfFdU7NWe2JlFi7LoClyBIXbcW1J44yxc6OBp4cCI4bk3HY96Sh1+Of7tYT+q5SSCUtIyHWjgaX76j5saF3X1d7lVANdy0T2dKUSburIjJJ+/kXVxbpRr6x/iDK611ocPs0LbEgIw6LJ2Zpt+vzZ+SitMGF574qHLC83MRYG67h2KdeuvnUcVgwOh0biurwzsYSlDW4B/zqkRy25MT4u8ePxFnTc1GQHn/YOpPDRGhMG2pcd6xk3/jUNfOQEMMa70Oy2szRSLUE6cr69y8L8a/NpWj2+Lu8BJQYY8V/nDIO728tw6bihk4vsYUarAz6FzHCjM+Kx4s3nMjFLdQjEnye/9gy7Cpv0qA80NnYXzROT/pl7Le/jTQ8ChjBMZ+dFB2sYNHJpEBwHyH7GIteDZADtAWysNY4VHpRyk1GWCBvbamsI6+X1rZvc5SWxcHyu8hr8L2FY3DnNyfhvEc/x+aSgbmqMXFYAl644UTmx9IxkffwwVonrnjqa5TWOftlDEo5VQk3jJYJgWl5KRg7LAEnjMnUK8eysLYri37zMfbXODFY5afFYtkdp3LmvYcG7cx7W7IIQj5+d2kqmj0+LNtVqXXh0xNi4A0EUNccTK2Rhj9yoEpPjMb/O2siLpmTr5fZS+tc2p1QSsSF6jWj5XPbgxoNDClz9/i/zWPgTj0WZbfquP5kewXKG916RS43JVZn2MvqXdrhLzT2t8vYlxlnp1drpR9y6GRdZqiPlj8fuhIcF2WF3Spl7BI16N1YXA9D67tbtMup1Fm39nEu/rHkpg5PlSouFl34K02R2pJ9pZCTj43Fdfjpkk1wD1CzNBn7j101l4E7HTM51kuZVEmzXbW/RstOSuO/Yx2C6fFROHXSMF0sf+n8ERiTmYD3t5TqCfzZU3N08WxPtzMSdLQ/CdXZ721FL6msc8WCkRHzO5rJkJh5b0sWrr23uQxnTc3BvFHpmhe75WA9PtpejkanT8+G545Mw8wRqXr78gYXVuyrwcp91VpLXmbZ6hzBy2ydXSUO56KXwU7q3y656URMywv+fYh6Sw7Yeyub8M3puUiItuOrvdVIirEfNvZl/yAlFN/ZVAq/P9joqDtkH2C3WTQol8B9VkEaTp6QhWtPHI3/W1OMX769RWf+tUNsyx1kMak2ezrGnYcE1fIYoauC8nVPTgpGZ8bj8avm4pkv9uGN9SWdpsNIIK1nJ0ZAn0s6uvYnjn3qDzJG6p1ePPHZHjyzfB+8vZyQk3E8LCkaD10yA4snZffZ9l38+BdYeyC8ZVn7yx1nTcRNi8eFezNMacgF751pdHnh9PgxLDm2w5/LyyQzTl/uqcaq/dX4Ync1qpvcGsy7vf6jnnmGOsEN9goX/U1ihdd/uBDT8xm408CRsb/5YL3WIV6ythgVjW4NumXPGark1NGMlMzyazdTqxWJMTatTz09PxnfGJuJZ77cr4vo91c162epTS9xsFSJMfogn1bi7dDnnlabkm0dmR6PbaWNnd4vvmWBWdsUxPY/l3rbOyua+2Qyg2OfBmJi785XN2JvZXOvijxICt1Pz52CC2YO75OZ5KomN377/g5tSvXZzqoub2+2ScMZeSl485ZvhHszTIvBey/JrNz+6ma8vvYgtpc1YHdFU5edBkMzbDrIIizH1QxGZcbj058sDvdm0BCn62e+2o/NxQ3aJKasQdLqvHB4Aoct4JJ0VplNlxl76UMh/5byitIGPDMxGieMyYAnYOhl9ldWF6PO4TkiRSUSFpR1ZPaIZGwtaUBnu7yzpmZjYnYSXlx1ABWNnmN+Po596m9yoi1X45asPYhPd1SgpllO0ru+37CkKJw3Iw+nT87GieMy+2x7Xlh5APe9taXHRTYinZyIS+bDw5fNOqIsJnUfg/c+GvT/XHEA//i6UAN65yAbbJFAZgPlcuR5M4aHe1OIDhv7H24tx77KZjy5bK82h+voYGUPpbBYZbFrMLCX03hZ/CnrbyT3dn1RLbwR2jymN7msMkHRF91tpbrMQxdz7NPAkfVvv/9gB/4uVZS8fh2z7d/KMoRHZSbgT1fMwtR+SOOU4P3u1zaFpY9Cf5H94Ldm5eGBi6bpJAb13pBYsNrf5BLZVceP1I/fvrcdf1m2VwecHKilWkOgh7mqg2is9on4aCse5MGbInTsnzk1R/8tHZ3/snxvMJ3GYtF66NrDtKU0pASylpaZdbn6pvntAUMXy8ol8r5a8xkJTdnaz1/Ivm1iTpKm4vR47F/EwJ0GllSBOXtaLlbtr0Wz26sL12VMJ8VGwe3zY3hKHL4zLx8LxmRgbFZiv2yDFNmIsdvgHCRn9LJm5YJZebj/Wwzc+wJn3vvYrvJG/OqdbVpV4pZF43Dzi+u0WVRPzp7NlrvWXyQIkZX50gZdztaJzDD2J2Qn4eZFY3GLjP09VVpaUhbBdbS6SGaoJZ4P7R8G89jPTo5BeYO7W7fl2KdIIA3Iqps8eG1dMSbmJGtlmgPVDm1alhrfs6oxPSWL3WWNzRsbSrBqXw1cA9RHoa/F2i24Yn4B5o5O1yo88dGcM+4LDN77mVSW+MOHO+EPBLSsnFxm58LVrsliO6l4ITtLlpEiM499wwho3ndHY19mo6TmOx3CsU90uNteWofX1pWY7mWRtMBbTx2PG04Zw+N4H2PwPgAqGlxaQ/bZr/Zr3eQtJQ16Sd3lC+bS0ZE5wk9cPU8Dd6LBMvYlNWazjH1vcOzLLHv7Bkg9IbP2g215Dcc+0SGF1c06AbD+QC0KTdaoScbyjYvG4sdnTNQUYupbDN7DUJJy+a4q7Klswj9XHtDLw2WN7mCXxR52au3PahLhIkP86Wvn4dQ+rJNLFGlj/4WVRTp+pVGU5L1r/ns3HiMY8B+q4S5fd7SYzow49okO2VHWiNtfXq+TfWYUa7fivy+Zjotm54d7UwYlBu9hJLPv20ob8NaGEmwtbdB/y6ycwxfsp9zdA3IoT3Yw5Ms+f90CLByfFe7NIBqwsS+ft3Zz7IfGuMy6Swrs2KwEjMtOwpe7q3Thq5lx7BMdct3fVmLp9krTviQnjEnDo1fMRVaSdGumvsbgPUI0u33aCGbdgVrNbat3elDT5Ib0X+ztZXWz+cs1c3D65NxwbwbRgI99mV1bW1ijY7/B6UF1s3Rx7nrsS/dWrWxlgalL1HLsEx3u8j9/ia/31ZryZZEqkM9ffzwWjM4I96YMWlz2GyESYuw4bkyGfty4aBw2Ftdh2a4qLNtViR2lDbrSXA7Og2F2vbNW6+OyksO9GURhGfsLRqfrR9uxv3xXJbaXNWrFi87GvlSkkMZOZs4o5dgnOlJmonlnrDMTY5EcFxXuzRjUOPMe4eTAXVzrwOc7q/Dh1jLNl21w+jB2WKKWoCuuc2p1hs66GMqiEVnx3VX313CRoOP8mTk4ZUI2LpnL3Diirsb+uGGJWnP6YL1Tx3dfdDANB459os4drHPivje36NV4rVQXwS+WNqKzWXUyITXOjoe+PROnTea6tf7E4N1kJD923YE6nDs9FynxUbpobd2BGvzXks04UOPQy+dCZuqSYm34r29OwaNLd6Ksm/WVB7r+6/9cORensaoMUZ+MfUvL2I/kA73g2CfqHgmIP91ZgaVby/DS6mJd69ITUVYLouxW7RqbEmvHqMxErCms7VUjt1CRDCm0kRBjQ7PHr4vnr1wwAv9xyjis2F+D4alxmD8qnX/efsbgfRDmza89UItXVhfjpsXj8O25+Vj40Md6Fh9J0uLtePraBZhTkBbuTSEaPGtmiurw8uoiNLu8KI/QGXkZ+3+9dgFmc+wT9WiR+4IHPkSds+uF6RmJUbhqwUisL6rD8WMycMPJo7GppBGJMXY96b/2mZXw+gM4aVwmtpQ2oKzeiUaXv7XwhXaFNoAYu1Wv8Etp25TYKIzIiMeeiiaMzEjAZfNH4Onle7Fo4jD88lvT+JccYAzeh4CTf/MxDkRQjdisxGj86co5ulMhor63en81Ln9yRVgXu3dUypZjn6jnpMHbi6uKcO8bm7vV1C0vNRZf3HVapz/fW9kEr9/AxJwk/drt8+OT7ZWantfo9mFrSYMunD97Wi5yU+LwzqZS/Ofp43Wy7ePtFTh5fBYKMuL1BMButbABUxgweB8CTvv9p9hT2YxIkJkYjT9ePhsLx2WGe1OIBi2X14c5938Ehyc8a11mj0jRVL3Selfr9zj2iXpHgu2LH/8SdU5vl7fNSorGgxfNOKYmh7vKG3WxvDxGrJSOoYjDajNDwK8unI7/+WQXvtxTHbamTjITEGW14oGLpzNwJ+pnMjsnl7sHiiya9weC1XBkxn1LSSOe+u5cbTTz7uZS1DV7OfaJekkCaKe38xNxGenDkmK078P1J4855iaH47OT9IMiF2feh5BFv/0E+6sdA/qcc0emYkJ2Eu765mSksHQU0YD5y7K9eGb5PpTUu/p9Aev9F0zBh9sqUO/0tnaE/J+r5uCsqTn9/MxEg59UnfrWY8u1S7MsWG07CSeB+9Thyfj9pbNa02Bo8GPwPoR8sKUMjyzdiW0ljf12MB+eHIvShuCl8psWjcWPz5wIa6gEDhENeK7smv21+MFzq1Hj6PqSe09J1Yl7z5+CaxaObn2+N9aXaC7sJXPyOfaJ+sjSbeV6JevVNcWaPvP9k0ajqsmt5WNvOGWslpCloYPB+xD0jV9/jOJaZ581fDp+TDpW7a/FpJwk/PP64/D4p3u0wcT1J43mQhaiCHDrC+u03JyUnWvqw54Pt50+Hj86fUKfPR4RHZ1c3ZIZ+Py0eL5UQxiD9yHoldVFWk6ustGNkjonDAPw9jIZ/lszc/HI5bNR6/AiOdaujRqIKLJIjWepBb9qfw3uf3sbmj0+WIxgSbhuFK846ti3DGBuPRERMXgf0gqrm/Hpjkqs3l+Df20u61FZOQnRf3LWRPzHorE8eBOZhMPj074PjS4f5oxMQ3ZSDN7bXNZ68t6dq3Ec+0RE4cWZd9JL6bsqGvHsV4VYtqtSU2qE1G8N1ZQNHdSlDXJBejy+PW8Efrh4HF89IhPmzkqHxWtOHIWsxJjWsS/l4WodHuyqOLysLMc+EVFkYfBOR9hZ1qhdWjcdrMfr6w7i0nkjMHNECjYU1WPRpGE4ZUIWXzWiQais3oVfv7cNX++t0UD+ygUFmJGfgg3F9dpJkWOfiCj8GLzTUdU7vEiJj+KrRDTEcOwTEUUmBu9ERERERCbB0iBERERERCbB4J2IiIiIyCQYvBMRERERmQSDdyIiIiIik2DwTkRERERkEgzeiYiIiIhMgsE7EREREZFJMHgnIiIiIjIJBu9ERERERCbB4J2IiIiIyCQYvBMRERERmQSDdyIiIiIik2DwTkRERERkEgzeiYiIiIhMgsE7EREREZFJMHgnIiIiIjIJBu9ERERERCbB4J2IiIiIyCQYvBMRERERmQSDdyIiIiIik2DwTkRERERkEgzeiYiIiIhMgsE7EREREZFJMHgnIiIiIjIJBu9ERERERCbB4J2IiIiIyCQYvBMRERERmQSDdyIiIiIik2DwTkRERERkEgzeiYiIiIhMgsE7EREREZFJMHgnIiIiIjIJBu9ERERERDCH/w9bdswSBAfKBAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "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]),\n", + " (decoded, 0, f\"decoded (t={t:.2f}, noise={noise:.1f})\"),\n", + " (gt_grid, target, shape_names[target]),\n", + " ]\n", + " )\n", + "\n", + "\n", + "try:\n", + " import ipywidgets\n", + "\n", + " shape_options = [(name, i) for i, name in enumerate(shape_names)]\n", + " ipywidgets.interact(\n", + " explore,\n", + " source=ipywidgets.Dropdown(options=shape_options, value=0, description=\"from\"),\n", + " target=ipywidgets.Dropdown(options=shape_options, value=4, 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=0, target=4, t=0.5, noise=0.0)" + ] + } + ], + "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 +} \ No newline at end of file From f34b7bf954e9e5983985cf526119a4d2da323210 Mon Sep 17 00:00:00 2001 From: Jonathan Swartz Date: Tue, 1 Sep 2026 18:27:16 +1200 Subject: [PATCH 3/7] Train the shape VAE on the GSO shoe dataset Switch examples/shape_vae.py and the sampling notebook from the 6 bundled meshes to the 254-model Google Scanned Objects 'Shoe' subset (CC-BY 4.0) now in fvdb-example-data: bump the pinned data revision and add a load_gso_shoes() loader to fvdb.utils.examples. One object category with real intra-class variation (runners, flats, cleats, boots) makes latent interpolation and prior sampling meaningful, mirroring the role of ModelNet40 chairs in MinkowskiEngine's vae.py. Training now runs random minibatches over the pre-voxelized dataset (GridBatch indexing); the ground-truth conv_grid pyramid is built once and sub-indexed per batch. The notebook interpolates a ballet flat into a tall boot and uses a side-on camera. Generative training remains bound by per-iteration generated-topology grid construction (conv_transpose_grid); tracked upstream as #755. Signed-off-by: Jonathan Swartz --- examples/shape_vae.py | 59 +++++----- fvdb/utils/examples/__init__.py | 39 ++++++- notebooks/04_shape_vae.ipynb | 190 ++++++++++++++++++-------------- 3 files changed, 175 insertions(+), 113 deletions(-) diff --git a/examples/shape_vae.py b/examples/shape_vae.py index 2029f2e36..bce1478c5 100644 --- a/examples/shape_vae.py +++ b/examples/shape_vae.py @@ -30,10 +30,14 @@ the decoder could not tell neck positions apart). The first decoder level then learns which neck children to keep. -Deviations from MinkowskiEngine, chosen so the example trains in minutes on the -bundled meshes instead of hours on ModelNet40: a 6-shape dataset (4 cars, dragon, -happy Buddha), Adam instead of SGD, and a down-weighted KL term (``KLD_WEIGHT``) -since a 6-shape "dataset" is an overfit regime. +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), which is +the same role ModelNet40's chair class plays in MinkowskiEngine's example. Training +runs small random minibatches over the pre-voxelized dataset. Deviations from +MinkowskiEngine, chosen so the example trains in minutes: Adam instead of SGD, a +down-weighted KL term (``KLD_WEIGHT``), and a compressed iteration budget — crank +up ``NUM_ITERATIONS`` for better samples. """ import logging @@ -43,14 +47,7 @@ import torch.nn as nn import torch.nn.functional as F import tqdm -from fvdb.utils.examples import ( - load_car_1_mesh, - load_car_2_mesh, - load_car_3_mesh, - load_car_4_mesh, - load_dragon_mesh, - load_happy_mesh, -) +from fvdb.utils.examples import load_gso_shoes import fvdb import fvdb.nn as fvnn @@ -61,10 +58,12 @@ CHANNELS = [16, 32, 64, 128, 256] # CHANNELS[0] = full resolution, CHANNELS[NUM_LEVELS] = coarsest LATENT_DIM = 128 KLD_WEIGHT = 1e-2 -NUM_ITERATIONS = 1000 +NUM_ITERATIONS = 1500 +BATCH_SIZE = 16 LEARNING_RATE = 1e-3 -LOG_EVERY = 50 +LOG_EVERY = 100 NUM_PRIOR_SAMPLES = 4 +NUM_EVAL_SHAPES = 8 # reconstruction / visualization subset def normalize_vertices(vertices: torch.Tensor) -> torch.Tensor: @@ -75,16 +74,8 @@ def normalize_vertices(vertices: torch.Tensor) -> torch.Tensor: def prepare_shapes(device: torch.device) -> GridBatch: - """Voxelize the six bundled triangle meshes into a single GridBatch 'dataset'.""" - loaders = ( - load_car_1_mesh, - load_car_2_mesh, - load_car_3_mesh, - load_car_4_mesh, - load_dragon_mesh, - load_happy_mesh, - ) - meshes = [loader(mode="vf", device=device) for loader in loaders] + """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) @@ -273,8 +264,9 @@ def main() -> None: 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) - input_features = gt_grid.jagged_like(torch.ones(gt_grid.total_voxels, 1, device=device)) logging.info(f"dataset: {gt_grid.grid_count} shapes, {gt_grid.total_voxels} voxels total") model = ShapeVAE().to(device) @@ -282,7 +274,12 @@ def main() -> None: model.train() for iteration in tqdm.trange(NUM_ITERATIONS, desc="training"): - logits, targets, _, _, mu, logvar = model(input_features, gt_grid, gt_pyramid) + 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() @@ -294,15 +291,17 @@ def main() -> None: model.eval() with torch.no_grad(): - # Reconstructions: encode each training shape and decode from z = mu. - _, _, _, recon_grid, _, _ = model(input_features, gt_grid, None) - logging.info(f"reconstruction IoU vs ground truth: {grid_iou(recon_grid, gt_grid):.3f}") + # 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(gt_grid, recon_grid, sample_grid) + visualize(eval_gt, recon_grid, sample_grid) if __name__ == "__main__": 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 index 00d46f959..65c8a1b68 100644 --- a/notebooks/04_shape_vae.ipynb +++ b/notebooks/04_shape_vae.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "2dab3eeb", + "id": "a42ebc66", "metadata": {}, "source": [ "# Generative Shape VAE: Interactive Sampling Demo\n", @@ -27,13 +27,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "6f2e6704", + "id": "d11a2b99", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:44:57.925181Z", - "iopub.status.busy": "2026-08-31T23:44:57.925078Z", - "iopub.status.idle": "2026-08-31T23:44:59.371305Z", - "shell.execute_reply": "2026-08-31T23:44:59.370717Z" + "iopub.execute_input": "2026-09-01T06:17:46.128259Z", + "iopub.status.busy": "2026-09-01T06:17:46.128145Z", + "iopub.status.idle": "2026-09-01T06:17:47.626981Z", + "shell.execute_reply": "2026-09-01T06:17:47.626387Z" } }, "outputs": [ @@ -65,26 +65,29 @@ }, { "cell_type": "markdown", - "id": "7c1be16e", + "id": "2199dfe3", "metadata": {}, "source": [ "## The dataset\n", "\n", - "Six bundled meshes (four cars, the dragon, and the happy Buddha), each voxelized to a sparse grid at\n", - "resolution 64 inside the unit cube. The whole \"dataset\" is one `GridBatch`, and the input features are\n", - "just a constant 1 per voxel — the network learns *topology*, not appearance." + "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": "662fbeb6", + "id": "f39b7380", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:44:59.372891Z", - "iopub.status.busy": "2026-08-31T23:44:59.372711Z", - "iopub.status.idle": "2026-08-31T23:45:00.801439Z", - "shell.execute_reply": "2026-08-31T23:45:00.800778Z" + "iopub.execute_input": "2026-09-01T06:17:47.628672Z", + "iopub.status.busy": "2026-09-01T06:17:47.628471Z", + "iopub.status.idle": "2026-09-01T06:17:48.858904Z", + "shell.execute_reply": "2026-09-01T06:17:48.858366Z" } }, "outputs": [ @@ -92,36 +95,39 @@ "name": "stdout", "output_type": "stream", "text": [ - "6 shapes, per-shape voxel counts: [8031, 9048, 8119, 5854, 8559, 6782]\n" + "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", - "gt_pyramid = sv.build_gt_pyramid(gt_grid)\n", - "input_features = gt_grid.jagged_like(torch.ones(gt_grid.total_voxels, 1, device=device))\n", - "shape_names = [\"car 1\", \"car 2\", \"car 3\", \"car 4\", \"dragon\", \"happy\"]\n", - "print(f\"{gt_grid.grid_count} shapes, per-shape voxel counts: {gt_grid.num_voxels.tolist()}\")" + "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": "6e874a5e", + "id": "52c988c5", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:45:00.803406Z", - "iopub.status.busy": "2026-08-31T23:45:00.803166Z", - "iopub.status.idle": "2026-08-31T23:45:01.522881Z", - "shell.execute_reply": "2026-08-31T23:45:01.522196Z" + "iopub.execute_input": "2026-09-01T06:17:48.860497Z", + "iopub.status.busy": "2026-09-01T06:17:48.860311Z", + "iopub.status.idle": "2026-09-01T06:17:49.656870Z", + "shell.execute_reply": "2026-09-01T06:17:49.656354Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -138,6 +144,7 @@ " if grid.num_voxels_at(b) > 0:\n", " pts = grid.voxel_to_world(grid.ijk.float())[b].jdata.cpu().numpy()\n", " ax.scatter(pts[:, 0], pts[:, 2], pts[:, 1], s=point_size)\n", + " ax.view_init(elev=12, azim=-75)\n", " ax.set_title(title, fontsize=9)\n", " ax.set_xlim(0, 1), ax.set_ylim(0, 1), ax.set_zlim(0, 1)\n", " ax.set_axis_off()\n", @@ -145,12 +152,12 @@ " plt.show()\n", "\n", "\n", - "plot_grids([(gt_grid, b, shape_names[b]) for b in range(gt_grid.grid_count)])" + "plot_grids([(gt_grid, b, shape_names[b][:24]) for b in range(8)])" ] }, { "cell_type": "markdown", - "id": "f0653dbe", + "id": "78415f2a", "metadata": {}, "source": [ "## Training\n", @@ -160,19 +167,24 @@ "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`), exactly as in MinkowskiEngine. The loss is per-level binary cross-entropy plus a\n", - "down-weighted KL term." + "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": "47907ec9", + "id": "066b0608", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:45:01.524625Z", - "iopub.status.busy": "2026-08-31T23:45:01.524482Z", - "iopub.status.idle": "2026-08-31T23:46:20.716367Z", - "shell.execute_reply": "2026-08-31T23:46:20.715830Z" + "iopub.execute_input": "2026-09-01T06:17:49.658437Z", + "iopub.status.busy": "2026-09-01T06:17:49.658323Z", + "iopub.status.idle": "2026-09-01T06:21:15.139956Z", + "shell.execute_reply": "2026-09-01T06:21:15.139528Z" } }, "outputs": [ @@ -180,7 +192,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "final loss 0.0058 (bce 0.0034, kld 0.2453)\n" + "final loss 0.2529 (bce 0.2478, kld 0.5142)\n" ] }, { @@ -194,10 +206,16 @@ "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", - " logits, targets, _, _, mu, logvar = model(input_features, gt_grid, gt_pyramid)\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", @@ -207,25 +225,26 @@ }, { "cell_type": "markdown", - "id": "9d87281e", + "id": "3e5d1569", "metadata": {}, "source": [ "## Reconstructions\n", "\n", - "Encode every training shape and decode from `z = mu` with **no teacher forcing** — the decoder keeps only\n", - "the voxels its classifiers predict." + "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": "333f0aa5", + "id": "15b935a4", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:46:20.718058Z", - "iopub.status.busy": "2026-08-31T23:46:20.717845Z", - "iopub.status.idle": "2026-08-31T23:46:21.199579Z", - "shell.execute_reply": "2026-08-31T23:46:21.198922Z" + "iopub.execute_input": "2026-09-01T06:21:15.141557Z", + "iopub.status.busy": "2026-09-01T06:21:15.141385Z", + "iopub.status.idle": "2026-09-01T06:21:15.868397Z", + "shell.execute_reply": "2026-09-01T06:21:15.867853Z" } }, "outputs": [ @@ -233,12 +252,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "reconstruction IoU vs ground truth: 0.999\n" + "reconstruction IoU on 4 shapes: 0.462\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -250,44 +269,45 @@ "source": [ "model.eval()\n", "with torch.no_grad():\n", - " mu, _ = model.encoder(input_features, gt_grid)\n", - " _, _, _, recon_grid = model.decoder(mu, None)\n", - "print(f\"reconstruction IoU vs ground truth: {sv.grid_iou(recon_grid, gt_grid):.3f}\")\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, 4, \"gt dragon\"), (recon_grid, 4, \"recon dragon\"), (gt_grid, 0, \"gt car 1\"), (recon_grid, 0, \"recon car 1\")]\n", + " [(gt_grid, 0, \"gt\"), (recon_grid, 0, \"recon\"), (gt_grid, 1, \"gt\"), (recon_grid, 1, \"recon\")]\n", ")" ] }, { "cell_type": "markdown", - "id": "4183dbc3", + "id": "4ede89a8", "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 shapes. With only six training shapes the prior\n", - "samples land between memorized modes — with a real dataset (e.g. ModelNet40 chairs, as in MinkowskiEngine's\n", - "`vae.py`) this is where genuinely new shapes appear." + "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": "a0423a93", + "id": "ae6ab699", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:46:21.201202Z", - "iopub.status.busy": "2026-08-31T23:46:21.201035Z", - "iopub.status.idle": "2026-08-31T23:46:21.509657Z", - "shell.execute_reply": "2026-08-31T23:46:21.509039Z" + "iopub.execute_input": "2026-09-01T06:21:15.870135Z", + "iopub.status.busy": "2026-09-01T06:21:15.869996Z", + "iopub.status.idle": "2026-09-01T06:21:16.243463Z", + "shell.execute_reply": "2026-09-01T06:21:16.242872Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -311,7 +331,7 @@ }, { "cell_type": "markdown", - "id": "9e98c580", + "id": "c0add8da", "metadata": {}, "source": [ "## Latent interpolation\n", @@ -323,19 +343,19 @@ { "cell_type": "code", "execution_count": 7, - "id": "983987a5", + "id": "01e2a748", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:46:21.511228Z", - "iopub.status.busy": "2026-08-31T23:46:21.511064Z", - "iopub.status.idle": "2026-08-31T23:46:22.100917Z", - "shell.execute_reply": "2026-08-31T23:46:22.100317Z" + "iopub.execute_input": "2026-09-01T06:21:16.245039Z", + "iopub.status.busy": "2026-09-01T06:21:16.244878Z", + "iopub.status.idle": "2026-09-01T06:21:16.727944Z", + "shell.execute_reply": "2026-09-01T06:21:16.727434Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -351,12 +371,18 @@ " plot_grids([(grids, i, f\"t = {t[i].item():.2f}\") for i in range(num_steps)])\n", "\n", "\n", - "interpolate(source=0, target=4) # car 1 -> dragon" + "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": "097f0e40", + "id": "3f63b245", "metadata": {}, "source": [ "## Interactive latent explorer\n", @@ -370,13 +396,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "d7a056e9", + "id": "8f647122", "metadata": { "execution": { - "iopub.execute_input": "2026-08-31T23:46:22.122077Z", - "iopub.status.busy": "2026-08-31T23:46:22.121912Z", - "iopub.status.idle": "2026-08-31T23:46:22.496068Z", - "shell.execute_reply": "2026-08-31T23:46:22.495526Z" + "iopub.execute_input": "2026-09-01T06:21:16.729452Z", + "iopub.status.busy": "2026-09-01T06:21:16.729331Z", + "iopub.status.idle": "2026-09-01T06:21:16.989499Z", + "shell.execute_reply": "2026-09-01T06:21:16.989023Z" } }, "outputs": [ @@ -389,7 +415,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -404,9 +430,9 @@ " decoded = decode_latents(z.unsqueeze(0))\n", " plot_grids(\n", " [\n", - " (gt_grid, source, shape_names[source]),\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]),\n", + " (gt_grid, target, shape_names[target][:24]),\n", " ]\n", " )\n", "\n", @@ -414,18 +440,18 @@ "try:\n", " import ipywidgets\n", "\n", - " shape_options = [(name, i) for i, name in enumerate(shape_names)]\n", + " n = gt_grid.grid_count\n", " ipywidgets.interact(\n", " explore,\n", - " source=ipywidgets.Dropdown(options=shape_options, value=0, description=\"from\"),\n", - " target=ipywidgets.Dropdown(options=shape_options, value=4, description=\"to\"),\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=0, target=4, t=0.5, noise=0.0)" + " explore(source=flat_idx, target=boot_idx, t=0.5, noise=0.0)" ] } ], From 79fcae4cf4c9f8af004f275ba576ec761e021ca2 Mon Sep 17 00:00:00 2001 From: Jonathan Swartz Date: Tue, 1 Sep 2026 18:41:19 +1200 Subject: [PATCH 4/7] Render notebook shapes as lit voxel surfaces Replace the matplotlib point scatters in the shape-VAE notebook with lit voxel-cube renders: exposed cube faces from pcu.voxel_grid_geometry (interior faces between adjacent voxels culled via duplicate-centroid removal), per-face Lambertian shading, per-panel auto-fit equal-aspect bounds, and unswapped z-up axes (the GSO scans follow the Gazebo z-up convention; the previous y-up swap was showing the shapes sole-on). Shapes are now clearly readable as shoes - laces, soles, and boot shafts are visible in the dataset, reconstruction, sampling, and interpolation figures. Signed-off-by: Jonathan Swartz --- notebooks/04_shape_vae.ipynb | 161 +++++++++++++++++++++-------------- 1 file changed, 96 insertions(+), 65 deletions(-) diff --git a/notebooks/04_shape_vae.ipynb b/notebooks/04_shape_vae.ipynb index 65c8a1b68..796f51fa7 100644 --- a/notebooks/04_shape_vae.ipynb +++ b/notebooks/04_shape_vae.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "a42ebc66", + "id": "8ea3da0a", "metadata": {}, "source": [ "# Generative Shape VAE: Interactive Sampling Demo\n", @@ -27,13 +27,13 @@ { "cell_type": "code", "execution_count": 1, - "id": "d11a2b99", + "id": "0ea4bd79", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:17:46.128259Z", - "iopub.status.busy": "2026-09-01T06:17:46.128145Z", - "iopub.status.idle": "2026-09-01T06:17:47.626981Z", - "shell.execute_reply": "2026-09-01T06:17:47.626387Z" + "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": [ @@ -65,7 +65,7 @@ }, { "cell_type": "markdown", - "id": "2199dfe3", + "id": "42288e91", "metadata": {}, "source": [ "## The dataset\n", @@ -81,13 +81,13 @@ { "cell_type": "code", "execution_count": 2, - "id": "f39b7380", + "id": "d685310c", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:17:47.628672Z", - "iopub.status.busy": "2026-09-01T06:17:47.628471Z", - "iopub.status.idle": "2026-09-01T06:17:48.858904Z", - "shell.execute_reply": "2026-09-01T06:17:48.858366Z" + "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": [ @@ -113,21 +113,21 @@ { "cell_type": "code", "execution_count": 3, - "id": "52c988c5", + "id": "20730e01", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:17:48.860497Z", - "iopub.status.busy": "2026-09-01T06:17:48.860311Z", - "iopub.status.idle": "2026-09-01T06:17:49.656870Z", - "shell.execute_reply": "2026-09-01T06:17:49.656354Z" + "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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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -135,18 +135,49 @@ } ], "source": [ - "def plot_grids(grids_and_titles, point_size=1.0, panel_size=2.6):\n", - " \"\"\"Scatter the voxel centers of each (GridBatch, batch_index, title) triple in a row of 3D axes.\"\"\"\n", + "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", - " pts = grid.voxel_to_world(grid.ijk.float())[b].jdata.cpu().numpy()\n", - " ax.scatter(pts[:, 0], pts[:, 2], pts[:, 1], s=point_size)\n", - " ax.view_init(elev=12, azim=-75)\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_xlim(0, 1), ax.set_ylim(0, 1), ax.set_zlim(0, 1)\n", " ax.set_axis_off()\n", " plt.tight_layout()\n", " plt.show()\n", @@ -157,7 +188,7 @@ }, { "cell_type": "markdown", - "id": "78415f2a", + "id": "13b87532", "metadata": {}, "source": [ "## Training\n", @@ -178,13 +209,13 @@ { "cell_type": "code", "execution_count": 4, - "id": "066b0608", + "id": "97a43a18", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:17:49.658437Z", - "iopub.status.busy": "2026-09-01T06:17:49.658323Z", - "iopub.status.idle": "2026-09-01T06:21:15.139956Z", - "shell.execute_reply": "2026-09-01T06:21:15.139528Z" + "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": [ @@ -192,7 +223,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "final loss 0.2529 (bce 0.2478, kld 0.5142)\n" + "final loss 0.2550 (bce 0.2499, kld 0.5118)\n" ] }, { @@ -225,7 +256,7 @@ }, { "cell_type": "markdown", - "id": "3e5d1569", + "id": "5d487c75", "metadata": {}, "source": [ "## Reconstructions\n", @@ -238,13 +269,13 @@ { "cell_type": "code", "execution_count": 5, - "id": "15b935a4", + "id": "710021f2", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:21:15.141557Z", - "iopub.status.busy": "2026-09-01T06:21:15.141385Z", - "iopub.status.idle": "2026-09-01T06:21:15.868397Z", - "shell.execute_reply": "2026-09-01T06:21:15.867853Z" + "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": [ @@ -252,14 +283,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "reconstruction IoU on 4 shapes: 0.462\n" + "reconstruction IoU on 4 shapes: 0.463\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -283,7 +314,7 @@ }, { "cell_type": "markdown", - "id": "4ede89a8", + "id": "b5320053", "metadata": {}, "source": [ "## Sampling novel shapes from the prior\n", @@ -295,21 +326,21 @@ { "cell_type": "code", "execution_count": 6, - "id": "ae6ab699", + "id": "4059d86d", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:21:15.870135Z", - "iopub.status.busy": "2026-09-01T06:21:15.869996Z", - "iopub.status.idle": "2026-09-01T06:21:16.243463Z", - "shell.execute_reply": "2026-09-01T06:21:16.242872Z" + "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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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -331,7 +362,7 @@ }, { "cell_type": "markdown", - "id": "c0add8da", + "id": "89ac16cd", "metadata": {}, "source": [ "## Latent interpolation\n", @@ -343,21 +374,21 @@ { "cell_type": "code", "execution_count": 7, - "id": "01e2a748", + "id": "972eaa9d", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:21:16.245039Z", - "iopub.status.busy": "2026-09-01T06:21:16.244878Z", - "iopub.status.idle": "2026-09-01T06:21:16.727944Z", - "shell.execute_reply": "2026-09-01T06:21:16.727434Z" + "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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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -382,7 +413,7 @@ }, { "cell_type": "markdown", - "id": "3f63b245", + "id": "ebafa729", "metadata": {}, "source": [ "## Interactive latent explorer\n", @@ -396,13 +427,13 @@ { "cell_type": "code", "execution_count": 8, - "id": "8f647122", + "id": "dd5f79c7", "metadata": { "execution": { - "iopub.execute_input": "2026-09-01T06:21:16.729452Z", - "iopub.status.busy": "2026-09-01T06:21:16.729331Z", - "iopub.status.idle": "2026-09-01T06:21:16.989499Z", - "shell.execute_reply": "2026-09-01T06:21:16.989023Z" + "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": [ @@ -415,9 +446,9 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, From a84582ee9b99731eb3f1a89c3d46d4cd21c23b28 Mon Sep 17 00:00:00 2001 From: Jonathan Swartz Date: Wed, 2 Sep 2026 15:56:36 +1200 Subject: [PATCH 5/7] Docstring cleanup Signed-off-by: Jonathan Swartz --- examples/shape_completion.py | 44 ++++++------------------------------ examples/shape_vae.py | 42 +++++++--------------------------- fvdb/nn/modules.py | 3 +-- 3 files changed, 16 insertions(+), 73 deletions(-) diff --git a/examples/shape_completion.py b/examples/shape_completion.py index 0799e4b9d..fabfc04de 100644 --- a/examples/shape_completion.py +++ b/examples/shape_completion.py @@ -3,43 +3,15 @@ # """Sparse 3D shape completion with generative transposed convolutions. -This example is the fvdb analog of MinkowskiEngine's ``examples/completion.py``. 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, exactly like MinkowskiEngine's completion network. - -MinkowskiEngine to fvdb mapping: - -- ``MinkowskiGenerativeConvolutionTranspose`` -> - :class:`fvdb.nn.SparseConvTranspose3d` executed with a plan from - :meth:`fvdb.ConvolutionPlan.from_grid_batch_transposed` with ``target_grid=None``, - which generates the complete (uncropped) transposed support. -- ``MinkowskiPruning`` -> :class:`fvdb.nn.Prune`. -- ``get_target`` (per-level occupancy labels via strided coordinate keys) -> - a ground-truth pyramid built with :meth:`fvdb.GridBatch.conv_grid` (kernel 2, - stride 2) queried with :meth:`fvdb.GridBatch.coords_in_grid`. ``conv_grid(2, 2)`` - maps ``coarse = floor(fine / 2)``, the same lattice relation MinkowskiEngine uses - for its stride-2 pyramid (do NOT use ``coarsened_grid`` here - it has different, - block-centroid semantics). -- Teacher forcing (``keep += target`` while training) is reproduced verbatim. - -Kernel-anchoring note: MinkowskiEngine anchors even kernels at the corner of the -``[0, K)`` window, while fvdb centers kernels via ``padding = floor((K - 1) / 2)`` -(see fvdb-core PR #726). MinkowskiEngine's completion decoder relies on a -kernel-size-4 first transpose to reach coordinates beyond the partial input's -coarse support. Here shapes are normalized into ``[0, 1)`` (all-positive ijk, like -MinkowskiEngine's quantized coordinates) and the crop keeps enough of the shape -that its coarsest support matches the full shape's, so completion is structurally -reachable; we keep a kernel-size-4 first transpose to mirror MinkowskiEngine. - -Unlike the MinkowskiEngine example (ModelNet40, 30k iterations), this example -overfits two bundled meshes for a few hundred iterations so it runs in a couple of -minutes; crank up the constants below for a real experiment. +occupancy classifiers. """ import logging +import fvdb.nn as fvnn import polyscope as ps import torch import torch.nn as nn @@ -48,7 +20,6 @@ from fvdb.utils.examples import load_dragon_mesh, load_happy_mesh import fvdb -import fvdb.nn as fvnn from fvdb import ConvolutionPlan, GridBatch, JaggedTensor RESOLUTION = 64 # voxels along the longest axis of each shape @@ -130,8 +101,7 @@ def __init__(self, in_channels: int, out_channels: int, kernel_size: int): 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, - # the fvdb equivalent of MinkowskiGenerativeConvolutionTranspose. + # 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 @@ -140,7 +110,7 @@ def forward(self, data: JaggedTensor, grid: GridBatch) -> tuple[JaggedTensor, Gr class CompletionNet(nn.Module): - """Sparse encoder-decoder that completes a partial shape, mirroring MinkowskiEngine's CompletionNet.""" + """Sparse encoder-decoder that completes a partial shape.""" def __init__(self): super().__init__() @@ -152,7 +122,7 @@ def __init__(self): 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 (as in MinkowskiEngine); the rest use kernel size 2. + # 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) @@ -182,7 +152,7 @@ def forward( 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) - MinkowskiEngine's `dec + enc`. + # (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) @@ -194,7 +164,7 @@ def forward( keep = logits.jdata.squeeze(-1) > 0 if self.training: - keep |= target.jdata # teacher forcing, as in MinkowskiEngine + keep |= target.jdata # teacher forcing data, grid = self.prune(data, grid, grid.jagged_like(keep)) return logits_per_level, targets_per_level, data, grid diff --git a/examples/shape_vae.py b/examples/shape_vae.py index bce1478c5..b5c440c60 100644 --- a/examples/shape_vae.py +++ b/examples/shape_vae.py @@ -3,45 +3,23 @@ # """Sparse 3D shape variational autoencoder with generative transposed convolutions. -This example is the fvdb analog of MinkowskiEngine's ``examples/vae.py``. An -encoder compresses each sparse voxelized shape into a single latent vector; the +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. -MinkowskiEngine to fvdb mapping (see ``shape_completion.py`` for the shared -decoder pattern and lattice/anchoring notes): - -- ``MinkowskiGenerativeConvolutionTranspose`` -> - :meth:`fvdb.ConvolutionPlan.from_grid_batch_transposed` with ``target_grid=None``. -- ``MinkowskiPruning`` -> :class:`fvdb.nn.Prune`. -- ``MinkowskiGlobalPooling`` -> a jagged global average pool - (:meth:`fvdb.JaggedTensor.jsum` divided by voxel counts). MinkowskiEngine - instead strides all the way down to a single voxel per shape at - ``tensor_stride = resolution``; global pooling over the jagged batch is the - idiomatic fvdb equivalent. -- MinkowskiEngine seeds its decoder with one voxel per shape at the coarsest - stride; here the decoder starts from a small dense "neck" grid (4^3 voxels at - stride 16) built with :meth:`fvdb.GridBatch.from_dense`. The latent vector is - broadcast to every neck voxel and combined with a learned per-voxel positional - embedding (without it the broadcast features would be spatially identical and - the decoder could not tell neck positions apart). The first decoder level then - learns which neck children to keep. 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), which is -the same role ModelNet40's chair class plays in MinkowskiEngine's example. Training -runs small random minibatches over the pre-voxelized dataset. Deviations from -MinkowskiEngine, chosen so the example trains in minutes: Adam instead of SGD, a -down-weighted KL term (``KLD_WEIGHT``), and a compressed iteration budget — crank -up ``NUM_ITERATIONS`` for better samples. +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 @@ -50,7 +28,6 @@ from fvdb.utils.examples import load_gso_shoes import fvdb -import fvdb.nn as fvnn from fvdb import ConvolutionPlan, GridBatch, JaggedTensor RESOLUTION = 64 # voxels along the longest axis of each shape @@ -119,8 +96,7 @@ def __init__(self, in_channels: int, out_channels: int): 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, - # the fvdb equivalent of MinkowskiGenerativeConvolutionTranspose. + # 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 @@ -148,7 +124,7 @@ def forward(self, data: JaggedTensor, grid: GridBatch) -> tuple[torch.Tensor, to 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 (MinkowskiGlobalPooling analog). + # 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) @@ -163,9 +139,7 @@ def __init__(self): 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. (MinkowskiEngine's - # single-voxel seed gets this for free - every descendant has a unique kernel-tap - # path from the root.) + # 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)) @@ -202,7 +176,7 @@ def forward( logits_per_level.append(logits) targets_per_level.append(target) if self.training: - keep |= target.jdata # teacher forcing, as in MinkowskiEngine + keep |= target.jdata # teacher forcing data, grid = self.prune(data, grid, grid.jagged_like(keep)) return logits_per_level, targets_per_level, data, grid diff --git a/fvdb/nn/modules.py b/fvdb/nn/modules.py index fb70b62ed..8452b171f 100644 --- a/fvdb/nn/modules.py +++ b/fvdb/nn/modules.py @@ -270,8 +270,7 @@ class Prune(nn.Module): 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 the fvdb analog of - ``MinkowskiPruning`` from the MinkowskiEngine library and is typically used in generative + 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`). From 9f0228cf31a179815e744ef5a57efaef01d95729 Mon Sep 17 00:00:00 2001 From: Jonathan Swartz Date: Wed, 2 Sep 2026 16:13:40 +1200 Subject: [PATCH 6/7] Notebook update Signed-off-by: Jonathan Swartz --- notebooks/04_shape_vae.ipynb | 57 +++++++++++++++++++++--------------- 1 file changed, 33 insertions(+), 24 deletions(-) diff --git a/notebooks/04_shape_vae.ipynb b/notebooks/04_shape_vae.ipynb index 796f51fa7..79179c9b5 100644 --- a/notebooks/04_shape_vae.ipynb +++ b/notebooks/04_shape_vae.ipynb @@ -7,21 +7,18 @@ "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)\n", - "(the fvdb analog of MinkowskiEngine's `examples/vae.py`) and then explores its latent space interactively:\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", - " (the `MinkowskiGenerativeConvolutionTranspose` analog).\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 (the `MinkowskiPruning` analog).\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. See the module docstring of `examples/shape_vae.py` for the full\n", - "MinkowskiEngine-to-fvdb mapping and design notes." + "Training takes about 1–2 minutes on a GPU." ] }, { @@ -197,7 +194,7 @@ "(`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`), exactly as in MinkowskiEngine. The loss is per-level binary cross-entropy plus a\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", @@ -219,11 +216,18 @@ } }, "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.2550 (bce 0.2499, kld 0.5118)\n" + "final loss 0.2523 (bce 0.2471, kld 0.5176)\n" ] }, { @@ -283,12 +287,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "reconstruction IoU on 4 shapes: 0.463\n" + "reconstruction IoU on 4 shapes: 0.458\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -338,7 +342,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -386,7 +390,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -426,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "dd5f79c7", "metadata": { "execution": { @@ -437,18 +441,15 @@ } }, "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "ipywidgets is not installed - showing a single static frame instead.\nInstall it (`pip install ipywidgets`) and re-run this cell for live sliders.\n" - ] - }, { "data": { - "image/png": "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", + "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": {}, @@ -484,6 +485,14 @@ " 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": { @@ -507,4 +516,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} From 8dfa68e768e1de3c0f8fa97748e7d52de5b42600 Mon Sep 17 00:00:00 2001 From: Jonathan Swartz Date: Wed, 2 Sep 2026 16:19:15 +1200 Subject: [PATCH 7/7] Remove superseded structure-prediction wip example examples/wip/structure_prediction_net.py targeted a removed API surface (VDBTensor, fvnn.ReLU, fvnn.FillFromGrid, per-module conv backends) and undeclared dependencies (torch_cudamanaged, hardcoded local data paths), so it no longer runs. Its intent - hierarchical structure prediction with per-level occupancy classifiers, losses against a coarsened ground-truth pyramid, U-Net skips onto predicted topology, and a dense neck - is now covered by the maintained, CI-tested examples shape_completion.py and shape_vae.py, which use the generative transposed-convolution path from #726 plus fvdb.nn.Prune. Signed-off-by: Jonathan Swartz --- examples/wip/structure_prediction_net.py | 189 ----------------------- 1 file changed, 189 deletions(-) delete mode 100644 examples/wip/structure_prediction_net.py 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()