update playground

app.py

@@ -2455,7 +2455,7 @@ with demo:
             return inspect_output_row, output_tree_image, heatmap_gallery, text_block
         
         gr.Markdown('---')
-        MAX_ROWS = 100
+        MAX_ROWS = 10
         current_output_row = gr.State(MAX_ROWS-1)
         inspect_output_rows, output_tree_images, heatmap_galleries, text_blocks = [], [], [], []
         for i_row in range(MAX_ROWS, 0, -1):
@@ -4049,275 +4049,275 @@ with demo:
                     outputs=[mask_gallery, crop_gallery])
                 
     
-    with gr.Tab('PlayGround (test)', visible=False) as test_playground_tab:
-        eigvecs = gr.State(np.array([]))
-        with gr.Row():
-            with gr.Column(scale=5, min_width=200):
-                gr.Markdown("### Step 1: Load Images and Run NCUT")
-                input_gallery, submit_button, clear_images_button, dataset_dropdown, num_images_slider, random_seed_slider, load_images_button = make_input_images_section(n_example_images=100)
-                # submit_button.visible = False
-                num_images_slider.value = 30
-                [
-                    model_dropdown, layer_slider, node_type_dropdown, num_eig_slider, 
-                    affinity_focal_gamma_slider, num_sample_ncut_slider, ncut_knn_slider, ncut_indirect_connection, ncut_make_orthogonal, 
-                    embedding_method_dropdown, embedding_metric_dropdown, num_sample_tsne_slider, knn_tsne_slider, 
-                    perplexity_slider, n_neighbors_slider, min_dist_slider, 
-                    sampling_method_dropdown, ncut_metric_dropdown, positive_prompt, negative_prompt
-                ] = make_parameters_section(ncut_parameter_dropdown=False)
-                num_eig_slider.value = 1000
-                num_eig_slider.visible = False
-                logging_text = gr.Textbox("Logging information", label="Logging", elem_id="logging", type="text", placeholder="Logging information", autofocus=False, autoscroll=False)
+    # with gr.Tab('PlayGround (test)', visible=False) as test_playground_tab:
+    #     eigvecs = gr.State(np.array([]))
+    #     with gr.Row():
+    #         with gr.Column(scale=5, min_width=200):
+    #             gr.Markdown("### Step 1: Load Images and Run NCUT")
+    #             input_gallery, submit_button, clear_images_button, dataset_dropdown, num_images_slider, random_seed_slider, load_images_button = make_input_images_section(n_example_images=100)
+    #             # submit_button.visible = False
+    #             num_images_slider.value = 30
+    #             [
+    #                 model_dropdown, layer_slider, node_type_dropdown, num_eig_slider, 
+    #                 affinity_focal_gamma_slider, num_sample_ncut_slider, ncut_knn_slider, ncut_indirect_connection, ncut_make_orthogonal, 
+    #                 embedding_method_dropdown, embedding_metric_dropdown, num_sample_tsne_slider, knn_tsne_slider, 
+    #                 perplexity_slider, n_neighbors_slider, min_dist_slider, 
+    #                 sampling_method_dropdown, ncut_metric_dropdown, positive_prompt, negative_prompt
+    #             ] = make_parameters_section(ncut_parameter_dropdown=False)
+    #             num_eig_slider.value = 1000
+    #             num_eig_slider.visible = False
+    #             logging_text = gr.Textbox("Logging information", label="Logging", elem_id="logging", type="text", placeholder="Logging information", autofocus=False, autoscroll=False)
                 
-                false_placeholder = gr.Checkbox(label="False", value=False, elem_id="false_placeholder", visible=False)
-                no_prompt = gr.Textbox("", label="", elem_id="empty_placeholder", type="text", placeholder="", visible=False)
+    #             false_placeholder = gr.Checkbox(label="False", value=False, elem_id="false_placeholder", visible=False)
+    #             no_prompt = gr.Textbox("", label="", elem_id="empty_placeholder", type="text", placeholder="", visible=False)
                 
-                submit_button.click(
-                    partial(run_fn, n_ret=1, only_eigvecs=True),
-                    inputs=[
-                        input_gallery, model_dropdown, layer_slider, num_eig_slider, node_type_dropdown, 
-                        positive_prompt, negative_prompt,
-                        false_placeholder, no_prompt, no_prompt, no_prompt,
-                        affinity_focal_gamma_slider, num_sample_ncut_slider, ncut_knn_slider, ncut_indirect_connection, ncut_make_orthogonal, 
-                        embedding_method_dropdown, embedding_metric_dropdown, num_sample_tsne_slider, knn_tsne_slider, 
-                        perplexity_slider, n_neighbors_slider, min_dist_slider, sampling_method_dropdown, ncut_metric_dropdown
-                    ],
-                    outputs=[eigvecs, logging_text],
-                )
+    #             submit_button.click(
+    #                 partial(run_fn, n_ret=1, only_eigvecs=True),
+    #                 inputs=[
+    #                     input_gallery, model_dropdown, layer_slider, num_eig_slider, node_type_dropdown, 
+    #                     positive_prompt, negative_prompt,
+    #                     false_placeholder, no_prompt, no_prompt, no_prompt,
+    #                     affinity_focal_gamma_slider, num_sample_ncut_slider, ncut_knn_slider, ncut_indirect_connection, ncut_make_orthogonal, 
+    #                     embedding_method_dropdown, embedding_metric_dropdown, num_sample_tsne_slider, knn_tsne_slider, 
+    #                     perplexity_slider, n_neighbors_slider, min_dist_slider, sampling_method_dropdown, ncut_metric_dropdown
+    #                 ],
+    #                 outputs=[eigvecs, logging_text],
+    #             )
                 
-            with gr.Column(scale=5, min_width=200):
-                gr.Markdown("### Step 2a: Pick an Image")
-                from gradio_image_prompter import ImagePrompter
-                with gr.Row():
-                    image1_slider = gr.Slider(0, 100, step=1, label="Image#1 Index", value=0, elem_id="image1_slider", interactive=True)
-                load_one_image_button = gr.Button("🔴 Load", elem_id="load_one_image_button", variant='primary')
-                gr.Markdown("### Step 2b: Draw a Point")
-                gr.Markdown("""
-                    <h5>
-                    🖱️ Left Click: Foreground </br>
-                    </h5>
-                """)
-                prompt_image1 = ImagePrompter(show_label=False, elem_id="prompt_image1", interactive=False)
-                def update_prompt_image(original_images, index):
-                    images = original_images
-                    if images is None:
-                        return 
-                    total_len = len(images)
-                    if total_len == 0:
-                        return 
-                    if index >= total_len:
-                        index = total_len - 1
+    #         with gr.Column(scale=5, min_width=200):
+    #             gr.Markdown("### Step 2a: Pick an Image")
+    #             from gradio_image_prompter import ImagePrompter
+    #             with gr.Row():
+    #                 image1_slider = gr.Slider(0, 100, step=1, label="Image#1 Index", value=0, elem_id="image1_slider", interactive=True)
+    #             load_one_image_button = gr.Button("🔴 Load", elem_id="load_one_image_button", variant='primary')
+    #             gr.Markdown("### Step 2b: Draw a Point")
+    #             gr.Markdown("""
+    #                 <h5>
+    #                 🖱️ Left Click: Foreground </br>
+    #                 </h5>
+    #             """)
+    #             prompt_image1 = ImagePrompter(show_label=False, elem_id="prompt_image1", interactive=False)
+    #             def update_prompt_image(original_images, index):
+    #                 images = original_images
+    #                 if images is None:
+    #                     return 
+    #                 total_len = len(images)
+    #                 if total_len == 0:
+    #                     return 
+    #                 if index >= total_len:
+    #                     index = total_len - 1
                                             
-                    return ImagePrompter(value={'image': images[index][0], 'points': []}, interactive=True)
-                    # return gr.Image(value=images[index][0], elem_id=f"prompt_image{randint}", interactive=True)
-                load_one_image_button.click(update_prompt_image, inputs=[input_gallery, image1_slider], outputs=[prompt_image1])
+    #                 return ImagePrompter(value={'image': images[index][0], 'points': []}, interactive=True)
+    #                 # return gr.Image(value=images[index][0], elem_id=f"prompt_image{randint}", interactive=True)
+    #             load_one_image_button.click(update_prompt_image, inputs=[input_gallery, image1_slider], outputs=[prompt_image1])
                 
-            child_idx = gr.State([])
-            current_idx = gr.State(None)
-            n_eig = gr.State(64)
-            with gr.Column(scale=5, min_width=200):
-                gr.Markdown("### Step 3: Check groupping")
-                child_distance_slider = gr.Slider(0, 0.5, step=0.001, label="Child Distance", value=0.1, elem_id="child_distance_slider", interactive=True)
-                overlay_image_checkbox = gr.Checkbox(label="Overlay Image", value=True, elem_id="overlay_image_checkbox", interactive=True)
-                run_button = gr.Button("🔴 RUN", elem_id="run_groupping", variant='primary')
-                parent_plot = gr.Gallery(value=None, label="Parent", show_label=True, elem_id="parent_plot", interactive=False, rows=[1], columns=[2])
-                parent_button = gr.Button("Use Parent", elem_id="run_parent")
-                current_plot = gr.Gallery(value=None, label="Current", show_label=True, elem_id="current_plot", interactive=False, rows=[1], columns=[2])
-            with gr.Column(scale=5, min_width=200):
-                child_plots = []
-                child_buttons = []
-                for i in range(4):
-                    child_plots.append(gr.Gallery(value=None, label=f"Child {i}", show_label=True, elem_id=f"child_plot_{i}", interactive=False, rows=[1], columns=[2]))
-                    child_buttons.append(gr.Button(f"Use Child {i}", elem_id=f"run_child_{i}"))
+    #         child_idx = gr.State([])
+    #         current_idx = gr.State(None)
+    #         n_eig = gr.State(64)
+    #         with gr.Column(scale=5, min_width=200):
+    #             gr.Markdown("### Step 3: Check groupping")
+    #             child_distance_slider = gr.Slider(0, 0.5, step=0.001, label="Child Distance", value=0.1, elem_id="child_distance_slider", interactive=True)
+    #             overlay_image_checkbox = gr.Checkbox(label="Overlay Image", value=True, elem_id="overlay_image_checkbox", interactive=True)
+    #             run_button = gr.Button("🔴 RUN", elem_id="run_groupping", variant='primary')
+    #             parent_plot = gr.Gallery(value=None, label="Parent", show_label=True, elem_id="parent_plot", interactive=False, rows=[1], columns=[2])
+    #             parent_button = gr.Button("Use Parent", elem_id="run_parent")
+    #             current_plot = gr.Gallery(value=None, label="Current", show_label=True, elem_id="current_plot", interactive=False, rows=[1], columns=[2])
+    #         with gr.Column(scale=5, min_width=200):
+    #             child_plots = []
+    #             child_buttons = []
+    #             for i in range(4):
+    #                 child_plots.append(gr.Gallery(value=None, label=f"Child {i}", show_label=True, elem_id=f"child_plot_{i}", interactive=False, rows=[1], columns=[2]))
+    #                 child_buttons.append(gr.Button(f"Use Child {i}", elem_id=f"run_child_{i}"))
     
-        def relative_xy(prompts):
-            image = prompts['image']
-            points = np.asarray(prompts['points'])
-            if points.shape[0] == 0:
-                return [], []
-            is_point = points[:, 5] == 4.0
-            points = points[is_point]
-            is_positive = points[:, 2] == 1.0
-            is_negative = points[:, 2] == 0.0
-            xy = points[:, :2].tolist()
-            if isinstance(image, str):
-                image = Image.open(image)
-                image = np.array(image)
-            h, w = image.shape[:2]
-            new_xy = [(x/w, y/h) for x, y in xy]
-            # print(new_xy)
-            return new_xy, is_positive
+    #     def relative_xy(prompts):
+    #         image = prompts['image']
+    #         points = np.asarray(prompts['points'])
+    #         if points.shape[0] == 0:
+    #             return [], []
+    #         is_point = points[:, 5] == 4.0
+    #         points = points[is_point]
+    #         is_positive = points[:, 2] == 1.0
+    #         is_negative = points[:, 2] == 0.0
+    #         xy = points[:, :2].tolist()
+    #         if isinstance(image, str):
+    #             image = Image.open(image)
+    #             image = np.array(image)
+    #         h, w = image.shape[:2]
+    #         new_xy = [(x/w, y/h) for x, y in xy]
+    #         # print(new_xy)
+    #         return new_xy, is_positive
         
-        def xy_eigvec(prompts, image_idx, eigvecs):
-            eigvec = eigvecs[image_idx]
-            xy, is_positive = relative_xy(prompts)
-            for i, (x, y) in enumerate(xy):
-                if not is_positive[i]:
-                    continue
-                x = int(x * eigvec.shape[1])
-                y = int(y * eigvec.shape[0])
-                return eigvec[y, x], (y, x)
+    #     def xy_eigvec(prompts, image_idx, eigvecs):
+    #         eigvec = eigvecs[image_idx]
+    #         xy, is_positive = relative_xy(prompts)
+    #         for i, (x, y) in enumerate(xy):
+    #             if not is_positive[i]:
+    #                 continue
+    #             x = int(x * eigvec.shape[1])
+    #             y = int(y * eigvec.shape[0])
+    #             return eigvec[y, x], (y, x)
         
-        from ncut_pytorch.ncut_pytorch import _transform_heatmap
-        def _run_heatmap_fn(images, eigvecs, prompt_image_idx, prompt_points, n_eig, flat_idx=None, raw_heatmap=False, overlay_image=True):
-            left = eigvecs[..., :n_eig]
-            if flat_idx is not None:
-                right = eigvecs.reshape(-1, eigvecs.shape[-1])[flat_idx]
-                y, x = None, None
-            else:
-                right, (y, x) = xy_eigvec(prompt_points, prompt_image_idx, eigvecs)
-            right = right[:n_eig]
-            left = F.normalize(left, p=2, dim=-1)
-            _right = F.normalize(right, p=2, dim=-1)
-            heatmap = left @ _right.unsqueeze(-1)
-            heatmap = heatmap.squeeze(-1)
-            heatmap = 1 - heatmap
-            heatmap = _transform_heatmap(heatmap)
-            if raw_heatmap:
-                return heatmap
-            # apply hot colormap and covert to PIL image 256x256
-            heatmap = heatmap.cpu().numpy()
-            hot_map = matplotlib.colormaps['hot']
-            heatmap = hot_map(heatmap)
-            pil_images = to_pil_images(torch.tensor(heatmap), target_size=256, force_size=True)
-            if overlay_image:
-                overlaied_images = []
-                for i_image in range(len(images)):
-                    rgb_image = images[i_image].resize((256, 256))
-                    rgb_image = np.array(rgb_image)
-                    heatmap_image = np.array(pil_images[i_image])[..., :3]
-                    blend_image = 0.5 * rgb_image + 0.5 * heatmap_image
-                    blend_image = Image.fromarray(blend_image.astype(np.uint8))
-                    overlaied_images.append(blend_image)
-                pil_images = overlaied_images
-            return pil_images, (y, x)
-
-        def _farthest_point_sampling(
-            features,
-            start_feature,
-            num_sample=300,
-            h=9,
-        ):
-            import fpsample
-
-            h = min(h, int(np.log2(features.shape[0])))
+    #     from ncut_pytorch.ncut_pytorch import _transform_heatmap
+    #     def _run_heatmap_fn(images, eigvecs, prompt_image_idx, prompt_points, n_eig, flat_idx=None, raw_heatmap=False, overlay_image=True):
+    #         left = eigvecs[..., :n_eig]
+    #         if flat_idx is not None:
+    #             right = eigvecs.reshape(-1, eigvecs.shape[-1])[flat_idx]
+    #             y, x = None, None
+    #         else:
+    #             right, (y, x) = xy_eigvec(prompt_points, prompt_image_idx, eigvecs)
+    #         right = right[:n_eig]
+    #         left = F.normalize(left, p=2, dim=-1)
+    #         _right = F.normalize(right, p=2, dim=-1)
+    #         heatmap = left @ _right.unsqueeze(-1)
+    #         heatmap = heatmap.squeeze(-1)
+    #         heatmap = 1 - heatmap
+    #         heatmap = _transform_heatmap(heatmap)
+    #         if raw_heatmap:
+    #             return heatmap
+    #         # apply hot colormap and covert to PIL image 256x256
+    #         heatmap = heatmap.cpu().numpy()
+    #         hot_map = matplotlib.colormaps['hot']
+    #         heatmap = hot_map(heatmap)
+    #         pil_images = to_pil_images(torch.tensor(heatmap), target_size=256, force_size=True)
+    #         if overlay_image:
+    #             overlaied_images = []
+    #             for i_image in range(len(images)):
+    #                 rgb_image = images[i_image].resize((256, 256))
+    #                 rgb_image = np.array(rgb_image)
+    #                 heatmap_image = np.array(pil_images[i_image])[..., :3]
+    #                 blend_image = 0.5 * rgb_image + 0.5 * heatmap_image
+    #                 blend_image = Image.fromarray(blend_image.astype(np.uint8))
+    #                 overlaied_images.append(blend_image)
+    #             pil_images = overlaied_images
+    #         return pil_images, (y, x)
+
+    #     def _farthest_point_sampling(
+    #         features,
+    #         start_feature,
+    #         num_sample=300,
+    #         h=9,
+    #     ):
+    #         import fpsample
+
+    #         h = min(h, int(np.log2(features.shape[0])))
             
-            inp = features.cpu().numpy()
-            inp = np.concatenate([inp, start_feature[None, :]], axis=0)
+    #         inp = features.cpu().numpy()
+    #         inp = np.concatenate([inp, start_feature[None, :]], axis=0)
 
-            kdline_fps_samples_idx = fpsample.bucket_fps_kdline_sampling(
-                inp, num_sample, h, start_idx=inp.shape[0] - 1
-            ).astype(np.int64)
-            return kdline_fps_samples_idx
+    #         kdline_fps_samples_idx = fpsample.bucket_fps_kdline_sampling(
+    #             inp, num_sample, h, start_idx=inp.shape[0] - 1
+    #         ).astype(np.int64)
+    #         return kdline_fps_samples_idx
         
-        @torch.no_grad()
-        def run_heatmap(images, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, flat_idx=None, overlay_image=True):
-            gr.Info(f"current number of eigenvectors: {n_eig}")
-            eigvecs = torch.tensor(eigvecs)
-            image1_slider = min(image1_slider, len(images)-1)
-            images = [image[0] for image in images]
-            if isinstance(images[0], str):
-                images = [Image.open(image[0]).convert("RGB").resize((256, 256)) for image in images]
+    #     @torch.no_grad()
+    #     def run_heatmap(images, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, flat_idx=None, overlay_image=True):
+    #         gr.Info(f"current number of eigenvectors: {n_eig}")
+    #         eigvecs = torch.tensor(eigvecs)
+    #         image1_slider = min(image1_slider, len(images)-1)
+    #         images = [image[0] for image in images]
+    #         if isinstance(images[0], str):
+    #             images = [Image.open(image[0]).convert("RGB").resize((256, 256)) for image in images]
                         
-            current_heatmap, (y, x) = _run_heatmap_fn(images, eigvecs, image1_slider, prompt_image1, n_eig, flat_idx, overlay_image=overlay_image)
-            parent_heatmap, _ = _run_heatmap_fn(images, eigvecs, image1_slider, prompt_image1, int(n_eig/2), flat_idx, overlay_image=overlay_image)
+    #         current_heatmap, (y, x) = _run_heatmap_fn(images, eigvecs, image1_slider, prompt_image1, n_eig, flat_idx, overlay_image=overlay_image)
+    #         parent_heatmap, _ = _run_heatmap_fn(images, eigvecs, image1_slider, prompt_image1, int(n_eig/2), flat_idx, overlay_image=overlay_image)
             
-            # find childs
-            # pca_eigvecs
-            _eigvecs = eigvecs.reshape(-1, eigvecs.shape[-1])
-            u, s, v = torch.pca_lowrank(_eigvecs, q=8)
-            _n = _eigvecs.shape[0]
-            s /= math.sqrt(_n)
-            _eigvecs = u @ torch.diag(s)
+    #         # find childs
+    #         # pca_eigvecs
+    #         _eigvecs = eigvecs.reshape(-1, eigvecs.shape[-1])
+    #         u, s, v = torch.pca_lowrank(_eigvecs, q=8)
+    #         _n = _eigvecs.shape[0]
+    #         s /= math.sqrt(_n)
+    #         _eigvecs = u @ torch.diag(s)
             
-            if flat_idx is None:
-                _picked_eigvec = _eigvecs.reshape(*eigvecs.shape[:-1], 8)[image1_slider, y, x]
-            else:
-                _picked_eigvec = _eigvecs[flat_idx]
-            l2_distance = torch.norm(_eigvecs - _picked_eigvec, dim=-1)
-            average_distance = l2_distance.mean()
-            distance_threshold = distance_slider * average_distance
-            distance_mask = l2_distance < distance_threshold
-            masked_eigvecs = _eigvecs[distance_mask]
-            num_childs = min(4, masked_eigvecs.shape[0])
-            assert num_childs > 0
+    #         if flat_idx is None:
+    #             _picked_eigvec = _eigvecs.reshape(*eigvecs.shape[:-1], 8)[image1_slider, y, x]
+    #         else:
+    #             _picked_eigvec = _eigvecs[flat_idx]
+    #         l2_distance = torch.norm(_eigvecs - _picked_eigvec, dim=-1)
+    #         average_distance = l2_distance.mean()
+    #         distance_threshold = distance_slider * average_distance
+    #         distance_mask = l2_distance < distance_threshold
+    #         masked_eigvecs = _eigvecs[distance_mask]
+    #         num_childs = min(4, masked_eigvecs.shape[0])
+    #         assert num_childs > 0
             
-            child_idx = _farthest_point_sampling(masked_eigvecs, _picked_eigvec, num_sample=num_childs+1)
-            child_idx = np.sort(child_idx)[:-1]
+    #         child_idx = _farthest_point_sampling(masked_eigvecs, _picked_eigvec, num_sample=num_childs+1)
+    #         child_idx = np.sort(child_idx)[:-1]
             
-            # convert child_idx to flat_idx
-            dummy_idx = torch.zeros(_eigvecs.shape[0], dtype=torch.bool)
-            dummy_idx2 = torch.zeros(int(distance_mask.sum().item()), dtype=torch.bool)
-            dummy_idx2[child_idx] = True
-            dummy_idx[distance_mask] = dummy_idx2
-            child_idx = torch.where(dummy_idx)[0]
+    #         # convert child_idx to flat_idx
+    #         dummy_idx = torch.zeros(_eigvecs.shape[0], dtype=torch.bool)
+    #         dummy_idx2 = torch.zeros(int(distance_mask.sum().item()), dtype=torch.bool)
+    #         dummy_idx2[child_idx] = True
+    #         dummy_idx[distance_mask] = dummy_idx2
+    #         child_idx = torch.where(dummy_idx)[0]
             
             
-            # current_child heatmap, for contrast
-            current_child_heatmap = _run_heatmap_fn(images,eigvecs, image1_slider, prompt_image1, int(n_eig*2), flat_idx, raw_heatmap=True, overlay_image=overlay_image)
+    #         # current_child heatmap, for contrast
+    #         current_child_heatmap = _run_heatmap_fn(images,eigvecs, image1_slider, prompt_image1, int(n_eig*2), flat_idx, raw_heatmap=True, overlay_image=overlay_image)
             
-            # child_heatmaps, contrast mean of current clicked point
-            child_heatmaps = []
-            for idx in child_idx:
-                child_heatmap = _run_heatmap_fn(images,eigvecs, image1_slider, prompt_image1, int(n_eig*2), idx, raw_heatmap=True, overlay_image=overlay_image)
-                heatmap = child_heatmap - current_child_heatmap
-                # convert [-1, 1] to [0, 1]
-                heatmap = (heatmap + 1) / 2
-                heatmap = heatmap.cpu().numpy()
-                cm = matplotlib.colormaps['bwr']
-                heatmap = cm(heatmap)
-                # bwr with contrast
-                pil_images1 = to_pil_images(torch.tensor(heatmap), resize=256)
-                # no contrast
-                pil_images2, _ = _run_heatmap_fn(images, eigvecs, image1_slider, prompt_image1, int(n_eig*2), idx, overlay_image=overlay_image)
+    #         # child_heatmaps, contrast mean of current clicked point
+    #         child_heatmaps = []
+    #         for idx in child_idx:
+    #             child_heatmap = _run_heatmap_fn(images,eigvecs, image1_slider, prompt_image1, int(n_eig*2), idx, raw_heatmap=True, overlay_image=overlay_image)
+    #             heatmap = child_heatmap - current_child_heatmap
+    #             # convert [-1, 1] to [0, 1]
+    #             heatmap = (heatmap + 1) / 2
+    #             heatmap = heatmap.cpu().numpy()
+    #             cm = matplotlib.colormaps['bwr']
+    #             heatmap = cm(heatmap)
+    #             # bwr with contrast
+    #             pil_images1 = to_pil_images(torch.tensor(heatmap), resize=256)
+    #             # no contrast
+    #             pil_images2, _ = _run_heatmap_fn(images, eigvecs, image1_slider, prompt_image1, int(n_eig*2), idx, overlay_image=overlay_image)
                 
-                # combine contrast and no contrast
-                pil_images = []
-                for i in range(len(pil_images1)):
-                    pil_images.append(pil_images2[i])
-                    pil_images.append(pil_images1[i])
+    #             # combine contrast and no contrast
+    #             pil_images = []
+    #             for i in range(len(pil_images1)):
+    #                 pil_images.append(pil_images2[i])
+    #                 pil_images.append(pil_images1[i])
                 
                                     
-                child_heatmaps.append(pil_images)
+    #             child_heatmaps.append(pil_images)
             
-            return parent_heatmap, current_heatmap, *child_heatmaps, child_idx.tolist()
+    #         return parent_heatmap, current_heatmap, *child_heatmaps, child_idx.tolist()
                 
-        # def debug_fn(eigvecs):
-        #     shape = eigvecs.shape
-        #     gr.Info(f"eigvecs shape: {shape}")
+    #     # def debug_fn(eigvecs):
+    #     #     shape = eigvecs.shape
+    #     #     gr.Info(f"eigvecs shape: {shape}")
         
-        # run_button.click(
-        #     debug_fn,
-        #     inputs=[eigvecs],
-        #     outputs=[],
-        # )
-        none_placeholder = gr.State(None)
-        run_button.click(
-            run_heatmap,
-            inputs=[input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, child_distance_slider, none_placeholder, overlay_image_checkbox],
-            outputs=[parent_plot, current_plot, *child_plots, child_idx],
-        )
+    #     # run_button.click(
+    #     #     debug_fn,
+    #     #     inputs=[eigvecs],
+    #     #     outputs=[],
+    #     # )
+    #     none_placeholder = gr.State(None)
+    #     run_button.click(
+    #         run_heatmap,
+    #         inputs=[input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, child_distance_slider, none_placeholder, overlay_image_checkbox],
+    #         outputs=[parent_plot, current_plot, *child_plots, child_idx],
+    #     )
         
-        def run_paraent(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, current_idx=None, overlay_image=True):
-            n_eig = int(n_eig/2)
-            return n_eig, *run_heatmap(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, current_idx, overlay_image)
+    #     def run_paraent(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, current_idx=None, overlay_image=True):
+    #         n_eig = int(n_eig/2)
+    #         return n_eig, *run_heatmap(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, current_idx, overlay_image)
         
-        parent_button.click(
-            run_paraent,
-            inputs=[input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, child_distance_slider, current_idx, overlay_image_checkbox],
-            outputs=[n_eig, parent_plot, current_plot, *child_plots, child_idx],
-        )
+    #     parent_button.click(
+    #         run_paraent,
+    #         inputs=[input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, child_distance_slider, current_idx, overlay_image_checkbox],
+    #         outputs=[n_eig, parent_plot, current_plot, *child_plots, child_idx],
+    #     )
         
-        def run_child(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, child_idx=[], overlay_image=True, i_child=0):
-            n_eig = int(n_eig*2)
-            flat_idx = child_idx[i_child]
-            return n_eig, flat_idx, *run_heatmap(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, flat_idx, overlay_image)
-
-        for i in range(4):
-            child_buttons[i].click(
-                partial(run_child, i_child=i),
-                inputs=[input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, child_distance_slider, child_idx, overlay_image_checkbox],
-                outputs=[n_eig, current_idx, parent_plot, current_plot, *child_plots, child_idx],
-            )
+    #     def run_child(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, child_idx=[], overlay_image=True, i_child=0):
+    #         n_eig = int(n_eig*2)
+    #         flat_idx = child_idx[i_child]
+    #         return n_eig, flat_idx, *run_heatmap(input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, distance_slider, flat_idx, overlay_image)
+
+    #     for i in range(4):
+    #         child_buttons[i].click(
+    #             partial(run_child, i_child=i),
+    #             inputs=[input_gallery, eigvecs, image1_slider, prompt_image1, n_eig, child_distance_slider, child_idx, overlay_image_checkbox],
+    #             outputs=[n_eig, current_idx, parent_plot, current_plot, *child_plots, child_idx],
+    #         )
             
         
     with gr.Tab('📄About'):
@@ -4371,7 +4371,7 @@ with demo:
         
         hidden_button.change(update_smile, [n_smiles], [n_smiles, hidden_button])
         hidden_tabs = [tab_alignedcut_advanced, tab_model_aligned_advanced, tab_recursivecut_advanced, 
-                        tab_compare_models_advanced, tab_directed_ncut, test_playground_tab, tab_aligned, tab_lisa]
+                        tab_compare_models_advanced, tab_directed_ncut, tab_aligned, tab_lisa]
         hidden_button.change(partial(unlock_tabs, n_tab=len(hidden_tabs)), [n_smiles], hidden_tabs)
                 
     with gr.Row():