Update app.py

app.py

@@ -7,6 +7,7 @@ from sklearn.preprocessing import StandardScaler
 from sklearn.metrics.pairwise import cosine_similarity
 from scipy import signal
 from scipy.signal import get_window as scipy_get_window
+from scipy.stats import pearsonr
 import plotly.express as px
 import plotly.graph_objects as go
 import os
@@ -156,44 +157,31 @@ def compare_frames_enhanced(near_feats, far_feats, metrics):
     return pd.DataFrame(results)
 
 # ----------------------------
-# 5. Dual Clustering Logic
+# 5. Dual Clustering & Feature Relation (NEW)
 # ----------------------------
 def perform_dual_clustering(near_df, far_df, cluster_features, algo, n_clusters, eps):
-    """
-    Fits clustering on Near Field (clean), then predicts on Far Field (noisy).
-    This ensures Cluster 0 in Near corresponds to the same physical sound in Far.
-    """
-    if not cluster_features:
-        return near_df, far_df
+    if not cluster_features: return near_df, far_df
 
     valid_features = [f for f in cluster_features if f in near_df.columns]
-    if not valid_features:
-        return near_df, far_df
+    if not valid_features: return near_df, far_df
 
-    X_near = near_df[valid_features].values
-    X_near = np.nan_to_num(X_near)
-    
-    X_far = far_df[valid_features].values
-    X_far = np.nan_to_num(X_far)
+    X_near = np.nan_to_num(near_df[valid_features].values)
+    X_far = np.nan_to_num(far_df[valid_features].values)
 
-    # We use a Scaler to ensure features are comparable
     scaler = StandardScaler()
     X_near_scaled = scaler.fit_transform(X_near)
-    X_far_scaled = scaler.transform(X_far) # Use same scaler for Far
+    X_far_scaled = scaler.transform(X_far)
 
     if algo == "KMeans":
         model = KMeans(n_clusters=min(n_clusters, len(X_near)), random_state=42, n_init=10)
         near_labels = model.fit_predict(X_near_scaled)
-        far_labels = model.predict(X_far_scaled) # Predict using Near model
+        far_labels = model.predict(X_far_scaled)
     elif algo == "Agglomerative":
-        # Agglomerative cannot "predict" on new data easily, so we cluster independently
-        # This is a limitation, but acceptable fallback
         model = AgglomerativeClustering(n_clusters=min(n_clusters, len(X_near)))
         near_labels = model.fit_predict(X_near_scaled)
         far_model = AgglomerativeClustering(n_clusters=min(n_clusters, len(X_far)))
         far_labels = far_model.fit_predict(X_far_scaled) 
     elif algo == "DBSCAN":
-        # DBSCAN also cannot "predict", must fit_predict.
         model = DBSCAN(eps=eps, min_samples=3)
         near_labels = model.fit_predict(X_near_scaled)
         far_labels = model.fit_predict(X_far_scaled)
@@ -201,43 +189,70 @@ def perform_dual_clustering(near_df, far_df, cluster_features, algo, n_clusters,
         near_labels = np.zeros(len(X_near))
         far_labels = np.zeros(len(X_far))
         
-    near_df = near_df.copy()
-    near_df["cluster"] = near_labels
-    near_df["cluster"] = near_df["cluster"].astype(str) # For categorical coloring
-    
-    far_df = far_df.copy()
-    far_df["cluster"] = far_labels
-    far_df["cluster"] = far_df["cluster"].astype(str)
+    near_df = near_df.copy(); near_df["cluster"] = near_labels.astype(str)
+    far_df = far_df.copy(); far_df["cluster"] = far_labels.astype(str)
 
     return near_df, far_df
 
+def compute_feature_correlations(near_df, far_df, quality_scores):
+    """
+    Calculates the correlation between Near Features and Far Features
+    weighted by the Match Quality.
+    Returns a correlation matrix dataframe for plotting.
+    """
+    # Filter numeric columns only
+    near_num = near_df.select_dtypes(include=[np.number])
+    far_num = far_df.select_dtypes(include=[np.number])
+    
+    # We want to see: For a high quality frame, how does Near Feature X relate to Far Feature X?
+    # Simple approach: Calculate Pearson Correlation of (Near_Col, Far_Col) across all frames.
+    
+    correlations = {}
+    
+    common_cols = [c for c in near_num.columns if c in far_num.columns]
+    
+    for col in common_cols:
+        if col == "cluster": continue
+        try:
+            # Basic Correlation: Do Near and Far move together?
+            corr, _ = pearsonr(near_num[col], far_num[col])
+            correlations[col] = corr
+        except:
+            correlations[col] = 0.0
+            
+    # Also calculate correlation with Quality
+    quality_corr = {}
+    for col in common_cols:
+         if col == "cluster": continue
+         try:
+             # Does this feature predict high quality?
+             # e.g., Does high 'rms' usually mean better match score?
+             corr, _ = pearsonr(near_num[col], quality_scores)
+             quality_corr[col] = corr
+         except:
+             quality_corr[col] = 0.0
+
+    return pd.DataFrame({"Near-Far Correlation": correlations, "Correlation with Quality": quality_corr})
+
 # ----------------------------
 # 6. Plotting Helpers
 # ----------------------------
 def generate_cluster_plot(df, x_attr, y_attr, title_suffix):
     if len(df) == 0 or x_attr not in df.columns or y_attr not in df.columns:
         return px.scatter(title="No Data")
-    
     fig = px.scatter(
         df, x=x_attr, y=y_attr, color="cluster",
         title=f"Clustering Analysis ({title_suffix}): {x_attr} vs {y_attr}",
-        color_discrete_sequence=px.colors.qualitative.Bold # Consistent colors
+        color_discrete_sequence=px.colors.qualitative.Bold
     )
     return fig
 
 def update_cluster_view(view_mode, near_df, far_df, cluster_features):
-    if near_df is None or far_df is None:
-        return px.scatter(title="Run Analysis First")
-    
-    if len(cluster_features) < 2:
-         return px.scatter(title="Select at least 2 features")
-
+    if near_df is None or far_df is None: return px.scatter(title="Run Analysis First")
+    if len(cluster_features) < 2: return px.scatter(title="Select at least 2 features")
     x_attr, y_attr = cluster_features[0], cluster_features[1]
-    
-    if view_mode == "Near Field":
-        return generate_cluster_plot(near_df, x_attr, y_attr, "Near Field")
-    else:
-        return generate_cluster_plot(far_df, x_attr, y_attr, "Far Field")
+    if view_mode == "Near Field": return generate_cluster_plot(near_df, x_attr, y_attr, "Near Field")
+    else: return generate_cluster_plot(far_df, x_attr, y_attr, "Far Field")
 
 # ----------------------------
 # 7. Main Analysis
@@ -252,7 +267,6 @@ def analyze_audio_pair(
     # Load & Align
     y_near, sr = librosa.load(near_file.name, sr=None)
     y_far, _ = librosa.load(far_file.name, sr=sr)
-    
     y_near = librosa.util.normalize(y_near)
     y_far = librosa.util.normalize(y_far)
     y_near, y_far = align_signals(y_near, y_far)
@@ -260,41 +274,30 @@ def analyze_audio_pair(
     # Process
     frames_near, _ = segment_audio(y_near, sr, frame_length_ms, hop_length_ms, window_type)
     frames_far, _ = segment_audio(y_far, sr, frame_length_ms, hop_length_ms, window_type)
-    
     near_feats = extract_features_with_spectrum(frames_near, sr)
     far_feats = extract_features_with_spectrum(frames_far, sr)
     
-    # Comparison Data
+    # Compare & Cluster
     comparison_df = compare_frames_enhanced(near_feats, far_feats, comparison_metrics)
-    
-    # Clustering Data
     near_df_raw = pd.DataFrame(near_feats).drop(columns=["spectrum"], errors="ignore")
     far_df_raw = pd.DataFrame(far_feats).drop(columns=["spectrum"], errors="ignore")
-    
-    # Perform Dual Clustering
     near_clustered, far_clustered = perform_dual_clustering(
         near_df_raw, far_df_raw, cluster_features, clustering_algo, n_clusters, dbscan_eps
     )
 
-    # 1. Comparison Plot (Dual Axis)
+    # 1. Comparison Plot
     plot_comparison = go.Figure()
-    # Axis 1: Similarity (0-1)
     for col in ["cosine_similarity", "spectral_overlap", "combined_match_score"]:
         if col in comparison_df.columns:
             plot_comparison.add_trace(go.Scatter(x=comparison_df["frame_index"], y=comparison_df[col], name=col, yaxis="y1"))
-    # Axis 2: dB Loss
     if "high_freq_loss_db" in comparison_df.columns:
         plot_comparison.add_trace(go.Scatter(x=comparison_df["frame_index"], y=comparison_df["high_freq_loss_db"], 
                                              name="High Freq Loss (dB)", line=dict(color="red", width=1), yaxis="y2"))
-    
     plot_comparison.update_layout(
-        title="Comparison Metrics (Dual Axis)",
-        yaxis=dict(title="Similarity (0-1)", range=[0, 1.1]),
-        yaxis2=dict(title="Energy Diff (dB)", overlaying="y", side="right"),
-        legend=dict(x=1.1, y=1)
+        title="Comparison Metrics", yaxis=dict(title="Similarity"), yaxis2=dict(title="dB Loss", overlaying="y", side="right")
     )
 
-    # 2. Initial Cluster Plot (Near Field)
+    # 2. Cluster Plot
     init_cluster_plot = update_cluster_view("Near Field", near_clustered, far_clustered, cluster_features)
 
     # 3. Spectral Heatmap
@@ -303,7 +306,7 @@ def analyze_audio_pair(
     spec_heatmap = go.Figure(data=go.Heatmap(z=diff, colorscale='RdBu', zmid=0))
     spec_heatmap.update_layout(title=f"Spectral Diff (Frame {safe_idx})", height=350)
     
-    # 4. Overlay Plot (Simple)
+    # 4. Overlay Plot
     near_clustered["match_quality"] = comparison_df["combined_match_score"]
     if len(cluster_features) > 0:
         overlay_fig = px.scatter(near_clustered, x=cluster_features[0], y="match_quality", color="cluster", 
@@ -311,11 +314,22 @@ def analyze_audio_pair(
     else:
         overlay_fig = px.scatter(title="No features")
 
-    # Return: Plots + Dataframes for State + Raw Tables
+    # 5. NEW: Feature Relation Heatmap
+    corr_df = compute_feature_correlations(near_clustered, far_clustered, comparison_df["combined_match_score"])
+    corr_fig = px.imshow(corr_df.T, text_auto=True, aspect="auto", color_continuous_scale="RdBu", zmin=-1, zmax=1,
+                         title="Feature Correlation Analysis")
+    
+    # 6. Scatter Matrix (Inter-feature)
+    # Pick top 3 features and Quality
+    top_cols = cluster_features[:3] + ["match_quality"]
+    scatter_matrix_fig = px.scatter_matrix(near_clustered, dimensions=top_cols, color="cluster",
+                                           title="Inter-Feature Scatter Matrix (Near Field)")
+
     return (plot_comparison, comparison_df, 
-            init_cluster_plot, near_clustered, # Table 
+            init_cluster_plot, near_clustered, 
             spec_heatmap, overlay_fig, 
-            near_clustered, far_clustered) # States
+            corr_fig, scatter_matrix_fig,
+            near_clustered, far_clustered)
 
 def export_results(comparison_df, near_df, far_df):
     temp_dir = tempfile.mkdtemp()
@@ -334,7 +348,6 @@ feature_list = ["rms", "spectral_centroid", "zcr", "spectral_flatness",
                 "low_freq_energy", "mid_freq_energy", "high_freq_energy"] + [f"mfcc_{i}" for i in range(1, 14)]
 
 with gr.Blocks(title="Audio Field Analyzer", theme=gr.themes.Soft()) as demo:
-    # State storage for interactivity
     state_near_df = gr.State()
     state_far_df = gr.State()
 
@@ -348,13 +361,8 @@ with gr.Blocks(title="Audio Field Analyzer", theme=gr.themes.Soft()) as demo:
         frame_length_ms = gr.Slider(10, 200, value=30, label="Frame Length (ms)")
         hop_length_ms = gr.Slider(5, 100, value=15, label="Hop Length (ms)")
         window_type = gr.Dropdown(["hann", "hamming"], value="hann", label="Window")
-        
-        comparison_metrics = gr.CheckboxGroup(["Cosine Similarity", "High-Freq Loss Ratio"], 
-                                              value=["Cosine Similarity", "High-Freq Loss Ratio"], label="Metrics")
-        
-        cluster_features = gr.CheckboxGroup(feature_list, value=["spectral_centroid", "spectral_flatness"], 
-                                            label="Clustering Features")
-        
+        comparison_metrics = gr.CheckboxGroup(["Cosine Similarity", "High-Freq Loss Ratio"], value=["Cosine Similarity", "High-Freq Loss Ratio"], label="Metrics")
+        cluster_features = gr.CheckboxGroup(feature_list, value=["spectral_centroid", "spectral_flatness", "rms"], label="Clustering Features")
         clustering_algo = gr.Dropdown(["KMeans", "Agglomerative"], value="KMeans", label="Algorithm")
         n_clusters = gr.Slider(2, 10, value=4, step=1, label="Clusters")
         dbscan_eps = gr.Slider(0.1, 5.0, value=0.5, visible=False)
@@ -365,24 +373,23 @@ with gr.Blocks(title="Audio Field Analyzer", theme=gr.themes.Soft()) as demo:
         with gr.Tab("📈 Comparison"):
             comp_plot = gr.Plot()
             comp_table = gr.Dataframe()
-        
         with gr.Tab("🧩 Phoneme Clustering"):
-            with gr.Row():
-                # TOGGLE SWITCH
-                view_toggle = gr.Radio(["Near Field", "Far Field"], value="Near Field", label="View Mode")
+            view_toggle = gr.Radio(["Near Field", "Far Field"], value="Near Field", label="View Mode")
             cluster_plot = gr.Plot()
             cluster_table = gr.Dataframe()
-            
         with gr.Tab("🔍 Spectral"):
             spec_heatmap = gr.Plot()
         with gr.Tab("🧭 Overlay"):
             overlay_plot = gr.Plot()
+        with gr.Tab("🔗 Feature Relations"):
+            gr.Markdown("### Correlation Heatmap & Scatter Matrix")
+            corr_plot = gr.Plot(label="Correlation Heatmap")
+            scatter_matrix_plot = gr.Plot(label="Scatter Matrix")
 
     with gr.Tab("📤 Export"):
         export_btn = gr.Button("Download CSVs")
         export_files = gr.Files()
 
-    # Main Analysis Event
     btn.click(
         fn=analyze_audio_pair,
         inputs=[near_file, far_file, frame_length_ms, hop_length_ms, window_type,
@@ -390,16 +397,11 @@ with gr.Blocks(title="Audio Field Analyzer", theme=gr.themes.Soft()) as demo:
         outputs=[comp_plot, comp_table, 
                  cluster_plot, cluster_table, 
                  spec_heatmap, overlay_plot, 
-                 state_near_df, state_far_df] # Save to State
-    )
-
-    # Toggle Event (Updates plot without re-running analysis)
-    view_toggle.change(
-        fn=update_cluster_view,
-        inputs=[view_toggle, state_near_df, state_far_df, cluster_features],
-        outputs=[cluster_plot]
+                 corr_plot, scatter_matrix_plot,
+                 state_near_df, state_far_df]
     )
 
+    view_toggle.change(fn=update_cluster_view, inputs=[view_toggle, state_near_df, state_far_df, cluster_features], outputs=[cluster_plot])
     export_btn.click(fn=export_results, inputs=[comp_table, state_near_df, state_far_df], outputs=export_files)
 
 if __name__ == "__main__":