Multiple Principal Components Combinations

app.py

@@ -13,9 +13,10 @@ import ot
 from sklearn.linear_model import LinearRegression
 from scipy.stats import binned_statistic_2d
 import json
+import itertools
 
 
-N_COMPONENTS = 2
+N_COMPONENTS = 3
 TSNE_NEIGHBOURS = 150
 # WEIGHT_FACTOR = 0.05
 
@@ -508,6 +509,12 @@ def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, r
     
     return results
 
+# def get_color(color_entry):
+#     if isinstance(color_entry, dict):
+#         # Extrae el primer valor (o ajusta según convenga)
+#         return list(color_entry.values())[0]
+#     return color_entry
+
 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)
@@ -730,21 +737,22 @@ def run_model(model_name):
         key=f"download_button_excel_{model_name}"
     )
 
-    # Nuevo bloque: PCA solo para df_real
     if reduction_method == "PCA":
         st.markdown("## PCA - Solo Muestras Reales")
-        # Extraemos únicamente las muestras reales
+        # -------------------------------------------------------------------------
+        # 1. PCA sobre las muestras reales
         df_real_only = embeddings["real"].copy()
         pca_real = PCA(n_components=N_COMPONENTS)
         reduced_real = pca_real.fit_transform(df_real_only[embedding_cols].values)
-        df_real_only['embedding'] = list(reduced_real)
-        if reduced_real.shape[1] == 2:
-            df_real_only['x'] = reduced_real[:, 0]
-            df_real_only['y'] = reduced_real[:, 1]
+        
+        # Agregar columnas PC1, PC2, … a df_real_only
+        for i in range(reduced_real.shape[1]):
+            df_real_only[f'PC{i+1}'] = reduced_real[:, i]
+        
         explained_variance_real = pca_real.explained_variance_ratio_
         unique_labels_real = sorted(df_real_only['label'].unique().tolist())
         
-        # Definir mapeo de colores usando la paleta Reds9
+        # Mapeo de colores para las muestras reales usando la paleta Reds9
         num_labels = len(unique_labels_real)
         if num_labels <= 9:
             red_palette = Reds9[:num_labels]
@@ -752,6 +760,7 @@ def run_model(model_name):
             red_palette = (Reds9 * ((num_labels // 9) + 1))[:num_labels]
         real_color_mapping = {label: red_palette[i] for i, label in enumerate(unique_labels_real)}
         
+        # Mostrar tabla de Explained Variance Ratio
         st.subheader("PCA - Real: Explained Variance Ratio")
         component_names_real = [f"PC{i+1}" for i in range(len(explained_variance_real))]
         variance_df_real = pd.DataFrame({
@@ -759,8 +768,8 @@ def run_model(model_name):
             "Explained Variance": explained_variance_real
         })
         st.table(variance_df_real)
-
-        # Mostrar los plots de loadings (Component Loadings)
+        
+        # Mostrar los plots de loadings para cada componente
         st.subheader("PCA - Real: Component Loadings")
         st.markdown("### Pesos de las Componentes Principales (Loadings) - Conjunto Combinado")
         for i, comp in enumerate(pca_real.components_):
@@ -777,62 +786,52 @@ def run_model(model_name):
                 tools="pan,wheel_zoom,reset,save,hover",
                 active_scroll="wheel_zoom"
             )
-            # Fondo blanco y solo grid horizontal
             p.background_fill_color = "white"
             p.xgrid.grid_line_color = None
             p.ygrid.grid_line_color = "gray"
             p.vbar(x='dimensions', top='weight', width=0.8, source=source,
                 fill_color="#2b83ba", line_color="#2b83ba")
-            # No se muestran etiquetas en el eje horizontal
             p.xaxis.axis_label = "Dimensiones Originales"
             p.xaxis.major_label_text_font_size = '0pt'
-            # Configurar el HoverTool
             hover = p.select_one(HoverTool)
             hover.tooltips = [("Dimensión", "@dimensions"), ("Peso", "@weight")]
             st.bokeh_chart(p)
         
-        # Segundo PCA: Proyección de todos los subconjuntos usando los loadings calculados con df_real_only
-        st.subheader("PCA - Todos los subconjuntos proyectados (usando loadings de df_real)")
-
-        # Crear un diccionario para almacenar las proyecciones usando el PCA calculado con las muestras reales (pca_real)
+        # -------------------------------------------------------------------------
+        # 2. Proyección de todos los subconjuntos usando los loadings de df_real (para PC completos)
+        # Se proyectan real, synthetic y pretrained (si existen) y se agregan todas las PC's.
         df_all = {}
-
-        # Proyectar las muestras reales
+        # Real
         df_real_proj = embeddings["real"].copy()
         proj_real = pca_real.transform(df_real_proj[embedding_cols].values)
-        df_real_proj['pc1'] = proj_real[:, 0]
-        df_real_proj['pc2'] = proj_real[:, 1]
+        for i in range(proj_real.shape[1]):
+            df_real_proj[f'PC{i+1}'] = proj_real[:, i]
         df_all["real"] = df_real_proj
 
-        # Proyectar el subconjunto synthetic, si existe
+        # Synthetic
         if "synthetic" in embeddings:
             df_synth_proj = embeddings["synthetic"].copy()
             proj_synth = pca_real.transform(df_synth_proj[embedding_cols].values)
-            df_synth_proj['pc1'] = proj_synth[:, 0]
-            df_synth_proj['pc2'] = proj_synth[:, 1]
+            for i in range(proj_synth.shape[1]):
+                df_synth_proj[f'PC{i+1}'] = proj_synth[:, i]
             df_all["synthetic"] = df_synth_proj
 
-        # Proyectar el subconjunto pretrained, si existe
+        # Pretrained
         if "pretrained" in embeddings:
             df_pretr_proj = embeddings["pretrained"].copy()
             proj_pretr = pca_real.transform(df_pretr_proj[embedding_cols].values)
-            df_pretr_proj['pc1'] = proj_pretr[:, 0]
-            df_pretr_proj['pc2'] = proj_pretr[:, 1]
+            for i in range(proj_pretr.shape[1]):
+                df_pretr_proj[f'PC{i+1}'] = proj_pretr[:, i]
             df_all["pretrained"] = df_pretr_proj
 
-        # Para utilizar las mismas funciones de plot (create_figure, add_dataset_to_fig, add_synthetic_dataset_to_fig),
-        # renombramos las columnas 'pc1' y 'pc2' a 'x' y 'y' en cada dataframe
+        # Para el plot global usaremos PC1 y PC2 (se asignan a 'x' y 'y')
         for key in df_all:
-            df_all[key]["x"] = df_all[key]["pc1"]
-            df_all[key]["y"] = df_all[key]["pc2"]
+            df_all[key]["x"] = df_all[key]["PC1"]
+            df_all[key]["y"] = df_all[key]["PC2"]
 
-        # Construir los subconjuntos únicos con la granularidad deseada:
-        # - Para "real" y "pretrained": agrupamos por label.
-        # - Para "synthetic": agrupamos por la columna "source" (cada source tendrá sus labels).
+        # Construir los subconjuntos únicos para agrupar:
         unique_subsets = {}
-        # Real:
         unique_subsets["real"] = sorted(df_all["real"]['label'].unique().tolist())
-        # Synthetic:
         if "synthetic" in df_all:
             unique_synth = {}
             for source in df_all["synthetic"]["source"].unique():
@@ -840,16 +839,15 @@ def run_model(model_name):
             unique_subsets["synthetic"] = unique_synth
         else:
             unique_subsets["synthetic"] = {}
-        # Pretrained:
         if "pretrained" in df_all:
             unique_subsets["pretrained"] = sorted(df_all["pretrained"]['label'].unique().tolist())
         else:
             unique_subsets["pretrained"] = []
-
-        # Obtener los mapeos de colores utilizando la función ya definida
+        
+        # Obtener mapeo de colores para cada subconjunto (función definida externamente)
         color_maps = get_color_maps(unique_subsets)
-
-        # Definir un mapeo de marcadores para los subconjuntos synthetic (granularidad por source)
+        
+        # Mapeo de marcadores para synthetic (por source)
         marker_mapping = {
             "es-digital-paragraph-degradation-seq": "x",
             "es-digital-line-degradation-seq": "cross",
@@ -858,9 +856,9 @@ def run_model(model_name):
             "es-digital-zoom-degradation-seq": "asterisk",
             "es-render-seq": "inverted_triangle"
         }
-
-        # Ahora, crear la figura utilizando las funciones existentes para mantener la granularidad:
-        # Se plotean las muestras reales, synthetic (por source) y pretrained con sus respectivos marcadores y colores.
+        
+        # Plot global: se muestran real, synthetic y pretrained (según checkbox)
+        st.subheader("PCA - Todos los subconjuntos proyectados (PC1 vs PC2)")
         fig_all = figure(
             title="PCA - Todos los subconjuntos proyectados",
             plot_width=600,
@@ -870,11 +868,10 @@ def run_model(model_name):
             background_fill_color="white",
             tooltips=TOOLTIPS
         )
-        # Solo grid horizontal
         fig_all.xgrid.grid_line_color = None
         fig_all.ygrid.grid_line_color = "gray"
-
-        # Ploteamos los puntos de las muestras reales (agrupados por label)
+        
+        # Plotear las muestras reales, agrupadas por label
         for label in unique_subsets["real"]:
             subset = df_all["real"][df_all["real"]['label'] == label]
             source = ColumnDataSource(data={
@@ -883,28 +880,28 @@ def run_model(model_name):
                 'label': subset['label'],
                 'img': subset['img']
             })
-            # Usamos 'circle' para las reales
             fig_all.circle('x', 'y', size=10,
                         fill_color=color_maps["real"][label],
                         line_color=color_maps["real"][label],
                         legend_label=f"Real: {label}",
                         source=source)
-
+        
         show_real_only = st.checkbox("Show only real samples", value=True, key=f"show_real_only_{model_name}")
-
         if not show_real_only:
-
-            # Ploteamos los puntos de synthetic, diferenciando cada source con su marcador
+            # Agregar synthetic
             if unique_subsets["synthetic"]:
                 for source_name, labels in unique_subsets["synthetic"].items():
                     df_source = df_all["synthetic"][df_all["synthetic"]["source"] == source_name]
                     marker = marker_mapping.get(source_name, "square")
-                    # Para cada label en ese source, usamos la función auxiliar
-                    renderers = add_synthetic_dataset_to_fig(fig_all, df_source, labels,
-                                                            marker=marker,
-                                                            color_mapping=color_maps["synthetic"][source_name],
-                                                            group_label=source_name)
-            # Ploteamos los puntos de pretrained (agrupados por label)
+                    # Se usa el mapeo de colores para synthetic
+                    color_val = color_maps["synthetic"][source_name]
+                    renderers = add_synthetic_dataset_to_fig(
+                        fig_all, df_source, labels,
+                        marker=marker,
+                        color_mapping=color_val,
+                        group_label=source_name
+                    )
+            # Agregar pretrained
             if unique_subsets["pretrained"]:
                 for label in unique_subsets["pretrained"]:
                     subset = df_all["pretrained"][df_all["pretrained"]['label'] == label]
@@ -914,76 +911,151 @@ def run_model(model_name):
                         'label': subset['label'],
                         'img': subset['img']
                     })
-                    # Usamos 'triangle' para pretrained (por ejemplo)
                     fig_all.triangle('x', 'y', size=10,
                                     fill_color=color_maps["pretrained"][label],
                                     line_color=color_maps["pretrained"][label],
                                     legend_label=f"Pretrained: {label}",
                                     source=source)
-
-        # Calcular el centroide y el radio (usando solo las muestras reales)
+        
+        show_legend_global = st.checkbox("Show Legend", value=False, key=f"legend_global_{model_name}")
+        fig_all.legend.visible = show_legend_global
+        fig_all.legend.location = "top_right"
+        fig_all.match_aspect = True
+        st.bokeh_chart(fig_all)
+        
+        # Calcular centroide y radio (usando solo las muestras reales)
         center_x = df_all["real"]['x'].mean()
         center_y = df_all["real"]['y'].mean()
         distances = np.sqrt((df_all["real"]['x'] - center_x)**2 + (df_all["real"]['y'] - center_y)**2)
         radius = distances.max()
-
-        # Dibujar el centroide y la circunferencia en el plot
+        
+        # Dibujar el centroide y la circunferencia
         centroid_glyph = fig_all.circle(
             x=center_x, y=center_y, size=15,
             fill_color="white", line_color="black",
             legend_label="Centroide",
-            name="centroid"  # Asigna un nombre único
+            name="centroid"
         )
-
         circumference_glyph = fig_all.circle(
             x=center_x, y=center_y, radius=radius,
             fill_color=None, line_color="black",
             line_dash="dashed",
             legend_label="Circunferencia",
-            name="circumference"  # Asigna un nombre único
+            name="circumference"
         )
-
+        
+        # Ajustar ejes y tooltips
         fig_all.xaxis.axis_label = "PC1"
         fig_all.yaxis.axis_label = "PC2"
         hover_all = fig_all.select_one(HoverTool)
         hover_all.renderers = [r for r in fig_all.renderers if r.name not in ["centroid", "circumference"]]
-
-        # hover_all.tooltips = [("Label", "@label"), ("PC1", "@x"), ("PC2", "@y")]
-
-        # Agregar checkbox para mostrar u ocultar la leyenda, igual que en el primer PCA
-        show_legend_second = st.checkbox("Show Legend", value=False, key=f"legend_second_{model_name}")
-        fig_all.legend.visible = show_legend_second
-        fig_all.legend.location = "top_right"
-        fig_all.match_aspect = True
-
-        st.bokeh_chart(fig_all)
-
-        # Mostrar el valor del radio debajo del gráfico
+        
         st.write(f"El radio de la circunferencia (calculado a partir de las muestras reales) es: {radius:.4f}")
+        
+        # -------------------------------------------------------------------------
+        # Calcular el rango global: recorrer todas las proyecciones de todos los subconjuntos
+        all_vals = []
+        for key in df_all:
+            for comp in [f'PC{i+1}' for i in range(N_COMPONENTS)]:
+                all_vals.append(df_all[key][comp])
+        all_vals = pd.concat(all_vals)
+        # Tomar el máximo valor absoluto de todas las proyecciones
+        max_val = all_vals.abs().max()
+        global_range = (-max_val, max_val)
+
+        # 3. Scatter plots para cada combinación (vistas planta, alzado y perfil)
+        st.subheader("Scatter Plots: Vistas de Componentes (Combinaciones)")
+        pairs = list(itertools.combinations(range(N_COMPONENTS), 2))
+        for (i, j) in pairs:
+            x_comp = f'PC{i+1}'
+            y_comp = f'PC{j+1}'
+            
+            st.markdown(f"### Scatter Plot: {x_comp} vs {y_comp}")
+            # Usar el rango global para ambos ejes
+            p = figure(
+                title=f"{x_comp} vs {y_comp}",
+                plot_width=700,
+                plot_height=700,
+                x_range=global_range,
+                y_range=global_range,
+                tools="pan,wheel_zoom,reset,save,hover",
+                active_scroll="wheel_zoom",
+                background_fill_color="white",
+                tooltips=TOOLTIPS
+            )
+            # Etiquetas de ejes
+            p.xaxis.axis_label = x_comp
+            p.yaxis.axis_label = y_comp
+
+            # Muestras reales: se usan directamente los valores de PC{i+1} y PC{j+1}
+            for label in unique_subsets["real"]:
+                subset = df_all["real"][df_all["real"]['label'] == label]
+                source = ColumnDataSource(data={
+                    'x': subset[x_comp],
+                    'y': subset[y_comp],
+                    'label': subset['label'],
+                    'img': subset['img']
+                })
+                p.circle('x', 'y', size=10,
+                        fill_color=color_maps["real"][label],
+                        line_color=color_maps["real"][label],
+                        legend_label=f"Real: {label}",
+                        source=source)
+            
+            # Selector para incluir o no synthetic y pretrained en este gráfico
+            show_pair_only_real = st.checkbox("Show only real samples", value=True, key=f"pair_show_real_{i}_{j}_{model_name}")
+            if not show_pair_only_real:
+                # Synthetic
+                if "synthetic" in df_all:
+                    for source_name, labels in unique_subsets["synthetic"].items():
+                        # Obtener las filas de synthetic para ese source y asignar el rango adecuado
+                        df_source = df_all["synthetic"][df_all["synthetic"]["source"] == source_name].copy()
+                        df_source["x"] = df_source[x_comp]
+                        df_source["y"] = df_source[y_comp]
+                        marker = marker_mapping.get(source_name, "square")
+                        renderers = add_synthetic_dataset_to_fig(
+                            p, df_source, labels,
+                            marker=marker,
+                            color_mapping=color_maps["synthetic"][source_name],
+                            group_label=source_name
+                        )
+                # Pretrained
+                if "pretrained" in df_all:
+                    for label in unique_subsets["pretrained"]:
+                        subset = df_all["pretrained"][df_all["pretrained"]['label'] == label]
+                        source = ColumnDataSource(data={
+                            'x': subset[x_comp],
+                            'y': subset[y_comp],
+                            'label': subset['label'],
+                            'img': subset['img']
+                        })
+                        p.triangle('x', 'y', size=10,
+                                fill_color=color_maps["pretrained"][label],
+                                line_color=color_maps["pretrained"][label],
+                                legend_label=f"Pretrained: {label}",
+                                source=source)
+            show_legend_pair = st.checkbox("Show Legend", value=False, key=f"legend_pair_{i}_{j}_{model_name}")
+            p.legend.visible = show_legend_pair
+            st.bokeh_chart(p)
 
-
-        # --- Cálculo de distancias y scatter plot de Distance vs F1 para el nuevo PCA ---
-
-        # Se calcula la distancia de cada subset synthetic a cada subset real usando los datos proyectados (df_all)
-        # Se utiliza la función compute_cluster_distances_synthetic_individual ya definida
+        
+        # -------------------------------------------------------------------------
+        # 4. Cálculo de distancias y scatter plot: Distance vs F1 (usando PC1 y PC2 globales)
         real_labels_new = sorted(df_all["real"]['label'].unique().tolist())
         df_distances_new = compute_cluster_distances_synthetic_individual(
             df_all["synthetic"],
             df_all["real"],
             real_labels_new,
-            metric="wasserstein",  # Puedes cambiar la métrica según lo requieras
+            metric="wasserstein",  # O la métrica que prefieras
             bins=20
         )
-
-        # Extraer las distancias globales (por cada source) del dataframe obtenido,
-        # buscando filas cuyo índice comience con "Global" (formato "Global (source)")
+        
         global_distances_new = {}
         for idx in df_distances_new.index:
             if idx.startswith("Global"):
                 source_name = idx.split("(")[1].rstrip(")")
                 global_distances_new[source_name] = df_distances_new.loc[idx].values
-
-        # Ahora, relacionar estas distancias con los valores de F1 (ya cargados en df_f1)
+        
         all_x_new = []
         all_y_new = []
         for source in df_f1.columns:
@@ -994,14 +1066,12 @@ def run_model(model_name):
                 all_y_new.extend(y_vals)
         all_x_arr_new = np.array(all_x_new).reshape(-1, 1)
         all_y_arr_new = np.array(all_y_new)
-
-        # Realizar la regresión lineal global sobre estos datos
+        
         model_global_new = LinearRegression().fit(all_x_arr_new, all_y_arr_new)
         r2_new = model_global_new.score(all_x_arr_new, all_y_arr_new)
         slope_new = model_global_new.coef_[0]
         intercept_new = model_global_new.intercept_
-
-        # Crear el scatter plot
+        
         scatter_fig_new = figure(
             width=600,
             height=600,
@@ -1011,12 +1081,10 @@ def run_model(model_name):
             background_fill_color="white",
             y_range=(0, 1)
         )
-        # Configurar únicamente grid horizontal
         scatter_fig_new.xgrid.grid_line_color = None
         scatter_fig_new.ygrid.grid_line_color = "gray"
         scatter_fig_new.match_aspect = True
-
-        # Mantenemos el mismo código de colores que en el otro scatter plot
+        
         source_colors = {
             "es-digital-paragraph-degradation-seq": "blue",
             "es-digital-line-degradation-seq": "green",
@@ -1026,8 +1094,7 @@ def run_model(model_name):
             "es-digital-rotation-zoom-degradation-seq": "brown",
             "es-render-seq": "cyan"
         }
-
-        # Dibujar cada conjunto: para cada source (por ejemplo, es-render-seq, etc.)
+        
         for source in df_f1.columns:
             if source in global_distances_new:
                 x_vals = global_distances_new[source]
@@ -1040,81 +1107,59 @@ def run_model(model_name):
                     line_color=source_colors.get(source, "gray"),
                     legend_label=source
                 )
-
+        
         scatter_fig_new.xaxis.axis_label = "Distance (Global, por Colegio) - Nueva PCA"
         scatter_fig_new.yaxis.axis_label = "F1 Score"
         scatter_fig_new.legend.location = "top_right"
-
         hover_tool_new = scatter_fig_new.select_one(HoverTool)
         hover_tool_new.tooltips = [("Distance", "@x"), ("F1", "@y"), ("Subset", "@Fuente")]
-
-        # Dibujar la línea de regresión global
         x_line_new = np.linspace(all_x_arr_new.min(), all_x_arr_new.max(), 100)
         y_line_new = model_global_new.predict(x_line_new.reshape(-1,1))
         scatter_fig_new.line(x_line_new, y_line_new, line_width=2, line_color="black", legend_label="Global Regression")
-
         st.bokeh_chart(scatter_fig_new)
-
         st.write(f"Regresión global (Nueva PCA): R² = {r2_new:.4f}, Slope = {slope_new:.4f}, Intercept = {intercept_new:.4f}")
-
-
-
-
-
-
-
-
-
-        # --- INICIO DEL BLOQUE: Heatmap de características ---
+        
+        # -------------------------------------------------------------------------
+        # 5. BLOQUE: Heatmap de Características
         st.markdown("## Heatmap de Características")
-
         try:
             df_heat = pd.read_csv("data/heatmaps.csv")
-            # Si fuera necesario, se pueden limpiar los nombres de las columnas:
-            # df_heat.columns = [col.strip("'\"") for col in df_heat.columns]
         except Exception as e:
             st.error(f"Error al cargar heatmaps.csv: {e}")
             df_heat = None
-
+        
         if df_heat is not None:
-            # Verificamos que la columna 'img' esté presente en df_all["real"]
             if 'img' not in df_all["real"].columns:
                 st.error("La columna 'img' no se encuentra en las muestras reales para hacer el merge con heatmaps.csv.")
             else:
-                # Crear la columna 'name' extrayendo el nombre final de la URL y removiendo ".png"
+                # Crear columna 'name' a partir del nombre final de la URL de la imagen
                 df_all["real"]["name"] = df_all["real"]["img"].apply(
                     lambda x: x.split("/")[-1].replace(".png", "") if isinstance(x, str) else x
                 )
-                
-                # Hacemos merge de las posiciones reales con el CSV de heatmaps usando la columna 'name'
+                # Realizar merge de las posiciones reales con el CSV de heatmaps
                 df_heatmap = pd.merge(df_all["real"], df_heat, on="name", how="inner")
                 
-                # Extraemos las características disponibles (excluyendo 'name')
+                # Extraer las características disponibles (excluyendo 'name')
                 feature_options = [col for col in df_heat.columns if col != "name"]
                 selected_feature = st.selectbox("Select heatmap feature:", 
                                                 options=feature_options, key=f"heatmap_{model_name}")
-                
                 select_extra_dataset_hm = st.selectbox("Select a dataset:", 
                                                 options=["-", "es-digital-line-degradation-seq", "es-digital-seq", "es-digital-rotation-degradation-seq", "es-digital-zoom-degradation-seq", "es-render-seq"], key=f"heatmap_extra_dataset_{model_name}")
                 
-                # Determinar el rango de las posiciones (x, y) de las muestras reales
+                # Definir el rango de posiciones (x, y)
                 x_min, x_max = df_heatmap['x'].min(), df_heatmap['x'].max()
                 y_min, y_max = df_heatmap['y'].min(), df_heatmap['y'].max()
                 
-                # Definir resolución de la rejilla (por ejemplo, 50x50)
                 grid_size = 50
                 x_bins = np.linspace(x_min, x_max, grid_size + 1)
                 y_bins = np.linspace(y_min, y_max, grid_size + 1)
                 
-                # Si la variable seleccionada no es numérica, la convertimos a códigos numéricos
-                # y guardamos la correspondencia para la leyenda.
                 cat_mapping = None
                 if df_heatmap[selected_feature].dtype == bool or not pd.api.types.is_numeric_dtype(df_heatmap[selected_feature]):
                     cat = df_heatmap[selected_feature].astype('category')
                     cat_mapping = list(cat.cat.categories)
                     df_heatmap[selected_feature] = cat.cat.codes
                 
-                # Intentamos calcular el heatmap; si falla, aplicamos la conversión a categoría
                 try:
                     heat_stat, x_edges, y_edges, binnumber = binned_statistic_2d(
                         df_heatmap['x'], df_heatmap['y'], df_heatmap[selected_feature],
@@ -1129,32 +1174,23 @@ def run_model(model_name):
                         statistic='mean', bins=[x_bins, y_bins]
                     )
                 
-                # La función image de Bokeh espera una lista de arrays; se transpone para alinear los ejes.
+                # Transponer la matriz para alinear correctamente los ejes
                 heatmap_data = heat_stat.T
                 
-                # Crear el mapa de color
-                color_mapper = LinearColorMapper(palette="Viridis256", low=np.nanmin(heatmap_data), high=np.nanmax(heatmap_data), nan_color = 'rgba(0, 0, 0, 0)')
+                color_mapper = LinearColorMapper(palette="Viridis256", low=np.nanmin(heatmap_data), high=np.nanmax(heatmap_data), nan_color='rgba(0, 0, 0, 0)')
                 
-                # Crear la figura para el heatmap con fondo blanco
                 heatmap_fig = figure(title=f"Heatmap de '{selected_feature}'",
                                     x_range=(x_min, x_max), y_range=(y_min, y_max),
                                     width=600, height=600,
                                     tools="pan,wheel_zoom,reset,save", active_scroll="wheel_zoom", tooltips=TOOLTIPS)
-                
-                # Dibujar el heatmap usando la imagen
                 heatmap_fig.image(image=[heatmap_data], x=x_min, y=y_min,
                                 dw=x_max - x_min, dh=y_max - y_min,
                                 color_mapper=color_mapper)
                 
-                # Crear la barra de colores
                 color_bar = ColorBar(color_mapper=color_mapper, location=(0, 0))
-                # Si se usó conversión a categoría, formateamos la barra para mostrar las etiquetas originales
                 if cat_mapping is not None:
-                    
-                    # Creamos ticks fijos solo para cada categoría
                     ticks = list(range(len(cat_mapping)))
                     color_bar.ticker = FixedTicker(ticks=ticks)
-                    
                     categories_json = json.dumps(cat_mapping)
                     color_bar.formatter = FuncTickFormatter(code=f"""
                         var categories = {categories_json};
@@ -1166,22 +1202,17 @@ def run_model(model_name):
                         }}
                     """)
                 heatmap_fig.add_layout(color_bar, 'right')
-
-
-
-                # Agregar renderer de puntos invisibles para tooltips
+                
                 source_points = ColumnDataSource(data={
                     'x': df_heatmap['x'],
                     'y': df_heatmap['y'],
                     'img': df_heatmap['img'],
-                    'label': df_heatmap['name']  # Asegúrate de que esta columna exista; si no, usa otra
+                    'label': df_heatmap['name']
                 })
-                # Dibujar círculos con transparencia total (no se verán)
                 invisible_renderer = heatmap_fig.circle('x', 'y', size=10, source=source_points, fill_alpha=0, line_alpha=0.5)
-
+                
                 if select_extra_dataset_hm != "-":
                     df_extra = df_all["synthetic"][df_all["synthetic"]["source"] == select_extra_dataset_hm]
-                    # Asegurarse de que exista la columna 'name'
                     if 'name' not in df_extra.columns:
                         df_extra["name"] = df_extra["img"].apply(
                             lambda x: x.split("/")[-1].replace(".png", "") if isinstance(x, str) else x
@@ -1192,9 +1223,8 @@ def run_model(model_name):
                         'img': df_extra['img'],
                         'label': df_extra['name']
                     })
-                    # Agregar renderer para el dataset extra
                     extra_renderer = heatmap_fig.circle('x', 'y', size=10, source=source_extra_points, fill_alpha=0, line_alpha=0.5, color="red")
-
+                
                 hover_tool_points = HoverTool(renderers=[invisible_renderer], tooltips=TOOLTIPS)
                 heatmap_fig.add_tools(hover_tool_points)