adding new frontend

app.py

@@ -1583,6 +1583,30 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                     outputs=[context_analysis]
                 )
             """
+
+            # def get_choices(model_name, label_type):
+            #     viz = analyzer.projector_vizs[model_name]
+            #     df = pd.DataFrame(viz.labels)
+            #     choices = [str(x) for x in df[label_type].unique()]
+            #     print(choices)
+            #     value = choices[0] if choices else None
+            #     return choices, value
+
+            def get_choices(model_name, label_type):
+                viz = analyzer.projector_vizs[model_name]
+                df = pd.DataFrame(viz.labels)
+                if label_type == "phone":
+                    choices = df["phone"].unique()
+                elif label_type == "cluster":
+                    choices = df["cluster"].unique()
+                else:
+                    choices = df["language"].unique()
+
+                return gr.update(
+                    choices=[str(x) for x in choices],   # MUST be a Python list of strings
+                    value=str(choices[0])                # MUST be one of the choices
+                )
+
             with gr.Tab("Embedding Projector"):
                 gr.Markdown("### TensorFlow Projector-Style 3D Visualization")
                 gr.Markdown("Interactive exploration similar to TensorFlow's Embedding Projector")
@@ -1599,12 +1623,24 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                         )
                         
                         projection_method = gr.Radio(
-                            # choices=['PCA', 't-SNE', 'UMAP'],
-                            choices=['PCA', 'UMAP'],
+                            choices=['PCA', 't-SNE', 'UMAP'],
+                            # choices=['PCA', 'UMAP'],
                             value='UMAP',
                             label="Projection Method"
                         )
-                        
+
+                        tsne_perplexity = gr.Slider(5, 50, value=30, step=1, label="t-SNE Perplexity", visible=False)
+                        tsne_lr = gr.Slider(10, 1000, value=200, step=10, label="t-SNE Learning Rate", visible=False)
+                        tsne_iters = gr.Slider(250, 5000, value=1000, step=250, label="t-SNE Iterations", visible=False)
+
+
+                        projection_method.change(
+                            fn=toggle_tsne_params,
+                            inputs=[projection_method],
+                            outputs=[tsne_perplexity, tsne_lr, tsne_iters]
+                        )
+
+                                                
                         dimension = gr.Radio(
                             choices=['3D', '2D'],
                             value='3D',
@@ -1628,19 +1664,57 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                             value='By Label',
                             label="Search Mode"
                         )
+
+                        phones = ["æ", "ɑ", "ə", "i", "u"]
+                        clusters = [0, 1, 2, 3]
+                        languages = ["hi", "pa"]
                         
                         # Label search (simple)
                         with gr.Group(visible=True) as label_search_group:
+                            # search_label_type = gr.Radio(
+                            #     choices=['phone', 'cluster', 'language'],
+                            #     value='phone',
+                            #     label="Search in"
+                            # )
+                            
+                            # search_term = gr.Textbox(
+                            #     label="Search term",
+                            #     placeholder="e.g., 'æ' or '5'"
+                            # )
+
+                            # search_term = gr.Dropdown(
+                            #     choices=list(phones),  # initial choices
+                            #     value=phones[0],  # initial value
+                            #     label="Search term",
+                            #     allow_custom_value=True
+                            # )
+
+                            # # Update dropdown choices when the label type changes
+                            # # Update search_term whenever the label type changes
+                            # search_label_type.change(
+                            #     fn=get_choices,
+                            #     inputs=[projector_model, search_label_type],
+                            #     outputs=[search_term, search_term]  # first = choices, second = value
+                            # )
+
                             search_label_type = gr.Radio(
-                                choices=['phone', 'cluster', 'language'],
-                                value='phone',
+                                choices=["phone", "cluster", "language"],
+                                value="phone",
                                 label="Search in"
                             )
-                            
-                            search_term = gr.Textbox(
-                                label="Search term",
-                                placeholder="e.g., 'æ' or '5'"
+
+                            search_term = gr.Dropdown(
+                                choices=[str(x) for x in phones],
+                                value=str(phones[0]),
+                                label="Search term"
+                            )
+
+                            search_label_type.change(
+                                fn=get_choices,
+                                inputs=[projector_model, search_label_type],
+                                outputs=search_term
                             )
+
                         
                         # Feature search (advanced)
                         with gr.Group(visible=False) as feature_search_group:
@@ -1679,21 +1753,21 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                         
                         search_btn = gr.Button("🔍 Search")
                         
-                        gr.Markdown("#### Nearest Neighbors")
+                        # gr.Markdown("#### Nearest Neighbors")
                         
-                        point_idx = gr.Number(
-                            label="Point index",
-                            value=0,
-                            precision=0
-                        )
+                        # point_idx = gr.Number(
+                        #     label="Point index",
+                        #     value=0,
+                        #     precision=0
+                        # )
                         
-                        n_neighbors = gr.Slider(
-                            1, 50, value=10,
-                            step=1,
-                            label="Number of neighbors"
-                        )
+                        # n_neighbors = gr.Slider(
+                        #     1, 50, value=10,
+                        #     step=1,
+                        #     label="Number of neighbors"
+                        # )
                         
-                        show_nn_btn = gr.Button("Show Neighbors")
+                        # show_nn_btn = gr.Button("Show Neighbors")
                         
                         info_display = gr.Markdown("*Select a point or search*")
                     
@@ -1707,7 +1781,7 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                         # comparison_plot = gr.Plot(label="Comparison", visible=False)
                 
                 # Projector callbacks
-                def compute_projections(model_name, method):
+                def compute_projections(model_name, method, tsne_perplexity, tsne_lr, tsne_iters):
                     if not model_name or model_name not in analyzer.projector_vizs:
                         return "Model not available", None
                     
@@ -1715,7 +1789,7 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                     
                     try:
                         method_lower = method.lower()
-                        viz.compute_projections(method_lower)
+                        viz.compute_projections(method_lower, tsne_perplexity, tsne_lr, tsne_iters)
                         
                         # Create initial plot
                         proj_key = f"{method_lower}_3d"
@@ -1882,12 +1956,21 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                     return gr.update(visible=True), fig
                 
                 # Connect callbacks
+                # compute_btn.click(
+                #     fn=compute_projections,
+                #     inputs=[projector_model, projection_method],
+                #     outputs=[compute_status, projector_plot]
+                # )
+
                 compute_btn.click(
                     fn=compute_projections,
-                    inputs=[projector_model, projection_method],
+                    inputs=[projector_model, projection_method,
+                            tsne_perplexity, tsne_lr, tsne_iters],
                     outputs=[compute_status, projector_plot]
                 )
-                
+
+
+                                
                 search_mode.change(
                     fn=toggle_search_mode,
                     inputs=[search_mode],
@@ -1910,21 +1993,24 @@ def create_integrated_gradio_interface(analyzer: MultiModelAnalyzer):
                     outputs=[projector_plot, info_display]
                 )
                 
-                show_nn_btn.click(
-                    fn=show_neighbors,
-                    inputs=[projector_model, point_idx, n_neighbors, 
-                           projection_method, dimension, projector_color_by],
-                    outputs=[projector_plot, info_display]
-                )
+                # show_nn_btn.click(
+                #     fn=show_neighbors,
+                #     inputs=[projector_model, point_idx, n_neighbors, 
+                #            projection_method, dimension, projector_color_by],
+                #     outputs=[projector_plot, info_display]
+                # )
                 
                 # comparison_btn.click(
                 #     fn=lambda m, c: show_comparison_view(m, c),
                 #     inputs=[projector_model, projector_color_by],
                 #     outputs=[comparison_plot, comparison_plot]
                 # )
+    
     return demo
 
 
+
+
 def create_root_interface(output_dir):
     subdirs = get_top_level_dirs(output_dir)