Show PCA for Targe Dataset (Real)

app.py

@@ -14,7 +14,7 @@ from sklearn.linear_model import LinearRegression
 
 N_COMPONENTS = 2
 TSNE_NEIGHBOURS = 150
-WEIGHT_FACTOR = 0.25
+WEIGHT_FACTOR = 0.1
 
 TOOLTIPS = """
 <div>
@@ -76,17 +76,17 @@ def load_embeddings(model, version, embedding_prefix, weight_factor):
                 "pretrained": df_pretratrained}
     
     elif model == "Idefics2":
-        df_real = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_secret_britanico_{weight_factor}embeddings.csv")
-        df_par = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-paragraph-degradation-seq_{weight_factor}embeddings.csv")
-        df_line = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-line-degradation-seq_{weight_factor}embeddings.csv")
-        df_seq  = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-seq_{weight_factor}embeddings.csv")
-        df_rot  = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-rotation-degradation-seq_{weight_factor}embeddings.csv")
-        df_zoom = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-zoom-degradation-seq_{weight_factor}embeddings.csv")
-        df_render = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_es-render-seq_{weight_factor}embeddings.csv")
+        df_real = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_secret_britanico_{weight_factor}embeddings.csv")
+        df_par = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-paragraph-degradation-seq_{weight_factor}embeddings.csv")
+        df_line = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-line-degradation-seq_{weight_factor}embeddings.csv")
+        df_seq  = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-seq_{weight_factor}embeddings.csv")
+        df_rot  = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-rotation-degradation-seq_{weight_factor}embeddings.csv")
+        df_zoom = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_es-digital-zoom-degradation-seq_{weight_factor}embeddings.csv")
+        df_render = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_es-render-seq_{weight_factor}embeddings.csv")
         
         # Cargar ambos subconjuntos pretrained y combinarlos
-        df_pretratrained_PDFA = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_aux_PDFA_{weight_factor}embeddings.csv")
-        df_pretratrained_IDL = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_aux_IDL_{weight_factor}embeddings.csv")
+        df_pretratrained_PDFA = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_aux_PDFA_{weight_factor}embeddings.csv")
+        df_pretratrained_IDL = pd.read_csv(f"data/idefics2/{version}/{embedding_prefix}/de_Rodrigo_merit_aux_IDL_{weight_factor}embeddings.csv")
         df_pretratrained = pd.concat([df_pretratrained_PDFA, df_pretratrained_IDL], ignore_index=True)
         
         # Asignar etiquetas de versión
@@ -116,9 +116,6 @@ def load_embeddings(model, version, embedding_prefix, weight_factor):
         st.error("Modelo no reconocido")
         return None
 
-
-
-
 def split_versions(df_combined, reduced):
     # Asignar las coordenadas si la reducción es 2D
     if reduced.shape[1] == 2:
@@ -138,7 +135,6 @@ def split_versions(df_combined, reduced):
     unique_subsets = {"real": unique_real, "synthetic": unique_synth, "pretrained": unique_pretrained}
     return df_dict, unique_subsets
 
-
 def get_embedding_from_df(df):
     # Retorna el embedding completo (4 dimensiones en este caso) guardado en la columna 'embedding'
     if 'embedding' in df.columns:
@@ -282,7 +278,6 @@ def create_figure(dfs, unique_subsets, color_maps, model_name):
     fig.legend.visible = show_legend
     return fig, real_renderers, synthetic_renderers, pretrained_renderers
 
-
 def add_dataset_to_fig(fig, df, selected_labels, marker, color_mapping, group_label):
     renderers = {}
     for label in selected_labels:
@@ -392,7 +387,6 @@ def get_color_maps(unique_subsets):
     
     return color_map
 
-
 def calculate_cluster_centers(df, labels):
     centers = {}
     for label in labels:
@@ -541,13 +535,10 @@ def run_model(model_name):
     # Selector para el método de cómputo del embedding
     embedding_computation = st.selectbox("¿Cómo se computa el embedding?", options=["weighted", "averaged"], key=f"embedding_method_{model_name}")
     # Se asigna el prefijo correspondiente
-    # prefijo_embedding = "weighted_" if embedding_computation == "weighted" else "averaged_"
 
     if embedding_computation == "weighted":
-        # prefijo_embedding = "weighted_"
         weight_factor = f"{WEIGHT_FACTOR}_"
     else:
-        # prefijo_embedding = "averaged_"
         weight_factor = ""
     
     embeddings = load_embeddings(model_name, version, embedding_computation, weight_factor)
@@ -555,7 +546,7 @@ def run_model(model_name):
         return
 
     # Nuevo selector para incluir o excluir el dataset pretrained
-    include_pretrained = st.checkbox("Incluir dataset pretrained", value=True)
+    include_pretrained = st.checkbox("Incluir dataset pretrained", value=True, key=f"legend_{model_name}_pretrained")
     if not include_pretrained:
         # Removemos la entrada pretrained del diccionario, si existe.
         embeddings.pop("pretrained", None)
@@ -572,10 +563,10 @@ def run_model(model_name):
         return
 
     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}")
+    reduction_method = st.selectbox("", options=["PCA", "t-SNE"], key=f"reduction_{model_name}")
     
     distance_metric = st.selectbox("Select Distance Metric:", 
-                                   options=["Wasserstein", "Euclidean", "KL"], 
+                                   options=["Euclidean", "Wasserstein", "KL"], 
                                    key=f"distance_metric_{model_name}")
     
     tsne_params = {}
@@ -628,13 +619,12 @@ def run_model(model_name):
         st.write(f"Trustworthiness: {result['trustworthiness']:.4f}")
         st.write(f"Continuity: {result['continuity']:.4f}")
 
-    # Si se usó PCA, se muestran los plots de loadings con Bokeh (con hover para ver la etiqueta)
+    # Mostrar los plots de loadings si se usó PCA (para el conjunto combinado)
     if reduction_method == "PCA" and result.get("pca_model") is not None:
         pca_model = result["pca_model"]
         components = pca_model.components_  # Shape: (n_components, n_features)
         
-        st.subheader("Pesos de las Componentes Principales (Loadings)")
-        # Se crea un plot de barras por cada componente
+        st.subheader("Pesos de las Componentes Principales (Loadings) - Conjunto Combinado")
         for i, comp in enumerate(components):
             source = ColumnDataSource(data=dict(
                 dimensions=embedding_cols,
@@ -642,11 +632,17 @@ def run_model(model_name):
             ))
             p = figure(x_range=embedding_cols, title=f"Componente Principal {i+1}",
                        plot_height=400, plot_width=600,
-                       toolbar_location=None, tools="")
+                       toolbar_location="above",
+                       tools="pan,wheel_zoom,reset,save,hover",
+                       active_scroll="wheel_zoom")
+
+            # Establecer fondo blanco
+            p.background_fill_color = "white"
+            # Mostrar solo grilla horizontal
+            p.xgrid.grid_line_color = None
+            p.ygrid.grid_line_color = "gray"
             p.vbar(x='dimensions', top='weight', width=0.8, source=source)
-            # Ocultar etiquetas del eje x para un aspecto más limpio
             p.xaxis.major_label_text_font_size = '0pt'
-            # Agregar HoverTool para mostrar la dimensión y su peso
             hover = HoverTool(tooltips=[("Dimensión", "@dimensions"), ("Peso", "@weight")])
             p.add_tools(hover)
             p.xaxis.axis_label = "Dimensiones originales"
@@ -709,7 +705,7 @@ def run_model(model_name):
         layout = column(result["scatter_fig"], column(real_select, reset_button, data_table))
     
     st.bokeh_chart(layout, use_container_width=True)
-    
+
     buffer = io.BytesIO()
     df_table.to_excel(buffer, index=False)
     buffer.seek(0)
@@ -722,6 +718,124 @@ 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
+        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]
+        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
+        num_labels = len(unique_labels_real)
+        if num_labels <= 9:
+            red_palette = Reds9[:num_labels]
+        else:
+            red_palette = (Reds9 * ((num_labels // 9) + 1))[:num_labels]
+        real_color_mapping = {label: red_palette[i] for i, label in enumerate(unique_labels_real)}
+        
+        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({
+            "Component": component_names_real,
+            "Explained Variance": explained_variance_real
+        })
+        st.table(variance_df_real)
+        
+        # Agregar scatter plot para visualizar el PCA real
+        st.subheader("PCA - Real: Scatter Plot")
+        fig_real = figure(
+            title="PCA - Solo Real: Scatter Plot",
+            plot_width=600,
+            plot_height=600,
+            tools="pan,wheel_zoom,reset,save,hover",
+            active_scroll="wheel_zoom",
+            background_fill_color="white"
+        )
+        # Mostrar solo grid horizontal
+        fig_real.xgrid.grid_line_color = None
+        fig_real.ygrid.grid_line_color = "gray"
+
+        # Dibujar los puntos por cada etiqueta
+        for label in unique_labels_real:
+            subset = df_real_only[df_real_only['label'] == label]
+            source_scatter = ColumnDataSource(data={
+                'x': subset['x'],
+                'y': subset['y'],
+                'label': subset['label']
+            })
+            fig_real.circle('x', 'y', size=10,
+                            fill_color=real_color_mapping[label],
+                            line_color=real_color_mapping[label],
+                            legend_label=label,
+                            source=source_scatter)
+
+        # Calcular el centroide de todos los puntos
+        center_x = df_real_only['x'].mean()
+        center_y = df_real_only['y'].mean()
+
+        # Calcular el radio como la máxima distancia desde el centroide
+        distances = np.sqrt((df_real_only['x'] - center_x)**2 + (df_real_only['y'] - center_y)**2)
+        radius = distances.max()
+
+        # Dibujar el centroide
+        fig_real.circle(x=center_x, y=center_y, size=15,
+                        fill_color="black", line_color="black", legend_label="Centroide")
+
+        # Dibujar la circunferencia (con línea discontinua)
+        fig_real.circle(x=center_x, y=center_y, radius=radius,
+                        fill_color=None, line_color="black", line_dash="dashed", legend_label="Circunferencia")
+
+        fig_real.xaxis.axis_label = "PC1"
+        fig_real.yaxis.axis_label = "PC2"
+
+        hover_scatter = fig_real.select_one(HoverTool)
+        hover_scatter.tooltips = [("Label", "@label"), ("PC1", "@x"), ("PC2", "@y")]
+
+        fig_real.legend.location = "top_right"
+        st.bokeh_chart(fig_real)
+
+        # Mostrar el valor del radio debajo del gráfico
+        st.write(f"El radio de la circunferencia es: {int(radius)}")
+
+        # Mostrar los plots de loadings (Component Loadings)
+        st.subheader("PCA - Real: Component Loadings")
+        st.markdown("### Pesos de las Componentes Principales (Loadings) - Conjunto Combinado")
+        for i, comp in enumerate(pca_real.components_):
+            source = ColumnDataSource(data=dict(
+                dimensions=embedding_cols,
+                weight=comp
+            ))
+            p = figure(
+                x_range=embedding_cols,
+                title=f"Componente Principal {i+1}",
+                plot_height=400,
+                plot_width=600,
+                toolbar_location="above",
+                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)
+
+
 def main():
     config_style()
     tabs = st.tabs(["Donut", "Idefics2"])
@@ -733,4 +847,4 @@ def main():
         run_model("Idefics2")
 
 if __name__ == "__main__":
-    main()
+    main()