Refactor Code

app.py

@@ -17,6 +17,7 @@ TOOLTIPS = """
 </div>
 """
 
+
 def config_style():
     st.markdown("""
         <style>
@@ -25,17 +26,43 @@ def config_style():
         .custom-text { font-size: 18px; line-height: 1.5; }
         </style>
     """, unsafe_allow_html=True)
-    st.markdown('<h1 class="main-title">Merit Secret Embeddings 🎒📃🏆</h1>', unsafe_allow_html=True)
-    st.markdown('<h2 class="sub-title">Donut - Comparación de versiones</h2>', unsafe_allow_html=True)
+    st.markdown('<h1 class="main-title">Merit Embeddings 🎒📃🏆</h1>', unsafe_allow_html=True)
+    st.markdown('<h2 class="sub-title">Donut 🤗</h2>', unsafe_allow_html=True)
     st.markdown(
         """
         <p class="custom-text">
         Se cargan ambas versiones de los embeddings y se aplica una reducción dimensional sobre el conjunto combinado.
-        Los puntos de la versión vanilla se muestran como <strong>círculos</strong> (tonos de rojo)
-        y los de la v2 como <strong>cuadrados</strong> (tonos de azul).
+        Los puntos de la versión real se muestran como <strong>círculos</strong> (tonos de rojo)
+        y los de la es_digital_seq como <strong>cuadrados</strong> (tonos de azul).
         </p>
         """, unsafe_allow_html=True)
 
+
+def load_embeddings():
+    df_real = pd.read_csv("data/donut_de_Rodrigo_merit_secret_all_embeddings.csv")
+    df_es_digital_seq = pd.read_csv("data/donut_de_Rodrigo_merit_es-digital-seq_embeddings.csv")
+
+    embeddings = {
+        "real": df_real,
+        "es-digital-seq": df_es_digital_seq
+    }
+
+    return embeddings
+
+
+def reducer_selector(df_combined, embedding_cols):
+
+    reduction_method = st.selectbox("Seleccione método de reducción:", options=["PCA", "t-SNE"])
+    all_embeddings = df_combined[embedding_cols].values
+    if reduction_method == "PCA":
+        reducer = PCA(n_components=2)
+    else:
+        reducer = TSNE(n_components=2, random_state=42, perplexity=30, learning_rate=200)
+    reduced = reducer.fit_transform(all_embeddings)
+
+    return reduced
+
+
 def add_dataset_to_fig(fig, df, selected_labels, marker, color_mapping):
     for label in selected_labels:
         subset = df[df['label'] == label]
@@ -53,90 +80,119 @@ def add_dataset_to_fig(fig, df, selected_labels, marker, color_mapping):
                        fill_color=color, line_color=color,
                        legend_label=f"{label} (Real)")
         elif marker == "square":
-            fig.square('x', 'y', size=10, source=source,
-                       fill_alpha=0, line_color=color,
+            fig.square('x', 'y', size=4, source=source, fill_color=color, line_color=color,
                        legend_label=f"{label} (Sintético)")
 
-def main():
-    config_style()
-    
-    st.markdown('<h2 class="sub-title">Carga y reducción dimensional</h2>', unsafe_allow_html=True)
-    
-    # Cargar ambas versiones de los embeddings
-    df_vanilla = pd.read_csv("data/donut_de_Rodrigo_merit_secret_all_embeddings.csv")
-    df_v2      = pd.read_csv("data/donut_de_Rodrigo_merit_es-digital-seq_embeddings.csv")
-    
-    # Agregar una columna para identificar la versión
-    df_vanilla["version"] = "vanilla"
-    df_v2["version"]      = "v2"
-    
-    # Se asume que ambas versiones tienen columnas de embedding que comienzan con "dim_"
-    embedding_cols = [col for col in df_vanilla.columns if col.startswith("dim_")]
-    
-    # Combinar ambos dataframes para que la reducción se aplique sobre el conjunto completo
-    df_combined = pd.concat([df_vanilla, df_v2], ignore_index=True)
+
+def get_color_maps(selected_subsets: dict):
     
-    # Selección del método de reducción dimensional
-    reduction_method = st.selectbox("Seleccione método de reducción:", options=["PCA", "t-SNE"])
-    all_embeddings = df_combined[embedding_cols].values
-    if reduction_method == "PCA":
-        reducer = PCA(n_components=2)
+    # real
+    num_real = len(selected_subsets["real"])
+    if num_real <= 9:
+        red_palette = Reds9[:num_real]
     else:
-        reducer = TSNE(n_components=2, random_state=42, perplexity=30, learning_rate=200)
-    reduced = reducer.fit_transform(all_embeddings)
+        red_palette = (Reds9 * ((num_real // 9) + 1))[:num_real]
+    color_mapping_real = {label: red_palette[i] for i, label in enumerate(sorted(selected_subsets["real"]))}
     
-    # Asignar las coordenadas resultantes al dataframe combinado
+    # es-digital-seq
+    num_es_digital_seq = len(selected_subsets["es-digital-seq"])
+    if num_es_digital_seq <= 9:
+        blue_palette = Blues9[:num_es_digital_seq]
+    else:
+        blue_palette = (Blues9 * ((num_es_digital_seq // 9) + 1))[:num_es_digital_seq]
+    color_mapping_es_digital_seq = {label: blue_palette[i] for i, label in enumerate(sorted(selected_subsets["es-digital-seq"]))}
+
+    # Gather color maps
+    color_maps = {
+        "real": color_mapping_real,
+        "es-digital-seq": color_mapping_es_digital_seq
+    }
+
+    return color_maps
+
+
+def split_versions(df_combined, reduced):
+
     df_combined['x'] = reduced[:, 0]
     df_combined['y'] = reduced[:, 1]
-    
-    # Separar nuevamente según la versión
-    df_vanilla_trans = df_combined[df_combined["version"] == "vanilla"].copy()
-    df_v2_trans      = df_combined[df_combined["version"] == "v2"].copy()
+
+    df_real_reduced = df_combined[df_combined["version"] == "real"].copy()
+    df_es_digital_seq_reduced = df_combined[df_combined["version"] == "es_digital_seq"].copy()
     
     # Obtener los subsets únicos de cada versión
-    unique_labels_vanilla = sorted(df_vanilla_trans['label'].unique().tolist())
-    unique_labels_v2      = sorted(df_v2_trans['label'].unique().tolist())
+    unique_subsets_real = sorted(df_real_reduced['label'].unique().tolist())
+    unique_subsets_es_digital_seq = sorted(df_es_digital_seq_reduced['label'].unique().tolist())
+
+    unique_subsets = {
+        "real": unique_subsets_real,
+        "es-digital-seq": unique_subsets_es_digital_seq,
+    }
+
+    dfs_reduced = {
+        "real": df_real_reduced,
+        "es-digital-seq": df_es_digital_seq_reduced,
+    }
+
+    return dfs_reduced, unique_subsets
+
+
+def subset_selectors(unique_subsets: dict):
+
+    selected_subsets_real = st.multiselect("Seleccione subsets para visualizar (Real):",
+                                             options=unique_subsets["real"],
+                                             default=unique_subsets["real"])
+    selected_subsets_es_digital_seq = st.multiselect("Seleccione subsets para visualizar (Sintético):",
+                                        options=unique_subsets["es-digital-seq"],
+                                        default=unique_subsets["es-digital-seq"])
+    
+    selected_subsets = {
+        "real": selected_subsets_real,
+        "es-digital-seq": selected_subsets_es_digital_seq
+    }
+
+    return selected_subsets
+
+
+def create_figure(dfs_reduced, selected_subsets: dict, color_maps: dict):
+
+    fig = figure(width=600, height=600, tooltips=TOOLTIPS,
+                 title="")
     
-    # Selectores para filtrar los subsets a visualizar
-    selected_labels_vanilla = st.multiselect("Seleccione subsets para visualizar (Real):",
-                                             options=unique_labels_vanilla,
-                                             default=unique_labels_vanilla)
-    selected_labels_v2 = st.multiselect("Seleccione subsets para visualizar (Sintético):",
-                                        options=unique_labels_v2,
-                                        default=unique_labels_v2)
+    add_dataset_to_fig(fig, dfs_reduced["real"], selected_subsets["real"],
+                       marker="circle", color_mapping=color_maps["real"])
+    add_dataset_to_fig(fig, dfs_reduced["es-digital-seq"], selected_subsets["es-digital-seq"],
+                       marker="square", color_mapping=color_maps["es-digital-seq"])
     
-    # Generar mapeos de colores específicos:
-    # Para vanilla se usarán tonos de rojo (paleta Reds9)
-    num_vanilla = len(selected_labels_vanilla)
-    if num_vanilla <= 9:
-        red_palette = Reds9[:num_vanilla]
-    else:
-        red_palette = (Reds9 * ((num_vanilla // 9) + 1))[:num_vanilla]
-    color_mapping_vanilla = {label: red_palette[i] for i, label in enumerate(sorted(selected_labels_vanilla))}
+    fig.legend.location = "top_right"
+    fig.legend.click_policy = "hide"
+
+    return fig
+
+
+def main():
     
-    # Para v2 se usarán tonos de azul (paleta Blues9)
-    num_v2 = len(selected_labels_v2)
-    if num_v2 <= 9:
-        blue_palette = Blues9[:num_v2]
-    else:
-        blue_palette = (Blues9 * ((num_v2 // 9) + 1))[:num_v2]
-    color_mapping_v2 = {label: blue_palette[i] for i, label in enumerate(sorted(selected_labels_v2))}
+    config_style()
     
-    # Crear una figura única para ambas versiones
-    fig = figure(width=600, height=600, tooltips=TOOLTIPS,
-                 title="Donut: Muestras Reales (círculos, rojos) vs Muestras Sintéticas (cuadrados, azules)")
+    embeddings_dfs = load_embeddings()
     
-    # Agregar datos de la versión vanilla (círculos con tonos de rojo)
-    add_dataset_to_fig(fig, df_vanilla_trans, selected_labels_vanilla,
-                       marker="circle", color_mapping=color_mapping_vanilla)
-    # Agregar datos de la versión v2 (cuadrados sin relleno, tonos de azul)
-    add_dataset_to_fig(fig, df_v2_trans, selected_labels_v2,
-                       marker="square", color_mapping=color_mapping_v2)
+    embeddings_dfs["real"]["version"] = "real"
+    embeddings_dfs["es-digital-seq"]["version"] = "es_digital_seq"
     
-    fig.legend.location = "top_right"
-    fig.legend.click_policy = "hide"
+    embedding_cols = [col for col in embeddings_dfs["real"].columns if col.startswith("dim_")]
+    
+    # Combine dataframes to apply method reduction
+    df_combined = pd.concat([embeddings_dfs["real"], embeddings_dfs["es-digital-seq"]], ignore_index=True)
+
+    reduced = reducer_selector(df_combined, embedding_cols)
+    
+    # Split back the different versions
+    dfs_reduced, unique_subsets = split_versions(df_combined, reduced)
+
+    selected_subsets = subset_selectors(unique_subsets)
+    color_maps = get_color_maps(selected_subsets)
+    figure = create_figure(dfs_reduced, selected_subsets, color_maps)
     
-    st.bokeh_chart(fig)
+    st.bokeh_chart(figure)
 
 if __name__ == "__main__":
     main()