CPU storage, GPU ad-hoc

pbnr_pytorch/scene_loaders/ibr_scene.py

@@ -59,12 +59,12 @@ class Camera(nn.Module):
         self.FoVx = FoVx
         self.FoVy = FoVy
 
-        self.original_image = image.clamp(0.0, 1.0).cuda()
+        self.original_image = image.clamp(0.0, 1.0)
         if loaded_optimizedimages is not None:
             self.image = nn.Parameter(loaded_optimizedimages.requires_grad_(True))
         else:
             image = image.clamp(0.0, 1.0)
-            self.image = nn.Parameter(image.cuda().requires_grad_(True))
+            self.image = nn.Parameter(image.requires_grad_(True))
 
         self.image_width = self.image.shape[3]
         self.image_height = self.image.shape[2]
@@ -74,30 +74,30 @@ class Camera(nn.Module):
         if loaded_expcoefs is not None:
             self.exposure_coef = nn.Parameter(loaded_expcoefs.requires_grad_(True))
         else:
-            self.exposure_coef = nn.Parameter(torch.ones(1, device="cuda").requires_grad_(True))
+            self.exposure_coef = nn.Parameter(torch.ones(1).requires_grad_(True))
 
         if loaded_uncertainty is not None:
             self.uncertainty_map = nn.Parameter(loaded_uncertainty.requires_grad_(True))
         else:
-            self.uncertainty_map = nn.Parameter(0.5*torch.ones(self.image_height*self.image_width, 1, device="cuda").requires_grad_(True))
+            self.uncertainty_map = nn.Parameter(0.5*torch.ones(self.image_height*self.image_width, 1).requires_grad_(True))
 
         if loaded_extrafeatures is not None:
             self.extra_features = nn.Parameter(loaded_extrafeatures.requires_grad_(True))
         else:
-            self.extra_features = nn.Parameter(torch.zeros(1, extra_features, self.image_height, self.image_width, device="cuda").requires_grad_(True))
+            self.extra_features = nn.Parameter(torch.zeros(1, extra_features, self.image_height, self.image_width).requires_grad_(True))
 
-        self.point_grid = getNormalisedImageGrid(self.image_height, self.image_width).cuda()
+        self.point_grid = getNormalisedImageGrid(self.image_height, self.image_width)
 
-        self.depth_map = loaded_depthmap.cuda()
+        self.depth_map = loaded_depthmap
         if loaded_depthdelta is not None:
             self.depth_delta = nn.Parameter(loaded_depthdelta.requires_grad_(True))
         else:
-            self.depth_delta = nn.Parameter(torch.zeros_like(self.depth_map, device="cuda").requires_grad_(True))
+            self.depth_delta = nn.Parameter(torch.zeros_like(self.depth_map).requires_grad_(True))
 
         if loaded_normaldelta is not None:
-            self.normal_map = nn.Parameter(loaded_normaldelta.cuda().requires_grad_(True))
+            self.normal_map = nn.Parameter(loaded_normaldelta.requires_grad_(True))
         else:
-            self.normal_map = nn.Parameter(loaded_normalmap.cuda().requires_grad_(True))
+            self.normal_map = nn.Parameter(loaded_normalmap.requires_grad_(True))
 
         self.zfar = self.getDepth().max()*2.0
         try:

pbnr_pytorch/test_render_and_save.py

@@ -93,10 +93,10 @@ with torch.no_grad():
     with open(args.input_path) as json_file:
         input_json = json.load(json_file)
     
-    input_json["neural_weights_folder"] = "/data/graphdeco/user/gkopanas/pointbased_neural_rendering/pbnr_pytorch/tensorboard_3d/" + dataset_name + "_final/neural_renderer"
-    input_json["scenes"][0]["scene_representation_folder"] = "/data/graphdeco/user/gkopanas/pointbased_neural_rendering/pbnr_pytorch/tensorboard_3d/" + dataset_name + "_final/" + dataset_name
+    input_json["neural_weights_folder"] = "/data/graphdeco/user/gkopanas/pointbased_neural_rendering/pbnr_pytorch/tensorboard_3d/" + dataset_name + "_final2/neural_renderer"
+    input_json["scenes"][0]["scene_representation_folder"] = "/data/graphdeco/user/gkopanas/pointbased_neural_rendering/pbnr_pytorch/tensorboard_3d/" + dataset_name + "_final2/" + dataset_name
 
-    for load_iter in [20000, 40000, 60000, 80000, 100000]:
+    for load_iter in [100000]:
         print("Load Iter {}:".format(load_iter))
         neural_renderer = torch.jit.load(os.path.join(input_json.get("neural_weights_folder"), "model_" + str(load_iter)))
 
@@ -104,7 +104,7 @@ with torch.no_grad():
                            args.max_radius, args.extra_features,
                            int(args.test_cameras), load_iter)
 
-        output = "/data/graphdeco/user/gkopanas/pointbased_neural_rendering/pbnr_pytorch/tensorboard_3d/" + dataset_name + "_final/backlisted_renders_{}_{}_".format(args.w, args.h) + str(load_iter)
+        output = "/data/graphdeco/user/gkopanas/pointbased_neural_rendering/pbnr_pytorch/tensorboard_3d/" + dataset_name + "_final2/backlisted_renders_{}_{}_".format(args.w, args.h) + str(load_iter)
         makedirs(output, exist_ok=True)
 
         imgs = torch.tensor([])
@@ -120,11 +120,11 @@ with torch.no_grad():
             torchvision.utils.save_image(view_cam.image,
                                          os.path.join(output, "gt_{}.png".format(view_cam.image_name)))
             imgs = torch.cat((imgs, image.cpu()), dim=0)
-            gts = torch.cat((gts, view_cam.image), dim=0)
+            gts = torch.cat((gts, view_cam.image.cpu()), dim=0)
 
-        num_psnr = psnr(imgs, gts)
-        print(num_psnr)
-        f = open(os.path.join(output, "psnr.txt"), "w")
-        f.write("PSNR: {}".format(num_psnr))
-        f.close()
+        #num_psnr = psnr(imgs, gts)
+        #print(num_psnr)
+        #f = open(os.path.join(output, "psnr.txt"), "w")
+        #f.write("PSNR: {}".format(num_psnr))
+        #f.close()
 

pbnr_pytorch/train_full_pipeline.py

@@ -50,7 +50,7 @@ def render_viewpoint(viewpoint_camera, pcloud_cameras, patch=None, gamma=1.0):
         features_stack = torch.cat((features_stack, rendered_point_cloud), dim=0)
         depth_gmms_stack = torch.cat((depth_gmms_stack, depth_gmms), dim=0)
         num_gmms_stack = torch.cat((num_gmms_stack, num_gmms.int()), dim=0)
-        l2_stack = torch.cat((l2_stack, torch.nn.functional.mse_loss(rendered_point_cloud[:,:3,:,:], crop_image(viewpoint_camera.image, patch)*blend_scores).unsqueeze(0)), dim=0)
+        l2_stack = torch.cat((l2_stack, torch.nn.functional.mse_loss(rendered_point_cloud[:,:3,:,:], crop_image(viewpoint_camera.image, patch).cuda()*blend_scores).unsqueeze(0)), dim=0)
     color_stack = color_stack.view(color_stack.shape[0], -1, 3, color_stack.shape[2], color_stack.shape[3])
 
     with torch.no_grad():
@@ -207,7 +207,7 @@ while True:
     with torch.no_grad():
         if not viewpoint_stack:
             viewpoint_stack = scene.getAllTrainCameras().copy()
-        if iteration%10000==0:
+        if iteration%20000==0:
             print("[ITER {}]Saving Model...".format(iteration))
             mkdir_p("./{}/neural_renderer/".format(tensorboard_folder))
             neural_renderer.save("./{}/neural_renderer/model_{}".format(tensorboard_folder, iteration))