Try to fix the gpu aborted problem : processing on downsampled meshes during optimization

app.py

@@ -241,7 +241,7 @@ def run_clicked(mesh1_path, mesh2_path, yaml_path, lambda_val, zoomout_val, time
     with torch.no_grad():
         n_fmap = C12_new.shape[-1]
         C12_all = C_up.squeeze()[:n_fmap, :n_fmap] @ C12_new.clone().squeeze() @ C_down.squeeze()[:n_fmap, :n_fmap]
-        C12_end_zo = torch_zoomout(evecs1, evecs2, evecs_2trans, C12_all, matcher.cfg.sds_conf.zoomout)
+        C12_end_zo = torch_zoomout(evecs1, evecs2, evecs_2trans, C12_all, 50)
         p2p_zo, _ = extract_p2p_torch_fmap(C12_end_zo, evecs1, evecs2)
     return build_outputs(datadicts.shape_surf, datadicts.target_surf, datadicts.cmap1, p2p_zo, tag="run")
 

notebook_helpers.py

@@ -21,7 +21,7 @@ def load_data(file, cache_path, name, num_evecs=128, make_cache=False):
     if not os.path.exists(cache_path) or make_cache:
         print("Computing operators ...")
         vnormals = surf.computeVertexNormals()
-        get_operators(surf.vertices, surf.faces, num_evecs, cache_path, vnormals)
+        get_operators(surf.vertices, surf.faces, 50, cache_path, vnormals)
         vnormals_down = surf_down.computeVertexNormals()
         get_operators(surf_down.vertices, surf_down.faces, num_evecs, cache_down, vnormals_down)
     data_dict = load_operators(cache_path)

utils/geometry.py

@@ -386,11 +386,7 @@ def compute_operators(verts, faces, k_eig, normals=None, normalize_desc=True):
     gradX = sparse_np_to_torch(gradX_np).to(device=device, dtype=dtype)
     gradY = sparse_np_to_torch(gradY_np).to(device=device, dtype=dtype)
 
-    hks = torch.from_numpy(compute_hks(evecs_np, evals_np, massvec_np, n_descr=128, subsample_step=1, n_eig=128, normalize=normalize_desc)).to(device=device, dtype=dtype)
-    wks = torch.from_numpy(compute_wks(evecs_np, evals_np, massvec_np, n_descr=128, subsample_step=1, n_eig=128, normalize=normalize_desc)).to(device=device, dtype=dtype)
-
-
-    return frames, massvec, L, evals, evecs, gradX, gradY, hks, wks
+    return frames, massvec, L, evals, evecs, gradX, gradY
 
 
 def get_all_operators(verts_list, faces_list, k_eig, op_cache_dir=None, normals=None):
@@ -514,8 +510,6 @@ def get_operators(verts, faces, k_eig=128, cache_path=None, normals=None, overwr
                 evecs = npzfile["evecs"][:, :k_eig]
                 gradX = read_sp_mat("gradX")
                 gradY = read_sp_mat("gradY")
-                frames = npzfile["hks"]
-                mass = npzfile["wks"]
 
                 frames = torch.from_numpy(frames).to(device=device, dtype=dtype)
                 mass = torch.from_numpy(mass).to(device=device, dtype=dtype)
@@ -541,7 +535,7 @@ def get_operators(verts, faces, k_eig=128, cache_path=None, normals=None, overwr
     if not found:
 
         # No matching entry found; recompute.
-        frames, mass, L, evals, evecs, gradX, gradY, hks, wks = compute_operators(verts, faces, k_eig, normals=normals)
+        frames, mass, L, evals, evecs, gradX, gradY = compute_operators(verts, faces, k_eig, normals=normals)
 
         dtype_np = np.float32
 
@@ -572,11 +566,10 @@ def get_operators(verts, faces, k_eig=128, cache_path=None, normals=None, overwr
                 gradY_data=gradY_np.data.astype(dtype_np),
                 gradY_indices=gradY_np.indices,
                 gradY_indptr=gradY_np.indptr,
-                gradY_shape=gradY_np.shape,
-                wks=wks
+                gradY_shape=gradY_np.shape
             )
 
-    return frames, mass, L, evals, evecs, gradX, gradY, wks
+    return frames, mass, L, evals, evecs, gradX, gradY
 
 
 def load_operators(filepath):
@@ -602,8 +595,7 @@ def load_operators(filepath):
         evals=npzfile['evals'],
         evecs=npzfile['evecs'],
         gradX=read_sp_mat('gradX'),
-        gradY=read_sp_mat('gradY'),
-        wks=npzfile['wks'], 
+        gradY=read_sp_mat('gradY')
     )