add sloth and axis

app.py

@@ -81,11 +81,9 @@ def fps(x, enabled, n, device, random_start=False):
 
 class DynamicsVisualizer:
 
-    def __init__(self):
-        self.width = 640
-        self.height = 480
-
-        best_models = {
+    def __init__(self, wp_device='cuda', torch_device='cuda'):
+        
+        self.best_models = {
             'cloth': ['cloth', 'train', 100000, [610, 650]],
             'rope': ['rope', 'train', 100000, [651, 691]],
             'paperbag': ['paperbag', 'train', 100000, [200, 220]],
@@ -93,16 +91,21 @@ class DynamicsVisualizer:
             'box': ['box', 'train', 100000, [306, 323]],
             'bread': ['bread', 'train', 100000, [143, 163]],
         }
-
         task_name = 'rope'
+        self.init(task_name)
 
-        with open(root / f'log/{best_models[task_name][0]}/{best_models[task_name][1]}/hydra.yaml', 'r') as f:
+    def init(self, task_name):
+        self.width = 640
+        self.height = 480
+        self.task_name = task_name
+
+        with open(root / f'log/{self.best_models[task_name][0]}/{self.best_models[task_name][1]}/hydra.yaml', 'r') as f:
             config = yaml.load(f, Loader=yaml.CLoader)
         cfg = OmegaConf.create(config)
 
-        cfg.iteration = best_models[task_name][2]
-        cfg.start_episode = best_models[task_name][3][0]
-        cfg.end_episode = best_models[task_name][3][1]
+        cfg.iteration = self.best_models[task_name][2]
+        cfg.start_episode = self.best_models[task_name][3][0]
+        cfg.end_episode = self.best_models[task_name][3][1]
         cfg.sim.num_steps = 1000
         cfg.sim.gripper_forcing = False
         cfg.sim.uniform = True
@@ -258,83 +261,6 @@ class DynamicsVisualizer:
             self.state['prev_key_pos'] = grippers[:, :3]  # (1, 3)
             # self.state['prev_key_pos_timestamp'] = torch.zeros(1).to(self.device).to(torch.float32)
             self.state['gripper_radius'] = cfg.model.gripper_radius
-
-    def load_params(self, params_path, remove_low_opa=True, remove_black=False):
-        pts, colors, scales, quats, opacities = read_splat(params_path)
-        
-        if remove_low_opa:
-            low_opa_idx = opacities[:, 0] < 0.1
-            pts = pts[~low_opa_idx]
-            colors = colors[~low_opa_idx]
-            quats = quats[~low_opa_idx]
-            opacities = opacities[~low_opa_idx]
-            scales = scales[~low_opa_idx]
-
-        if remove_black:
-            low_color_idx = colors.sum(axis=-1) < 0.5
-            pts = pts[~low_color_idx]
-            colors = colors[~low_color_idx]
-            quats = quats[~low_color_idx]
-            opacities = opacities[~low_color_idx]
-            scales = scales[~low_color_idx]
-        
-        self.params = {
-            'means3D': torch.from_numpy(pts).to(torch.float32).to(self.device),
-            'rgb_colors': torch.from_numpy(colors).to(torch.float32).to(self.device),
-            'log_scales': torch.log(torch.from_numpy(scales).to(torch.float32).to(self.device)),
-            'unnorm_rotations': torch.from_numpy(quats).to(torch.float32).to(self.device),
-            'logit_opacities': torch.logit(torch.from_numpy(opacities).to(torch.float32).to(self.device))
-        }
-
-        table_splat = root / 'log/gs/ckpts/table.splat'
-        sphere_splat = root / 'log/gs/ckpts/sphere.splat'
-        gripper_splat = root / 'log/gs/ckpts/gripper.splat'  # gripper_new.splat
-
-        table_params = read_splat(table_splat)  # numpy
-
-        ## add table and gripper
-        # add table
-        t_pts, t_colors, t_scales, t_quats, t_opacities = table_params
-        t_pts = torch.tensor(t_pts).to(torch.float32).to(self.device)
-        t_colors = torch.tensor(t_colors).to(torch.float32).to(self.device)
-        t_scales = torch.tensor(t_scales).to(torch.float32).to(self.device)
-        t_quats = torch.tensor(t_quats).to(torch.float32).to(self.device)
-        t_opacities = torch.tensor(t_opacities).to(torch.float32).to(self.device)
-
-        # add table pos
-        t_pts = t_pts + torch.tensor([0, 0, 0.02]).to(torch.float32).to(self.device)
-
-        # add gripper
-        gripper_params = read_splat(gripper_splat)  # numpy
-        
-        g_pts, g_colors, g_scales, g_quats, g_opacities = gripper_params
-        g_pts = torch.tensor(g_pts).to(torch.float32).to(self.device)
-        g_colors = torch.tensor(g_colors).to(torch.float32).to(self.device)
-        g_scales = torch.tensor(g_scales).to(torch.float32).to(self.device)
-        g_quats = torch.tensor(g_quats).to(torch.float32).to(self.device)
-        g_opacities = torch.tensor(g_opacities).to(torch.float32).to(self.device)
-
-        # we do not do the gripper translation now because this will center the gripper in the data frame but not the viewer frame
-
-        self.table_params = t_pts, t_colors, t_scales, t_quats, t_opacities  # data frame
-        self.gripper_params = g_pts, g_colors, g_scales, g_quats, g_opacities  # data frame
-
-        # load other info
-        n_particles = self.cfg.sim.n_particles
-        self.state['clip_bound'] = torch.tensor([self.cfg.model.clip_bound], dtype=torch.float32)
-        self.state['enabled'] = torch.ones(n_particles, dtype=torch.bool)
-
-    def set_camera(self, w, h, intr, w2c=None, R=None, t=None, near=0.01, far=100.0):
-        if w2c is None:
-            assert R is not None and t is not None
-            w2c = Rt_to_w2c(R, t)
-        self.metadata = {
-            'w': w,
-            'h': h,
-            'k': intr,
-            'w2c': w2c,
-        }
-        self.config = {'near': near, 'far': far}
     
     def load_eef(self, grippers=None, eef_t=None):
         assert self.state['prev_key_pos'] is None
@@ -453,7 +379,7 @@ class DynamicsVisualizer:
         self.colliders = colliders
         
         # load ckpt
-        ckpt_path = root / 'log/rope/train/ckpt/100000.pt'
+        ckpt_path = root / f'log/{self.task_name}/train/ckpt/100000.pt'
         ckpt = torch.load(ckpt_path, map_location=self.torch_device)
         
         material: nn.Module = PGNDModel(cfg)
@@ -704,6 +630,76 @@ class DynamicsVisualizer:
         t_pts = t_pts @ R_viewer.T
         t_quats = mat2quat(R_viewer @ quat2mat(t_quats))
         t_pts += t_viewer
+        
+        axes = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
+        dirs = [[1, 0, 0], [0, 0, -1], [0, 1, 0]]  # x, y, z axes
+        for ee in range(3):
+            gripper_direction = torch.tensor(dirs[ee], device=self.torch_device, dtype=t_pts.dtype).reshape(1, 3)
+            gripper_direction = gripper_direction / (torch.norm(gripper_direction, dim=-1, keepdim=True) + 1e-10)  # normalize
+
+            R = self.preprocess_metadata['R']
+            # model frame to data frame
+            direction = gripper_direction @ R.T
+
+            n_grippers = 1
+            N = 200
+            length = 0.2
+            kk = 5
+            xyz_test = torch.zeros((n_grippers, N + N // kk + N // kk, 3), device=self.torch_device, dtype=t_pts.dtype)
+
+            if self.task_name == 'rope':
+                pos = torch.tensor([0.0, 0.0, 1.2], device=self.torch_device, dtype=t_pts.dtype).reshape(1, 3)  # gripper position in model frame
+            else:
+                pos = torch.tensor([1.2, 0.0, 0.7], device=self.torch_device, dtype=t_pts.dtype).reshape(1, 3)
+            gripper_now_inv_xyz = self.inverse_preprocess_gripper(pos)
+            gripper_now_inv_rot = torch.eye(3, device=self.torch_device).unsqueeze(0).repeat(n_grippers, 1, 1)
+
+            center_point = torch.tensor([0.0, 0.0, 0.10], device=self.torch_device, dtype=t_pts.dtype).reshape(1, 3)  # center point in gripper frame
+            gripper_center_inv_xyz = gripper_now_inv_xyz + \
+                    torch.einsum('ijk,ik->ij', gripper_now_inv_rot, center_point)  # (n_grippers, 3)
+
+            for i in range(N):
+                offset = i / N * length * direction
+                xyz_test[:, i] = gripper_center_inv_xyz + offset
+            
+            if direction[0, 2] < 0.9 and direction[0, 2] > -0.9:  # not vertical
+                direction_up = -direction + torch.tensor([0.0, 0.0, 0.5], device=self.torch_device, dtype=t_pts.dtype)
+                direction_up = direction_up / (torch.norm(direction_up, dim=-1, keepdim=True) + 1e-10)  # normalize
+                direction_down = -direction + torch.tensor([0.0, 0.0, -0.5], device=self.torch_device, dtype=t_pts.dtype)
+                direction_down = direction_down / (torch.norm(direction_down, dim=-1, keepdim=True) + 1e-10)  # normalize
+            else:
+                direction_up = -direction + torch.tensor([0.0, 0.5, 0.0], device=self.torch_device, dtype=t_pts.dtype)
+                direction_up = direction_up / (torch.norm(direction_up, dim=-1, keepdim=True) + 1e-10)  # normalize
+                direction_down = -direction + torch.tensor([0.0, -0.5, 0.0], device=self.torch_device, dtype=t_pts.dtype)
+                direction_down = direction_down / (torch.norm(direction_down, dim=-1, keepdim=True) + 1e-10)  # normalize
+
+            for i in range(N, N + N // kk):
+                offset = length * direction + (i - N) / N * length * direction_up
+                xyz_test[:, i] = gripper_center_inv_xyz + offset
+            
+            for i in range(N + N // kk, N + N // kk + N // kk):
+                offset = length * direction + (i - N - N // kk) / N * length * direction_down
+                xyz_test[:, i] = gripper_center_inv_xyz + offset
+            
+            color_test = torch.zeros_like(xyz_test, device=self.torch_device, dtype=t_pts.dtype)
+            color_test[:, :, 0] = axes[ee][0]
+            color_test[:, :, 1] = axes[ee][1]
+            color_test[:, :, 2] = axes[ee][2]
+            quat_test = torch.zeros((n_grippers, N + N // kk + N // kk, 4), device=self.torch_device, dtype=t_pts.dtype)
+            quat_test[:, :, 0] = 1.0  # identity quaternion
+            opa_test = torch.ones((n_grippers, N + N // kk + N // kk, 1), device=self.torch_device, dtype=t_pts.dtype)
+            scales_test = torch.ones((n_grippers, N + N // kk + N // kk, 3), device=self.torch_device, dtype=t_pts.dtype) * 0.002
+            
+            t_pts = torch.cat([t_pts, xyz_test.reshape(-1, 3)], dim=0)
+            t_colors = torch.cat([t_colors, color_test.reshape(-1, 3)], dim=0)
+            t_quats = torch.cat([t_quats, quat_test.reshape(-1, 4)], dim=0)
+            t_opacities = torch.cat([t_opacities, opa_test.reshape(-1, 1)], dim=0)
+            t_scales = torch.cat([t_scales, scales_test.reshape(-1, 3)], dim=0)
+
+        t_pts = t_pts.reshape(-1, 3)
+        t_colors = t_colors.reshape(-1, 3)
+        t_quats = t_quats.reshape(-1, 4)
+        t_opacities = t_opacities.reshape(-1, 1)
 
         g_mat = quat2mat(g_quats)
         g_mat = R @ g_mat
@@ -720,7 +716,13 @@ class DynamicsVisualizer:
         # TODO: center gripper in the viewer frame
         g_pts_tip = g_pts[g_pts_tip_mask]
         g_pts_tip_mean_xy = g_pts_tip[:, :2].mean(dim=0)
-        g_pts_translation = torch.tensor([-g_pts_tip_mean_xy[0], -g_pts_tip_mean_xy[1], -0.23]).to(torch.float32).to(self.device)
+        
+        if self.task_name == 'rope':
+            g_pts_translation = torch.tensor([-g_pts_tip_mean_xy[0], -g_pts_tip_mean_xy[1], -0.23]).to(torch.float32).to(self.device)
+        elif self.task_name == 'sloth':
+            g_pts_translation = torch.tensor([-g_pts_tip_mean_xy[0], -g_pts_tip_mean_xy[1], -0.32]).to(torch.float32).to(self.device)
+        else:
+            raise NotImplementedError(f"Task {self.task_name} not implemented for gripper translation.")
         g_pts = g_pts + g_pts_translation
 
         self.table_params = t_pts, t_colors, t_scales, t_quats, t_opacities
@@ -882,7 +884,7 @@ class DynamicsVisualizer:
         center = (0, 0, 0.1)
         distance = 0.7
         elevation = 20
-        azimuth = 180.0
+        azimuth = 180.0 if self.task_name == 'rope' else 120.0
         target = np.array(center)
         theta = 90 + azimuth
         z = distance * math.sin(math.radians(elevation))
@@ -930,8 +932,9 @@ class DynamicsVisualizer:
 
         return rendervar_init
 
-    @spaces.GPU
-    def reset(self):
+    def reset(self, task_name, scene_name):
+        self.init(task_name)
+        
         import warp as wp
         wp.init()
         gpus = [int(gpu) for gpu in self.cfg.gpus]
@@ -942,7 +945,7 @@ class DynamicsVisualizer:
         self.wp_device = wp_devices[0]
         self.torch_device = torch_devices[0]
         
-        in_dir = root / 'log/gs/ckpts/rope_scene_1'
+        in_dir = root / f'log/gs/ckpts/{scene_name}'
         batch_size = 1
         num_steps = 1
         num_particles = self.cfg.sim.n_particles
@@ -1028,7 +1031,7 @@ class DynamicsVisualizer:
         center = (0, 0, 0.1)
         distance = 0.7
         elevation = 20
-        azimuth = 180.0
+        azimuth = 180.0 if self.task_name == 'rope' else 120.0
         target = np.array(center)
         theta = 90 + azimuth
         z = distance * math.sin(math.radians(elevation))
@@ -1191,6 +1194,14 @@ class DynamicsVisualizer:
             self.preprocess_metadata, self.state, self.params, \
             self.table_params, self.gripper_params, rendervar
     
+    @spaces.GPU
+    def reset_rope(self):
+        return self.reset('rope', 'rope_scene_1')
+
+    @spaces.GPU
+    def reset_plush(self):
+        return self.reset('sloth', 'sloth_scene_1')
+
     @spaces.GPU
     def on_click_run_xplus(self, preprocess_metadata, state, params, table_params, gripper_params, rendervar):
         return self.run_command([5.0, 0, 0], preprocess_metadata, state, params, table_params, gripper_params, rendervar)
@@ -1230,27 +1241,36 @@ class DynamicsVisualizer:
 
             with gr.Row():
                 gr.Markdown('### Project page: [https://kywind.github.io/pgnd](https://kywind.github.io/pgnd)')
-                
+            
+            with gr.Row():
+                gr.Markdown('### Instructions:')
+
             with gr.Row():
                 gr.Markdown(' '.join([
-                    'Instructions:\n',
-                    '- Click the "Reset" button to initialize the simulation with the predicted video and Gaussian splats. Due to compute limitations of Huggingface Space, each run may take a prolonged period (up to 30 seconds).\n',
+                    '- Click the "Reset-\<object\>" button to initialize the simulation with the predicted video and Gaussian splats. Due to compute limitations of Huggingface Space, each run may take a prolonged period (up to 30 seconds).\n',
                     '- Use the buttons to move the gripper in the x, y, z directions. The gripper will move for a fixed length per click. The predicted video and Gaussian splats will be updated accordingly.\n',
                     '- X-Y plane is the table surface, and Z is the height.\n',
                     '- The predicted video from the previous step to the current step will be shown in the "Predicted video" section.\n',
                     '- The Gaussian splats after the current step will be shown in the "Predicted Gaussians" section.\n',
-                    '- The simulation results may deviate from the initial shape due to accumulative prediction artifacts. Click the "Reset" button to reset the simulation state and reinitialize the predicted video and Gaussian splats.\n',
+                    '- The simulation results may deviate from the initial shape due to accumulative prediction artifacts. Click the Reset button to reset the simulation state and reinitialize the predicted video and Gaussian splats.\n',
                 ]))
-                
+            
+            with gr.Row():
+                gr.Markdown('### Select a scene to reset the simulation:')
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    with gr.Row():
+                        with gr.Column():
+                            run_reset_plush = gr.Button("Reset - Plush")
+                        with gr.Column():
+                            run_reset_rope = gr.Button("Reset - Rope")
+
+                with gr.Column(scale=2):
+                    _ = gr.Button(visible=False)  # empty placeholder
 
             with gr.Row():
                 
-                # with gr.Column(scale=2):
-                #     form_3dgs_orig = gr.Model3D(
-                #         label='Original Gaussian Splats',
-                #         value=None,
-                #     )
-                
                 with gr.Column(scale=2):
                     form_video = gr.Video(
                         label='Predicted video',
@@ -1269,10 +1289,11 @@ class DynamicsVisualizer:
                     )
 
             # Layout
+            with gr.Row():
+                gr.Markdown('### Control the gripper to move in the x, y, z directions:')
+            
             with gr.Row():
                 with gr.Column(scale=2):
-                    with gr.Row():
-                        run_reset = gr.Button("Reset")
 
                     with gr.Row():
                         with gr.Column():
@@ -1294,61 +1315,15 @@ class DynamicsVisualizer:
                 
                 with gr.Column(scale=2):
                     _ = gr.Button(visible=False)  # empty placeholder
-            
-            # with gr.Row():
-                
-            #     # with gr.Column(scale=2):
-            #     #     form_3dgs_orig = gr.Model3D(
-            #     #         label='Original Gaussian Splats',
-            #     #         value=None,
-            #     #     )
-                
-            #     with gr.Column(scale=2):
-            #         form_video_2 = gr.Video(
-            #             label='Predicted video',
-            #             value=None,
-            #             format='mp4',
-            #             width=self.width,
-            #             height=self.height,
-            #         )
-                
-            #     with gr.Column(scale=2):
-            #         form_3dgs_pred_2 = gr.Model3D(
-            #             label='Predicted Gaussians',
-            #             height=self.height,
-            #             value=None,
-            #             clear_color=[0, 0, 0, 0],
-            #         )
-
-            # # Layout
-            # with gr.Row():
-            #     with gr.Column(scale=2):
-            #         with gr.Row():
-            #             run_reset_2 = gr.Button("Reset")
-
-            #         with gr.Row():
-            #             with gr.Column():
-            #                 run_xminus_2 = gr.Button("x-")
-            #             with gr.Column():
-            #                 run_xplus_2 = gr.Button("x+")
-
-            #         with gr.Row():
-            #             with gr.Column():
-            #                 run_yminus_2 = gr.Button("y-")
-            #             with gr.Column():
-            #                 run_yplus_2 = gr.Button("y+")
-
-            #         with gr.Row():
-            #             with gr.Column():
-            #                 run_zminus_2 = gr.Button("z-")
-            #             with gr.Column():
-            #                 run_zplus_2 = gr.Button("z+")
-                
-            #     with gr.Column(scale=2):
-            #         _ = gr.Button(visible=False)  # empty placeholder
 
             # Set up callbacks
-            run_reset.click(self.reset,
+            run_reset_rope.click(self.reset_rope,
+                    inputs=[],
+                    outputs=[form_video, form_3dgs_pred, 
+                             preprocess_metadata, state, params,
+                             table_params, gripper_params, rendervar])
+            
+            run_reset_plush.click(self.reset_plush,
                     inputs=[],
                     outputs=[form_video, form_3dgs_pred, 
                              preprocess_metadata, state, params,
@@ -1396,35 +1371,6 @@ class DynamicsVisualizer:
                              preprocess_metadata, state, params,
                              table_params, gripper_params, rendervar])
 
-            # Set up callbacks
-            # run_reset_2.click(self.reset_2,
-            #         inputs=[],
-            #         outputs=[form_video_2, form_3dgs_pred_2])
-            
-            # run_xplus_2.click(self.on_click_run_xplus_2,
-            #         inputs=[],
-            #         outputs=[form_video_2, form_3dgs_pred_2])
-            
-            # run_xminus_2.click(self.on_click_run_xminus_2,
-            #         inputs=[],
-            #         outputs=[form_video_2, form_3dgs_pred_2])
-            
-            # run_yplus_2.click(self.on_click_run_yplus_2,
-            #         inputs=[],
-            #         outputs=[form_video_2, form_3dgs_pred_2])
-            
-            # run_yminus_2.click(self.on_click_run_yminus_2,
-            #         inputs=[],
-            #         outputs=[form_video_2, form_3dgs_pred_2])
-            
-            # run_zplus_2.click(self.on_click_run_zplus_2,
-            #         inputs=[],
-            #         outputs=[form_video_2, form_3dgs_pred_2])
-
-            # run_zminus_2.click(self.on_click_run_zminus_2,
-            #         inputs=[],
-            #         outputs=[form_video_2, form_3dgs_pred_2])
-
         app.launch(share=share)
 
 

src/experiments/log/gs/ckpts/sloth_scene_1/eef_xyz.txt

@@ -0,0 +1,3 @@
+-1.1209631912410259247e-02
+-0.754003190994262695e-02
+-1.769125705957412720e-01

src/experiments/log/gs/ckpts/sloth_scene_1/eef_xyz_old.txt

@@ -0,0 +1,3 @@
+-4.266144707798957825e-03
+-6.183005869388580322e-02
+-1.841607391834259033e-01

src/experiments/log/gs/ckpts/sloth_scene_1/gripper.splat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:893d6c2608a022685ab7cf8d044f044afe6eda3248d2baf1c1ac6d55160f1041
+size 1151264

src/experiments/log/gs/ckpts/sloth_scene_1/gripper_old.splat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:def7c4ecddf10a491a3717bbc271ab55b9ab35437452cf6d61666fa2ccbd7883
+size 1212288

src/experiments/log/gs/ckpts/sloth_scene_1/object.splat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:94110d55ce1ba8dd3021f70b3864b7b833f22cf94757b96640d8f9c74f0a2c1c
+size 4481248

src/experiments/log/gs/ckpts/sloth_scene_1/table.splat

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed2090607151595c8b4b7ec44ffde9196366c2201b3bbd21e03bf924cf54e29c
+size 7051104

src/experiments/log/gs/temp/gs_pred.splat

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:753a59d8cb6fb82e29d233db6865e6c6a87fabc5b469619e4310d3fbee619f6c
-size 7684352
+oid sha256:4d1d42fd7779673768a2604429439aba5c0228c08350d4c0173d6f7cce89a293
+size 12719456

src/experiments/log/sloth/train/ckpt/100000.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1ce7f86a40058c2680784ac40f633a67e00e9ce8af8a6111acc3362d71d3b052
+size 3374922

src/experiments/log/sloth/train/hydra.yaml

@@ -0,0 +1,95 @@
+model:
+  material:
+    requires_grad: true
+    output_scale: 1.0
+    input_scale: 2.0
+    radius: 0.2
+    absolute_y: false
+    pe_num_func_res: 0
+  friction:
+    value: 0.0
+    requires_grad: false
+  ckpt: null
+  clip_bound: 1.5
+  eef_t:
+  - 0.0
+  - 0.0
+  - 0.01
+  gripper_radius: 0.04
+render:
+  width: 512
+  height: 512
+  skip_frame: 1
+  bound: 1.5
+  fps: 5
+  radius_scale: 500
+  center:
+  - 0.5
+  - 0.3
+  - 0.5
+  distance: 1.4
+  azimuth: -125
+  elevation: 30
+  reflectance:
+  - 0.92941176
+  - 0.32941176
+  - 0.23137255
+sim:
+  num_steps_train: 5
+  num_steps: 1000
+  interval: 1
+  num_grids:
+  - 50
+  - 50
+  - 50
+  - 0.02
+  dt: 0.1
+  bound: 3
+  eps: 1.0e-07
+  skip_frame: 1
+  num_grippers: 1
+  preprocess_scale: 1.0
+  preprocess_with_table: true
+  n_particles: 1000
+  gripper_forcing: true
+  gripper_points: false
+  n_history: 2
+  uniform: false
+train:
+  name: sloth/train
+  dataset_name: sloth/dataset
+  source_dataset_name: data/sloth_merged/sub_episodes_v
+  num_iterations: 100000
+  resume_iteration: 0
+  batch_size: 32
+  num_workers: 8
+  material_lr: 0.0001
+  material_wd: 0.0
+  material_grad_max_norm: 0.1
+  training_start_episode: 0
+  training_end_episode: 113
+  eval_start_episode: 113
+  eval_end_episode: 133
+  iteration_log_interval: 10
+  iteration_save_interval: 1000
+  iteration_eval_interval: 10000
+  loss_factor: 1.0
+  loss_factor_v: 0.0
+  loss_factor_x: 100.0
+  friction_lr: 0.1
+  friction_wd: 0.0
+  friction_grad_max_norm: 0.1
+  dataset_load_skip_frame: 3
+  dataset_skip_frame: 1
+  downsample: false
+  use_pv: false
+  use_gs: false
+  dataset_non_overwrite: true
+seed: 0
+cpu: 0
+num_cpus: 128
+gpus:
+- 0
+overwrite: false
+resume: true
+debug: false