Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,223 @@
+
+import streamlit as st
+import os
+import torch
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+
+BASE_PATH = 'Models' 
+
+st.set_page_config(layout="wide", page_title="Audio Source Separation Inspector")
+
+def get_subdirs(path):
+  """Returns a list of subdirectories in a given path."""
+  if not os.path.exists(path):
+      return []
+  return [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))]
+
+def load_spectrogram_interactive(pt_path, title="Spectrogram"):
+  """Loads a .pt spectrogram and returns a Plotly figure."""
+  try:
+    spec_tensor = torch.load(pt_path, map_location='cpu')
+    
+    # Handle dimensions: [Channels, Freq, Time]
+    if spec_tensor.dim() == 4: # [Batch, C, F, T]
+      spec_tensor = spec_tensor[0]
+    if spec_tensor.dim() == 3: # [C, F, T]
+      spec_data = spec_tensor.mean(dim=0).numpy() # Average across channels
+    else: # [F, T]
+      spec_data = spec_tensor.numpy()
+
+    # Log scaling for better visibility
+    if spec_data.min() >= 0:
+      spec_data = np.log1p(spec_data)
+    
+    # Create interactive heatmap
+    fig = px.imshow(
+        spec_data, 
+        origin='lower', 
+        aspect='auto', 
+        color_continuous_scale='Magma',
+        labels=dict(x="Time Frame", y="Frequency Bin", color="Log Magnitude"),
+        title=title
+    )
+    fig.update_layout(margin=dict(l=0, r=0, t=30, b=0), height=300)
+    return fig
+  except Exception as e:
+    st.error(f"Error loading spectrogram: {e}")
+    return None
+
+def load_feature_map_interactive(pt_path):
+  """Loads an internal feature map and visualizes its mean activation interactively."""
+  try:
+    feat_tensor = torch.load(pt_path, map_location='cpu')
+    
+    # Squeeze batch if present
+    if feat_tensor.dim() == 4: 
+      feat_tensor = feat_tensor[0]
+    
+    # feat_tensor is likely [Channels, Freq, Time]
+    mean_activation = feat_tensor.mean(dim=0).numpy()
+    
+    fig = px.imshow(
+        mean_activation, 
+        origin='lower', 
+        aspect='auto', 
+        color_continuous_scale='Viridis',
+        labels=dict(x="Time", y="Freq/Feature", color="Activation"),
+        title=f"Mean Activation (Shape: {list(feat_tensor.shape)})"
+    )
+    fig.update_layout(margin=dict(l=0, r=0, t=40, b=0))
+    return fig
+  except Exception as e:
+    return None
+
+st.title("🎵 Audio Source Separation Inspector")
+
+# Check if data uploaded correctly
+if not os.path.exists(BASE_PATH):
+  st.error(f"Models directory not found at {BASE_PATH}. Please ensure your data was uploaded correctly.")
+  st.stop()
+
+# 1. Select Model
+models = get_subdirs(BASE_PATH)
+selected_model = st.sidebar.selectbox("Select Model", models)
+
+if selected_model:
+  model_path = os.path.join(BASE_PATH, selected_model)
+  artifacts_path = os.path.join(model_path, "test_artifacts")
+  
+  # 2. Select Sample
+  if os.path.exists(artifacts_path):
+    samples = get_subdirs(artifacts_path)
+    # Sort samples numerically
+    samples.sort(key=lambda x: int(x.split('_')[-1]) if '_' in x else 0)
+    
+    selected_sample = st.sidebar.selectbox("Select Sample ID", samples)
+    
+    if selected_sample:
+      sample_path = os.path.join(artifacts_path, selected_sample)
+      audio_dir = os.path.join(sample_path, "audio")
+      specs_dir = os.path.join(sample_path, "specs")
+      feats_dir = os.path.join(sample_path, "feats")
+      
+      # 3. Detect Classes
+      all_files = os.listdir(audio_dir)
+      target_files = [f for f in all_files if f.startswith("target_") and f.endswith(".wav")]
+      classes = [f.replace("target_", "").replace(".wav", "") for f in target_files]
+      
+      # Sidebar Class Filter
+      selected_class = st.sidebar.selectbox("Focus Class", classes)
+
+      # --- MAIN CONTENT TABS ---
+      tab1, tab2, tab3 = st.tabs(["🎧 Audio & Spectrograms", "🧠 Internal Activations", "📊 Model Metadata"])
+
+      with tab1:
+        st.header(f"Sample {selected_sample} | Focus: {selected_class.capitalize()}")
+        
+        # --- Mixture (Input) ---
+        st.subheader("1. Mixture (Input)")
+        mix_audio = os.path.join(audio_dir, "mixture.wav")
+        mix_spec = os.path.join(specs_dir, "mixture.pt")
+        
+        c1, c2 = st.columns([1, 3]) # Audio on left, Graph on right (wider)
+        with c1:
+            if os.path.exists(mix_audio):
+                st.markdown("**Audio:**")
+                st.audio(mix_audio)
+        with c2:
+            if os.path.exists(mix_spec):
+                fig = load_spectrogram_interactive(mix_spec, title="Mixture Spectrogram")
+                if fig: st.plotly_chart(fig, width='stretch')
+        
+        st.divider()
+
+        # --- Target (Ground Truth) ---
+        st.subheader(f"2. Target: {selected_class}")
+        tgt_audio = os.path.join(audio_dir, f"target_{selected_class}.wav")
+        tgt_spec = os.path.join(specs_dir, f"target_{selected_class}.pt")
+        
+        c1, c2 = st.columns([1, 3])
+        with c1:
+            if os.path.exists(tgt_audio):
+                st.markdown("**Audio:**")
+                st.audio(tgt_audio)
+        with c2:
+            if os.path.exists(tgt_spec):
+                fig = load_spectrogram_interactive(tgt_spec, title=f"Target Spectrogram ({selected_class})")
+                if fig: st.plotly_chart(fig, width='stretch')
+        
+        st.divider()
+
+        # --- Prediction (Output) ---
+        st.subheader(f"3. Prediction: {selected_class}")
+        pred_audio = os.path.join(audio_dir, f"pred_{selected_class}.wav")
+        pred_spec = os.path.join(specs_dir, f"pred_{selected_class}.pt")
+        
+        c1, c2 = st.columns([1, 3])
+        with c1:
+            if os.path.exists(pred_audio):
+                st.markdown("**Audio:**")
+                st.audio(pred_audio)
+        with c2:
+            if os.path.exists(pred_spec):
+                fig = load_spectrogram_interactive(pred_spec, title=f"Predicted Spectrogram ({selected_class})")
+                if fig: st.plotly_chart(fig, width='stretch')
+      
+      with tab2:
+        st.header("Internal Feature Maps")
+        
+        if os.path.exists(feats_dir):
+          feat_files = sorted(os.listdir(feats_dir))
+          
+          if feat_files:
+            selected_layer = st.selectbox("Select Probed Layer", feat_files)
+            if selected_layer:
+              st.write(f"Layer: **{selected_layer.replace('.pt', '')}**")
+              fig = load_feature_map_interactive(os.path.join(feats_dir, selected_layer))
+              if fig:
+                st.plotly_chart(fig, width='stretch')
+          else:
+            st.warning("No feature maps found for this sample.")
+        else:
+          st.error("Features directory not found.")
+
+      with tab3:
+        st.header("Training and Testing Logs")
+        
+        c1, c2 = st.columns(2)
+        with c1:
+          results_csv = os.path.join(model_path, "test_results.csv")
+          if os.path.exists(results_csv):
+            st.subheader("Test Results")
+            df = pd.read_csv(results_csv)
+            # Use Plotly for the table/chart
+            fig = px.line(df, title="Test Metrics")
+            st.plotly_chart(fig, width='stretch')
+            st.dataframe(df, width='stretch')
+          else:
+            st.info("No `test_results.csv` found.")
+                
+        with c2:
+          loss_csv = os.path.join(model_path, "loss.csv")
+          if os.path.exists(loss_csv):
+            st.subheader("Training Loss")
+            try:
+              df_loss = pd.read_csv(loss_csv)
+              # Try to find an epoch column, otherwise use index
+              x_axis = 'epoch' if 'epoch' in df_loss.columns else df_loss.index
+              
+              # Melt if multiple loss columns exist for better visualization
+              numeric_cols = df_loss.select_dtypes(include=np.number).columns
+              fig = px.line(df_loss, x=x_axis, y=numeric_cols, title="Loss Curves")
+              st.plotly_chart(fig, width='stretch')
+              st.dataframe(df_loss, width='stretch')
+            except Exception as e:
+              st.write("Could not parse `loss.csv`.", e)
+          else:
+            st.info("No `loss.csv` found.")
+
+  else:
+    st.warning(f"No 'test_artifacts' folder found in {selected_model}")