Incllude Selector for Distance Method

app.py

@@ -6,7 +6,8 @@ from bokeh.models import ColumnDataSource, DataTable, TableColumn, CustomJS, Sel
 from bokeh.layouts import column
 from bokeh.palettes import Reds9, Blues9, Oranges9, Purples9, Greys9, BuGn9, Greens9
 from sklearn.decomposition import PCA
-from sklearn.manifold import TSNE
+from sklearn.manifold import TSNE, trustworthiness
+from sklearn.metrics import pairwise_distances
 import io
 import ot
 from sklearn.linear_model import LinearRegression
@@ -37,7 +38,7 @@ def config_style():
     st.markdown('<h1 class="main-title">Merit Embeddings 🎒📃🏆</h1>', unsafe_allow_html=True)
 
 # =============================================================================
-# Funciones de carga de datos, generación de gráficos y cálculo de distancias (sin cambios)
+# Funciones de carga de datos y procesamiento (sin cambios en su mayoría)
 # =============================================================================
 
 def load_embeddings(model, version):
@@ -106,36 +107,90 @@ def split_versions(df_combined, reduced):
     unique_subsets = {"real": unique_real, "synthetic": unique_synth}
     return df_dict, unique_subsets
 
-def compute_wasserstein_distances_synthetic_individual(synthetic_df: pd.DataFrame, df_real: pd.DataFrame, real_labels: list) -> pd.DataFrame:
+# =============================================================================
+# Funciones para calcular distancias entre clusters según la métrica seleccionada
+# (Wasserstein, Euclidean o KL)
+# =============================================================================
+
+def compute_cluster_distance(synthetic_points, real_points, metric="wasserstein", bins=20):
+    if metric.lower() == "wasserstein":
+        n = synthetic_points.shape[0]
+        m = real_points.shape[0]
+        weights = np.ones(n) / n
+        weights_real = np.ones(m) / m
+        M = ot.dist(synthetic_points, real_points, metric='euclidean')
+        return ot.emd2(weights, weights_real, M)
+    elif metric.lower() == "euclidean":
+        center_syn = np.mean(synthetic_points, axis=0)
+        center_real = np.mean(real_points, axis=0)
+        return np.linalg.norm(center_syn - center_real)
+    elif metric.lower() == "kl":
+        all_points = np.vstack([synthetic_points, real_points])
+        x_min, y_min = np.min(all_points, axis=0)
+        x_max, y_max = np.max(all_points, axis=0)
+        x_bins = np.linspace(x_min, x_max, bins+1)
+        y_bins = np.linspace(y_min, y_max, bins+1)
+        H_syn, _, _ = np.histogram2d(synthetic_points[:,0], synthetic_points[:,1], bins=[x_bins, y_bins])
+        H_real, _, _ = np.histogram2d(real_points[:,0], real_points[:,1], bins=[x_bins, y_bins])
+        eps = 1e-10
+        P = H_syn + eps
+        Q = H_real + eps
+        P = P / P.sum()
+        Q = Q / Q.sum()
+        kl = np.sum(P * np.log(P / Q))
+        return kl
+    else:
+        raise ValueError("Métrica desconocida. Usa 'wasserstein', 'euclidean' o 'kl'.")
+
+def compute_cluster_distances_synthetic_individual(synthetic_df: pd.DataFrame, df_real: pd.DataFrame, real_labels: list, metric="wasserstein", bins=20) -> pd.DataFrame:
     distances = {}
     groups = synthetic_df.groupby(['source', 'label'])
     for (source, label), group in groups:
         key = f"{label} ({source})"
         data = group[['x', 'y']].values
-        n = data.shape[0]
-        weights = np.ones(n) / n
         distances[key] = {}
         for real_label in real_labels:
             real_data = df_real[df_real['label'] == real_label][['x','y']].values
-            m = real_data.shape[0]
-            weights_real = np.ones(m) / m
-            M = ot.dist(data, real_data, metric='euclidean')
-            distances[key][real_label] = ot.emd2(weights, weights_real, M)
-    
+            d = compute_cluster_distance(data, real_data, metric=metric, bins=bins)
+            distances[key][real_label] = d
     for source, group in synthetic_df.groupby('source'):
         key = f"Global ({source})"
         data = group[['x','y']].values
-        n = data.shape[0]
-        weights = np.ones(n) / n
         distances[key] = {}
         for real_label in real_labels:
             real_data = df_real[df_real['label'] == real_label][['x','y']].values
-            m = real_data.shape[0]
-            weights_real = np.ones(m) / m
-            M = ot.dist(data, real_data, metric='euclidean')
-            distances[key][real_label] = ot.emd2(weights, weights_real, M)
+            d = compute_cluster_distance(data, real_data, metric=metric, bins=bins)
+            distances[key][real_label] = d
     return pd.DataFrame(distances).T
 
+# =============================================================================
+# Función para calcular continuidad (mide la preservación de la vecindad original en el embedding)
+# =============================================================================
+
+def compute_continuity(X, X_embedded, n_neighbors=5):
+    n = X.shape[0]
+    D_high = pairwise_distances(X, metric='euclidean')
+    D_low = pairwise_distances(X_embedded, metric='euclidean')
+    indices_high = np.argsort(D_high, axis=1)
+    indices_low = np.argsort(D_low, axis=1)
+    k_high = indices_high[:, 1:n_neighbors+1]
+    k_low = indices_low[:, 1:n_neighbors+1]
+    total = 0.0
+    for i in range(n):
+        set_high = set(k_high[i])
+        set_low = set(k_low[i])
+        missing = set_high - set_low
+        for j in missing:
+            rank = np.where(indices_low[i] == j)[0][0]
+            total += (rank - n_neighbors)
+    norm = 2.0 / (n * n_neighbors * (2*n - 3*n_neighbors - 1))
+    continuity_value = 1 - norm * total
+    return continuity_value
+
+# =============================================================================
+# Funciones de visualización (sin cambios)
+# =============================================================================
+
 def create_table(df_distances):
     df_table = df_distances.copy()
     df_table.reset_index(inplace=True)
@@ -300,10 +355,12 @@ def calculate_cluster_centers(df, labels):
     return centers
 
 # =============================================================================
-# Función centralizada para la pipeline: reducción, distancias y regresión global
+# Pipeline central: reducción, cálculo de distancias y regresión global.
+# Se agrega el parámetro distance_metric.
+# Además, si se utiliza t-SNE, se calculan trustworthiness y continuity.
 # =============================================================================
 
-def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method="t-SNE"):
+def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method="t-SNE", distance_metric="wasserstein"):
     if reduction_method == "PCA":
         reducer = PCA(n_components=2)
     else:
@@ -313,17 +370,26 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
     
     reduced = reducer.fit_transform(df_combined[embedding_cols].values)
     
-    # Si se usa PCA, capturamos la varianza explicada
+    # Para PCA se captura la explained variance ratio
     explained_variance = None
     if reduction_method == "PCA":
         explained_variance = reducer.explained_variance_ratio_
     
+    # Si se usa t-SNE, calculamos trustworthiness y continuity
+    trust = None
+    cont = None
+    if reduction_method == "t-SNE":
+        X = df_combined[embedding_cols].values
+        trust = trustworthiness(X, reduced, n_neighbors=5)
+        cont = compute_continuity(X, reduced, n_neighbors=5)
+    
     dfs_reduced, unique_subsets = split_versions(df_combined, reduced)
     
-    df_distances = compute_wasserstein_distances_synthetic_individual(
+    df_distances = compute_cluster_distances_synthetic_individual(
         dfs_reduced["synthetic"],
         dfs_reduced["real"],
-        unique_subsets["real"]
+        unique_subsets["real"],
+        metric=distance_metric
     )
     
     global_distances = {}
@@ -349,7 +415,7 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
     intercept = model_global.intercept_
     
     scatter_fig = figure(width=600, height=600, tools="pan,wheel_zoom,reset,save", 
-                         title="Scatter Plot: Wasserstein vs F1")
+                         title="Scatter Plot: Distance vs F1")
     source_colors = {
         "es-digital-paragraph-degradation-seq": "blue",
         "es-digital-line-degradation-seq": "green",
@@ -369,10 +435,10 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
                                fill_color=source_colors.get(source, "gray"),
                                line_color=source_colors.get(source, "gray"),
                                legend_label=source)
-    scatter_fig.xaxis.axis_label = "Wasserstein Distance (Global, por Colegio)"
+    scatter_fig.xaxis.axis_label = "Distance (Global, por Colegio)"
     scatter_fig.yaxis.axis_label = "F1 Score"
     scatter_fig.legend.location = "top_right"
-    hover_tool = HoverTool(tooltips=[("Wass. Distance", "@x"), ("f1", "@y"), ("Subset", "@Fuente")])
+    hover_tool = HoverTool(tooltips=[("Distance", "@x"), ("F1", "@y"), ("Subset", "@Fuente")])
     scatter_fig.add_tools(hover_tool)
     
     x_line = np.linspace(all_x_arr.min(), all_x_arr.max(), 100)
@@ -387,15 +453,16 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
         "dfs_reduced": dfs_reduced,
         "unique_subsets": unique_subsets,
         "df_distances": df_distances,
-        "explained_variance": explained_variance  # Se incluye la varianza explicada (solo para PCA)
+        "explained_variance": explained_variance,  # Solo para PCA
+        "trustworthiness": trust,                  # Solo para t-SNE
+        "continuity": cont                         # Solo para t-SNE
     }
 
-
 # =============================================================================
-# Función de optimización (grid search) para TSNE, usando la misma pipeline
+# Optimización de parámetros para TSNE (se propaga también la métrica de distancia)
 # =============================================================================
 
-def optimize_tsne_params(df_combined, embedding_cols, df_f1):
+def optimize_tsne_params(df_combined, embedding_cols, df_f1, distance_metric):
     perplexity_range = np.linspace(30, 50, 10)
     learning_rate_range = np.linspace(200, 1000, 20)
     
@@ -412,7 +479,7 @@ def optimize_tsne_params(df_combined, embedding_cols, df_f1):
             progress_text.text(f"Evaluating: Perplexity={p:.2f}, Learning Rate={lr:.2f} (Step {step}/{total_steps})")
             
             tsne_params = {"perplexity": p, "learning_rate": lr}
-            result = compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method="t-SNE")
+            result = compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method="t-SNE", distance_metric=distance_metric)
             r2_temp = result["R2"]
             st.write(f"Parameters: Perplexity={p:.2f}, Learning Rate={lr:.2f} -> R²={r2_temp:.4f}")
             
@@ -424,11 +491,11 @@ def optimize_tsne_params(df_combined, embedding_cols, df_f1):
     return best_params, best_R2
 
 # =============================================================================
-# Función principal run_model que integra optimización, selector de versión y ejecución manual
+# Función principal run_model: incluye selector de versión, método de reducción, métrica de distancia,
+# y, si se usa t-SNE, muestra trustworthiness y continuity.
 # =============================================================================
 
 def run_model(model_name):
-    # Seleccionar la versión del modelo
     version = st.selectbox("Select Model Version:", options=["vanilla", "finetuned_real"], key=f"version_{model_name}")
     
     embeddings = load_embeddings(model_name, version)
@@ -446,11 +513,15 @@ def run_model(model_name):
     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}")
     
+    distance_metric = st.selectbox("Select Distance Metric:", 
+                                   options=["Wasserstein", "Euclidean", "KL"], 
+                                   key=f"distance_metric_{model_name}")
+    
     tsne_params = {}
     if reduction_method == "t-SNE":
         if st.button("Optimize TSNE parameters", key=f"optimize_tsne_{model_name}"):
             st.info("Running optimization, this can take a while...")
-            best_params, best_R2 = optimize_tsne_params(df_combined, embedding_cols, df_f1)
+            best_params, best_R2 = optimize_tsne_params(df_combined, embedding_cols, df_f1, distance_metric.lower())
             st.success(f"Best parameters: Perplexity = {best_params[0]:.2f}, Learning Rate = {best_params[1]:.2f} with R² = {best_R2:.4f}")
             tsne_params = {"perplexity": best_params[0], "learning_rate": best_params[1]}
         else:
@@ -473,9 +544,8 @@ def run_model(model_name):
                 key=f"learning_rate_{model_name}"
             )
             tsne_params = {"perplexity": perplexity_val, "learning_rate": learning_rate_val}
-    # Si se selecciona PCA, tsne_params no se usa.
     
-    result = compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method=reduction_method)
+    result = compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method=reduction_method, distance_metric=distance_metric.lower())
     
     reg_metrics = pd.DataFrame({
         "Slope": [result["slope"]],
@@ -484,7 +554,6 @@ def run_model(model_name):
     })
     st.table(reg_metrics)
     
-    # Si se ha utilizado PCA, mostramos la varianza explicada
     if reduction_method == "PCA" and result["explained_variance"] is not None:
         st.subheader("Explained Variance Ratio")
         variance_df = pd.DataFrame({
@@ -492,6 +561,10 @@ def run_model(model_name):
             "Explained Variance": result["explained_variance"]
         })
         st.table(variance_df)
+    elif reduction_method == "t-SNE":
+        st.subheader("t-SNE Quality Metrics")
+        st.write(f"Trustworthiness: {result['trustworthiness']:.4f}")
+        st.write(f"Continuity: {result['continuity']:.4f}")
     
     data_table, df_table, source_table = create_table(result["df_distances"])
     real_subset_names = list(df_table.columns[1:])
@@ -554,7 +627,6 @@ def run_model(model_name):
         key=f"download_button_excel_{model_name}"
     )
 
-
 def main():
     config_style()
     tabs = st.tabs(["Donut", "Idefics2"])