set sh degree as 0

arguments/__init__.py

@@ -46,7 +46,7 @@ class ParamGroup:
 
 class ModelParams(ParamGroup): 
     def __init__(self, parser, sentinel=False):
-        self.sh_degree = 3
+        self.sh_degree = 0
         self._source_path = ""
         self._model_path = ""
         self._images = "images"
@@ -91,7 +91,7 @@ class ModelParams(ParamGroup):
                 },
             'Gft':{
                 'head': ['xyz', 'scaling', 'rotation', 'opacity'],
-                'opt':['f_dc', 'f_rest', 'pc_feat']
+                'opt':['f_dc', 'pc_feat']   #, 'f_rest' delete for vis
                 },
             'Tft':{
                 'head': ['f_dc', 'f_rest'],

scene/gaussian_model.py

@@ -187,8 +187,8 @@ class GaussianModel:
     @property
     def get_features(self):
         features_dc = self._features_dc
-        features_rest = self._features_rest
-        return torch.cat((features_dc, features_rest), dim=1)
+        # features_rest = self._features_rest
+        return features_dc
 
     @property
     def get_opacity(self):
@@ -285,8 +285,8 @@ class GaussianModel:
         # All channels except the 3 DC
         for i in range(self._features_dc.shape[1]*self._features_dc.shape[2]):
             l.append('f_dc_{}'.format(i))
-        for i in range(self._features_rest.shape[1]*self._features_rest.shape[2]):
-            l.append('f_rest_{}'.format(i))
+        # for i in range(self._features_rest.shape[1]*self._features_rest.shape[2]):
+        #     l.append('f_rest_{}'.format(i))
         l.append('opacity')
         for i in range(self._scaling.shape[1]):
             l.append('scale_{}'.format(i))
@@ -300,7 +300,7 @@ class GaussianModel:
         xyz = self._xyz.detach().cpu().numpy()
         normals = np.zeros_like(xyz)
         f_dc = self._features_dc.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
-        f_rest = self._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
+        # f_rest = self._features_rest.detach().transpose(1, 2).flatten(start_dim=1).contiguous().cpu().numpy()
         opacities = self._opacity.detach().cpu().numpy()
         scale = self._scaling.detach().cpu().numpy()
         rotation = self._rotation.detach().cpu().numpy()
@@ -308,7 +308,7 @@ class GaussianModel:
         dtype_full = [(attribute, 'f4') for attribute in self.construct_list_of_attributes()]
 
         elements = np.empty(xyz.shape[0], dtype=dtype_full)
-        attributes = np.concatenate((xyz, normals, f_dc, f_rest, opacities, scale, rotation), axis=1)
+        attributes = np.concatenate((xyz, normals, f_dc, opacities, scale, rotation), axis=1)   # f_rest, 
         elements[:] = list(map(tuple, attributes))
         el = PlyElement.describe(elements, 'vertex')
         PlyData([el]).write(path)
@@ -331,7 +331,7 @@ class GaussianModel:
         features_dc[:, 1, 0] = np.asarray(plydata.elements[0]["f_dc_1"])
         features_dc[:, 2, 0] = np.asarray(plydata.elements[0]["f_dc_2"])
 
-        extra_f_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("f_rest_")]
+        # extra_f_names = [p.name for p in plydata.elements[0].properties if p.name.startswith("f_rest_")]
         extra_f_names = sorted(extra_f_names, key = lambda x: int(x.split('_')[-1]))
         assert len(extra_f_names)==3*(self.max_sh_degree + 1) ** 2 - 3
         features_extra = np.zeros((xyz.shape[0], len(extra_f_names)))
@@ -354,7 +354,7 @@ class GaussianModel:
 
         self._xyz = nn.Parameter(torch.tensor(xyz, dtype=torch.float, device="cuda").requires_grad_(True))
         self._features_dc = nn.Parameter(torch.tensor(features_dc, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True))
-        self._features_rest = nn.Parameter(torch.tensor(features_extra, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True))
+        # self._features_rest = nn.Parameter(torch.tensor(features_extra, dtype=torch.float, device="cuda").transpose(1, 2).contiguous().requires_grad_(True))
         self._opacity = nn.Parameter(torch.tensor(opacities, dtype=torch.float, device="cuda").requires_grad_(True))
         self._scaling = nn.Parameter(torch.tensor(scales, dtype=torch.float, device="cuda").requires_grad_(True))
         self._rotation = nn.Parameter(torch.tensor(rots, dtype=torch.float, device="cuda").requires_grad_(True))
@@ -526,7 +526,7 @@ class Feat2GaussianModel(GaussianModel):
         self.active_sh_degree = sh_degree
         self.sh_coeffs = ((sh_degree + 1) ** 2) * 3-3
         net_width = feat_dim
-        out_dim = {'xyz': 3, 'scaling': 3, 'rotation': 4, 'opacity': 1, 'f_dc': 3, 'f_rest': self.sh_coeffs}
+        out_dim = {'xyz': 3, 'scaling': 3, 'rotation': 4, 'opacity': 1, 'f_dc': 3}  # , 'f_rest': self.sh_coeffs
         for key in gs_params_group.get('head', []):
             setattr(self, f'head_{key}', conditionalWarp(layers=[feat_dim, net_width, out_dim[key]], skip=[]).cuda())
 
@@ -536,7 +536,7 @@ class Feat2GaussianModel(GaussianModel):
             'rotation': '_rotation', 
             'opacity': '_opacity', 
             'f_dc': '_features_dc', 
-            'f_rest': '_features_rest',
+            # 'f_rest': '_features_rest',
             'pc_feat': 'pc_feat',
             }
         
@@ -554,7 +554,7 @@ class Feat2GaussianModel(GaussianModel):
             self.active_sh_degree,
             self._xyz,
             self._features_dc,
-            self._features_rest,
+            # self._features_rest,
             self._scaling,
             self._rotation,
             self._opacity,
@@ -571,7 +571,7 @@ class Feat2GaussianModel(GaussianModel):
         (self.active_sh_degree,
         self._xyz,
         self._features_dc,
-        self._features_rest,
+        # self._features_rest,
         self._scaling,
         self._rotation,
         self._opacity,
@@ -598,8 +598,8 @@ class Feat2GaussianModel(GaussianModel):
 
             if key == 'f_dc':
                 self._features_dc = getattr(self, f'head_{key}')(feat_in, self.param_init[key].view(-1, 3)).reshape(-1, 1, 3)
-            elif key == 'f_rest':
-                self._features_rest = getattr(self, f'head_{key}')(feat_in.detach(), self.param_init[key].view(-1, self.sh_coeffs)).reshape(-1, self.sh_coeffs // 3, 3)
+            # elif key == 'f_rest':
+            #     self._features_rest = getattr(self, f'head_{key}')(feat_in.detach(), self.param_init[key].view(-1, self.sh_coeffs)).reshape(-1, self.sh_coeffs // 3, 3)
             else:
                 setattr(self, f'_{key}', getattr(self, f'head_{key}')(feat_in, self.param_init[key]))
 
@@ -661,7 +661,7 @@ class Feat2GaussianModel(GaussianModel):
             'rotation': rots,
             'opacity': opacities,
             'f_dc': features[:, :, 0:1].transpose(1, 2).contiguous(),
-            'f_rest': features[:, :, 1:].transpose(1, 2).contiguous(),
+            # 'f_rest': features[:, :, 1:].transpose(1, 2).contiguous(),
             'pc_feat': fused_point_feat,
         }
 
@@ -696,7 +696,7 @@ class Feat2GaussianModel(GaussianModel):
         self.param_lr = {
             "xyz": training_args.position_lr_init * self.spatial_lr_scale,
             "f_dc": training_args.feature_lr,
-            "f_rest": training_args.feature_sh_lr,
+            # "f_rest": training_args.feature_sh_lr,
             "opacity": training_args.opacity_lr,
             "scaling": training_args.scaling_lr,
             "rotation": training_args.rotation_lr