TSNE Parameters Optimization

app.py

@@ -312,19 +312,105 @@ def create_table(df_distances):
     data_table = DataTable(source=source_table, columns=columns, sizing_mode='stretch_width', height=total_height)
     return data_table, df_table, source_table
 
+def optimize_tsne_params(df_combined, embedding_cols, df_f1):
+    # Rangos de búsqueda (puedes ajustar estos límites y pasos)
+    perplexity_range = np.linspace(30, 50, 10)
+    learning_rate_range = np.linspace(200, 1000, 20)
+    
+    best_R2 = -np.inf
+    best_params = None
+    total_steps = len(perplexity_range) * len(learning_rate_range)
+    step = 0
+
+    # Usamos un placeholder de Streamlit para actualizar mensajes de progreso
+    progress_text = st.empty()
+    
+    for p in perplexity_range:
+        for lr in learning_rate_range:
+            step += 1
+            # Actualizamos el mensaje de progreso
+            progress_text.text(f"Evaluating: Perplexity={p:.2f}, Learning Rate={lr:.2f} (Step: {step}/{total_steps})")
+            
+            # Calcular la reducción con TSNE
+            reducer_temp = TSNE(n_components=2, random_state=42, perplexity=p, learning_rate=lr)
+            reduced_temp = reducer_temp.fit_transform(df_combined[embedding_cols].values)
+            dfs_reduced_temp, unique_subsets_temp = split_versions(df_combined, reduced_temp)
+            
+            # Calcular distancias Wasserstein
+            df_distances_temp = compute_wasserstein_distances_synthetic_individual(
+                dfs_reduced_temp["synthetic"],
+                dfs_reduced_temp["real"],
+                unique_subsets_temp["real"]
+            )
+            # Extraer los valores globales (suponemos 10 por fuente)
+            global_distances_temp = {}
+            for idx in df_distances_temp.index:
+                if idx.startswith("Global"):
+                    source = idx.split("(")[1].rstrip(")")
+                    global_distances_temp[source] = df_distances_temp.loc[idx].values
+            
+            # Acumular datos para la regresión global
+            all_x_temp = []
+            all_y_temp = []
+            for source in df_f1.columns:
+                if source in global_distances_temp:
+                    x_vals_temp = global_distances_temp[source]
+                    y_vals_temp = df_f1[source].values
+                    all_x_temp.extend(x_vals_temp)
+                    all_y_temp.extend(y_vals_temp)
+            if len(all_x_temp) == 0:
+                continue
+            all_x_temp_arr = np.array(all_x_temp).reshape(-1, 1)
+            all_y_temp_arr = np.array(all_y_temp)
+            
+            model_temp = LinearRegression().fit(all_x_temp_arr, all_y_temp_arr)
+            r2_temp = model_temp.score(all_x_temp_arr, all_y_temp_arr)
+            
+            # Mostrar en pantalla (o log) la tupla evaluada y el R² obtenido
+            st.write(f"Parameters: Perplexity={p:.2f}, Learning Rate={lr:.2f} -> R²={r2_temp:.4f}")
+            
+            if r2_temp > best_R2:
+                best_R2 = r2_temp
+                best_params = (p, lr)
+    
+    progress_text.text("Optimization completed!")
+    return best_params, best_R2
+
+
+
 def run_model(model_name):
     embeddings = load_embeddings(model_name)
     if embeddings is None:
         return
-    
+
     embedding_cols = [col for col in embeddings["real"].columns if col.startswith("dim_")]
     df_combined = pd.concat(list(embeddings.values()), ignore_index=True)
+    
+    # Leer el CSV de f1-donut (usado para evaluar la regresión)
+    try:
+        df_f1 = pd.read_csv("data/f1-donut.csv", sep=';', index_col=0)
+    except Exception as e:
+        st.error(f"Error loading f1-donut.csv: {e}")
+        return
+
     st.markdown('<h6 class="sub-title">Select Dimensionality Reduction Method</h6>', unsafe_allow_html=True)
     reduction_method = st.selectbox("", options=["t-SNE", "PCA"], key=f"reduction_{model_name}")
+    
+    # Opción para optimizar los parámetros TSNE
+    if reduction_method == "t-SNE":
+        if st.button("Optimize TSNE parameters", key=f"optimize_tnse_{model_name}"):
+            st.info("Running optimization, this can take a while...")
+            best_params, best_R2 = optimize_tsne_params(df_combined, embedding_cols, df_f1)
+            st.success(f"Mejores parámetros: Perplexity = {best_params[0]:.2f}, Learning Rate = {best_params[1]:.2f} con R² = {best_R2:.4f}")
+    
+    # Permitir al usuario ingresar manualmente los valores (o podrías reemplazar estos por los optimizados)
     if reduction_method == "PCA":
         reducer = PCA(n_components=2)
     else:
-        reducer = TSNE(n_components=2, random_state=42, perplexity=30, learning_rate=200)
+        perplexity_val = st.number_input("Perplexity", min_value=5, max_value=50, value=30, step=1, key=f"perplexity_{model_name}")
+        learning_rate_val = st.number_input("Learning Rate", min_value=10, max_value=1000, value=200, step=10, key=f"learning_rate_{model_name}")
+        reducer = TSNE(n_components=2, random_state=42, perplexity=perplexity_val, learning_rate=learning_rate_val)
+    
     reduced = reducer.fit_transform(df_combined[embedding_cols].values)
     dfs_reduced, unique_subsets = split_versions(df_combined, reduced)
     
@@ -389,7 +475,7 @@ def run_model(model_name):
     scatter_fig.legend.location = "top_right"
     
     # Agregar HoverTool para mostrar x, y y la fuente al hacer hover
-    hover_tool = HoverTool(tooltips=[("x", "@x"), ("y", "@y"), ("Fuente", "@Fuente")])
+    hover_tool = HoverTool(tooltips=[("Wass. Distance", "@x"), ("f1", "@y"), ("Subset", "@Fuente")])
     scatter_fig.add_tools(hover_tool)
     # --- Fin scatter plot ---