reduced-3dgs 1.9.1__cp310-cp310-win_amd64.whl → 1.10.12__cp310-cp310-win_amd64.whl

reduced_3dgs/combinations.py

@@ -17,9 +17,19 @@ def BaseFullPruningTrainer(
         scene_extent: float,
         dataset: List[Camera],
         *args,
-        importance_prune_from_iter=1000,
-        importance_prune_until_iter=15000,
-        importance_prune_interval: int = 100,
+        importance_prune_from_iter=15000,
+        importance_prune_until_iter=20000,
+        importance_prune_interval: int = 1000,
+        importance_score_resize=None,
+        importance_prune_type="comprehensive",
+        importance_prune_percent=0.1,
+        importance_prune_thr_important_score=None,
+        importance_prune_thr_v_important_score=3.0,
+        importance_prune_thr_max_v_important_score=None,
+        importance_prune_thr_count=1,
+        importance_prune_thr_T_alpha=1.0,
+        importance_prune_thr_T_alpha_avg=0.001,
+        importance_v_pow=0.1,
         **kwargs):
     return PruningTrainerWrapper(
         lambda model, scene_extent, dataset: ImportancePruner(
@@ -28,6 +38,16 @@ def BaseFullPruningTrainer(
             importance_prune_from_iter=importance_prune_from_iter,
             importance_prune_until_iter=importance_prune_until_iter,
             importance_prune_interval=importance_prune_interval,
+            importance_score_resize=importance_score_resize,
+            importance_prune_type=importance_prune_type,
+            importance_prune_percent=importance_prune_percent,
+            importance_prune_thr_important_score=importance_prune_thr_important_score,
+            importance_prune_thr_v_important_score=importance_prune_thr_v_important_score,
+            importance_prune_thr_max_v_important_score=importance_prune_thr_max_v_important_score,
+            importance_prune_thr_count=importance_prune_thr_count,
+            importance_prune_thr_T_alpha=importance_prune_thr_T_alpha,
+            importance_prune_thr_T_alpha_avg=importance_prune_thr_T_alpha_avg,
+            importance_v_pow=importance_v_pow,
         ),
         model, scene_extent, dataset,
         *args, **kwargs
@@ -39,9 +59,19 @@ def BaseFullPrunerInDensifyTrainer(
         scene_extent: float,
         dataset: List[Camera],
         *args,
-        importance_prune_from_iter=1000,
-        importance_prune_until_iter=15000,
-        importance_prune_interval: int = 100,
+        importance_prune_from_iter=15000,
+        importance_prune_until_iter=20000,
+        importance_prune_interval: int = 1000,
+        importance_score_resize=None,
+        importance_prune_type="comprehensive",
+        importance_prune_percent=0.1,
+        importance_prune_thr_important_score=None,
+        importance_prune_thr_v_important_score=3.0,
+        importance_prune_thr_max_v_important_score=None,
+        importance_prune_thr_count=1,
+        importance_prune_thr_T_alpha=1.0,
+        importance_prune_thr_T_alpha_avg=0.001,
+        importance_v_pow=0.1,
         **kwargs):
     return PrunerInDensifyTrainerWrapper(
         lambda model, scene_extent, dataset: ImportancePruner(
@@ -50,6 +80,16 @@ def BaseFullPrunerInDensifyTrainer(
             importance_prune_from_iter=importance_prune_from_iter,
             importance_prune_until_iter=importance_prune_until_iter,
             importance_prune_interval=importance_prune_interval,
+            importance_score_resize=importance_score_resize,
+            importance_prune_type=importance_prune_type,
+            importance_prune_percent=importance_prune_percent,
+            importance_prune_thr_important_score=importance_prune_thr_important_score,
+            importance_prune_thr_v_important_score=importance_prune_thr_v_important_score,
+            importance_prune_thr_max_v_important_score=importance_prune_thr_max_v_important_score,
+            importance_prune_thr_count=importance_prune_thr_count,
+            importance_prune_thr_T_alpha=importance_prune_thr_T_alpha,
+            importance_prune_thr_T_alpha_avg=importance_prune_thr_T_alpha_avg,
+            importance_v_pow=importance_v_pow,
         ),
         model, scene_extent, dataset,
         *args, **kwargs
@@ -57,11 +97,17 @@ def BaseFullPrunerInDensifyTrainer(
 
 
 def DepthFullPruningTrainer(model: GaussianModel, scene_extent: float, dataset: TrainableCameraDataset, *args, **kwargs):
-    return DepthTrainerWrapper(BaseFullPruningTrainer, model, scene_extent, *args, dataset=dataset, **kwargs)
+    return DepthTrainerWrapper(
+        BaseFullPruningTrainer,
+        model, scene_extent, dataset,
+        *args, **kwargs)
 
 
 def DepthFullPrunerInDensifyTrainer(model: GaussianModel, scene_extent: float, dataset: TrainableCameraDataset, *args, **kwargs):
-    return DepthTrainerWrapper(BaseFullPrunerInDensifyTrainer, model, scene_extent, *args, dataset=dataset, **kwargs)
+    return DepthTrainerWrapper(
+        BaseFullPrunerInDensifyTrainer,
+        model, scene_extent, dataset,
+        *args, **kwargs)
 
 
 def OpacityResetPruningTrainer(

reduced_3dgs/importance/combinations.py

@@ -13,13 +13,15 @@ def BaseImportancePrunerInDensifyTrainer(
         importance_prune_from_iter=15000,
         importance_prune_until_iter=20000,
         importance_prune_interval: int = 1000,
+        importance_score_resize=None,
         importance_prune_type="comprehensive",
         importance_prune_percent=0.1,
         importance_prune_thr_important_score=None,
-        importance_prune_thr_v_important_score=1.0,
+        importance_prune_thr_v_important_score=3.0,
         importance_prune_thr_max_v_important_score=None,
         importance_prune_thr_count=1,
-        importance_prune_thr_T_alpha=0.01,
+        importance_prune_thr_T_alpha=1.0,
+        importance_prune_thr_T_alpha_avg=0.001,
         importance_v_pow=0.1,
         **kwargs):
     return DensificationTrainerWrapper(
@@ -29,6 +31,7 @@ def BaseImportancePrunerInDensifyTrainer(
             importance_prune_from_iter=importance_prune_from_iter,
             importance_prune_until_iter=importance_prune_until_iter,
             importance_prune_interval=importance_prune_interval,
+            importance_score_resize=importance_score_resize,
             importance_prune_type=importance_prune_type,
             importance_prune_percent=importance_prune_percent,
             importance_prune_thr_important_score=importance_prune_thr_important_score,
@@ -36,6 +39,7 @@ def BaseImportancePrunerInDensifyTrainer(
             importance_prune_thr_max_v_important_score=importance_prune_thr_max_v_important_score,
             importance_prune_thr_count=importance_prune_thr_count,
             importance_prune_thr_T_alpha=importance_prune_thr_T_alpha,
+            importance_prune_thr_T_alpha_avg=importance_prune_thr_T_alpha_avg,
             importance_v_pow=importance_v_pow,
         ),
         model,
@@ -48,11 +52,17 @@ def BaseImportancePrunerInDensifyTrainer(
 
 
 def DepthImportancePruningTrainer(model: GaussianModel, scene_extent: float, dataset: TrainableCameraDataset, *args, **kwargs):
-    return DepthTrainerWrapper(BaseImportancePruningTrainer, model, scene_extent, *args, dataset=dataset, **kwargs)
+    return DepthTrainerWrapper(
+        BaseImportancePruningTrainer,
+        model, scene_extent, dataset,
+        *args, **kwargs)
 
 
 def DepthImportancePrunerInDensifyTrainer(model: GaussianModel, scene_extent: float, dataset: TrainableCameraDataset, *args, **kwargs):
-    return DepthTrainerWrapper(BaseImportancePrunerInDensifyTrainer, model, scene_extent, *args, dataset=dataset, **kwargs)
+    return DepthTrainerWrapper(
+        BaseImportancePrunerInDensifyTrainer,
+        model, scene_extent, dataset,
+        *args, **kwargs)
 
 
 ImportancePruningTrainer = DepthImportancePruningTrainer

reduced_3dgs/importance/trainer.py

@@ -1,8 +1,9 @@
 import math
-from typing import Callable, List
+from typing import List
 import torch
 
 from gaussian_splatting import Camera, GaussianModel
+from gaussian_splatting.camera import build_camera
 from gaussian_splatting.trainer import AbstractDensifier, DensifierWrapper, DensificationTrainer, NoopDensifier
 from gaussian_splatting.dataset import CameraDataset
 from .diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRasterizer
@@ -75,11 +76,20 @@ def count_render(self: GaussianModel, viewpoint_camera: Camera):
     }
 
 
-def prune_list(model: GaussianModel, dataset: CameraDataset):
+def prune_list(model: GaussianModel, dataset: CameraDataset, resize=None):
     gaussian_count = torch.zeros(model.get_xyz.shape[0], device=model.get_xyz.device, dtype=torch.int)
     opacity_important_score = torch.zeros(model.get_xyz.shape[0], device=model.get_xyz.device, dtype=torch.float)
     T_alpha_important_score = torch.zeros(model.get_xyz.shape[0], device=model.get_xyz.device, dtype=torch.float)
     for camera in dataset:
+        if resize is not None:
+            height, width = camera.image_height, camera.image_width
+            scale = resize / max(height, width)
+            height, width = int(height * scale), int(width * scale)
+            camera = build_camera(
+                image_height=height, image_width=width,
+                FoVx=camera.FoVx, FoVy=camera.FoVy,
+                R=camera.R, T=camera.T,
+                device=camera.R.device)
         out = count_render(model, camera)
         gaussian_count += out["gaussians_count"]
         opacity_important_score += out["opacity_important_score"]
@@ -118,15 +128,17 @@ def score2mask(percent, import_score: list, threshold=None):
 
 def prune_gaussians(
         gaussians: GaussianModel, dataset: CameraDataset,
+        resize=None,
         prune_type="comprehensive",
         prune_percent=0.1,
         prune_thr_important_score=None,
-        prune_thr_v_important_score=1.0,
+        prune_thr_v_important_score=None,
         prune_thr_max_v_important_score=None,
-        prune_thr_count=1,
-        prune_thr_T_alpha=0.01,
+        prune_thr_count=None,
+        prune_thr_T_alpha=None,
+        prune_thr_T_alpha_avg=None,
         v_pow=0.1):
-    gaussian_list, opacity_imp_list, T_alpha_imp_list = prune_list(gaussians, dataset)
+    gaussian_list, opacity_imp_list, T_alpha_imp_list = prune_list(gaussians, dataset, resize)
     match prune_type:
         case "important_score":
             mask = score2mask(prune_percent, opacity_imp_list, prune_thr_important_score)
@@ -141,6 +153,10 @@ def prune_gaussians(
         case "T_alpha":
             # new importance score defined by doji
             mask = score2mask(prune_percent, T_alpha_imp_list, prune_thr_T_alpha)
+        case "T_alpha_avg":
+            v_list = T_alpha_imp_list / gaussian_list
+            v_list[gaussian_list <= 0] = 0
+            mask = score2mask(prune_percent, v_list, prune_thr_T_alpha_avg)
         case "comprehensive":
             mask = torch.zeros_like(gaussian_list, dtype=torch.bool)
             if prune_thr_important_score is not None:
@@ -155,6 +171,10 @@ def prune_gaussians(
                 mask |= score2mask(prune_percent, gaussian_list, prune_thr_count)
             if prune_thr_T_alpha is not None:
                 mask |= score2mask(prune_percent, T_alpha_imp_list, prune_thr_T_alpha)
+            if prune_thr_T_alpha_avg is not None:
+                v_list = T_alpha_imp_list / gaussian_list
+                v_list[gaussian_list <= 0] = 0
+                mask |= score2mask(prune_percent, v_list, prune_thr_T_alpha_avg)
         case _:
             raise Exception("Unsupportive prunning method")
     return mask
@@ -167,26 +187,29 @@ class ImportancePruner(DensifierWrapper):
             importance_prune_from_iter=15000,
             importance_prune_until_iter=20000,
             importance_prune_interval: int = 1000,
+            importance_score_resize=None,
             importance_prune_type="comprehensive",
             importance_prune_percent=0.1,
             importance_prune_thr_important_score=None,
-            importance_prune_thr_v_important_score=1.0,
+            importance_prune_thr_v_important_score=3.0,
             importance_prune_thr_max_v_important_score=None,
             importance_prune_thr_count=1,
-            importance_prune_thr_T_alpha=0.01,
-            importance_v_pow=0.1
-    ):
+            importance_prune_thr_T_alpha=1,
+            importance_prune_thr_T_alpha_avg=0.001,
+            importance_v_pow=0.1):
         super().__init__(base_densifier)
         self.dataset = dataset
         self.importance_prune_from_iter = importance_prune_from_iter
         self.importance_prune_until_iter = importance_prune_until_iter
         self.importance_prune_interval = importance_prune_interval
+        self.resize = importance_score_resize
         self.prune_percent = importance_prune_percent
         self.prune_thr_important_score = importance_prune_thr_important_score
         self.prune_thr_v_important_score = importance_prune_thr_v_important_score
         self.prune_thr_max_v_important_score = importance_prune_thr_max_v_important_score
         self.prune_thr_count = importance_prune_thr_count
         self.prune_thr_T_alpha = importance_prune_thr_T_alpha
+        self.prune_thr_T_alpha_avg = importance_prune_thr_T_alpha_avg
         self.v_pow = importance_v_pow
         self.prune_type = importance_prune_type
 
@@ -195,10 +218,11 @@ class ImportancePruner(DensifierWrapper):
         if self.importance_prune_from_iter <= step <= self.importance_prune_until_iter and step % self.importance_prune_interval == 0:
             remove_mask = prune_gaussians(
                 self.model, self.dataset,
+                self.resize,
                 self.prune_type, self.prune_percent,
                 self.prune_thr_important_score, self.prune_thr_v_important_score,
                 self.prune_thr_max_v_important_score, self.prune_thr_count,
-                self.prune_thr_T_alpha, self.v_pow,
+                self.prune_thr_T_alpha, self.prune_thr_T_alpha_avg, self.v_pow,
             )
             ret = ret._replace(remove_mask=remove_mask if ret.remove_mask is None else torch.logical_or(ret.remove_mask, remove_mask))
         return ret
@@ -212,13 +236,15 @@ def BaseImportancePruningTrainer(
         importance_prune_from_iter=15000,
         importance_prune_until_iter=20000,
         importance_prune_interval: int = 1000,
+        importance_score_resize=None,
         importance_prune_type="comprehensive",
         importance_prune_percent=0.1,
         importance_prune_thr_important_score=None,
-        importance_prune_thr_v_important_score=1.0,
+        importance_prune_thr_v_important_score=3.0,
         importance_prune_thr_max_v_important_score=None,
         importance_prune_thr_count=1,
-        importance_prune_thr_T_alpha=0.01,
+        importance_prune_thr_T_alpha=1.0,
+        importance_prune_thr_T_alpha_avg=0.001,
         importance_v_pow=0.1,
         **kwargs):
     return DensificationTrainer(
@@ -229,6 +255,7 @@ def BaseImportancePruningTrainer(
             importance_prune_from_iter=importance_prune_from_iter,
             importance_prune_until_iter=importance_prune_until_iter,
             importance_prune_interval=importance_prune_interval,
+            importance_score_resize=importance_score_resize,
             importance_prune_type=importance_prune_type,
             importance_prune_percent=importance_prune_percent,
             importance_prune_thr_important_score=importance_prune_thr_important_score,
@@ -236,6 +263,7 @@ def BaseImportancePruningTrainer(
             importance_prune_thr_max_v_important_score=importance_prune_thr_max_v_important_score,
             importance_prune_thr_count=importance_prune_thr_count,
             importance_prune_thr_T_alpha=importance_prune_thr_T_alpha,
+            importance_prune_thr_T_alpha_avg=importance_prune_thr_T_alpha_avg,
             importance_v_pow=importance_v_pow,
         ), *args, **kwargs
     )

reduced_3dgs/prepare.py

@@ -0,0 +1,105 @@
+from gaussian_splatting import GaussianModel
+from gaussian_splatting.dataset import CameraDataset
+from gaussian_splatting.dataset.colmap import colmap_init
+from gaussian_splatting.trainer import AbstractTrainer
+from gaussian_splatting.trainer.extensions import ScaleRegularizeTrainerWrapper
+from reduced_3dgs.quantization import VectorQuantizeTrainerWrapper
+from reduced_3dgs.shculling import VariableSHGaussianModel, SHCullingTrainer
+from reduced_3dgs.pruning import PruningTrainer
+from reduced_3dgs.combinations import PrunerInDensifyTrainer, SHCullingDensificationTrainer, SHCullingPruningTrainer, SHCullingPrunerInDensifyTrainer
+from reduced_3dgs.combinations import CameraTrainableVariableSHGaussianModel, CameraSHCullingTrainer, CameraPruningTrainer
+from reduced_3dgs.combinations import CameraPrunerInDensifyTrainer, CameraSHCullingDensifyTrainer, CameraSHCullingPruningTrainer, CameraSHCullingPruningDensifyTrainer
+
+
+def prepare_gaussians(sh_degree: int, source: str, device: str, trainable_camera: bool = False, load_ply: str = None) -> GaussianModel:
+    if trainable_camera:
+        gaussians = CameraTrainableVariableSHGaussianModel(sh_degree).to(device)
+        gaussians.load_ply(load_ply) if load_ply else colmap_init(gaussians, source)
+    else:
+        gaussians = VariableSHGaussianModel(sh_degree).to(device)
+        gaussians.load_ply(load_ply) if load_ply else colmap_init(gaussians, source)
+    return gaussians
+
+
+modes = {
+    "shculling": SHCullingTrainer,
+    "pruning": PruningTrainer,
+    "densify-pruning": PrunerInDensifyTrainer,
+    "densify-shculling": SHCullingDensificationTrainer,
+    "prune-shculling": SHCullingPruningTrainer,
+    "densify-prune-shculling": SHCullingPrunerInDensifyTrainer,
+    "camera-shculling": CameraSHCullingTrainer,
+    "camera-pruning": CameraPruningTrainer,
+    "camera-densify-pruning": CameraPrunerInDensifyTrainer,
+    "camera-densify-shculling": CameraSHCullingDensifyTrainer,
+    "camera-prune-shculling": CameraSHCullingPruningTrainer,
+    "camera-densify-prune-shculling": CameraSHCullingPruningDensifyTrainer,
+}
+
+
+def prepare_quantizer(
+        gaussians: GaussianModel,
+        scene_extent: float,
+        dataset: CameraDataset,
+        base_constructor,
+        load_quantized: str = None,
+
+        num_clusters=256,
+        num_clusters_rotation_re=None,
+        num_clusters_rotation_im=None,
+        num_clusters_opacity=None,
+        num_clusters_scaling=None,
+        num_clusters_features_dc=None,
+        num_clusters_features_rest=[],
+
+        quantize_from_iter=5000,
+        quantize_until_iter=30000,
+        quantize_interval=1000,
+        **configs):
+    trainer = VectorQuantizeTrainerWrapper(
+        base_constructor(
+            gaussians,
+            scene_extent=scene_extent,
+            dataset=dataset,
+            **configs
+        ),
+
+        num_clusters=num_clusters,
+        num_clusters_rotation_re=num_clusters_rotation_re,
+        num_clusters_rotation_im=num_clusters_rotation_im,
+        num_clusters_opacity=num_clusters_opacity,
+        num_clusters_scaling=num_clusters_scaling,
+        num_clusters_features_dc=num_clusters_features_dc,
+        num_clusters_features_rest=num_clusters_features_rest,
+
+        quantize_from_iter=quantize_from_iter,
+        quantize_until_iter=quantize_until_iter,
+        quantize_interval=quantize_interval,
+    )
+    if load_quantized:
+        trainer.quantizer.load_quantized(load_quantized)
+    return trainer, trainer.quantizer
+
+
+def prepare_trainer(gaussians: GaussianModel, dataset: CameraDataset, mode: str, with_scale_reg=False, quantize: bool = False, load_quantized: str = None, configs={}) -> AbstractTrainer:
+    constructor = modes[mode]
+    if with_scale_reg:
+        constructor = lambda *args, **kwargs: ScaleRegularizeTrainerWrapper(modes[mode], *args, **kwargs)
+    if quantize:
+        trainer, quantizer = prepare_quantizer(
+            gaussians,
+            scene_extent=dataset.scene_extent(),
+            dataset=dataset,
+            base_constructor=modes[mode],
+            load_quantized=load_quantized,
+            **configs
+        )
+    else:
+        trainer = constructor(
+            gaussians,
+            scene_extent=dataset.scene_extent(),
+            dataset=dataset,
+            **configs
+        )
+        quantizer = None
+    return trainer, quantizer

reduced_3dgs/pruning/combinations.py

@@ -23,7 +23,7 @@ def PrunerInDensifyTrainerWrapper(
     return SplitCloneDensifierTrainerWrapper(
         lambda model, scene_extent: BasePruner(
             noargs_base_densifier_constructor(model, scene_extent, dataset),
-            dataset,
+            scene_extent, dataset,
             prune_from_iter=prune_from_iter,
             prune_until_iter=prune_until_iter,
             prune_interval=prune_interval,
@@ -54,11 +54,17 @@ def BasePrunerInDensifyTrainer(
 
 
 def DepthPruningTrainer(model: GaussianModel, scene_extent: float, dataset: TrainableCameraDataset, *args, **kwargs):
-    return DepthTrainerWrapper(BasePruningTrainer, model, scene_extent, *args, dataset=dataset, **kwargs)
+    return DepthTrainerWrapper(
+        BasePruningTrainer,
+        model, scene_extent, dataset,
+        *args, **kwargs)
 
 
 def DepthPrunerInDensifyTrainer(model: GaussianModel, scene_extent: float, dataset: TrainableCameraDataset, *args, **kwargs):
-    return DepthTrainerWrapper(BasePrunerInDensifyTrainer, model, scene_extent, *args, dataset=dataset, **kwargs)
+    return DepthTrainerWrapper(
+        BasePrunerInDensifyTrainer,
+        model, scene_extent, dataset,
+        *args, **kwargs)
 
 
 PruningTrainer = DepthPruningTrainer

reduced_3dgs/pruning/trainer.py

@@ -1,7 +1,7 @@
 from typing import Callable, List
 import torch
 from gaussian_splatting import GaussianModel, Camera
-from gaussian_splatting.trainer import AbstractDensifier, DensifierWrapper, DensificationTrainer, NoopDensifier
+from gaussian_splatting.trainer import AbstractDensifier, OpacityPruner, 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,33 +79,28 @@ def mercy_gaussians(
     return mask
 
 
-class BasePruner(DensifierWrapper):
+class BasePruner(OpacityPruner):
     def __init__(
             self, base_densifier: AbstractDensifier,
+            scene_extent,
             dataset: List[Camera],
-            prune_from_iter=1000,
-            prune_until_iter=15000,
-            prune_interval: int = 100,
+            *args,
             box_size=1.,
             lambda_mercy=1.,
             mercy_minimum=3,
-            mercy_type='redundancy_opacity'):
-        super().__init__(base_densifier)
+            mercy_type='redundancy_opacity',
+            **kwargs):
+        super().__init__(base_densifier, scene_extent, *args, **kwargs)
         self.dataset = dataset
-        self.prune_from_iter = prune_from_iter
-        self.prune_until_iter = prune_until_iter
-        self.prune_interval = prune_interval
         self.box_size = box_size
         self.lambda_mercy = lambda_mercy
         self.mercy_minimum = mercy_minimum
         self.mercy_type = mercy_type
 
-    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:
-            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 prune(self) -> torch.Tensor:
+        remove_mask = mercy_gaussians(self.model, self.dataset, self.box_size, self.lambda_mercy, self.mercy_minimum, self.mercy_type)
+        prune_mask = torch.logical_or(super().prune(), remove_mask)
+        return prune_mask
 
 
 def PruningTrainerWrapper(
@@ -126,7 +121,7 @@ def PruningTrainerWrapper(
         model, scene_extent,
         BasePruner(
             noargs_base_densifier_constructor(model, scene_extent, dataset),
-            dataset,
+            scene_extent, dataset,
             prune_from_iter=prune_from_iter,
             prune_until_iter=prune_until_iter,
             prune_interval=prune_interval,

reduced_3dgs/quantization/quantizer.py

@@ -4,7 +4,15 @@ from typing import Dict, Tuple
 import torch
 import torch.nn as nn
 import numpy as np
-from sklearn.cluster import MiniBatchKMeans as KMeans
+try:
+    from cuml.cluster import KMeans
+    kmeans_init = 'k-means||'
+except ImportError:
+    print("Cuml not found, using sklearn's MiniBatchKMeans for quantization.")
+    from sklearn.cluster import MiniBatchKMeans
+    from functools import partial
+    KMeans = partial(MiniBatchKMeans, batch_size=256 * os.cpu_count())
+    kmeans_init = 'k-means++'
 from gaussian_splatting import GaussianModel
 from plyfile import PlyData, PlyElement
 import numpy as np
@@ -65,9 +73,8 @@ class VectorQuantizer(AbstractQuantizer):
     def generate_codebook(self, values: torch.Tensor, num_clusters, init_codebook=None):
         kmeans = KMeans(
             n_clusters=num_clusters, tol=self.tol, max_iter=self.max_iter,
-            init='k-means++' if init_codebook is None else init_codebook.cpu().numpy(),
-            random_state=0, n_init="auto", verbose=0,
-            batch_size=256 * os.cpu_count()
+            init=kmeans_init if init_codebook is None else init_codebook.cpu().numpy(),
+            random_state=0, n_init="auto", verbose=1,
         )
         ids = torch.tensor(kmeans.fit_predict(values.cpu().numpy()), device=values.device)
         centers = torch.tensor(kmeans.cluster_centers_, dtype=values.dtype, device=values.device)
@@ -119,10 +126,12 @@ class VectorQuantizer(AbstractQuantizer):
         return self.one_nearst(model._opacity.detach(), codebook)
 
     def produce_clusters_scaling(self, model: GaussianModel, *args, **kwargs):
-        return self.generate_codebook(model.get_scaling.detach(), self.num_clusters_scaling, *args, **kwargs)
+        centers, ids = self.generate_codebook(model.get_scaling.detach(), self.num_clusters_scaling, *args, **kwargs)
+        centers_log = model.scaling_inverse_activation(centers)
+        return centers_log, ids
 
     def find_nearest_cluster_id_scaling(self, model: GaussianModel, codebook: torch.Tensor):
-        return self.one_nearst(model.get_scaling.detach(), codebook)
+        return self.one_nearst(model.get_scaling.detach(), model.scaling_activation(codebook))
 
     def produce_clusters(self, model: GaussianModel, init_codebook_dict={}):
         codebook_dict: Dict[str, torch.Tensor] = {}
@@ -163,7 +172,7 @@ class VectorQuantizer(AbstractQuantizer):
 
     def dequantize(self, model: GaussianModel, ids_dict: Dict[str, torch.Tensor], codebook_dict: Dict[str, torch.Tensor], xyz: torch.Tensor = None, replace=False) -> GaussianModel:
         opacity = codebook_dict["opacity"][ids_dict["opacity"], ...]
-        scaling = model.scaling_inverse_activation(codebook_dict["scaling"][ids_dict["scaling"], ...])
+        scaling = codebook_dict["scaling"][ids_dict["scaling"], ...]
 
         rotation = torch.cat((
             codebook_dict["rotation_re"][ids_dict["rotation_re"], ...],
@@ -204,8 +213,7 @@ class VectorQuantizer(AbstractQuantizer):
             ids_dict = self.find_nearest_cluster_id(model, self._codebook_dict)
         return ids_dict, codebook_dict
 
-    def save_quantized(self, model: GaussianModel, ply_path: str):
-        ids_dict, codebook_dict = self.quantize(model, update_codebook=False)
+    def ply_dtype(self, max_sh_degree: int):
         dtype_full = [
             ('x', 'f4'), ('y', 'f4'), ('z', 'f4'),
             ('nx', 'f4'), ('ny', 'f4'), ('nz', 'f4'),
@@ -215,13 +223,16 @@ class VectorQuantizer(AbstractQuantizer):
             ('scale', self.force_code_dtype or compute_uint_dtype(self.num_clusters_scaling)),
             ('f_dc', self.force_code_dtype or compute_uint_dtype(self.num_clusters_features_dc)),
         ]
-        for sh_degree in range(model.max_sh_degree):
+        for sh_degree in range(max_sh_degree):
             force_code_dtype = self.force_code_dtype or compute_uint_dtype(self.num_clusters_features_rest[sh_degree])
             dtype_full.extend([
                 (f'f_rest_{sh_degree}_0', force_code_dtype),
                 (f'f_rest_{sh_degree}_1', force_code_dtype),
                 (f'f_rest_{sh_degree}_2', force_code_dtype),
             ])
+        return dtype_full
+
+    def ply_data(self, model: GaussianModel, ids_dict: Dict[str, torch.Tensor]):
         data_full = [
             *np.array_split(model._xyz.detach().cpu().numpy(), 3, axis=1),
             *np.array_split(torch.zeros_like(model._xyz).detach().cpu().numpy(), 3, axis=1),
@@ -234,6 +245,12 @@ class VectorQuantizer(AbstractQuantizer):
         for sh_degree in range(model.max_sh_degree):
             features_rest = ids_dict[f'features_rest_{sh_degree}'].cpu().numpy()
             data_full.extend(np.array_split(features_rest, 3, axis=1))
+        return data_full
+
+    def save_quantized(self, model: GaussianModel, ply_path: str):
+        ids_dict, codebook_dict = self.quantize(model, update_codebook=False)
+        dtype_full = self.ply_dtype(model.max_sh_degree)
+        data_full = self.ply_data(model, ids_dict)
 
         elements = np.rec.fromarrays([data.squeeze(-1) for data in data_full], dtype=dtype_full)
         el = PlyElement.describe(elements, 'vertex')
@@ -252,36 +269,46 @@ class VectorQuantizer(AbstractQuantizer):
 
         PlyData([el, *cb]).write(ply_path)
 
-    def load_quantized(self, model: GaussianModel, ply_path: str) -> GaussianModel:
-        plydata = PlyData.read(ply_path)
-
+    def parse_ids(self, plydata: PlyData, max_sh_degree: int, device: torch.device) -> Dict[str, torch.Tensor]:
         ids_dict = {}
         elements = plydata['vertex']
-        kwargs = dict(dtype=torch.long, device=model._xyz.device)
+        kwargs = dict(dtype=torch.long, device=device)
         ids_dict["rotation_re"] = torch.tensor(elements["rot_re"].copy(), **kwargs)
         ids_dict["rotation_im"] = torch.tensor(elements["rot_im"].copy(), **kwargs)
         ids_dict["opacity"] = torch.tensor(elements["opacity"].copy(), **kwargs)
         ids_dict["scaling"] = torch.tensor(elements["scale"].copy(), **kwargs)
         ids_dict["features_dc"] = torch.tensor(elements["f_dc"].copy(), **kwargs).unsqueeze(-1)
-        for sh_degree in range(model.max_sh_degree):
+        for sh_degree in range(max_sh_degree):
             ids_dict[f'features_rest_{sh_degree}'] = torch.tensor(np.stack([elements[f'f_rest_{sh_degree}_{ch}'] for ch in range(3)], axis=1), **kwargs)
+        return ids_dict
 
+    def parse_codebook(self, plydata: PlyData, max_sh_degree: int, device: torch.device) -> Dict[str, torch.Tensor]:
         codebook_dict = {}
-        kwargs = dict(dtype=torch.float32, device=model._xyz.device)
+        kwargs = dict(dtype=torch.float32, device=device)
         codebook_dict["rotation_re"] = torch.tensor(plydata["codebook_rot_re"]["rot_re"], **kwargs).unsqueeze(-1)
         codebook_dict["rotation_im"] = torch.tensor(np.stack([plydata["codebook_rot_im"][f'rot_im_{ch}'] for ch in range(3)], axis=1), **kwargs)
         codebook_dict["opacity"] = torch.tensor(plydata["codebook_opacity"]["opacity"], **kwargs).unsqueeze(-1)
         codebook_dict["scaling"] = torch.tensor(np.stack([plydata["codebook_scaling"][f'scaling_{ch}'] for ch in range(3)], axis=1), **kwargs)
         codebook_dict["features_dc"] = torch.tensor(np.stack([plydata["codebook_f_dc"][f'f_dc_{ch}'] for ch in range(3)], axis=1), **kwargs)
-        for sh_degree in range(model.max_sh_degree):
+        for sh_degree in range(max_sh_degree):
             n_channels = (sh_degree + 2) ** 2 - (sh_degree + 1) ** 2
             codebook_dict[f'features_rest_{sh_degree}'] = torch.tensor(np.stack([plydata[f"codebook_f_rest_{sh_degree}"][f'f_rest_{sh_degree}_{ch}'] for ch in range(n_channels)], axis=1), **kwargs)
+        return codebook_dict
 
-        self._codebook_dict = codebook_dict
-
+    def parse_xyz(self, plydata: PlyData, device: torch.device) -> torch.Tensor:
+        elements = plydata['vertex']
+        kwargs = dict(dtype=torch.float32, device=device)
         xyz = torch.stack([
             torch.tensor(elements["x"].copy(), **kwargs),
             torch.tensor(elements["y"].copy(), **kwargs),
             torch.tensor(elements["z"].copy(), **kwargs),
         ], dim=1)
+        return xyz
+
+    def load_quantized(self, model: GaussianModel, ply_path: str) -> GaussianModel:
+        plydata = PlyData.read(ply_path)
+        ids_dict = self.parse_ids(plydata, model.max_sh_degree, model._xyz.device)
+        codebook_dict = self.parse_codebook(plydata, model.max_sh_degree, model._xyz.device)
+        xyz = self.parse_xyz(plydata, model._xyz.device)
+        self._codebook_dict = codebook_dict
         return self.dequantize(model, ids_dict, codebook_dict, xyz=xyz, replace=True)

reduced_3dgs/quantize.py

@@ -13,6 +13,7 @@ def copy_not_exists(source, destination):
 
 
 def quantize(source, destination, iteration, sh_degree, device, **kwargs):
+    os.makedirs(destination, exist_ok=True)
     copy_not_exists(os.path.join(source, "cfg_args"), os.path.join(destination, "cfg_args"))
     copy_not_exists(os.path.join(source, "cameras.json"), os.path.join(destination, "cameras.json"))
 

reduced_3dgs/train.py

@@ -1,150 +1,65 @@
 import os
 import random
 import shutil
-from typing import List, Tuple
+from typing import List
 import torch
 from tqdm import tqdm
-from argparse import Namespace
 from gaussian_splatting import GaussianModel
-from gaussian_splatting.dataset import CameraDataset, JSONCameraDataset, TrainableCameraDataset
+from gaussian_splatting.dataset import CameraDataset
 from gaussian_splatting.utils import psnr
-from gaussian_splatting.dataset.colmap import ColmapCameraDataset, ColmapTrainableCameraDataset, colmap_init
 from gaussian_splatting.trainer import AbstractTrainer
-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.combinations import PrunerInDensifyTrainer, SHCullingDensificationTrainer, SHCullingPruningTrainer, SHCullingPrunerInDensifyTrainer
-from reduced_3dgs.combinations import CameraTrainableVariableSHGaussianModel, CameraSHCullingTrainer, CameraPruningTrainer
-from reduced_3dgs.combinations import CameraPrunerInDensifyTrainer, CameraSHCullingDensifyTrainer, CameraSHCullingPruningTrainer, CameraSHCullingPruningDensifyTrainer
-
-
-basemodes = {
-    "shculling": SHCullingTrainer,
-    "pruning": PruningTrainer,
-    "densify-pruning": PrunerInDensifyTrainer,
-    "densify-shculling": SHCullingDensificationTrainer,
-    "prune-shculling": SHCullingPruningTrainer,
-    "densify-prune-shculling": SHCullingPrunerInDensifyTrainer,
-}
-cameramodes = {
-    "camera-shculling": CameraSHCullingTrainer,
-    "camera-pruning": CameraPruningTrainer,
-    "camera-densify-pruning": CameraPrunerInDensifyTrainer,
-    "camera-densify-shculling": CameraSHCullingDensifyTrainer,
-    "camera-prune-shculling": CameraSHCullingPruningTrainer,
-    "camera-densify-prune-shculling": CameraSHCullingPruningDensifyTrainer,
-}
-
-
-def prepare_quantizer(
-        gaussians: GaussianModel,
-        scene_extent: float,
-        dataset: CameraDataset,
-        base_constructor,
-        load_quantized: str = None,
-
-        num_clusters=256,
-        num_clusters_rotation_re=None,
-        num_clusters_rotation_im=None,
-        num_clusters_opacity=None,
-        num_clusters_scaling=None,
-        num_clusters_features_dc=None,
-        num_clusters_features_rest=[],
-
-        quantize_from_iter=5000,
-        quantize_until_iter=30000,
-        quantize_interval=1000,
-        **configs):
-    trainer = VectorQuantizeTrainerWrapper(
-        base_constructor(
-            gaussians,
-            scene_extent=scene_extent,
-            dataset=dataset,
-            **configs
-        ),
-
-        num_clusters=num_clusters,
-        num_clusters_rotation_re=num_clusters_rotation_re,
-        num_clusters_rotation_im=num_clusters_rotation_im,
-        num_clusters_opacity=num_clusters_opacity,
-        num_clusters_scaling=num_clusters_scaling,
-        num_clusters_features_dc=num_clusters_features_dc,
-        num_clusters_features_rest=num_clusters_features_rest,
-
-        quantize_from_iter=quantize_from_iter,
-        quantize_until_iter=quantize_until_iter,
-        quantize_interval=quantize_interval,
-    )
-    if load_quantized:
-        trainer.quantizer.load_quantized(load_quantized)
-    return trainer, trainer.quantizer
-
-
-def prepare_training(sh_degree: int, source: str, device: str, mode: str, load_ply: str = None, load_camera: str = None, load_depth=False, with_scale_reg=False, quantize: bool = False, load_quantized: str = None, configs={}) -> Tuple[CameraDataset, GaussianModel, AbstractTrainer]:
-    quantizer = None
-    if mode in basemodes:
-        gaussians = VariableSHGaussianModel(sh_degree).to(device)
-        gaussians.load_ply(load_ply) if load_ply else colmap_init(gaussians, source)
-        dataset = (JSONCameraDataset(load_camera, load_depth=load_depth) if load_camera else ColmapCameraDataset(source, load_depth=load_depth)).to(device)
-        modes = basemodes
-    elif mode in cameramodes:
-        gaussians = CameraTrainableVariableSHGaussianModel(sh_degree).to(device)
-        gaussians.load_ply(load_ply) if load_ply else colmap_init(gaussians, source)
-        dataset = (TrainableCameraDataset.from_json(load_camera, load_depth=load_depth) if load_camera else ColmapTrainableCameraDataset(source, load_depth=load_depth)).to(device)
-        modes = cameramodes
-    else:
-        raise ValueError(f"Unknown mode: {mode}")
-    constructor = modes[mode]
-    if with_scale_reg:
-        constructor = lambda *args, **kwargs: ScaleRegularizeTrainerWrapper(modes[mode], *args, **kwargs)
-    if quantize:
-        trainer, quantizer = prepare_quantizer(
-            gaussians,
-            scene_extent=dataset.scene_extent(),
-            dataset=dataset,
-            base_constructor=modes[mode],
-            load_quantized=load_quantized,
-            **configs
-        )
-    else:
-        trainer = constructor(
-            gaussians,
-            scene_extent=dataset.scene_extent(),
-            dataset=dataset,
-            **configs
-        )
+from gaussian_splatting.prepare import prepare_dataset
+from gaussian_splatting.train import save_cfg_args
+from reduced_3dgs.quantization import AbstractQuantizer
+from reduced_3dgs.prepare import modes, prepare_gaussians, prepare_trainer
+
+
+def prepare_training(
+        sh_degree: int, source: str, device: str, mode: str,
+        trainable_camera: bool = False, load_ply: str = None, load_camera: str = None,
+        load_mask=True, load_depth=True,
+        with_scale_reg=False, quantize: bool = False, load_quantized: str = None, configs={}):
+    dataset = prepare_dataset(source=source, device=device, trainable_camera=trainable_camera, load_camera=load_camera, load_mask=load_mask, load_depth=load_depth)
+    gaussians = prepare_gaussians(sh_degree=sh_degree, source=source, device=device, trainable_camera=trainable_camera, load_ply=load_ply)
+    trainer, quantizer = prepare_trainer(gaussians=gaussians, dataset=dataset, mode=mode, with_scale_reg=with_scale_reg, quantize=quantize, load_quantized=load_quantized, configs=configs)
     return dataset, gaussians, trainer, quantizer
 
 
-def save_cfg_args(destination: str, sh_degree: int, source: str):
-    os.makedirs(destination, exist_ok=True)
-    with open(os.path.join(destination, "cfg_args"), 'w') as cfg_log_f:
-        cfg_log_f.write(str(Namespace(sh_degree=sh_degree, source_path=source)))
-
-
 def training(dataset: CameraDataset, gaussians: GaussianModel, trainer: AbstractTrainer, quantizer: AbstractQuantizer, destination: str, iteration: int, save_iterations: List[int], device: str, empty_cache_every_step=False):
     shutil.rmtree(os.path.join(destination, "point_cloud"), ignore_errors=True)  # remove the previous point cloud
-    pbar = tqdm(range(1, iteration+1))
+    pbar = tqdm(range(1, iteration+1), dynamic_ncols=True, desc="Training")
     epoch = list(range(len(dataset)))
     epoch_psnr = torch.empty(3, 0, device=device)
+    epoch_maskpsnr = torch.empty(3, 0, device=device)
     ema_loss_for_log = 0.0
     avg_psnr_for_log = 0.0
+    avg_maskpsnr_for_log = 0.0
     for step in pbar:
         epoch_idx = step % len(dataset)
         if epoch_idx == 0:
             avg_psnr_for_log = epoch_psnr.mean().item()
+            avg_maskpsnr_for_log = epoch_maskpsnr.mean().item()
             epoch_psnr = torch.empty(3, 0, device=device)
+            epoch_maskpsnr = torch.empty(3, 0, device=device)
             random.shuffle(epoch)
         idx = epoch[epoch_idx]
         loss, out = trainer.step(dataset[idx])
         if empty_cache_every_step:
             torch.cuda.empty_cache()
         with torch.no_grad():
+            ground_truth_image = dataset[idx].ground_truth_image
+            rendered_image = out["render"]
+            epoch_psnr = torch.concat([epoch_psnr, psnr(rendered_image, ground_truth_image)], dim=1)
+            if dataset[idx].ground_truth_image_mask is not None:
+                ground_truth_maskimage = ground_truth_image * dataset[idx].ground_truth_image_mask
+                rendered_maskimage = rendered_image * dataset[idx].ground_truth_image_mask
+                epoch_maskpsnr = torch.concat([epoch_maskpsnr, psnr(rendered_maskimage, ground_truth_maskimage)], dim=1)
             ema_loss_for_log = 0.4 * loss.item() + 0.6 * ema_loss_for_log
-            epoch_psnr = torch.concat([epoch_psnr, psnr(out["render"], dataset[idx].ground_truth_image)], dim=1)
             if step % 10 == 0:
-                pbar.set_postfix({'epoch': step // len(dataset), 'loss': ema_loss_for_log, 'psnr': avg_psnr_for_log, 'n': gaussians._xyz.shape[0]})
+                postfix = {'epoch': step // len(dataset), 'loss': ema_loss_for_log, 'psnr': avg_psnr_for_log, 'n': gaussians._xyz.shape[0]}
+                if avg_maskpsnr_for_log > 0:
+                    postfix['psnr (mask)'] = avg_maskpsnr_for_log
+                pbar.set_postfix(postfix)
         if step in save_iterations:
             save_path = os.path.join(destination, "point_cloud", "iteration_" + str(step))
             os.makedirs(save_path, exist_ok=True)
@@ -161,7 +76,7 @@ def training(dataset: CameraDataset, gaussians: GaussianModel, trainer: Abstract
 
 
 if __name__ == "__main__":
-    from argparse import ArgumentParser, Namespace
+    from argparse import ArgumentParser
     parser = ArgumentParser()
     parser.add_argument("--sh_degree", default=3, type=int)
     parser.add_argument("-s", "--source", required=True, type=str)
@@ -170,10 +85,11 @@ if __name__ == "__main__":
     parser.add_argument("-l", "--load_ply", default=None, type=str)
     parser.add_argument("--load_camera", default=None, type=str)
     parser.add_argument("--quantize", action='store_true')
+    parser.add_argument("--no_image_mask", action="store_true")
     parser.add_argument("--no_depth_data", action='store_true')
     parser.add_argument("--with_scale_reg", action="store_true")
     parser.add_argument("--load_quantized", default=None, type=str)
-    parser.add_argument("--mode", choices=list(basemodes.keys()) + list(cameramodes.keys()), default="densify-prune-shculling")
+    parser.add_argument("--mode", choices=list(modes), default="densify-prune-shculling")
     parser.add_argument("--save_iterations", nargs="+", type=int, default=[7000, 30000])
     parser.add_argument("--device", default="cuda", type=str)
     parser.add_argument("--empty_cache_every_step", action='store_true')
@@ -184,8 +100,10 @@ if __name__ == "__main__":
 
     configs = {o.split("=", 1)[0]: eval(o.split("=", 1)[1]) for o in args.option}
     dataset, gaussians, trainer, quantizer = prepare_training(
-        sh_degree=args.sh_degree, source=args.source, device=args.device, mode=args.mode,
-        load_ply=args.load_ply, load_camera=args.load_camera, load_depth=not args.no_depth_data, with_scale_reg=args.with_scale_reg,
+        sh_degree=args.sh_degree, source=args.source, device=args.device, mode=args.mode, trainable_camera="camera" in args.mode,
+        load_ply=args.load_ply, load_camera=args.load_camera,
+        load_mask=not args.no_image_mask, load_depth=not args.no_depth_data,
+        with_scale_reg=args.with_scale_reg,
         quantize=args.quantize, load_quantized=args.load_quantized, configs=configs)
     dataset.save_cameras(os.path.join(args.destination, "cameras.json"))
     torch.cuda.empty_cache()

{reduced_3dgs-1.9.1.dist-info → reduced_3dgs-1.10.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reduced_3dgs
-Version: 1.9.1
+Version: 1.10.12
 Summary: Refactored code for the paper "Reducing the Memory Footprint of 3D Gaussian Splatting"
 Home-page: https://github.com/yindaheng98/reduced-3dgs
 Author: yindaheng98
@@ -8,13 +8,8 @@ Author-email: yindaheng98@gmail.com
 Classifier: Programming Language :: Python :: 3
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: tqdm
-Requires-Dist: plyfile
-Requires-Dist: scikit-learn
-Requires-Dist: torch
-Requires-Dist: torchvision
-Requires-Dist: numpy
 Requires-Dist: gaussian-splatting
+Requires-Dist: scikit-learn
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -40,47 +35,35 @@ This repository contains the **refactored Python code for [Reduced-3DGS](https:/
 
 * [Pytorch](https://pytorch.org/) (v2.4 or higher recommended)
 * [CUDA Toolkit](https://developer.nvidia.com/cuda-12-4-0-download-archive) (12.4 recommended, should match with PyTorch version)
+* (Optional) [cuML](https://github.com/rapidsai/cuml) for faster vector quantization
 
-## Install (PyPI)
-
+(Optional) If you have trouble with [`gaussian-splatting`](https://github.com/yindaheng98/gaussian-splatting), try to install it from source:
 ```sh
-pip install --upgrade reduced-3dgs
+pip install wheel setuptools
+pip install --upgrade git+https://github.com/yindaheng98/gaussian-splatting.git@master --no-build-isolation
 ```
 
-## Install (Build from source)
-
-```sh
-pip install --upgrade git+https://github.com/yindaheng98/reduced-3dgs.git@main
-```
-If you have trouble with [`gaussian-splatting`](https://github.com/yindaheng98/gaussian-splatting), you can install it from source:
-```sh
-pip install --upgrade git+https://github.com/yindaheng98/gaussian-splatting.git@master
-```
+## PyPI Install
 
-## Install (Development)
-
-Install [`gaussian-splatting`](https://github.com/yindaheng98/gaussian-splatting).
-You can download the wheel from [PyPI](https://pypi.org/project/gaussian-splatting/):
 ```shell
-pip install --upgrade gaussian-splatting
+pip install --upgrade reduced-3dgs
 ```
-Alternatively, install the latest version from the source:
-```sh
-pip install --upgrade git+https://github.com/yindaheng98/gaussian-splatting.git@master
+or
+build latest from source:
+```shell
+pip install wheel setuptools
+pip install --upgrade git+https://github.com/yindaheng98/reduced-3dgs.git@main --no-build-isolation
 ```
 
+### Development Install
+
 ```shell
 git clone --recursive https://github.com/yindaheng98/reduced-3dgs
 cd reduced-3dgs
-pip install tqdm plyfile scikit-learn numpy tifffile triton xformers
+pip install scikit-learn
 pip install --target . --upgrade --no-deps .
 ```
 
-(Optional) If you prefer not to install `gaussian-splatting` in your environment, you can install it in your `reduced-3dgs` directory:
-```sh
-pip install --target . --no-deps --upgrade git+https://github.com/yindaheng98/gaussian-splatting.git@master
-```
-
 ## Quick Start
 
 1. Download the dataset (T&T+DB COLMAP dataset, size 650MB):

reduced_3dgs-1.10.12.dist-info/RECORD

@@ -0,0 +1,29 @@
+reduced_3dgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+reduced_3dgs/combinations.py,sha256=dRrtTIQLggUP22Olp0DVSlD0C8YDgnrpTlrCcGZyWM0,9441
+reduced_3dgs/prepare.py,sha256=MFUUckRHKfgcva4ZOBxfPFyE95N-OlCQLplpmEPuzOk,4440
+reduced_3dgs/quantize.py,sha256=BVqBb2tQgiP3hap5-OByD8VELtJJGfEeFzaVFyzCJZU,2572
+reduced_3dgs/train.py,sha256=P9GCoEVl_VGldKuA3ycj1nea5rTc3xqu_f02a8oe-Lc,6734
+reduced_3dgs/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=T3bwC1BQvTG47Ha-VCGjtTOPU81HYv7TCsa0lYAqVF4,1610752
+reduced_3dgs/diff_gaussian_rasterization/__init__.py,sha256=oV6JjTc-50MscX4XHeIWSgLr3l8Y25knBIs-0gRbJr4,7932
+reduced_3dgs/importance/__init__.py,sha256=neJsbY5cLikEGBQGdR4MjwCQ5VWVikT1357DwL0EtWU,289
+reduced_3dgs/importance/combinations.py,sha256=F9IYDZ6iquZw5Djn2An88dlp2MUGieAyuZyVaDZdSts,2962
+reduced_3dgs/importance/trainer.py,sha256=Sj4ORvoYtFT7z3hifzFZDfhFyqumHraXyk3vMVtk0AU,12661
+reduced_3dgs/importance/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=TLEsXJXzHr3fYCzE-P17gGkpoQ_X80LsvqCeT9vzchQ,1302016
+reduced_3dgs/importance/diff_gaussian_rasterization/__init__.py,sha256=Tix8auyXBb_QFQtXrV3sLE9kdnl5zgHH0BbqcFzDp84,12850
+reduced_3dgs/pruning/__init__.py,sha256=E_YxJ9cDV_B6EJbYUBEcuRYMIht_C72rI1VJUXFCLpM,201
+reduced_3dgs/pruning/combinations.py,sha256=xO39d08DEsDnKI5np_1xQ4H29O486Q_cThLfWhlH810,2385
+reduced_3dgs/pruning/trainer.py,sha256=JJml-uYfDfUpbsjRNZbIvnUYYslVgFXkhejbkYSo0s4,6542
+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=2myyBsYPGbzjZhjpKnYMYcvk6INqeds7wRdBRbIPki4,17948
+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=elGT2b5IdsO5qGhW0XBj_5qdUyJBNveMgEM6yVdoHiY,1248768
+reduced_3dgs-1.10.12.dist-info/licenses/LICENSE.md,sha256=LQ4_LAqlncGkg_mQy5ykMAFtQDSPB0eKmIEtBut0yjw,4916
+reduced_3dgs-1.10.12.dist-info/METADATA,sha256=7cQgH63LmWATezhRqXDPA6ytT_Ld9mYXKppGqvR8QTw,12404
+reduced_3dgs-1.10.12.dist-info/WHEEL,sha256=KUuBC6lxAbHCKilKua8R9W_TM71_-9Sg5uEP3uDWcoU,101
+reduced_3dgs-1.10.12.dist-info/top_level.txt,sha256=PpU5aT3-baSCdqCtTaZknoB32H93UeKCkYDkRCCZMEI,13
+reduced_3dgs-1.10.12.dist-info/RECORD,,

{reduced_3dgs-1.9.1.dist-info → reduced_3dgs-1.10.12.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_amd64
 

reduced_3dgs-1.9.1.dist-info/RECORD

@@ -1,28 +0,0 @@
-reduced_3dgs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-reduced_3dgs/combinations.py,sha256=FrZLxd3AZlHPSq_WJeEdGWH5zh40rAuV5txxr8HsSPY,7031
-reduced_3dgs/quantize.py,sha256=Y44qHyFdOIqke7NoeqXmyKloS43j-al74ZiNsuZZHbM,2527
-reduced_3dgs/train.py,sha256=jXHdXk05o_ebHjx_VBzcY6fRNn9EdKve6Tf5YC5an0o,9803
-reduced_3dgs/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=_DFCX447pmdRjDE8JsGkGYCo5-Q5YYk8ODuAql4tMUU,1618432
-reduced_3dgs/diff_gaussian_rasterization/__init__.py,sha256=oV6JjTc-50MscX4XHeIWSgLr3l8Y25knBIs-0gRbJr4,7932
-reduced_3dgs/importance/__init__.py,sha256=neJsbY5cLikEGBQGdR4MjwCQ5VWVikT1357DwL0EtWU,289
-reduced_3dgs/importance/combinations.py,sha256=Q2WqwXNuclPWBsw15aR14xQ72JewVeZo9igMeaSfuf8,2693
-reduced_3dgs/importance/trainer.py,sha256=ozzjPSXIpHNP4H1mkXlyAv5KJXWt1k4NKCikx9E9S1E,11151
-reduced_3dgs/importance/diff_gaussian_rasterization/_C.cp310-win_amd64.pyd,sha256=VrYLQY0VPX5jte3KXwGYyp7tuvDECMNVi0VaWfZp8yE,1308160
-reduced_3dgs/importance/diff_gaussian_rasterization/__init__.py,sha256=Tix8auyXBb_QFQtXrV3sLE9kdnl5zgHH0BbqcFzDp84,12850
-reduced_3dgs/pruning/__init__.py,sha256=E_YxJ9cDV_B6EJbYUBEcuRYMIht_C72rI1VJUXFCLpM,201
-reduced_3dgs/pruning/combinations.py,sha256=UivTfbSMmaWYVi9E4OF-_AZA-WBWniMiX-wKUftezF8,2331
-reduced_3dgs/pruning/trainer.py,sha256=898m5-7AZFmzQJtyMdQcInOZtDGsAeM3OAplHsm3oSY,6948
-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=pdtHUA8FOmQkP2L9f0yJs8b3KBcjyVjdwAwv2Om0rY4,1255424
-reduced_3dgs-1.9.1.dist-info/licenses/LICENSE.md,sha256=LQ4_LAqlncGkg_mQy5ykMAFtQDSPB0eKmIEtBut0yjw,4916
-reduced_3dgs-1.9.1.dist-info/METADATA,sha256=TIrUop8Y3QjsjnVAxNEGADwBMtVArYSbYhhzMYLWMYc,13014
-reduced_3dgs-1.9.1.dist-info/WHEEL,sha256=f7LviPjlKeAUpCmKrQrAXn06zBZT0604QctSZKHK6ZM,101
-reduced_3dgs-1.9.1.dist-info/top_level.txt,sha256=PpU5aT3-baSCdqCtTaZknoB32H93UeKCkYDkRCCZMEI,13
-reduced_3dgs-1.9.1.dist-info/RECORD,,