Try this wheels

demo/gs_train.py

@@ -12,6 +12,7 @@ from demo_globals import DEVICE
 import spaces
 from simple_knn._C import distCUDA2
 
+
 @dataclass
 class PipelineParams:
     convert_SHs_python: bool = False
@@ -78,7 +79,7 @@ def train(
 
         # Import necessary modules from the gaussian-splatting directory
         from utils.loss_utils import l1_loss, ssim
-        from gaussian_renderer import render
+        # from gaussian_renderer import render
         from scene import Scene, GaussianModel
         from utils.general_utils import safe_state
         from utils.image_utils import psnr
@@ -132,6 +133,114 @@ def train(
         random_background=random_background
     )
 
+
+    #
+    # 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  [email protected]
+    #
+    print("local_renderer")
+    import torch
+    import math
+    from diff_gaussian_rasterization import GaussianRasterizationSettings, GaussianRasterizer
+    from scene.gaussian_model import GaussianModel
+    from utils.sh_utils import eval_sh
+
+    def render(viewpoint_camera, pc : GaussianModel, pipe, bg_color : torch.Tensor, scaling_modifier = 1.0, override_color = None):
+        """
+        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(pc.get_xyz, dtype=pc.get_xyz.dtype, requires_grad=True, device="cuda") + 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)
+
+        kernel_size = 0.1
+        subpixel_offset = torch.zeros((int(viewpoint_camera.image_height), int(viewpoint_camera.image_width), 2), dtype=torch.float32, device="cuda")
+
+        raster_settings = GaussianRasterizationSettings(
+            image_height=int(viewpoint_camera.image_height),
+            image_width=int(viewpoint_camera.image_width),
+            tanfovx=tanfovx,
+            tanfovy=tanfovy,
+            kernel_size=kernel_size,
+            subpixel_offset=subpixel_offset,
+            bg=bg_color,
+            scale_modifier=scaling_modifier,
+            viewmatrix=viewpoint_camera.world_view_transform,
+            projmatrix=viewpoint_camera.full_proj_transform,
+            sh_degree=pc.active_sh_degree,
+            campos=viewpoint_camera.camera_center,
+            prefiltered=False,
+            debug=pipe.debug
+        )
+
+        rasterizer = GaussianRasterizer(raster_settings=raster_settings)
+
+        means3D = pc.get_xyz
+        means2D = screenspace_points
+        opacity = pc.get_opacity
+
+        # If precomputed 3d covariance is provided, use it. If not, then it will be computed from
+        # scaling / rotation by the rasterizer.
+        scales = None
+        rotations = None
+        cov3D_precomp = None
+        if pipe.compute_cov3D_python:
+            cov3D_precomp = pc.get_covariance(scaling_modifier)
+        else:
+            scales = pc.get_scaling
+            rotations = pc.get_rotation
+
+        # If precomputed colors are provided, use them. Otherwise, if it is desired to precompute colors
+        # from SHs in Python, do it. If not, then SH -> RGB conversion will be done by rasterizer.
+        shs = None
+        colors_precomp = None
+        if override_color is None:
+            if pipe.convert_SHs_python:
+                shs_view = pc.get_features.transpose(1, 2).view(-1, 3, (pc.max_sh_degree+1)**2)
+                dir_pp = (pc.get_xyz - viewpoint_camera.camera_center.repeat(pc.get_features.shape[0], 1))
+                dir_pp_normalized = dir_pp/dir_pp.norm(dim=1, keepdim=True)
+                sh2rgb = eval_sh(pc.active_sh_degree, shs_view, dir_pp_normalized)
+                colors_precomp = torch.clamp_min(sh2rgb + 0.5, 0.0)
+            else:
+                shs = pc.get_features
+        else:
+            colors_precomp = override_color
+
+        # Rasterize visible Gaussians to image, obtain their radii (on screen). 
+        rendered_image, radii = rasterizer(
+            means3D = means3D,
+            means2D = means2D,
+            shs = shs,
+            colors_precomp = colors_precomp,
+            opacities = opacity,
+            scales = scales,
+            rotations = rotations,
+            cov3D_precomp = cov3D_precomp)
+
+        # 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}
+
+
     args = TrainingArgs()
 
     testing_iterations = args.test_iterations
@@ -280,8 +389,8 @@ def train(
             view.projection_matrix = getProjectionMatrix(znear=view.znear, zfar=view.zfar, fovX=view.FoVx, fovY=view.FoVy).transpose(0,1).cuda().float()
             view.full_proj_transform = (view.world_view_transform.unsqueeze(0).bmm(view.projection_matrix.unsqueeze(0))).squeeze(0)
 
-            print("background.device: ", background.device)
-            print("view.device: ", view.original_image.device)
+            # print("background.device: ", background.device)
+            # print("view.device: ", view.original_image.device)
             render_pkg = render(view, gaussians, pipeline, background)
             rendering = render_pkg["render"]
             torchvision.utils.save_image(rendering, os.path.join(render_path, '{0:05d}'.format(idx) + ".png"))

requirements.txt

@@ -33,4 +33,4 @@ ipywidgets
 jupyterlab
 sql
 
-https://huggingface.co/spaces/ostapagon/mast3r-3dgs/resolve/main/wheels/diff_gaussian_rasterization-0.0.0-cp310-cp310-linux_x86_64.whl?download=true
+https://huggingface.co/spaces/JeffreyXiang/TRELLIS/resolve/main/wheels/diff_gaussian_rasterization-0.0.0-cp310-cp310-linux_x86_64.whl?download=true