Try Visualization

app.py

@@ -52,10 +52,12 @@ class RelativeScaler(BaseEstimator, TransformerMixin):
         
         return np.hstack(transformed)
 
+
 N_COMPONENTS = 3
 TSNE_NEIGHBOURS = 15
 # WEIGHT_FACTOR = 0.05
 
+
 TOOLTIPS = """
 <div>
     <div>
@@ -70,6 +72,7 @@ TOOLTIPS = """
 </div>
 """
 
+
 def config_style():
     # st.set_page_config(layout="wide")
     st.markdown("""
@@ -85,6 +88,7 @@ def config_style():
     """, unsafe_allow_html=True)
     st.markdown('<h1 class="main-title">Merit Embeddings 🎒📃🏆</h1>', unsafe_allow_html=True)
 
+
 def load_embeddings(model, version, embedding_prefix, weight_factor):
     if model == "Donut":
         df_real = pd.read_csv(f"data/donut/{version}/{embedding_prefix}/de_Rodrigo_merit_secret_all_{weight_factor}embeddings.csv")
@@ -275,6 +279,7 @@ 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:
@@ -294,6 +299,7 @@ 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:
@@ -303,6 +309,7 @@ def get_embedding_from_df(df):
     else:
         raise ValueError("No se encontró embedding o coordenadas x,y en el DataFrame.")
 
+
 def compute_cluster_distance(synthetic_points, real_points, metric="wasserstein", bins=20):
     if metric.lower() == "wasserstein":
         n = synthetic_points.shape[0]
@@ -334,6 +341,7 @@ def compute_cluster_distance(synthetic_points, real_points, metric="wasserstein"
     else:
         raise ValueError("Métrica desconocida. Usa 'wasserstein', 'euclidean' o 'kl'.")
 
+
 def compute_cluster_distances_synthetic_individual(synthetic_df: pd.DataFrame, df_real: pd.DataFrame, real_labels: list, metric="wasserstein", bins=20) -> pd.DataFrame:
     distances = {}
     groups = synthetic_df.groupby(['source', 'label'])
@@ -355,6 +363,7 @@ def compute_cluster_distances_synthetic_individual(synthetic_df: pd.DataFrame, d
             distances[key][real_label] = d
     return pd.DataFrame(distances).T
 
+
 def compute_continuity(X, X_embedded, n_neighbors=5):
     n = X.shape[0]
     D_high = pairwise_distances(X, metric='euclidean')
@@ -375,6 +384,7 @@ def compute_continuity(X, X_embedded, n_neighbors=5):
     continuity_value = 1 - norm * total
     return continuity_value
 
+
 def create_table(df_distances):
     df_table = df_distances.copy()
     df_table.reset_index(inplace=True)
@@ -438,6 +448,7 @@ 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:
@@ -467,6 +478,7 @@ def add_dataset_to_fig(fig, df, selected_labels, marker, color_mapping, group_la
         renderers[label + f" ({group_label})"] = r
     return renderers
 
+
 def add_synthetic_dataset_to_fig(fig, df, labels, marker, color_mapping, group_label):
     renderers = {}
     for label in labels:
@@ -516,6 +528,7 @@ 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, result):
     color_map = {}
     num_real = len(unique_subsets["real"])
@@ -548,6 +561,7 @@ def get_color_maps(unique_subsets, result):
     
     return color_map
 
+
 def calculate_cluster_centers(df, labels):
     centers = {}
     for label in labels:
@@ -556,22 +570,27 @@ def calculate_cluster_centers(df, labels):
             centers[label] = (subset['x'].mean(), subset['y'].mean())
     return centers
 
+
 def compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method="t-SNE", distance_metric="wasserstein"):
     if reduction_method == "PCA":
         reducer = Pipeline([
             ("pca", PCA(n_components=N_COMPONENTS)),
             ("rel_scaler", RelativeScaler())
         ])
+
     elif reduction_method == "UMAP":
         reducer = umap.UMAP(n_components=N_COMPONENTS, 
-                       random_state=42, 
-                       n_neighbors=15, 
-                       min_dist=0.1,
-                       metric='cosine')
+            random_state=42, 
+            n_neighbors=15, 
+            min_dist=0.1,
+            metric='cosine'
+        )
+
     else:
         reducer = TSNE(n_components=2, random_state=42, 
-                         perplexity=tsne_params["perplexity"], 
-                         learning_rate=tsne_params["learning_rate"])
+            perplexity=tsne_params["perplexity"], 
+            learning_rate=tsne_params["learning_rate"]
+        )
     
     reduced = reducer.fit_transform(df_combined[embedding_cols].values)
     # reduced = reducer.fit_transform(df_combined[df_combined["version"] == "real"][embedding_cols].values)
@@ -874,7 +893,6 @@ def run_model(model_name):
             tsne_params = {"perplexity": perplexity_val, "learning_rate": learning_rate_val}
     
     result = compute_global_regression(df_combined, embedding_cols, tsne_params, df_f1, reduction_method=reduction_method, distance_metric=distance_metric.lower())
-    print(result)
     
     reg_metrics = pd.DataFrame({
         "Slope": [result["slope"]],
@@ -1033,24 +1051,32 @@ def run_model(model_name):
         key=f"download_button_excel_{model_name}"
     )
 
-    if reduction_method == "PCA":
+    if reduction_method in ("PCA", "UMAP"):
         st.markdown("## PCA - Solo Muestras Reales")
         # -------------------------------------------------------------------------
         # 1. PCA sobre las muestras reales
         df_real_only = embeddings["real"].copy()
-        reducer_real = Pipeline([
-            ("pca", PCA(n_components=N_COMPONENTS)),
-            ("rel_scaler", RelativeScaler())
-        ])
+
+        if reduction_method == "PCA":
+            reducer_real = Pipeline([
+                ("pca", PCA(n_components=N_COMPONENTS)),
+                ("rel_scaler", RelativeScaler())
+            ])
+        
+        elif reduction_method == "UMAP":
+            reducer_real = umap.UMAP(n_components=N_COMPONENTS, 
+                random_state=42, 
+                n_neighbors=15, 
+                min_dist=0.1,
+                metric='cosine'
+            )
 
         reduced_real = reducer_real.fit_transform(df_real_only[embedding_cols].values)
 
-        
         # 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 = reducer_real.named_steps["pca"].explained_variance_ratio_
         unique_labels_real = sorted(df_real_only['label'].unique().tolist())
         
         # Mapeo de colores para las muestras reales usando la paleta Reds9
@@ -1062,13 +1088,15 @@ def run_model(model_name):
         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({
-            "Component": component_names_real,
-            "Explained Variance": explained_variance_real
-        })
-        st.table(variance_df_real)
+        if reduction_method == "PCA":
+            explained_variance_real = reducer_real.named_steps["pca"].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({
+                "Component": component_names_real,
+                "Explained Variance": explained_variance_real
+            })
+            st.table(variance_df_real)
         
         # Mostrar los plots de loadings para cada componente
         # st.subheader("PCA - Real: Component Loadings")