Merge branch 'main' of https://huggingface.co/spaces/de-Rodrigo/Embeddings

app.py

@@ -4,7 +4,7 @@ import numpy as np
 from bokeh.plotting import figure
 from bokeh.models import ColumnDataSource, DataTable, TableColumn, CustomJS, Select, Button, HoverTool, LinearColorMapper, ColorBar, FuncTickFormatter, FixedTicker
 from bokeh.layouts import column
-from bokeh.palettes import Reds9, Blues9, Oranges9, Purples9, Greys9, BuGn9, Greens9
+from bokeh.palettes import Reds9, Blues9, Oranges9, Purples9, Greys9, BuGn9, Greens9, RdYlGn11, linear_palette
 from sklearn.decomposition import PCA
 from sklearn.manifold import TSNE, trustworthiness
 from sklearn.metrics import pairwise_distances
@@ -14,6 +14,8 @@ from sklearn.linear_model import LinearRegression
 from scipy.stats import binned_statistic_2d
 import json
 import itertools
+import matplotlib.pyplot as plt
+import matplotlib.colors as mcolors
 
 
 N_COMPONENTS = 3
@@ -1041,6 +1043,17 @@ def run_model(model_name):
         
         # -------------------------------------------------------------------------
         # 4. Cálculo de distancias y scatter plot: Distance vs F1 (usando PC1 y PC2 globales)
+        model_options = ["es-digital-paragraph-degradation-seq", "es-digital-line-degradation-seq", "es-digital-seq", "es-digital-rotation-degradation-seq", "es-digital-zoom-degradation-seq", "es-render-seq"]
+        model_options_with_default = [""]
+        model_options_with_default.extend(model_options)
+
+
+        # Genera una paleta de 256 colores basada en RdYlGn11
+        cmap = plt.get_cmap("RdYlGn")
+        red_green_palette = [mcolors.rgb2hex(cmap(i)) for i in np.linspace(0, 1, 256)]
+
+
+
         real_labels_new = sorted(df_all["real"]['label'].unique().tolist())
         df_distances_new = compute_cluster_distances_synthetic_individual(
             df_all["synthetic"],
@@ -1132,103 +1145,139 @@ def run_model(model_name):
             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 columna 'name' a partir del nombre final de la URL de la imagen
+                # Crear columna 'name' en las muestras reales (si aún no existe)
                 df_all["real"]["name"] = df_all["real"]["img"].apply(
                     lambda x: x.split("/")[-1].replace(".png", "") if isinstance(x, str) else x
                 )
-                # Realizar merge de las posiciones reales con el CSV de heatmaps
-                df_heatmap = pd.merge(df_all["real"], df_heat, on="name", how="inner")
+                # Merge de las posiciones reales con el CSV de heatmaps (se usa el merge base)
+                df_heatmap_base = pd.merge(df_all["real"], df_heat, on="name", how="inner")
                 
-                # Extraer las características disponibles (excluyendo 'name')
+                # Extraer opciones de feature (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}")
-                
-                # 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()
+                                                options=model_options_with_default, key=f"heatmap_extra_dataset_{model_name}")
                 
+                # Definir un rango fijo para los ejes (por ejemplo, de -4 a 4) y rejilla
+                x_min, x_max = -4, 4
+                y_min, y_max = -4, 4
                 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)
                 
-                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
-                
-                try:
-                    heat_stat, x_edges, y_edges, binnumber = binned_statistic_2d(
-                        df_heatmap['x'], df_heatmap['y'], df_heatmap[selected_feature],
-                        statistic='mean', bins=[x_bins, y_bins]
-                    )
-                except TypeError:
-                    cat = df_heatmap[selected_feature].astype('category')
-                    cat_mapping = list(cat.cat.categories)
-                    df_heatmap[selected_feature] = cat.cat.codes
-                    heat_stat, x_edges, y_edges, binnumber = binned_statistic_2d(
-                        df_heatmap['x'], df_heatmap['y'], df_heatmap[selected_feature],
-                        statistic='mean', bins=[x_bins, y_bins]
-                    )
-                
-                # Transponer la matriz para alinear correctamente los ejes
-                heatmap_data = heat_stat.T
-                
-                color_mapper = LinearColorMapper(palette="Viridis256", low=np.nanmin(heatmap_data), high=np.nanmax(heatmap_data), nan_color='rgba(0, 0, 0, 0)')
-                
-                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)
-                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)
-                
-                color_bar = ColorBar(color_mapper=color_mapper, location=(0, 0))
-                if cat_mapping is not None:
-                    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};
-                        var index = Math.round(tick);
-                        if(index >= 0 && index < categories.length) {{
-                            return categories[index];
-                        }} else {{
-                            return "";
-                        }}
-                    """)
-                heatmap_fig.add_layout(color_bar, 'right')
-                
-                source_points = ColumnDataSource(data={
-                    'x': df_heatmap['x'],
-                    'y': df_heatmap['y'],
-                    'img': df_heatmap['img'],
-                    'label': df_heatmap['name']
-                })
-                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]
-                    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
+                # Generar heatmaps para cada combinación de componentes
+                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"### Heatmap: {x_comp} vs {y_comp}")
+                    
+                    # Crear un DataFrame de heatmap para la combinación actual a partir del merge base
+                    df_heatmap = df_heatmap_base.copy()
+                    df_heatmap["x"] = df_heatmap[x_comp]
+                    df_heatmap["y"] = df_heatmap[y_comp]
+                    
+                    # Si la feature seleccionada no es numérica, convertir a códigos y guardar la correspondencia
+                    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
+                    
+                    # Calcular la estadística binned (por ejemplo, la media) en la rejilla
+                    try:
+                        heat_stat, x_edges, y_edges, binnumber = binned_statistic_2d(
+                            df_heatmap['x'], df_heatmap['y'], df_heatmap[selected_feature],
+                            statistic='mean', bins=[x_bins, y_bins]
+                        )
+                    except TypeError:
+                        cat = df_heatmap[selected_feature].astype('category')
+                        cat_mapping = list(cat.cat.categories)
+                        df_heatmap[selected_feature] = cat.cat.codes
+                        heat_stat, x_edges, y_edges, binnumber = binned_statistic_2d(
+                            df_heatmap['x'], df_heatmap['y'], df_heatmap[selected_feature],
+                            statistic='mean', bins=[x_bins, y_bins]
                         )
-                    source_extra_points = ColumnDataSource(data={
-                        'x': df_extra['x'],
-                        'y': df_extra['y'],
-                        'img': df_extra['img'],
-                        'label': df_extra['name']
+                    # Transponer la matriz para alinear correctamente los ejes
+                    heatmap_data = heat_stat.T
+                    
+                    # Definir el color mapper: si la feature es de un modelo (model_options) usar la paleta rojo-verde con rango 0 a 1
+                    if selected_feature in model_options:
+                        color_mapper = LinearColorMapper(
+                            palette=red_green_palette,
+                            low=0,
+                            high=1,
+                            nan_color='rgba(0, 0, 0, 0)'
+                        )
+                    else:
+                        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 la misma escala para x e y
+                    heatmap_fig = figure(title=f"Heatmap de '{selected_feature}' ({x_comp} vs {y_comp})",
+                                        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,
+                                        sizing_mode="fixed")
+                    heatmap_fig.match_aspect = True
+                    
+                    heatmap_fig.xaxis.axis_label = x_comp
+                    heatmap_fig.yaxis.axis_label = y_comp
+                    # Dibujar la imagen del heatmap
+                    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)
+                    
+                    # Agregar la barra de color
+                    color_bar = ColorBar(color_mapper=color_mapper, location=(0, 0))
+                    if cat_mapping is not None:
+                        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};
+                            var index = Math.round(tick);
+                            if(index >= 0 && index < categories.length) {{
+                                return categories[index];
+                            }} else {{
+                                return "";
+                            }}
+                        """)
+                    heatmap_fig.add_layout(color_bar, 'right')
+                    
+                    # Agregar renderer invisible para tooltips (usando puntos en cada bin)
+                    source_points = ColumnDataSource(data={
+                        'x': df_heatmap['x'],
+                        'y': df_heatmap['y'],
+                        'img': df_heatmap['img'],
+                        'label': df_heatmap['name']
                     })
-                    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)
-                
-                st.bokeh_chart(heatmap_fig)
+                    invisible_renderer = heatmap_fig.circle('x', 'y', size=10, source=source_points, fill_alpha=0, line_alpha=0.5)
+                    
+                    # Si se selecciona un dataset extra, proyectar sus puntos en la combinación actual
+                    if select_extra_dataset_hm != "-":
+                        df_extra = df_all["synthetic"][df_all["synthetic"]["source"] == select_extra_dataset_hm].copy()
+                        df_extra["x"] = df_extra[x_comp]
+                        df_extra["y"] = df_extra[y_comp]
+                        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)
+                        source_extra_points = ColumnDataSource(data={
+                            'x': df_extra['x'],
+                            'y': df_extra['y'],
+                            'img': df_extra['img'],
+                            'label': df_extra['name']
+                        })
+                        extra_renderer = heatmap_fig.circle('x', 'y', size=5, source=source_extra_points, fill_alpha=0, line_alpha=0.5, color="purple")
+                    
+                    hover_tool_points = HoverTool(renderers=[invisible_renderer], tooltips=TOOLTIPS)
+                    heatmap_fig.add_tools(hover_tool_points)
+                    
+                    st.bokeh_chart(heatmap_fig)
 
 def main():
     config_style()