Vanilla or Overfitted Model Selection

app.py

@@ -40,15 +40,15 @@ def config_style():
 # Funciones de carga de datos, generación de gráficos y cálculo de distancias (sin cambios)
 # =============================================================================
 
-def load_embeddings(model):
+def load_embeddings(model, version):
     if model == "Donut":
-        df_real = pd.read_csv("data/donut_de_Rodrigo_merit_secret_all_embeddings.csv")
-        df_par = pd.read_csv("data/donut_de_Rodrigo_merit_es-digital-paragraph-degradation-seq_embeddings.csv")
-        df_line = pd.read_csv("data/donut_de_Rodrigo_merit_es-digital-line-degradation-seq_embeddings.csv")
-        df_seq  = pd.read_csv("data/donut_de_Rodrigo_merit_es-digital-seq_embeddings.csv")
-        df_rot  = pd.read_csv("data/donut_de_Rodrigo_merit_es-digital-rotation-degradation-seq_embeddings.csv")
-        df_zoom  = pd.read_csv("data/donut_de_Rodrigo_merit_es-digital-zoom-degradation-seq_embeddings.csv")
-        df_render  = pd.read_csv("data/donut_de_Rodrigo_merit_es-render-seq_embeddings.csv")
+        df_real = pd.read_csv(f"data/donut_{version}_de_Rodrigo_merit_secret_all_embeddings.csv")
+        df_par = pd.read_csv(f"data/donut_{version}_de_Rodrigo_merit_es-digital-paragraph-degradation-seq_embeddings.csv")
+        df_line = pd.read_csv(f"data/donut_{version}_de_Rodrigo_merit_es-digital-line-degradation-seq_embeddings.csv")
+        df_seq  = pd.read_csv(f"data/donut_{version}_de_Rodrigo_merit_es-digital-seq_embeddings.csv")
+        df_rot  = pd.read_csv(f"data/donut_{version}_de_Rodrigo_merit_es-digital-rotation-degradation-seq_embeddings.csv")
+        df_zoom = pd.read_csv(f"data/donut_{version}_de_Rodrigo_merit_es-digital-zoom-degradation-seq_embeddings.csv")
+        df_render = pd.read_csv(f"data/donut_{version}_de_Rodrigo_merit_es-render-seq_embeddings.csv")
         df_real["version"] = "real"
         df_par["version"] = "synthetic"
         df_line["version"] = "synthetic"
@@ -66,13 +66,13 @@ def load_embeddings(model):
         return {"real": df_real, "synthetic": pd.concat([df_seq, df_line, df_par, df_rot, df_zoom, df_render], ignore_index=True)}
     
     elif model == "Idefics2":
-        df_real = pd.read_csv("data/idefics2_de_Rodrigo_merit_secret_britanico_embeddings.csv")
-        df_par = pd.read_csv("data/idefics2_de_Rodrigo_merit_es-digital-paragraph-degradation-seq_embeddings.csv")
-        df_line = pd.read_csv("data/idefics2_de_Rodrigo_merit_es-digital-line-degradation-seq_embeddings.csv")
-        df_seq  = pd.read_csv("data/idefics2_de_Rodrigo_merit_es-digital-seq_embeddings.csv")
-        df_rot  = pd.read_csv("data/idefics2_de_Rodrigo_merit_es-digital-rotation-degradation-seq_embeddings.csv")
-        df_zoom  = pd.read_csv("data/idefics2_de_Rodrigo_merit_es-digital-zoom-degradation-seq_embeddings.csv")
-        df_render  = pd.read_csv("data/idefics2_de_Rodrigo_merit_es-render-seq_embeddings.csv")
+        df_real = pd.read_csv(f"data/idefics2_{version}_de_Rodrigo_merit_secret_britanico_embeddings.csv")
+        df_par = pd.read_csv(f"data/idefics2_{version}_de_Rodrigo_merit_es-digital-paragraph-degradation-seq_embeddings.csv")
+        df_line = pd.read_csv(f"data/idefics2_{version}_de_Rodrigo_merit_es-digital-line-degradation-seq_embeddings.csv")
+        df_seq  = pd.read_csv(f"data/idefics2_{version}_de_Rodrigo_merit_es-digital-seq_embeddings.csv")
+        df_rot  = pd.read_csv(f"data/idefics2_{version}_de_Rodrigo_merit_es-digital-rotation-degradation-seq_embeddings.csv")
+        df_zoom = pd.read_csv(f"data/idefics2_{version}_de_Rodrigo_merit_es-digital-zoom-degradation-seq_embeddings.csv")
+        df_render = pd.read_csv(f"data/idefics2_{version}_de_Rodrigo_merit_es-render-seq_embeddings.csv")
         df_real["version"] = "real"
         df_par["version"] = "synthetic"
         df_line["version"] = "synthetic"
@@ -266,16 +266,12 @@ def add_synthetic_dataset_to_fig(fig, df, labels, marker, color_mapping, group_l
         renderers[label + f" ({group_label})"] = r
     return renderers
 
-
-
 def get_color_maps(unique_subsets):
     color_map = {}
-    # Para reales se asigna color para cada etiqueta
     num_real = len(unique_subsets["real"])
     red_palette = Reds9[:num_real] if num_real <= 9 else (Reds9 * ((num_real // 9) + 1))[:num_real]
     color_map["real"] = {label: red_palette[i] for i, label in enumerate(sorted(unique_subsets["real"]))}
     
-    # Para sintéticos se asigna color de forma granular: para cada source se mapea cada etiqueta
     color_map["synthetic"] = {}
     for source, labels in unique_subsets["synthetic"].items():
         if source == "es-digital-seq":
@@ -294,8 +290,7 @@ def get_color_maps(unique_subsets):
             palette = Blues9[:len(labels)] if len(labels) <= 9 else (Blues9 * ((len(labels)//9)+1))[:len(labels)]
         color_map["synthetic"][source] = {label: palette[i] for i, label in enumerate(sorted(labels))}
     return color_map
-    
-    
+
 def calculate_cluster_centers(df, labels):
     centers = {}
     for label in labels:
@@ -304,14 +299,11 @@ def calculate_cluster_centers(df, labels):
             centers[label] = (subset['x'].mean(), subset['y'].mean())
     return centers
 
-
-
 # =============================================================================
 # Función centralizada para la pipeline: reducción, distancias y regresión global
 # =============================================================================
 
 def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method="t-SNE"):
-    # Seleccionar el reductor según el método
     if reduction_method == "PCA":
         reducer = PCA(n_components=2)
     else:
@@ -319,25 +311,21 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
                          perplexity=tsne_params["perplexity"], 
                          learning_rate=tsne_params["learning_rate"])
     
-    # Aplicar reducción dimensional
     reduced = reducer.fit_transform(df_combined[embedding_cols].values)
     dfs_reduced, unique_subsets = split_versions(df_combined, reduced)
     
-    # Calcular distancias Wasserstein
     df_distances = compute_wasserstein_distances_synthetic_individual(
         dfs_reduced["synthetic"],
         dfs_reduced["real"],
         unique_subsets["real"]
     )
     
-    # Extraer valores globales para cada fuente (se esperan 10 por fuente)
     global_distances = {}
     for idx in df_distances.index:
         if idx.startswith("Global"):
             source = idx.split("(")[1].rstrip(")")
             global_distances[source] = df_distances.loc[idx].values
             
-    # Acumular todos los puntos (globales) y sus correspondientes f1 de cada colegio
     all_x = []
     all_y = []
     for source in df_f1.columns:
@@ -349,13 +337,11 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
     all_x_arr = np.array(all_x).reshape(-1, 1)
     all_y_arr = np.array(all_y)
     
-    # Realizar regresión lineal global
     model_global = LinearRegression().fit(all_x_arr, all_y_arr)
     r2 = model_global.score(all_x_arr, all_y_arr)
     slope = model_global.coef_[0]
     intercept = model_global.intercept_
     
-    # Crear scatter plot para visualizar la relación
     scatter_fig = figure(width=600, height=600, tools="pan,wheel_zoom,reset,save", 
                          title="Scatter Plot: Wasserstein vs F1")
     source_colors = {
@@ -383,7 +369,6 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
     hover_tool = HoverTool(tooltips=[("Wass. Distance", "@x"), ("f1", "@y"), ("Subset", "@Fuente")])
     scatter_fig.add_tools(hover_tool)
     
-    # Línea de regresión global
     x_line = np.linspace(all_x_arr.min(), all_x_arr.max(), 100)
     y_line = model_global.predict(x_line.reshape(-1, 1))
     scatter_fig.line(x_line, y_line, line_width=2, line_color="black", legend_label="Global Regression")
@@ -399,11 +384,10 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
     }
 
 # =============================================================================
-# Función de optimización (grid search) para TSNE, ahora que se usa la misma pipeline
+# Función de optimización (grid search) para TSNE, usando la misma pipeline
 # =============================================================================
 
 def optimize_tsne_params(df_combined, embedding_cols, df_f1):
-    # Rango de búsqueda
     perplexity_range = np.linspace(30, 50, 10)
     learning_rate_range = np.linspace(200, 1000, 20)
     
@@ -432,17 +416,19 @@ def optimize_tsne_params(df_combined, embedding_cols, df_f1):
     return best_params, best_R2
 
 # =============================================================================
-# Función principal run_model que integra la optimización y la ejecución manual
+# Función principal run_model que integra optimización, selector de versión y ejecución manual
 # =============================================================================
 
 def run_model(model_name):
-    embeddings = load_embeddings(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)
     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)
     
-    # Cargar CSV f1-donut
     try:
         df_f1 = pd.read_csv("data/f1-donut.csv", sep=';', index_col=0)
     except Exception as e:
@@ -457,7 +443,7 @@ def run_model(model_name):
         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)
-            st.success(f"Mejores parámetros: Perplexity = {best_params[0]:.2f}, Learning Rate = {best_params[1]:.2f} con R² = {best_R2:.4f}")
+            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:
             perplexity_val = st.number_input(
@@ -481,7 +467,6 @@ def run_model(model_name):
             tsne_params = {"perplexity": perplexity_val, "learning_rate": learning_rate_val}
     # Si se selecciona PCA, tsne_params no se usa.
     
-    # Usar la función centralizada para obtener la regresión global y el scatter plot
     result = compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method=reduction_method)
     
     reg_metrics = pd.DataFrame({
@@ -491,14 +476,12 @@ def run_model(model_name):
     })
     st.table(reg_metrics)
     
-    # No llamamos a st.bokeh_chart(result["scatter_fig"], ...) aquí
-    # Sino que combinamos todo en un único layout:
     data_table, df_table, source_table = create_table(result["df_distances"])
     real_subset_names = list(df_table.columns[1:])
     real_select = Select(title="", value=real_subset_names[0], options=real_subset_names)
     reset_button = Button(label="Reset Colors", button_type="primary")
     line_source = ColumnDataSource(data={'x': [], 'y': []})
-    # Suponiendo que tienes una figura base 'fig' para los clusters:
+    
     fig, real_renderers, synthetic_renderers = create_figure(result["dfs_reduced"], result["unique_subsets"], get_color_maps(result["unique_subsets"]), model_name)
     fig.line('x', 'y', source=line_source, line_width=2, line_color='black')
     centers_real = calculate_cluster_centers(result["dfs_reduced"]["real"], result["unique_subsets"]["real"])
@@ -543,7 +526,6 @@ def run_model(model_name):
     df_table.to_excel(buffer, index=False)
     buffer.seek(0)
     
-    # Combinar todos los gráficos en un único layout:
     layout = column(fig, result["scatter_fig"], column(real_select, reset_button, data_table))
     st.bokeh_chart(layout, use_container_width=True)