reduced-3dgs 1.8.15__cp310-cp310-win_amd64.whl → 1.8.17__cp310-cp310-win_amd64.whl

reduced_3dgs/pruning/__init__.py

@@ -1,2 +1,2 @@
-from .trainer import BasePruner, PrunerInDensify, BasePruningTrainer, BasePrunerInDensifyTrainer
-from .combinations import PruningTrainer, PrunerInDensifyTrainer
+from .trainer import BasePruner, BasePruningTrainer
+from .combinations import BasePrunerInDensifyTrainer, PruningTrainer, PrunerInDensifyTrainer

reduced_3dgs/pruning/combinations.py

@@ -1,8 +1,39 @@
 
-from gaussian_splatting import GaussianModel
+from typing import List
+from gaussian_splatting import Camera, GaussianModel
 from gaussian_splatting.dataset import TrainableCameraDataset
-from gaussian_splatting.trainer import DepthTrainerWrapper
-from .trainer import BasePruningTrainer, BasePrunerInDensifyTrainer
+from gaussian_splatting.trainer import DepthTrainerWrapper, NoopDensifier, DensificationTrainerWrapper
+from .trainer import BasePruner, BasePruningTrainer
+
+
+def BasePrunerInDensifyTrainer(
+        model: GaussianModel,
+        scene_extent: float,
+        dataset: List[Camera],
+        prune_from_iter=1000,
+        prune_until_iter=15000,
+        prune_interval: int = 100,
+        box_size=1.,
+        lambda_mercy=1.,
+        mercy_minimum=3,
+        mercy_type='redundancy_opacity',
+        *args, **kwargs):
+    return DensificationTrainerWrapper(
+        lambda model, scene_extent: BasePruner(
+            NoopDensifier(model),
+            dataset,
+            prune_from_iter=prune_from_iter,
+            prune_until_iter=prune_until_iter,
+            prune_interval=prune_interval,
+            box_size=box_size,
+            lambda_mercy=lambda_mercy,
+            mercy_minimum=mercy_minimum,
+            mercy_type=mercy_type,
+        ),
+        model,
+        scene_extent,
+        *args, **kwargs
+    )
 
 
 # Depth trainer

reduced_3dgs/pruning/importance/__init__.py

@@ -0,0 +1 @@
+from .trainer import ImportancePruningTrainerWrapper, BaseImportancePruningTrainer, ImportancePruningTrainer

reduced_3dgs/pruning/importance/diff_gaussian_rasterization/__init__.py

@@ -0,0 +1,347 @@
+#
+# Copyright (C) 2023, Inria
+# GRAPHDECO research group, https://team.inria.fr/graphdeco
+# All rights reserved.
+#
+# This software is free for non-commercial, research and evaluation use 
+# under the terms of the LICENSE.md file.
+#
+# For inquiries contact  george.drettakis@inria.fr
+#
+
+from typing import NamedTuple
+import torch.nn as nn
+import torch
+from . import _C
+
+
+def cpu_deep_copy_tuple(input_tuple):
+    copied_tensors = [item.cpu().clone() if isinstance(item, torch.Tensor) else item for item in input_tuple]
+    return tuple(copied_tensors)
+
+def rasterize_gaussians(
+    means3D,
+    means2D,
+    sh,
+    colors_precomp,
+    opacities,
+    scales,
+    rotations,
+    cov3Ds_precomp,
+    raster_settings,
+):
+    if raster_settings.f_count:
+        return _RasterizeGaussians.forward_count(
+        means3D,
+        means2D,
+        sh,
+        colors_precomp,
+        opacities,
+        scales,
+        rotations,
+        cov3Ds_precomp,
+        raster_settings,
+
+    )
+    return _RasterizeGaussians.apply(
+    means3D,
+    means2D,
+    sh,
+    colors_precomp,
+    opacities,
+    scales,
+    rotations,
+    cov3Ds_precomp,
+    raster_settings,
+    )
+
+class _RasterizeGaussians(torch.autograd.Function):
+    @staticmethod
+    def forward(
+        ctx,
+        means3D,
+        means2D,
+        sh,
+        colors_precomp,
+        opacities,
+        scales,
+        rotations,
+        cov3Ds_precomp,
+        raster_settings,
+    ):
+
+        # Restructure arguments the way that the C++ lib expects them
+        args = (
+            raster_settings.bg, 
+            means3D,
+            colors_precomp,
+            opacities,
+            scales,
+            rotations,
+            raster_settings.scale_modifier,
+            cov3Ds_precomp,
+            raster_settings.viewmatrix,
+            raster_settings.projmatrix,
+            raster_settings.tanfovx,
+            raster_settings.tanfovy,
+            raster_settings.image_height,
+            raster_settings.image_width,
+            sh,
+            raster_settings.sh_degree,
+            raster_settings.campos,
+            raster_settings.prefiltered,
+            raster_settings.debug
+        )
+        gaussians_count, opacity_important_score, T_alpha_important_score, num_rendered, color, radii, geomBuffer, \
+            binningBuffer, imgBuffer = None, None, None, None, None, None, None, None, None
+        
+        if raster_settings.f_count:
+            args = args + (raster_settings.f_count,)
+            if raster_settings.debug:
+                cpu_args = cpu_deep_copy_tuple(args)
+                try:
+                    gaussians_count, opacity_important_score, T_alpha_important_score, num_rendered, color, radii,\
+                        geomBuffer, binningBuffer, imgBuffer = _C.count_gaussians(*args)
+                except Exception as ex:
+                    torch.save(cpu_args, "snapshot_fw.dump")
+                    print("\nAn error occured in forward. Please forward snapshot_fw.dump for debugging.")
+                    raise ex
+            else:
+                gaussians_count, opacity_important_score, T_alpha_important_score, num_rendered, color, radii,\
+                    geomBuffer, binningBuffer, imgBuffer = _C.count_gaussians(*args)
+        else:
+            # Invoke C++/CUDA rasterizer
+            if raster_settings.debug:
+                cpu_args = cpu_deep_copy_tuple(args) # Copy them before they can be corrupted
+                try:
+                    num_rendered, color, radii, geomBuffer, binningBuffer, imgBuffer = _C.rasterize_gaussians(*args)
+                except Exception as ex:
+                    torch.save(cpu_args, "snapshot_fw.dump")
+                    print("\nAn error occured in forward. Please forward snapshot_fw.dump for debugging.")
+                    raise ex
+            else:
+                num_rendered, color, radii, geomBuffer, binningBuffer, imgBuffer = _C.rasterize_gaussians(*args)
+
+        # Keep relevant tensors for backward
+        ctx.raster_settings = raster_settings
+        ctx.num_rendered = num_rendered
+        ctx.save_for_backward(colors_precomp, means3D, scales, rotations, cov3Ds_precomp, radii, sh, geomBuffer, binningBuffer, imgBuffer)
+        ctx.count = gaussians_count
+        ctx.opacity_important_score = opacity_important_score
+        ctx.T_alpha_important_score = T_alpha_important_score
+        
+        if raster_settings.f_count: 
+            return gaussians_count, opacity_important_score, T_alpha_important_score, color, radii 
+        
+        return color, radii
+
+    @staticmethod
+    def forward_count(
+        means3D,
+        means2D,
+        sh,
+        colors_precomp,
+        opacities,
+        scales,
+        rotations,
+        cov3Ds_precomp,
+        raster_settings,
+    ):
+        assert(raster_settings.f_count)
+        # Restructure arguments the way that the C++ lib expects them
+        args = (
+            raster_settings.bg, 
+            means3D,
+            colors_precomp,
+            opacities,
+            scales,
+            rotations,
+            raster_settings.scale_modifier,
+            cov3Ds_precomp,
+            raster_settings.viewmatrix,
+            raster_settings.projmatrix,
+            raster_settings.tanfovx,
+            raster_settings.tanfovy,
+            raster_settings.image_height,
+            raster_settings.image_width,
+            sh,
+            raster_settings.sh_degree,
+            raster_settings.campos,
+            raster_settings.prefiltered,
+            raster_settings.debug,
+            raster_settings.f_count
+        )
+        # gaussians_count, important_score, num_rendered, color, radii, geomBuffer, binningBuffer, imgBuffer = None, None, None, None, None, None, None, None
+        # Invoke C++/CUDA rasterizer
+        # TODO(Kevin): pass the count in, but the output include a count list 
+        if raster_settings.debug:
+            cpu_args = cpu_deep_copy_tuple(args) # Copy them before they can be corrupted
+            try:
+                gaussians_count, opacity_important_score, T_alpha_important_score, num_rendered, color, radii, geomBuffer, binningBuffer, imgBuffer = _C.count_gaussians(*args)
+            except Exception as ex:
+                torch.save(cpu_args, "snapshot_fw.dump")
+                print("\nAn error occured in forward. Please forward snapshot_fw.dump for debugging.")
+                raise ex
+        else:
+            gaussians_count, opacity_important_score, T_alpha_important_score, num_rendered, color, radii, geomBuffer, binningBuffer, imgBuffer = _C.count_gaussians(*args)
+                   
+        return gaussians_count, opacity_important_score, T_alpha_important_score, color, radii 
+
+    @staticmethod
+    def backward(ctx, grad_out_color, _):
+
+        # Restore necessary values from context
+        num_rendered = ctx.num_rendered
+        raster_settings = ctx.raster_settings
+        colors_precomp, means3D, scales, rotations, cov3Ds_precomp, radii, sh, geomBuffer, binningBuffer, imgBuffer = ctx.saved_tensors
+
+        # Restructure args as C++ method expects them
+        args = (raster_settings.bg,
+                means3D, 
+                radii, 
+                colors_precomp, 
+                scales, 
+                rotations, 
+                raster_settings.scale_modifier, 
+                cov3Ds_precomp, 
+                raster_settings.viewmatrix, 
+                raster_settings.projmatrix, 
+                raster_settings.tanfovx, 
+                raster_settings.tanfovy, 
+                grad_out_color, 
+                sh, 
+                raster_settings.sh_degree, 
+                raster_settings.campos,
+                geomBuffer,
+                num_rendered,
+                binningBuffer,
+                imgBuffer,
+                raster_settings.debug)
+
+        # Compute gradients for relevant tensors by invoking backward method
+        if raster_settings.debug:
+            cpu_args = cpu_deep_copy_tuple(args) # Copy them before they can be corrupted
+            try:
+                grad_means2D, grad_colors_precomp, grad_opacities, grad_means3D, grad_cov3Ds_precomp, grad_sh, grad_scales, grad_rotations = _C.rasterize_gaussians_backward(*args)
+            except Exception as ex:
+                torch.save(cpu_args, "snapshot_bw.dump")
+                print("\nAn error occured in backward. Writing snapshot_bw.dump for debugging.\n")
+                raise ex
+        else:
+             grad_means2D, grad_colors_precomp, grad_opacities, grad_means3D, grad_cov3Ds_precomp, grad_sh, grad_scales, grad_rotations = _C.rasterize_gaussians_backward(*args)
+
+        grads = (
+            grad_means3D,
+            grad_means2D,
+            grad_sh,
+            grad_colors_precomp,
+            grad_opacities,
+            grad_scales,
+            grad_rotations,
+            grad_cov3Ds_precomp,
+            None,
+        )
+
+        return grads
+
+class GaussianRasterizationSettings(NamedTuple):
+    image_height: int
+    image_width: int 
+    tanfovx : float
+    tanfovy : float
+    bg : torch.Tensor
+    scale_modifier : float
+    viewmatrix : torch.Tensor
+    projmatrix : torch.Tensor
+    sh_degree : int
+    campos : torch.Tensor
+    prefiltered : bool
+    debug : bool
+    f_count : bool
+
+class GaussianRasterizer(nn.Module):
+    def __init__(self, raster_settings):
+        super().__init__()
+        self.raster_settings = raster_settings
+
+    def markVisible(self, positions):
+        # Mark visible points (based on frustum culling for camera) with a boolean 
+        with torch.no_grad():
+            raster_settings = self.raster_settings
+            visible = _C.mark_visible(
+                positions,
+                raster_settings.viewmatrix,
+                raster_settings.projmatrix)
+            
+        return visible
+
+    def forward(self, means3D, means2D, opacities, shs = None, colors_precomp = None, scales = None, rotations = None, cov3D_precomp = None):
+        
+        raster_settings = self.raster_settings
+
+        if (shs is None and colors_precomp is None) or (shs is not None and colors_precomp is not None):
+            raise Exception('Please provide excatly one of either SHs or precomputed colors!')
+        
+        if ((scales is None or rotations is None) and cov3D_precomp is None) or ((scales is not None or rotations is not None) and cov3D_precomp is not None):
+            raise Exception('Please provide exactly one of either scale/rotation pair or precomputed 3D covariance!')
+        
+        if shs is None:
+            shs = torch.Tensor([])
+        if colors_precomp is None:
+            colors_precomp = torch.Tensor([])
+
+        if scales is None:
+            scales = torch.Tensor([])
+        if rotations is None:
+            rotations = torch.Tensor([])
+        if cov3D_precomp is None:
+            cov3D_precomp = torch.Tensor([])
+
+        # Invoke C++/CUDA rasterization routine
+        return rasterize_gaussians(
+            means3D,
+            means2D,
+            shs,
+            colors_precomp,
+            opacities,
+            scales, 
+            rotations,
+            cov3D_precomp,
+            raster_settings, 
+        )
+    
+    def forward_count(self, means3D, means2D, opacities, shs = None, colors_precomp = None, scales = None, rotations = None, cov3D_precomp = None):
+        
+        raster_settings = self.raster_settings
+
+        if (shs is None and colors_precomp is None) or (shs is not None and colors_precomp is not None):
+            raise Exception('Please provide excatly one of either SHs or precomputed colors!')
+        
+        if ((scales is None or rotations is None) and cov3D_precomp is None) or ((scales is not None or rotations is not None) and cov3D_precomp is not None):
+            raise Exception('Please provide exactly one of either scale/rotation pair or precomputed 3D covariance!')
+        
+        if shs is None:
+            shs = torch.Tensor([])
+        if colors_precomp is None:
+            colors_precomp = torch.Tensor([])
+
+        if scales is None:
+            scales = torch.Tensor([])
+        if rotations is None:
+            rotations = torch.Tensor([])
+        if cov3D_precomp is None:
+            cov3D_precomp = torch.Tensor([])
+
+        # Invoke C++/CUDA rasterization routine
+        return rasterize_gaussians(
+            means3D,
+            means2D,
+            shs,
+            colors_precomp,
+            opacities,
+            scales, 
+            rotations,
+            cov3D_precomp,
+            raster_settings, 
+        ) 
+

reduced_3dgs/pruning/importance/trainer.py

@@ -0,0 +1,141 @@
+import math
+import torch
+
+from gaussian_splatting import Camera, GaussianModel
+from gaussian_splatting.trainer import AbstractTrainer, TrainerWrapper, BaseTrainer, Trainer
+from gaussian_splatting.dataset import CameraDataset
+from .diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRasterizer
+
+
+def count_render(self: GaussianModel, viewpoint_camera: Camera):
+    """
+    Render the scene.
+
+    Background tensor (bg_color) must be on GPU!
+    """
+    # Create zero tensor. We will use it to make pytorch return gradients of the 2D (screen-space) means
+    screenspace_points = torch.zeros_like(self.get_xyz, dtype=self.get_xyz.dtype, requires_grad=True, device=self._xyz.device) + 0
+    try:
+        screenspace_points.retain_grad()
+    except:
+        pass
+
+    # Set up rasterization configuration
+    tanfovx = math.tan(viewpoint_camera.FoVx * 0.5)
+    tanfovy = math.tan(viewpoint_camera.FoVy * 0.5)
+
+    raster_settings = GaussianRasterizationSettings(
+        image_height=int(viewpoint_camera.image_height),
+        image_width=int(viewpoint_camera.image_width),
+        tanfovx=tanfovx,
+        tanfovy=tanfovy,
+        bg=viewpoint_camera.bg_color.to(self._xyz.device),
+        scale_modifier=self.scale_modifier,
+        viewmatrix=viewpoint_camera.world_view_transform,
+        projmatrix=viewpoint_camera.full_proj_transform,
+        sh_degree=self.active_sh_degree,
+        campos=viewpoint_camera.camera_center,
+        prefiltered=False,
+        debug=self.debug,
+        f_count=True,
+    )
+
+    rasterizer = GaussianRasterizer(raster_settings=raster_settings)
+    means3D = self.get_xyz
+    means2D = screenspace_points
+    opacity = self.get_opacity
+
+    scales = self.get_scaling
+    rotations = self.get_rotation
+
+    shs = self.get_features
+
+    # Rasterize visible Gaussians to image, obtain their radii (on screen).
+    gaussians_count, opacity_important_score, T_alpha_important_score, rendered_image, radii = rasterizer(
+        means3D=means3D,
+        means2D=means2D,
+        shs=shs,
+        colors_precomp=None,
+        opacities=opacity,
+        scales=scales,
+        rotations=rotations,
+        cov3D_precomp=None)
+
+    # Those Gaussians that were frustum culled or had a radius of 0 were not visible.
+    # They will be excluded from value updates used in the splitting criteria.
+    return {
+        "render": rendered_image,
+        "viewspace_points": screenspace_points,
+        "visibility_filter": radii > 0,
+        "radii": radii,
+        "gaussians_count": gaussians_count,
+        "opacity_important_score": opacity_important_score,
+        "T_alpha_important_score": T_alpha_important_score
+    }
+
+
+class ImportancePruner(TrainerWrapper):
+    def __init__(
+            self, base_trainer: AbstractTrainer,
+            dataset: CameraDataset,
+            importance_prune_at_steps=[15000],
+    ):
+        super().__init__(base_trainer)
+        self.dataset = dataset
+        self.importance_prune_at_steps = importance_prune_at_steps
+
+    def optim_step(self):
+        ret = super().optim_step()
+        if self.curr_step in self.importance_prune_at_steps:
+            gaussian_count = torch.zeros(self.model.get_xyz.shape[0], device=self.model.get_xyz.device, dtype=torch.int)
+            opacity_important_score = torch.zeros(self.model.get_xyz.shape[0], device=self.model.get_xyz.device, dtype=torch.float)
+            T_alpha_important_score = torch.zeros(self.model.get_xyz.shape[0], device=self.model.get_xyz.device, dtype=torch.float)
+            for camera in self.dataset:
+                out = count_render(self.model, camera)
+                gaussian_count += out["gaussians_count"]
+                opacity_important_score += out["opacity_important_score"]
+                T_alpha_important_score += out["T_alpha_important_score"]
+            pass
+        return ret
+
+
+def ImportancePruningTrainerWrapper(
+    base_trainer_constructor,
+        model: GaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        importance_prune_at_steps=[15000],
+        *args, **kwargs):
+    return ImportancePruner(
+        base_trainer_constructor(model, scene_extent, dataset, *args, **kwargs),
+        dataset,
+        importance_prune_at_steps=importance_prune_at_steps,
+    )
+
+
+def BaseImportancePruningTrainer(
+    model: GaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        importance_prune_at_steps=[15000],
+        *args, **kwargs):
+    return ImportancePruningTrainerWrapper(
+        lambda model, scene_extent, dataset, *args, **kwargs: BaseTrainer(model, scene_extent, *args, **kwargs),
+        model, scene_extent, dataset,
+        importance_prune_at_steps=importance_prune_at_steps,
+        *args, **kwargs,
+    )
+
+
+def ImportancePruningTrainer(
+    model: GaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        importance_prune_at_steps=[15000],
+        *args, **kwargs):
+    return ImportancePruningTrainerWrapper(
+        lambda model, scene_extent, dataset, *args, **kwargs: Trainer(model, scene_extent, *args, **kwargs),
+        model, scene_extent, dataset,
+        importance_prune_at_steps=importance_prune_at_steps,
+        *args, **kwargs,
+    )

reduced_3dgs/pruning/trainer.py

@@ -1,7 +1,7 @@
 from typing import List
 import torch
 from gaussian_splatting import GaussianModel, Camera
-from gaussian_splatting.trainer import AbstractDensifier, Densifier, DensificationInstruct, DensificationTrainer
+from gaussian_splatting.trainer import AbstractDensifier, DensifierWrapper, DensificationTrainer, NoopDensifier
 from reduced_3dgs.diff_gaussian_rasterization._C import sphere_ellipsoid_intersection, allocate_minimum_redundancy_value, find_minimum_projected_pixel_size
 from reduced_3dgs.simple_knn._C import distIndex2
 
@@ -79,9 +79,10 @@ def mercy_gaussians(
     return mask
 
 
-class BasePruner(AbstractDensifier):
+class BasePruner(DensifierWrapper):
     def __init__(
-            self, model: GaussianModel, dataset: List[Camera],
+            self, base_densifier: AbstractDensifier,
+            dataset: List[Camera],
             prune_from_iter=1000,
             prune_until_iter=15000,
             prune_interval: int = 100,
@@ -89,7 +90,7 @@ class BasePruner(AbstractDensifier):
             lambda_mercy=1.,
             mercy_minimum=3,
             mercy_type='redundancy_opacity'):
-        self._model = model
+        super().__init__(base_densifier)
         self.dataset = dataset
         self.prune_from_iter = prune_from_iter
         self.prune_until_iter = prune_until_iter
@@ -99,14 +100,12 @@ class BasePruner(AbstractDensifier):
         self.mercy_minimum = mercy_minimum
         self.mercy_type = mercy_type
 
-    @property
-    def model(self) -> GaussianModel:
-        return self._model
-
-    def densify_and_prune(self, loss, out, camera, step: int) -> DensificationInstruct:
+    def densify_and_prune(self, loss, out, camera, step: int):
+        ret = super().densify_and_prune(loss, out, camera, step)
         if self.prune_from_iter <= step <= self.prune_until_iter and step % self.prune_interval == 0:
-            return DensificationInstruct(remove_mask=mercy_gaussians(self.model, self.dataset, self.box_size, self.lambda_mercy, self.mercy_minimum, self.mercy_type))
-        return DensificationInstruct()
+            remove_mask = mercy_gaussians(self.model, self.dataset, self.box_size, self.lambda_mercy, self.mercy_minimum, self.mercy_type)
+            ret = ret._replace(remove_mask=remove_mask if ret.remove_mask is None else torch.logical_or(remove_mask, ret.remove_mask))
+        return ret
 
 
 def BasePruningTrainer(
@@ -124,73 +123,14 @@ def BasePruningTrainer(
     return DensificationTrainer(
         model, scene_extent,
         BasePruner(
-            model, dataset,
-            prune_from_iter, prune_until_iter, prune_interval,
-            box_size, lambda_mercy, mercy_minimum, mercy_type
-        ), *args, **kwargs
-    )
-
-
-class PrunerInDensify(Densifier):
-    def __init__(
-            self, model: GaussianModel, scene_extent, dataset: List[Camera],
-            box_size=1.,
-            lambda_mercy=1.,
-            mercy_minimum=3,
-            mercy_type='redundancy_opacity',
-            *args, **kwargs):
-        super().__init__(model, scene_extent, *args, **kwargs)
-        self.dataset = dataset
-        self.box_size = box_size
-        self.lambda_mercy = lambda_mercy
-        self.mercy_minimum = mercy_minimum
-        self.mercy_type = mercy_type
-
-    def prune(self) -> torch.Tensor:
-        return torch.logical_or(mercy_gaussians(self.model, self.dataset, self.box_size, self.lambda_mercy, self.mercy_minimum, self.mercy_type), super().prune())
-
-
-def BasePrunerInDensifyTrainer(
-        model: GaussianModel,
-        scene_extent: float,
-
-        dataset: List[Camera],
-        box_size=1.,
-        lambda_mercy=1.,
-        mercy_minimum=3,
-        mercy_type='redundancy_opacity',
-
-        densify_from_iter=500,
-        densify_until_iter=15000,
-        densify_interval=100,
-        densify_grad_threshold=0.0002,
-        densify_opacity_threshold=0.005,
-        densify_percent_dense=0.01,
-        densify_percent_too_big=0.8,
-
-        prune_from_iter=1000,
-        prune_until_iter=15000,
-        prune_interval=100,
-        prune_screensize_threshold=20,
-        prune_percent_too_big=1,
-
-        *args, **kwargs):
-    return DensificationTrainer(
-        model, scene_extent,
-        PrunerInDensify(
-            model, scene_extent, dataset,
-            box_size, lambda_mercy, mercy_minimum, mercy_type,
-            densify_from_iter=densify_from_iter,
-            densify_until_iter=densify_until_iter,
-            densify_interval=densify_interval,
-            densify_grad_threshold=densify_grad_threshold,
-            densify_opacity_threshold=densify_opacity_threshold,
-            densify_percent_dense=densify_percent_dense,
-            densify_percent_too_big=densify_percent_too_big,
+            NoopDensifier(model),
+            dataset,
             prune_from_iter=prune_from_iter,
             prune_until_iter=prune_until_iter,
             prune_interval=prune_interval,
-            prune_screensize_threshold=prune_screensize_threshold,
-            prune_percent_too_big=prune_percent_too_big
+            box_size=box_size,
+            lambda_mercy=lambda_mercy,
+            mercy_minimum=mercy_minimum,
+            mercy_type=mercy_type,
         ), *args, **kwargs
     )

reduced_3dgs/train.py

@@ -14,6 +14,7 @@ from gaussian_splatting.trainer.extensions import ScaleRegularizeTrainerWrapper
 from reduced_3dgs.quantization import AbstractQuantizer, VectorQuantizeTrainerWrapper
 from reduced_3dgs.shculling import VariableSHGaussianModel, SHCullingTrainer
 from reduced_3dgs.pruning import PruningTrainer
+from reduced_3dgs.pruning.importance import ImportancePruningTrainerWrapper
 from reduced_3dgs.combinations import OpacityResetPrunerInDensifyTrainer, SHCullingDensifyTrainer, SHCullingPruneTrainer, SHCullingPruningDensifyTrainer
 from reduced_3dgs.combinations import CameraTrainableVariableSHGaussianModel, CameraSHCullingTrainer, CameraPruningTrainer
 from reduced_3dgs.combinations import CameraOpacityResetPrunerInDensifyTrainer, CameraSHCullingDensifyTrainer, CameraSHCullingPruneTrainer, CameraSHCullingPruningDensifyTrainer
@@ -27,6 +28,7 @@ basemodes = {
     "prune-shculling": SHCullingPruneTrainer,
     "densify-prune-shculling": SHCullingPruningDensifyTrainer,
 }
+basemodes = {k: lambda *args, **kwargs: ImportancePruningTrainerWrapper(v, *args, **kwargs) for k, v in basemodes.items()}
 cameramodes = {
     "camera-shculling": CameraSHCullingTrainer,
     "camera-pruning": CameraPruningTrainer,
@@ -35,6 +37,7 @@ cameramodes = {
     "camera-prune-shculling": CameraSHCullingPruneTrainer,
     "camera-densify-prune-shculling": CameraSHCullingPruningDensifyTrainer,
 }
+cameramodes = {k: lambda *args, **kwargs: ImportancePruningTrainerWrapper(v, *args, **kwargs) for k, v in cameramodes.items()}
 
 
 def prepare_quantizer(

{reduced_3dgs-1.8.15.dist-info → reduced_3dgs-1.8.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reduced_3dgs
-Version: 1.8.15
+Version: 1.8.17
 Summary: Refactored code for the paper "Reducing the Memory Footprint of 3D Gaussian Splatting"
 Home-page: https://github.com/yindaheng98/reduced-3dgs
 Author: yindaheng98

reduced_3dgs-1.8.17.dist-info/RECORD

@@ -0,0 +1,27 @@
+reduced_3dgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reduced_3dgs/combinations.py,sha256=YDDNRGQlOuLsXnOOMiZ6mqG0cx1ICtG7jz6ObVx4OUo,4794
+reduced_3dgs/quantize.py,sha256=Y44qHyFdOIqke7NoeqXmyKloS43j-al74ZiNsuZZHbM,2527
+reduced_3dgs/train.py,sha256=VKz55aF-Pq-cs9KSa1UHwwpjcy1oTQPFWPhsGbAZHp4,10158
+reduced_3dgs/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=zoV665wa2AxMAID1Rz35ns35h5ASHPY6fSPcUbYaxvY,1618432
+reduced_3dgs/diff_gaussian_rasterization/__init__.py,sha256=oV6JjTc-50MscX4XHeIWSgLr3l8Y25knBIs-0gRbJr4,7932
+reduced_3dgs/pruning/__init__.py,sha256=ZhjYTfHUFlBoQ9NROTtoRKSACaFxU-wb5rd9EVLPnhk,147
+reduced_3dgs/pruning/combinations.py,sha256=7MdBWls_ibtr8VGNXZnMQHBMl7buO6yWxaADFvH8K_M,1785
+reduced_3dgs/pruning/trainer.py,sha256=bSrxEOztamJ3ap0PJI8jahRN4mGVPJWwr53vXbfRj4s,6450
+reduced_3dgs/pruning/importance/__init__.py,sha256=MIYdZ0Gx_2WTNTpy8qylNaNxvMG5J8paEnqUrPNAvSw,110
+reduced_3dgs/pruning/importance/trainer.py,sha256=LMy2Y_Br91lrhHtwO7NJSRqaju-ZpIofN5H1LdxQYq0,5361
+reduced_3dgs/pruning/importance/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=c8VNpWSd---FOjTu98PF1wI86kRUK_elpDFy_1XLBbU,1308672
+reduced_3dgs/pruning/importance/diff_gaussian_rasterization/__init__.py,sha256=Tix8auyXBb_QFQtXrV3sLE9kdnl5zgHH0BbqcFzDp84,12850
+reduced_3dgs/quantization/__init__.py,sha256=1z1xMn3yj9u7cR9JizGrI3WSyIES_Tqq6oDquvglSeo,225
+reduced_3dgs/quantization/abc.py,sha256=rsi8HFRwQCltWTYiJ3BpygtQDT7hK6J01jKMOboOY8w,1910
+reduced_3dgs/quantization/exclude_zeros.py,sha256=fKSgjHous4OpdI6mQi9z23if9jnbB79w2jChpxkCJWw,2381
+reduced_3dgs/quantization/quantizer.py,sha256=-B07X1VrV7E1fT_NXXlZ0FLAb-c_jBUlZ8274KwHyVw,16614
+reduced_3dgs/quantization/wrapper.py,sha256=cyXqfJgo9b3fS7DYXxOk5LmQudvrEhweOebFsjRnXiQ,2549
+reduced_3dgs/shculling/__init__.py,sha256=nP2BejDCUdCmJNRbg0hfhHREO6jyZXwIcRiw6ttVgqo,149
+reduced_3dgs/shculling/gaussian_model.py,sha256=f8QWaL09vaV9Tcf6Dngjg_Fmk1wTQPAjWhuhI_N02Y8,2877
+reduced_3dgs/shculling/trainer.py,sha256=9hwR77djhZpyf-URhwKHjnLbe0ZAOS-DIw58RzkcHXQ,6369
+reduced_3dgs/simple_knn/_C.cp310-win_amd64.pyd,sha256=_NQNjRHGEgAPEn-k664JdF1-Owu16qkyKGcmC9QNeww,1255424
+reduced_3dgs-1.8.17.dist-info/licenses/LICENSE.md,sha256=LQ4_LAqlncGkg_mQy5ykMAFtQDSPB0eKmIEtBut0yjw,4916
+reduced_3dgs-1.8.17.dist-info/METADATA,sha256=pwG3GbJX9EUJaIY5Yp9bDLeLPXKAwDFmKX_t0VBYqsE,13015
+reduced_3dgs-1.8.17.dist-info/WHEEL,sha256=f7LviPjlKeAUpCmKrQrAXn06zBZT0604QctSZKHK6ZM,101
+reduced_3dgs-1.8.17.dist-info/top_level.txt,sha256=PpU5aT3-baSCdqCtTaZknoB32H93UeKCkYDkRCCZMEI,13
+reduced_3dgs-1.8.17.dist-info/RECORD,,

reduced_3dgs-1.8.15.dist-info/RECORD

@@ -1,23 +0,0 @@
-reduced_3dgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reduced_3dgs/combinations.py,sha256=YDDNRGQlOuLsXnOOMiZ6mqG0cx1ICtG7jz6ObVx4OUo,4794
-reduced_3dgs/quantize.py,sha256=Y44qHyFdOIqke7NoeqXmyKloS43j-al74ZiNsuZZHbM,2527
-reduced_3dgs/train.py,sha256=WdxDg2MC4HCwIaGta3c7oYVPA9gb6CMqHLDD6WeOwEk,9829
-reduced_3dgs/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=rKopFy0xnrDeJv6BGVT5O5C7Q6fvYbMBTQB0w3ltLaU,1618432
-reduced_3dgs/diff_gaussian_rasterization/__init__.py,sha256=oV6JjTc-50MscX4XHeIWSgLr3l8Y25knBIs-0gRbJr4,7932
-reduced_3dgs/pruning/__init__.py,sha256=T6vvO5RFMFUfHl2k7kleZ_AGgDwyMBfc7jxNJ-CRULA,164
-reduced_3dgs/pruning/combinations.py,sha256=ZaqvmmWsl1pJJZbA_yJOJVbv-MoQHLO8Lts3KT-5r_Q,833
-reduced_3dgs/pruning/trainer.py,sha256=5mOfYPEO6ZOW5ZSeI33LoN4EmGYxWKz2pMQw8RMRiEU,8530
-reduced_3dgs/quantization/__init__.py,sha256=1z1xMn3yj9u7cR9JizGrI3WSyIES_Tqq6oDquvglSeo,225
-reduced_3dgs/quantization/abc.py,sha256=rsi8HFRwQCltWTYiJ3BpygtQDT7hK6J01jKMOboOY8w,1910
-reduced_3dgs/quantization/exclude_zeros.py,sha256=fKSgjHous4OpdI6mQi9z23if9jnbB79w2jChpxkCJWw,2381
-reduced_3dgs/quantization/quantizer.py,sha256=-B07X1VrV7E1fT_NXXlZ0FLAb-c_jBUlZ8274KwHyVw,16614
-reduced_3dgs/quantization/wrapper.py,sha256=cyXqfJgo9b3fS7DYXxOk5LmQudvrEhweOebFsjRnXiQ,2549
-reduced_3dgs/shculling/__init__.py,sha256=nP2BejDCUdCmJNRbg0hfhHREO6jyZXwIcRiw6ttVgqo,149
-reduced_3dgs/shculling/gaussian_model.py,sha256=f8QWaL09vaV9Tcf6Dngjg_Fmk1wTQPAjWhuhI_N02Y8,2877
-reduced_3dgs/shculling/trainer.py,sha256=9hwR77djhZpyf-URhwKHjnLbe0ZAOS-DIw58RzkcHXQ,6369
-reduced_3dgs/simple_knn/_C.cp310-win_amd64.pyd,sha256=KabJeO-Ax9RSS0cI_W3OoIl_oI0yawmnfQfpgsT6MPw,1255424
-reduced_3dgs-1.8.15.dist-info/licenses/LICENSE.md,sha256=LQ4_LAqlncGkg_mQy5ykMAFtQDSPB0eKmIEtBut0yjw,4916
-reduced_3dgs-1.8.15.dist-info/METADATA,sha256=0O3KJo4RTyBSVD47eD6gGTGg3MgxDSYAJLDs_-vMm3U,13015
-reduced_3dgs-1.8.15.dist-info/WHEEL,sha256=f7LviPjlKeAUpCmKrQrAXn06zBZT0604QctSZKHK6ZM,101
-reduced_3dgs-1.8.15.dist-info/top_level.txt,sha256=PpU5aT3-baSCdqCtTaZknoB32H93UeKCkYDkRCCZMEI,13
-reduced_3dgs-1.8.15.dist-info/RECORD,,