(FEAT): Enhance application with streamlined analysis and confidence visualization

- Add streamlined "Details" tab with a research-grade layout for analysis results.
- Implement a unified confidence analysis section with a 2-column layout.
- Improve probability distribution visualization using bullet charts.
- Refactor classification results to include prediction, confidence, and ground truth in a compact format.
- Optimize layout for better readability and reduced visual clutter.
- Ensure compatibility with batch and single-file processing modes.

.gitignore

@@ -15,6 +15,7 @@ outputs/logs/
 docs/PROJECT_REPORT.md
 wea-*.txt
 sta-*.txt
+S3PR.md
 
 # --- Data (keep folder, ignore files) ---
 datasets/**

app.py

@@ -1,3 +1,9 @@
+from typing import Union
+from utils.multifile import create_batch_uploader, process_multiple_files, display_batch_results
+from utils.confidence import calculate_softmax_confidence, get_confidence_badge, create_confidence_progress_html
+from utils.results_manager import ResultsManager
+from utils.errors import ErrorHandler, safe_execute
+from utils.preprocessing import resample_spectrum
 from models.resnet_cnn import ResNet1D
 from models.figure2_cnn import Figure2CNN
 import hashlib
@@ -21,155 +27,189 @@ if utils_path.is_dir() and str(utils_path) not in sys.path:
     sys.path.append(str(utils_path))
 matplotlib.use("Agg")  # ensure headless rendering in Spaces
 
-#==Import local modules + new modules==
-from utils.preprocessing import resample_spectrum
-from utils.errors import ErrorHandler, safe_execute
-from utils.results_manager import ResultsManager
-from utils.confidence import calculate_softmax_confidence, get_confidence_badge, create_confidence_progress_html
-from utils.multifile import create_batch_uploader, process_multiple_files, display_batch_results
+# ==Import local modules + new modules==
 
 KEEP_KEYS = {
     # ==global UI context we want to keep after "Reset"==
     "model_select",     # sidebar model key
     "input_mode",       # radio for Upload|Sample
-    "uploader_version", # version counter for file uploader
+    "uploader_version",  # version counter for file uploader
     "input_registry",   # radio controlling Upload vs Sample
 }
 
-#==Page Configuration==
+# ==Page Configuration==
 st.set_page_config(
     page_title="ML Polymer Classification",
     page_icon="🔬",
     layout="wide",
-    initial_sidebar_state="expanded"
+    initial_sidebar_state="expanded",
+    menu_items={
+        "Get help": "https://github.com/KLab-AI3/ml-polymer-recycling"}
 )
 
-#==Custom CSS Page + Element Styling==
+# ==Custom CSS Page + Element Styling==
 st.markdown("""
 <style>
-/* Keep only scoped utility styles; no .block-container edits */
+/* Modern, slightly darker custom CSS for Streamlit app */
+/* Optimized for accessibility, consistency, and tech-forward aesthetics */
+
+/* Scoped global styles */
+:where(html, body, .stApp) {
+  background-color: #111827; /* Tailwind gray-900, dark and sleek */
+  color: #fff; /* Tailwind slate-100, high contrast */
+  font-family: 'roboto', 'ui-monospace', 'SFMono-Regular', 'Menlo', 'Consolas', monospace;
+  font-size: 16px; /* Base font size for accessibility */
+  line-height: 1.4;
+}
 
-/* Tabs content area height (your original intent) */
-div[data-testid="stTabs"] > div[role="tablist"] + div { min-height: 420px; }
+/* Tabs content area */
+div[data-testid="stTabs"] > div[role="tablist"] + div {
+  min-height: 400px;
+  background: #1f2937; /* Tailwind gray-800, slightly lighter for depth */
+  border-radius: 8px;
+  padding: 20px;
+}
 
-/* Compact info box for confidence bar */
+/* Confidence box */
 .confbox {
-  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-  font-size: 0.95rem;
-  padding: 8px 10px; border: 1px solid rgba(0,0,0,.07);
-  border-radius: 8px; background: rgba(0,0,0,.02);
+  font-size: 0.9rem;
+  padding: 10px 12px;
+  border: 1px solid #374151; /* Tailwind gray-700 */
+  border-radius: 6px;
+  background: #1e293b; /* Tailwind slate-800 */
+  color: #d1d5db; /* Tailwind gray-300 */
 }
 
-/* Clean key–value rows for technical info */
-.kv-row { display:flex; justify-content:space-between;
-  border-bottom: 1px dotted rgba(0,0,0,.10); padding: 3px 0; gap: 12px; }
-.kv-key { opacity:.75; font-size: 0.95rem; white-space: nowrap; }
-.kv-val { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-  overflow-wrap: anywhere; }
+/* Key-value rows */
+.kv-row {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  padding: 4px 0;
+  border-bottom: 1px solid #374151; /* Tailwind gray-700 */
+}
+.kv-key {
+  opacity: 0.8;
+  font-size: 0.9rem;
+  white-space: nowrap;
+}
+.kv-val {
+  font-family: 'Fira Code', monospace;
+  font-size: 0.9rem;
+  color: #e5e7eb; /* Tailwind gray-200 */
+  overflow-wrap: break-word;
+}
 
-/* Ensure markdown h5 headings remain visible after layout shifts */
-:where(h5, .stMarkdown h5) { margin-top: 0.25rem; }
+/* Markdown headings */
+:where(h5, .stMarkdown h5) {
+  margin-top: 0.5rem;
+  color: #f1f5f9; /* Tailwind slate-100 */
+  font-weight: 500;
+}
 
-/* === Base Expander Header === */
+/* Expander styles */
 div.stExpander > details > summary {
   display: flex;
   align-items: center;
   justify-content: space-between;
-  list-style: none;             /* remove default arrow */
   cursor: pointer;
-  border: 1px solid rgba(0,0,0,.15);
-  border-left: 4px solid #9ca3af;   /* default gray accent */
+  border: 1px solid #374151; /* Tailwind gray-700 */
   border-radius: 6px;
-  padding: 6px 12px;
-  margin: 6px 0;
-  background: rgba(0,0,0,0.04);
+  padding: 6px 10px;
+  margin: 0;
+  background: #1e293b; /* Tailwind slate-800 */
   font-weight: 600;
   font-size: 0.95rem;
+  color: #d1d5db; /* Tailwind gray-300 */
 }
 
-/* Remove ugly default disclosure triangle */
-div.stExpander > details > summary::-webkit-details-marker {
-  display: none;
-}
+/* Remove default disclosure markers */
+div.stExpander > details > summary::-webkit-details-marker,
 div.stExpander > details > summary::marker {
   display: none;
 }
 
-/* Hover/active subtlety */
-div.stExpander > details[open] > summary {
-  background: rgba(0,0,0,0.06);
-}
-
-/* Hide Streamlit's custom arrow icon inside expanders */
+/* Hide Streamlit's custom arrow icon */
 div[data-testid="stExpander"] summary svg {
   display: none !important;
 }
 
-/* === Right Badge === */
+/* Expander hover state */
+div.stExpander > details[open] > summary {
+  background: #374151; /* Tailwind gray-700 */
+}
+
+/* Expander badge */
 div.stExpander > details > summary::after {
-  content: "MORE ↓";
-  font-size: 0.70rem;
-  font-weight: 600;
-  letter-spacing: .04em;
-  padding: 2px 8px;
+  content: " ↓ ";
+  font-size: 1.2rem;
+  font-weight: 1000;
+  letter-spacing: 0.5 ;
+  padding: 3px 10px;
+  border: 1px solid #4b5563;
   border-radius: 999px;
-  margin-left: auto;
-  background: #e5e7eb;
-  color: #111827;
+  background: #374151; /* Tailwind gray-600 */
+  color: #e5e7eb; /* Tailwind gray-200 */
 }
 
-/* === Stable cross-browser expander behavior  === */
+/* Success/results expander */
 .expander-marker + div[data-testid="stExpander"] summary {
-  border-left-color: #2e7d32;
-  background: rgba(46,125,50,0.08);
+  border-left-color: #059669; /* Tailwind emerald-600 */
+  background: #1e293b; /* Tailwind slate-800 */
 }
 .expander-marker + div[data-testid="stExpander"] summary::after {
   content: "RESULTS";
-  background: rgba(46,125,50,0.15);
-  color: #184a1d;
+  background: #047857; /* Tailwind emerald-700 */
+  color: #d1fae5; /* Tailwind emerald-100 */
 }
 
+[data-testid="stExpanderDetails"] {
+    padding-top: 10px;
+}
 
+/* Technical expander */
 div.stExpander:has(summary:contains("Technical")) > details > summary {
-  border-left-color: #ed6c02;
-  background: rgba(237,108,2,0.08);
+  border-left-color: #ea580c; /* Tailwind orange-600 */
+  background: #1e293b; /* Tailwind slate-800 */
 }
 div.stExpander:has(summary:contains("Technical")) > details > summary::after {
   content: "ADVANCED";
-  background: rgba(237,108,2,0.18); color: #7a3d00;
+  background: #c2410c; /* Tailwind orange-700 */
+  color: #ffedd5; /* Tailwind orange-100 */
 }
 
-/* === FONT SIZE STANDARDIZATION === */
-
-/* Sidebar metrics (Accuracy, F1 Score) */
+/* Sidebar metrics */
 div[data-testid="stMetricValue"] {
-  font-size: 0.95rem !important;  /* uniform body size */
+  font-size: 0.95rem !important;
+  color: #f1f5f9; /* Tailwind slate-100 */
 }
 div[data-testid="stMetricLabel"] {
   font-size: 0.85rem !important;
-  opacity: 0.85;
+  opacity: 0.8;
+  color: #d1d5db; /* Tailwind gray-300 */
 }
 
-/* Sidebar expander text */
-section[data-testid="stSidebar"] .stMarkdown p {
+/* Sidebar text */
+section[data-testid="stSidebar"]{
   font-size: 0.95rem !important;
-  line-height: 1.4;
+  line-height: 1.25;
+  color: #fff; /* Tailwind gray-200 */
 }
 
-/* Diagnostics tab metrics (Logits) */
+/* Diagnostics metrics */
 div[data-testid="stMetricValue"] {
   font-size: 0.95rem !important;
+  color: #f1f5f9; /* Tailwind slate-100 */
 }
 div[data-testid="stMetricLabel"] {
   font-size: 0.85rem !important;
+  color: #d1d5db; /* Tailwind gray-300 */
 }
-
-
 </style>
 """, unsafe_allow_html=True)
 
 
-#==CONSTANTS==
+# ==CONSTANTS==
 TARGET_LEN = 500
 SAMPLE_DATA_DIR = Path("sample_data")
 # Prefer env var, else 'model_weights' if present; else canonical 'outputs'
@@ -198,11 +238,11 @@ MODEL_CONFIG = {
     }
 }
 
-#==Label mapping==
+# ==Label mapping==
 LABEL_MAP = {0: "Stable (Unweathered)", 1: "Weathered (Degraded)"}
 
 
-#==UTILITY FUNCTIONS==
+# ==UTILITY FUNCTIONS==
 def init_session_state():
     """Keep a persistent session state"""
     defaults = {
@@ -219,7 +259,7 @@ def init_session_state():
         "uploader_version": 0,
         "current_upload_key": "upload_txt_0",
         "active_tab": "Details",
-        "batch_mode": False # Track if in batch mode
+        "batch_mode": False  # Track if in batch mode
     }
     for k, v in defaults.items():
         st.session_state.setdefault(k, v)
@@ -228,7 +268,7 @@ def init_session_state():
         if key not in st.session_state:
             st.session_state[key] = default_value
 
-    #==Initialize results table==
+    # ==Initialize results table==
     ResultsManager.init_results_table()
 
 
@@ -248,7 +288,7 @@ def label_file(filename: str) -> int:
 def load_state_dict(_mtime, model_path):
     """Load state dict with mtime in cache key to detect file changes"""
     try:
-        return torch.load(model_path, map_location="cpu", weights_only=True)
+        return torch.load(model_path, map_location="cpu")
     except (FileNotFoundError, RuntimeError) as e:
         st.warning(f"Error loading state dict: {e}")
         return None
@@ -286,7 +326,7 @@ def load_model(model_name):
         else:
             return model, False
 
-    except (FileNotFoundError, KeyError) as e:
+    except (FileNotFoundError, KeyError, RuntimeError) as e:
         st.error(f"❌ Error loading model {model_name}: {str(e)}")
         return None, False
 
@@ -297,6 +337,7 @@ def cleanup_memory():
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
 
+
 @st.cache_data
 def run_inference(y_resampled, model_choice, _cache_key=None):
     """Run model inference and cache results"""
@@ -304,12 +345,14 @@ def run_inference(y_resampled, model_choice, _cache_key=None):
     if not model_loaded:
         return None, None, None, None, None
 
-    input_tensor = torch.tensor(y_resampled, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+    input_tensor = torch.tensor(
+        y_resampled, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
     start_time = time.time()
     model.eval()
     with torch.no_grad():
         if model is None:
-            raise ValueError("Model is not loaded. Please check the model configuration or weights.")
+            raise ValueError(
+                "Model is not loaded. Please check the model configuration or weights.")
         logits = model(input_tensor)
         prediction = torch.argmax(logits, dim=1).item()
         logits_list = logits.detach().numpy().tolist()[0]
@@ -374,6 +417,7 @@ def parse_spectrum_data(raw_text):
 
     return x, y
 
+
 @st.cache_data
 def create_spectrum_plot(x_raw, y_raw, x_resampled, y_resampled, _cache_key=None):
     """Create spectrum visualization plot"""
@@ -388,7 +432,8 @@ def create_spectrum_plot(x_raw, y_raw, x_resampled, y_resampled, _cache_key=None
     ax[0].legend()
 
     # == Resampled spectrum ==
-    ax[1].plot(x_resampled, y_resampled, label="Resampled", color="steelblue", linewidth=1)
+    ax[1].plot(x_resampled, y_resampled, label="Resampled",
+               color="steelblue", linewidth=1)
     ax[1].set_title(f"Resampled ({len(y_resampled)} points)")
     ax[1].set_xlabel("Wavenumber (cm⁻¹)")
     ax[1].set_ylabel("Intensity")
@@ -404,7 +449,6 @@ def create_spectrum_plot(x_raw, y_raw, x_resampled, y_resampled, _cache_key=None
 
     return Image.open(buf)
 
-from typing import Union
 
 def render_confidence_progress(
     probs: np.ndarray,
@@ -412,42 +456,59 @@ def render_confidence_progress(
     highlight_idx: Union[int, None] = None,
     side_by_side: bool = True
 ):
-    """Render Streamlit native progress bars (0 - 100). Optionally bold the winning class
-    and place the two bars side-by-side for compactness."""
+    """Render Streamlit native progress bars with scientific formatting."""
     p = np.asarray(probs, dtype=float)
     p = np.clip(p, 0.0, 1.0)
 
-    def _title(i: int, lbl: str, val: float) -> str:
-        t = f"{lbl} - {val*100:.1f}%"
-        return f"**{t}**" if (highlight_idx is not None and i == highlight_idx) else t
-
     if side_by_side:
         cols = st.columns(len(labels))
         for i, (lbl, val, col) in enumerate(zip(labels, p, cols)):
             with col:
-                st.markdown(_title(i, lbl, float(val)))
+                is_highlighted = (
+                    highlight_idx is not None and i == highlight_idx)
+                label_text = f"**{lbl}**" if is_highlighted else lbl
+                st.markdown(f"{label_text}: {val*100:.1f}%")
                 st.progress(int(round(val * 100)))
     else:
+        # Vertical layout for better readability
         for i, (lbl, val) in enumerate(zip(labels, p)):
-            st.markdown(_title(i, lbl, float(val)))
-            st.progress(int(round(val * 100)))
+            is_highlighted = (highlight_idx is not None and i == highlight_idx)
+
+            # Create a container for each probability
+            with st.container():
+                col1, col2 = st.columns([3, 1])
+                with col1:
+                    if is_highlighted:
+                        st.markdown(f"**{lbl}** ← Predicted")
+                    else:
+                        st.markdown(f"{lbl}")
+                with col2:
+                    st.metric(
+                        label="",
+                        value=f"{val*100:.1f}%",
+                        delta=None
+                    )
+
+                # Progress bar with conditional styling
+                if is_highlighted:
+                    st.progress(int(round(val * 100)))
+                    st.caption("🎯 **Model Prediction**")
+                else:
+                    st.progress(int(round(val * 100)))
+
+                if i < len(labels) - 1:  # Add spacing between items
+                    st.markdown("")
 
 
 def render_kv_grid(d: dict, ncols: int = 2):
-    """Display dict as a clean grid of key/value rows."""
-    if not d: 
+    """Display dict as a clean grid of key/value rows using native Streamlit components."""
+    if not d:
         return
     items = list(d.items())
     cols = st.columns(ncols)
     for i, (k, v) in enumerate(items):
         with cols[i % ncols]:
-            st.markdown(
-                f"<div class='kv-row'><span class='kv-key'>{k}</span>"
-                f"<span class='kv-val'>{v}</span></div>",
-                unsafe_allow_html=True
-            )
-
-
+            st.caption(f"**{k}:** {v}")
 
 
 def render_model_meta(model_choice: str):
@@ -478,14 +539,17 @@ def get_confidence_description(logit_margin):
     else:
         return "LOW", "🔴"
 
+
 def log_message(msg: str):
     """Append a timestamped line to the in-app log, creating the buffer if needed."""
     ErrorHandler.log_info(msg)
 
+
 def trigger_run():
     """Set a flag so we can detect button press reliably across reruns"""
     st.session_state['run_requested'] = True
 
+
 def on_sample_change():
     """Read selected sample once and persist as text."""
     sel = st.session_state.get("sample_select", "-- Select Sample --")
@@ -504,23 +568,32 @@ def on_sample_change():
         st.session_state["status_message"] = f"❌ Error loading sample: {e}"
         st.session_state["status_type"] = "error"
 
+
 def on_input_mode_change():
     """Reset sample when switching to Upload"""
     if st.session_state["input_mode"] == "Upload File":
         st.session_state["sample_select"] = "-- Select Sample --"
+        st.session_state["batch_mode"] = False  # Reset batch mode
+    elif st.session_state["input_mode"] == "Sample Data":
+        st.session_state["batch_mode"] = False  # Reset batch mode
     # 🔧 Reset when switching modes to prevent stale right-column visuals
     reset_results("Switched input mode")
 
+
 def on_model_change():
     """Force the right column back to init state when the model changes"""
     reset_results("Model changed")
 
+
 def reset_results(reason: str = ""):
     """Clear previous inference artifacts so the right column returns to initial state."""
     st.session_state["inference_run_once"] = False
     st.session_state["x_raw"] = None
     st.session_state["y_raw"] = None
     st.session_state["y_resampled"] = None
+    # ||== Clear batch results when resetting ==||
+    if "batch_results" in st.session_state:
+        del st.session_state["batch_results"]
     # ||== Clear logs between runs ==||
     st.session_state["log_messages"] = []
     # ||== Always reset the status box ==||
@@ -530,6 +603,7 @@ def reset_results(reason: str = ""):
     )
     st.session_state["status_type"] = "info"
 
+
 def reset_ephemeral_state():
     """remove everything except KEPT global UI context"""
     for k in list(st.session_state.keys()):
@@ -539,9 +613,9 @@ def reset_ephemeral_state():
     # == bump the uploader version → new widget instance with empty value ==
     st.session_state["uploader_version"] += 1
     st.session_state["current_upload_key"] = f"upload_txt_{st.session_state['uploader_version']}"
-    
+
     # == reseed other emphemeral state ==
-    st.session_state["input_text"] =  None
+    st.session_state["input_text"] = None
     st.session_state["filename"] = None
     st.session_state["input_source"] = None
     st.session_state["sample_select"] = "-- Select Sample --"
@@ -553,10 +627,12 @@ def reset_ephemeral_state():
     st.session_state["log_messages"] = []
     st.session_state["status_message"] = "Ready to analyze polymer spectra 🔬"
     st.session_state["status_type"] = "info"
-    
+
     st.rerun()
 
 # Main app
+
+
 def main():
     init_session_state()
 
@@ -564,43 +640,43 @@ def main():
     with st.sidebar:
         # Header
         st.header("AI-Driven Polymer Classification")
-        st.caption("Predict polymer degradation (Stable vs Weathered) from Raman spectra using validated CNN models. — v0.1")
-        model_labels = [f"{MODEL_CONFIG[name]['emoji']} {name}" for name in MODEL_CONFIG.keys()]
-        selected_label = st.selectbox("Choose AI Model", model_labels, key="model_select", on_change=on_model_change)
+        st.caption(
+            "Predict polymer degradation (Stable vs Weathered) from Raman spectra using validated CNN models. — v0.1")
+        model_labels = [
+            f"{MODEL_CONFIG[name]['emoji']} {name}" for name in MODEL_CONFIG.keys()]
+        selected_label = st.selectbox(
+            "Choose AI Model", model_labels, key="model_select", on_change=on_model_change)
         model_choice = selected_label.split(" ", 1)[1]
 
         # ===Compact metadata directly under dropdown===
         render_model_meta(model_choice)
 
         # ===Collapsed info to reduce clutter===
-        with st.expander("About This App",icon=":material/info:", expanded=False):
+        with st.expander("About This App", icon=":material/info:", expanded=False):
             st.markdown("""
             AI-Driven Polymer Aging Prediction and Classification
 
-            **Purpose**: Classify polymer degradation using AI  
+            **Purpose**: Classify polymer degradation using AI
             **Input**: Raman spectroscopy `.txt` files  
             **Models**: CNN architectures for binary classification  
             **Next**: More trained CNNs in evaluation pipeline
 
-            ---
 
             **Contributors**  
             Dr. Sanmukh Kuppannagari (Mentor)  
             Dr. Metin Karailyan (Mentor)  
-            👨‍💻 Jaser Hasan (Author)
+            Jaser Hasan (Author)
 
-            ---
 
             **Links**  
-            🔗 [Live HF Space](https://huggingface.co/spaces/dev-jas/polymer-aging-ml)  
-            📂 [GitHub Repository](https://github.com/KLab-AI3/ml-polymer-recycling)
+            [Live HF Space](https://huggingface.co/spaces/dev-jas/polymer-aging-ml)  
+            [GitHub Repository](https://github.com/KLab-AI3/ml-polymer-recycling)
 
-            ---
 
             **Citation Figure2CNN (baseline)**  
             Neo et al., 2023, *Resour. Conserv. Recycl.*, 188, 106718.
             [https://doi.org/10.1016/j.resconrec.2022.106718](https://doi.org/10.1016/j.resconrec.2022.106718)
-            """)
+            """, )
 
     # Main content area
     col1, col2 = st.columns([1, 1.35], gap="small")
@@ -616,7 +692,7 @@ def main():
             on_change=on_input_mode_change
         )
 
-        #==Upload tab==
+        # ==Upload tab==
         if mode == "Upload File":
             upload_key = st.session_state["current_upload_key"]
             up = st.file_uploader(
@@ -626,36 +702,38 @@ def main():
                 key=upload_key,     # ← versioned key
             )
 
-            #==Process change immediately (no on_change; simpler & reliable)==
+            # ==Process change immediately (no on_change; simpler & reliable)==
             if up is not None:
                 raw = up.read()
                 text = raw.decode("utf-8") if isinstance(raw, bytes) else raw
                 # == only reparse if its a different file|source ==
                 if st.session_state.get("filename") != getattr(up, "name", None) or st.session_state.get("input_source") != "upload":
-                    st.session_state["input_text"] = text 
-                    st.session_state["filename"] = getattr(up, "name", "uploaded.txt")
+                    st.session_state["input_text"] = text
+                    st.session_state["filename"] = getattr(up, "name", None)
                     st.session_state["input_source"] = "upload"
+                    # Ensure single file mode
                     st.session_state["batch_mode"] = False
-
-                    # == clear right column immediately ==
-                    reset_results("New file selected")
-                    st.session_state["status_message"] = f"📁 File '{st.session_state['filename']}' ready for analysis"
+                    st.session_state["status_message"] = f"File '{st.session_state['filename']}' ready for analysis"
                     st.session_state["status_type"] = "success"
-        #==Batch Upload tab==
+                    reset_results("New file uploaded")
+
+        # ==Batch Upload tab==
         elif mode == "Batch Upload":
             st.session_state["batch_mode"] = True
             uploaded_files = create_batch_uploader()
 
             if uploaded_files:
-                st.success(f"{len(uploaded_files)} files selected for batch processing")
+                st.success(
+                    f"{len(uploaded_files)} files selected for batch processing")
                 st.session_state["batch_files"] = uploaded_files
                 st.session_state["status_message"] = f"{len(uploaded_files)} ready for batch analysis"
                 st.session_state["status_type"] = "success"
             else:
-
                 st.session_state["batch_files"] = []
-                
-        #==Sample tab==
+                st.session_state["status_message"] = "No files selected for batch processing"
+                st.session_state["status_type"] = "info"
+
+        # ==Sample tab==
         elif mode == "Sample Data":
             st.session_state["batch_mode"] = False
             sample_files = get_sample_files()
@@ -666,14 +744,15 @@ def main():
                     "Choose sample spectrum:",
                     options,
                     key="sample_select",
-                    on_change=on_sample_change,  # <- critical
+                    on_change=on_sample_change,
                 )
                 if sel != "-- Select Sample --":
-                    st.markdown(f"✅ Loaded sample: {sel}")
+                    st.session_state["status_message"] = f"📁 Sample '{sel}' ready for analysis"
+                    st.session_state["status_type"] = "success"
             else:
                 st.info("No sample data available")
 
-        #==Status box==
+        # ==Status box==
         msg = st.session_state.get("status_message", "Ready")
         typ = st.session_state.get("status_type", "info")
         if typ == "success":
@@ -683,19 +762,21 @@ def main():
         else:
             st.info(msg)
 
-        #==Model load==
+        # ==Model load==
         model, model_loaded = load_model(model_choice)
         if not model_loaded:
             st.warning("⚠️ Model weights not available - using demo mode")
 
-        #==Ready to run if we have text (single) or files (batch) and a model==|
+        # ==Ready to run if we have text (single) or files (batch) and a model==|
         is_batch_mode = st.session_state.get("batch_mode", False)
         batch_files = st.session_state.get("batch_files", [])
 
         inference_ready = False  # Initialize with a default value
         if is_batch_mode:
             inference_ready = len(batch_files) > 0 and (model is not None)
-            button_text = "Run Analysis"
+        else:
+            inference_ready = st.session_state.get(
+                "input_text") is not None and (model is not None)
 
         # === Run Analysis (form submit batches state) ===
         with st.form("analysis_form", clear_on_submit=False):
@@ -708,92 +789,35 @@ def main():
         if st.button("Reset", help="Clear current file(s), plots, and results"):
             reset_ephemeral_state()
 
-            
-
         if submitted and inference_ready:
             if is_batch_mode:
-                #==Batch Mode Processing==|
-
                 with st.spinner(f"Processing {len(batch_files)} files ..."):
-                    progress_bar = st.progress(0)
-                    status_text = st.empty()
-                    def progress_callback(current, total, filename):
-                        progress = current / total if total > 0 else 0
-                        progress_bar.progress(progress)
-
-                        status_text.text(f"Processing: {filename} ({current}/{total})")
-
-                        #=Process all files=
+                    try:
                         batch_results = process_multiple_files(
-                            batch_files,
-                            model_choice,
-                            load_model,
-                            run_inference,
-                            label_file,
-                            progress_callback
+                            uploaded_files=batch_files,
+                            model_choice=model_choice,
+                            load_model_func=load_model,
+                            run_inference_func=run_inference,
+                            label_file_func=label_file
                         )
-
-                        progress_bar.progress(1.0)
-
-                        status_text.text("Batch processing complete!")
-
-                        #=Update session state=
                         st.session_state["batch_results"] = batch_results
-                        st.session_state["inference_run_once"] = True
-                        successful_count = sum(1 for r in batch_results if r.get("success", False))
-                        st.session_state["status_message"] = f"Batch analysis completed: {successful_count}/{len(batch_files)} successful"
-                        st.session_state["status_type"] = "success"
-
-                        st.rerun()
+                        st.success(
+                            f"Successfully processed {len([r for r in batch_results if r.get('success', False)])}/{len(batch_files)} files")
+                    except Exception as e:
+                        st.error(f"Error during batch processing: {e}")
             else:
-                # === Single File Mode Processing ===
-                # parse → preprocess → predict → render
-                # Handles the submission of the analysis form and performs spectrum data processing
                 try:
-                    raw_text = st.session_state["input_text"]
-                    filename = st.session_state.get("filename") or "unknown.txt"
-
-                    # Parse
-                    with st.spinner("Parsing spectrum data..."):
-                        x_raw, y_raw = parse_spectrum_data(raw_text)
-
-                    # Resample
-                    with st.spinner("Resampling spectrum..."):
-                        # ===Resample Unpack===
-                        r1, r2 = resample_spectrum(x_raw, y_raw, TARGET_LEN)
-
-                        def _is_strictly_increasing(a):
-                            a = np.asarray(a)
-                            return a.ndim == 1  and a.size >= 2 and np.all(np.diff(a) > 0)
-
-                        if _is_strictly_increasing(r1) and not _is_strictly_increasing(r2):
-                            x_resampled, y_resampled = np.asarray(r1), np.asarray(r2)
-                        elif _is_strictly_increasing(r2) and not _is_strictly_increasing(r1):
-                            x_resampled, y_resampled = np.asarray(r2), np.asarray(r1)
-                        else:
-                            # == Ambigous; assume (x, y) and log
-                            x_resampled, y_resampled = np.asarray(r1), np.asarray(r2)
-                            log_message("Resample outputs ambigous; assumed (x, y).")
-
-                        # ===Persists for plotting + inference===
-                        st.session_state["x_raw"] = x_raw
-                        st.session_state["y_raw"] = y_raw
-                        st.session_state["x_resampled"] = x_resampled   #  ←-- NEW 
-                        st.session_state["y_resampled"] = y_resampled
-
-                    # Persist results (drives right column)
+                    x_raw, y_raw = parse_spectrum_data(
+                        st.session_state["input_text"])
+                    x_resampled, y_resampled = resample_spectrum(
+                        x_raw, y_raw, TARGET_LEN)
                     st.session_state["x_raw"] = x_raw
                     st.session_state["y_raw"] = y_raw
+                    st.session_state["x_resampled"] = x_resampled
                     st.session_state["y_resampled"] = y_resampled
                     st.session_state["inference_run_once"] = True
-                    st.session_state["status_message"] = f"🔍 Analysis completed for: {filename}"
-                    st.session_state["status_type"] = "success"
-
-                    st.rerun()
-
                 except (ValueError, TypeError) as e:
-                    ErrorHandler.log_error(e, "Single file analysis")
-                    st.error(f"❌ Analysis failed: {e}")
+                    st.error(f"Error processing spectrum data: {e}")
                     st.session_state["status_message"] = f"❌ Error: {e}"
                     st.session_state["status_type"] = "error"
 
@@ -827,16 +851,20 @@ def main():
             if all(v is not None for v in [x_raw, y_raw, y_resampled]):
                 # ===Run inference===
                 if y_resampled is None:
-                    raise ValueError("y_resampled is None. Ensure spectrum data is properly resampled before proceeding.")
-                cache_key = hashlib.md5(f"{y_resampled.tobytes()}{model_choice}".encode()).hexdigest()
+                    raise ValueError(
+                        "y_resampled is None. Ensure spectrum data is properly resampled before proceeding.")
+                cache_key = hashlib.md5(
+                    f"{y_resampled.tobytes()}{model_choice}".encode()).hexdigest()
                 prediction, logits_list, probs, inference_time, logits = run_inference(
                     y_resampled, model_choice, _cache_key=cache_key
                 )
                 if prediction is None:
-                    st.error("❌ Inference failed: Model not loaded. Please check that weights are available.")
+                    st.error(
+                        "❌ Inference failed: Model not loaded. Please check that weights are available.")
                     st.stop()  # prevents the rest of the code in this block from executing
 
-                log_message(f"Inference completed in {inference_time:.2f}s, prediction: {prediction}")
+                log_message(
+                    f"Inference completed in {inference_time:.2f}s, prediction: {prediction}")
 
                 # ===Get ground truth===
                 true_label_idx = label_file(filename)
@@ -846,17 +874,19 @@ def main():
                 predicted_class = LABEL_MAP.get(
                     int(prediction), f"Class {int(prediction)}")
 
-
                 # Enhanced confidence calculation
                 if logits is not None:
                     # Use new softmax-based confidence
-                    probs_np, max_confidence, confidence_level, confidence_emoji = calculate_softmax_confidence(logits)
+                    probs_np, max_confidence, confidence_level, confidence_emoji = calculate_softmax_confidence(
+                        logits)
                     confidence_desc = confidence_level
                 else:
                     # Fallback to legace method
-                    logit_margin = abs((logits_list[0] - logits_list[1]) if logits_list is not None and len(logits_list) >= 2 else 0)
-                    confidence_desc, confidence_emoji = get_confidence_description(logit_margin)
-                    max_confidence = logit_margin / 10.0 # Normalize for display
+                    logit_margin = abs(
+                        (logits_list[0] - logits_list[1]) if logits_list is not None and len(logits_list) >= 2 else 0)
+                    confidence_desc, confidence_emoji = get_confidence_description(
+                        logit_margin)
+                    max_confidence = logit_margin / 10.0  # Normalize for display
                     probs_np = np.array([])
 
                 # Store result in results manager for single file too
@@ -875,7 +905,7 @@ def main():
                     }
                 )
 
-                #===Precompute Stats===
+                # ===Precompute Stats===
                 spec_stats = {
                     "Original Length": len(x_raw) if x_raw is not None else 0,
                     "Resampled Length": TARGET_LEN,
@@ -884,13 +914,15 @@ def main():
                     "Confidence Bucket": confidence_desc,
                 }
                 model_path = MODEL_CONFIG[model_choice]["path"]
-                mtime = os.path.getmtime(model_path) if os.path.exists(model_path) else None
+                mtime = os.path.getmtime(
+                    model_path) if os.path.exists(model_path) else None
                 file_hash = (
                     hashlib.md5(open(model_path, 'rb').read()).hexdigest()
                     if os.path.exists(model_path) else "N/A"
                 )
-                input_tensor = torch.tensor(y_resampled, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
-                model_stats =  {
+                input_tensor = torch.tensor(
+                    y_resampled, dtype=torch.float32).unsqueeze(0).unsqueeze(0)
+                model_stats = {
                     "Architecture": model_choice,
                     "Model Path": model_path,
                     "Weights Last Modified": time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mtime)) if mtime else "N/A",
@@ -909,98 +941,342 @@ def main():
                     ["Details", "Technical", "Explanation"],
                     key="active_tab",   # reuse the key you were managing manually
                 )
-                
+
                 if active_tab == "Details":
-                    with st.container():
-                        st.markdown(f"""
-                        **Sample**: `{filename}`  
-                        **Model**: `{model_choice}`  
-                        **Processing Time**: `{inference_time:.2f}s`
-                        """)
-                        st.markdown("<div class='expander-marker expander-success'></div>", unsafe_allow_html=True)
-                        with st.expander("Prediction/Ground Truth & Model Confidence Margin", expanded=True):
-                            if predicted_class == "Stable (Unweathered)":
-                                st.markdown(f"🟢 **Prediction**: {predicted_class}")
-                            else:
-                                st.markdown(f"🟡 **Prediction**: {predicted_class}")
+                    with st.expander("Results", expanded=True):
+                        # Clean header with key information
+                        st.markdown("<br>**Analysis Summary**",
+                                    width="content", unsafe_allow_html=True)
+
+                        # Streamlined header information
+                        header_col1, header_col2, header_col3 = st.columns([
+                                                                           2, 2, 2], border=True)
+
+                        with header_col1:
+                            st.metric(
+                                label="**Sample**",
+                                value=filename,
+                                delta=None,
+                            )
+
+                        with header_col2:
+                            st.metric(
+                                label="**Model**",
+                                value=model_choice.split(
+                                    " ")[0],  # Remove emoji
+                                delta=None
+                            )
+
+                        with header_col3:
+                            st.metric(
+                                label="**Processing Time**",
+                                value=f"{inference_time:.2f}s",
+                                delta=None
+                            )
+                        # Main classification results in clean cards
+                        st.markdown("**Classification Results**",
+                                    width="content", unsafe_allow_html=True)
+
+                        # Primary results in a clean 3-column layout
+                        result_col1, result_col2, result_col3 = st.columns([
+                                                                           1, 1, 1], border=True)
+
+                        with result_col1:
+                            st.metric(
+                                label="**Prediction**",
+                                value=predicted_class,
+                                delta=None
+                            )
+
+                        with result_col2:
+                            confidence_icon = "🟢" if max_confidence >= 0.8 else "🟡" if max_confidence >= 0.6 else "🔴"
+                            st.metric(
+                                label="**Confidence**",
+                                value=f"{confidence_icon} {max_confidence:.1%}",
+                                delta=None
+                            )
+
+                        with result_col3:
+                            st.metric(
+                                label="**Ground Truth**",
+                                value=f"{true_label_str}",
+                                delta=None
+                            )
+
+                        # Enhanced confidence analysis - more compact and scientific
+                        # Create a professional confidence display
+                        with st.container(border=True, height=325):
                             st.markdown(
-                                f"**{confidence_emoji} Confidence**: {confidence_desc} ({max_confidence:.1%})")
-                            if true_label_idx is not None:
-                                if predicted_class == true_label_str:
-                                    st.markdown(
-                                        f"✅ **Ground Truth**: {true_label_str} - **Correct!**")
-                                else:
-                                    st.markdown(
-                                        f"❌ **Ground Truth**: {true_label_str} - **Incorrect**")
-                            else:
+                                "**Confidence Analysis**", unsafe_allow_html=True)
+                            # Function to create enhanced bullet bars
+
+                            def create_bullet_bar(probability, width=20, predicted=False):
+                                filled_count = int(probability * width)
+                                empty_count = width - filled_count
+
+                                # Use professional symbols
+                                filled_symbol = "█ "  # Solid block
+                                empty_symbol = "░"   # Light shade
+
+                                # Create the bar
+                                bar = filled_symbol * filled_count + empty_symbol * empty_count
+
+                                # Add percentage with scientific formatting
+                                percentage = f"{probability:.1%}"
+
+                                # Add prediction indicator
+                                pred_marker = "↩ Predicted" if predicted else ""
+
+                                return f"{bar} {percentage}     {pred_marker}"
+
+                            # Get probabilities
+                            stable_prob = probs[0]
+                            weathered_prob = probs[1]
+                            is_stable_predicted = int(prediction) == 0
+                            is_weathered_predicted = int(prediction) == 1
+
+                            # Clean 2-column layout for assessment and probabilities
+                            assess_col, prob_col = st.columns(
+                                [1, 2.5], gap="small", border=True)
+
+                            # Left column: Assessment metrics
+                            with assess_col:
                                 st.markdown(
-                                    "**Ground Truth**: Unknown (filename doesn't follow naming convention)")
-
-                            st.markdown("###### Confidence Overview")
-                            if len(probs_np) > 0:
-                                confidence_html = create_confidence_progress_html(
-                                    probs_np,
-                                    labels=["Stable", "Weathered"],
-                                    highlight_idx=int(prediction)
-                                )
-                                st.markdown(confidence_html, unsafe_allow_html=True)
-                            else:
-                                # Fallback to legacy method
-                                render_confidence_progress(
-                                    probs if probs is not None else np.array([]),
-                                    labels=["Stable", "Weathered"],
-                                    highlight_idx=int(prediction),
-                                    side_by_side=True, # Set false for stacked <<
+                                    "Assessment", unsafe_allow_html=True)
+
+                                # Ground truth validation
+                                if true_label_idx is not None:
+                                    is_correct = predicted_class == true_label_str
+                                    accuracy_icon = "✅" if is_correct else ""
+                                    status_text = "Correct" if is_correct else "Incorrect"
+                                    st.metric(
+                                        label="**Ground Truth**",
+                                        value=f"{accuracy_icon} {status_text}",
+                                        delta=f"{'100%' if is_correct else '0%'}"
+                                    )
+                                else:
+                                    st.metric(
+                                        label="**Ground Truth**",
+                                        value="N/A",
+                                        delta="No reference"
+                                    )
+
+                                # Confidence level
+                                confidence_icon = "🟢" if max_confidence >= 0.8 else "🟡" if max_confidence >= 0.6 else "🔴"
+                                st.metric(
+                                    label="**Confidence Level**",
+                                    value=f"{confidence_icon} {confidence_desc}",
+                                    delta=f"{max_confidence:.1%}"
                                 )
 
+                            # Right column: Probability distribution
+                            with prob_col:
+                                st.markdown("Probability Distribution")
+
+                                st.markdown(f"""
+                                            <div style="">
+                                                Stable (Unweathered)<br>
+                                                {create_bullet_bar(stable_prob, predicted=is_stable_predicted)}<br><br>
+                                                Weathered (Degraded)<br>
+                                                {create_bullet_bar(weathered_prob, predicted=is_weathered_predicted)}
+                                            </div>
+                                            
+                                """, unsafe_allow_html=True)
+
                 elif active_tab == "Technical":
                     with st.container():
-                        st.markdown("<div class='expander-marker expander-success'></div>", unsafe_allow_html=True)
-                        with st.expander("Diagnostics/Technical Info (advanced)", expanded=True):
-                            st.markdown("###### Model Output (Logits)")
-                            cols = st.columns(2)
+                        st.markdown("Technical Diagnostics")
+
+                        # Model performance metrics
+                        with st.container(border=True):
+                            st.markdown("##### **Model Performance**")
+                            tech_col1, tech_col2 = st.columns(2)
+
+                            with tech_col1:
+                                st.metric("Inference Time",
+                                          f"{inference_time:.3f}s")
+                                st.metric(
+                                    "Input Length", f"{len(x_raw) if x_raw is not None else 0} points")
+                                st.metric("Resampled Length",
+                                          f"{TARGET_LEN} points")
+
+                            with tech_col2:
+                                st.metric("Model Loaded",
+                                          "✅ Yes" if model_loaded else "❌ No")
+                                st.metric("Device", "CPU")
+                                st.metric("Confidence Score",
+                                          f"{max_confidence:.3f}")
+
+                        # Raw logits display
+                        with st.container(border=True):
+                            st.markdown("##### **Raw Model Outputs (Logits)**")
                             if logits_list is not None:
-                                for i, score in enumerate(logits_list):
-                                    label = LABEL_MAP.get(i, f"Class {i}")
-                                    cols[i % 2].metric(label, f"{score:.2f}")
-                            st.markdown("###### Spectrum Statistics")
-                            render_kv_grid(spec_stats, ncols=2)
-                            st.markdown("---")
-                            st.markdown("###### Model Statistics")
-                            render_kv_grid(model_stats, ncols=2)
-                            st.markdown("---")
-                            st.markdown("###### Debug Log")
-                            st.text_area("Logs", "\n".join(st.session_state.get("log_messages", [])), height=110)
+                                logits_df = {
+                                    "Class": [LABEL_MAP.get(i, f"Class {i}") for i in range(len(logits_list))],
+                                    "Logit Value": [f"{score:.4f}" for score in logits_list],
+                                    "Probability": [f"{prob:.4f}" for prob in probs_np] if len(probs_np) > 0 else ["N/A"] * len(logits_list)
+                                }
+
+                            # Display as a simple table format
+                            for i, (cls, logit, prob) in enumerate(zip(logits_df["Class"], logits_df["Logit Value"], logits_df["Probability"])):
+                                col1, col2, col3 = st.columns([2, 1, 1])
+                                with col1:
+                                    if i == prediction:
+                                        st.markdown(f"**{cls}** ← Predicted")
+                                    else:
+                                        st.markdown(cls)
+                                with col2:
+                                    st.caption(f"Logit: {logit}")
+                                with col3:
+                                    st.caption(f"Prob: {prob}")
+
+                        # Spectrum statistics in organized sections
+                        with st.container(border=True):
+                            st.markdown("##### **Spectrum Analysis**")
+                            spec_cols = st.columns(2)
+
+                            with spec_cols[0]:
+                                st.markdown("**Original Spectrum:**")
+                                render_kv_grid({
+                                    "Length": f"{len(x_raw) if x_raw is not None else 0} points",
+                                    "Range": f"{min(x_raw):.1f} - {max(x_raw):.1f} cm⁻¹" if x_raw is not None else "N/A",
+                                    "Min Intensity": f"{min(y_raw):.2e}" if y_raw is not None else "N/A",
+                                    "Max Intensity": f"{max(y_raw):.2e}" if y_raw is not None else "N/A"
+                                }, ncols=1)
+
+                            with spec_cols[1]:
+                                st.markdown("**Processed Spectrum:**")
+                                render_kv_grid({
+                                    "Length": f"{TARGET_LEN} points",
+                                    "Resampling": "Linear interpolation",
+                                    "Normalization": "None",
+                                    "Input Shape": f"(1, 1, {TARGET_LEN})"
+                                }, ncols=1)
+
+                        # Model information
+                        with st.container(border=True):
+                            st.markdown("##### **Model Information**")
+                            model_info_cols = st.columns(2)
+
+                            with model_info_cols[0]:
+                                render_kv_grid({
+                                    "Architecture": model_choice,
+                                    "Path": MODEL_CONFIG[model_choice]["path"],
+                                    "Weights Modified": time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(mtime)) if mtime else "N/A"
+                                }, ncols=1)
+
+                            with model_info_cols[1]:
+                                if os.path.exists(model_path):
+                                    file_hash = hashlib.md5(
+                                        open(model_path, 'rb').read()).hexdigest()
+                                    render_kv_grid({
+                                        "Weights Hash": f"{file_hash[:16]}...",
+                                        "Output Shape": f"(1, {len(LABEL_MAP)})",
+                                        "Activation": "Softmax"
+                                    }, ncols=1)
+
+                        # Debug logs (collapsed by default)
+                        with st.expander("📋 Debug Logs", expanded=False):
+                            log_content = "\n".join(
+                                st.session_state.get("log_messages", []))
+                            if log_content.strip():
+                                st.code(log_content, language="text")
+                            else:
+                                st.caption("No debug logs available")
 
                 elif active_tab == "Explanation":
                     with st.container():
+                        st.markdown("### 🔍 Methodology & Interpretation")
+
+                        # Process explanation
+                        st.markdown("Analysis Pipeline")
+                        process_steps = [
+                            "📁 **Data Upload**: Raman spectrum file loaded and validated",
+                            "🔍 **Preprocessing**: Spectrum parsed and resampled to 500 data points using linear interpolation",
+                            "🧠 **AI Inference**: Convolutional Neural Network analyzes spectral patterns and molecular signatures",
+                            "📊 **Classification**: Binary prediction with confidence scoring using softmax probabilities",
+                            "✅ **Validation**: Ground truth comparison (when available from filename)"
+                        ]
+
+                        for step in process_steps:
+                            st.markdown(step)
+
+                        st.markdown("---")
+
+                        # Model interpretation
+                        st.markdown("#### Scientific Interpretation")
+
+                        interp_col1, interp_col2 = st.columns(2)
+
+                        with interp_col1:
+                            st.markdown("**Stable (Unweathered) Polymers:**")
+                            st.info("""
+                            - Well-preserved molecular structure
+                            - Minimal oxidative degradation
+                            - Characteristic Raman peaks intact
+                            - Suitable for recycling applications
+                            """)
+
+                        with interp_col2:
+                            st.markdown("**Weathered (Degraded) Polymers:**")
+                            st.warning("""
+                            - Oxidized molecular bonds
+                            - Surface degradation present
+                            - Altered spectral signatures
+                            - May require additional processing
+                            """)
+
+                        st.markdown("---")
+
+                        # Applications
+                        st.markdown("#### Research Applications")
+
+                        applications = [
+                            "🔬 **Material Science**: Polymer degradation studies",
+                            "♻️ **Recycling Research**: Viability assessment for circular economy",
+                            "🌱 **Environmental Science**: Microplastic weathering analysis",
+                            "🏭 **Quality Control**: Manufacturing process monitoring",
+                            "📈 **Longevity Studies**: Material aging prediction"
+                        ]
+
+                        for app in applications:
+                            st.markdown(app)
+
+                        # Technical details
+                        with st.expander("🔧 Technical Details", expanded=False):
                             st.markdown("""
-                            **🔍 Analysis Process**
-                        
-                            1. **Data Upload**: Raman spectrum file loaded
-                            2. **Preprocessing**: Data parsed and resampled to 500 points
-                            3. **AI Inference**: CNN model analyzes spectral patterns
-                            4. **Classification**: Binary prediction with confidence scores
-                            
-                            **🧠 Model Interpretation**
+                            **Model Architecture:**
+                            - Convolutional layers for feature extraction
+                            - Residual connections for gradient flow
+                            - Fully connected layers for classification
+                            - Softmax activation for probability distribution
                             
-                            The AI model identifies spectral features indicative of:
-                            - **Stable polymers**: Well-preserved molecular structure
-                            - **Weathered polymers**: Degraded/oxidized molecular bonds
+                            **Performance Metrics:**
+                            - Accuracy: 94.8-96.2% on validation set
+                            - F1-Score: 94.3-95.9% across classes
+                            - Robust to spectral noise and baseline variations
                             
-                            **🎯 Applications**
-                            
-                            - Material longevity assessment
-                            - Recycling viability evaluation  
-                            - Quality control in manufacturing
-                            - Environmental impact studies
+                            **Data Processing:**
+                            - Input: Raman spectra (any length)
+                            - Resampling: Linear interpolation to 500 points
+                            - Normalization: None (preserves intensity relationships)
                             """)
 
-                    render_time = time.time() - start_render
-                    log_message(f"col2 rendered in {render_time:.2f}s, active tab: {active_tab}")
+                        render_time = time.time() - start_render
+                        log_message(
+                            f"col2 rendered in {render_time:.2f}s, active tab: {active_tab}")
 
-                st.markdown("<div class='expander-marker expander-success'></div>", unsafe_allow_html=True)
                 with st.expander("Spectrum Preprocessing Results", expanded=False):
+                    st.caption("<br>Spectral Analysis", unsafe_allow_html=True)
+
+                    # Add some context about the preprocessing
+                    st.markdown("""
+                    **Preprocessing Overview:**
+                    - **Original Spectrum**: Raw Raman data as uploaded
+                    - **Resampled Spectrum**: Data interpolated to 500 points for model input
+                    - **Purpose**: Ensures consistent input dimensions for neural network
+                    """)
+
                     # Create and display plot
                     cache_key = hashlib.md5(
                         f"{(x_raw.tobytes() if x_raw is not None else b'')}"
@@ -1008,8 +1284,10 @@ def main():
                         f"{(x_resampled.tobytes() if x_resampled is not None else b'')}"
                         f"{(y_resampled.tobytes() if y_resampled is not None else b'')}".encode()
                     ).hexdigest()
-                    spectrum_plot = create_spectrum_plot(x_raw, y_raw, x_resampled, y_resampled, _cache_key=cache_key)
-                    st.image(spectrum_plot, caption="Spectrum Preprocessing Results", use_container_width=True)
+                    spectrum_plot = create_spectrum_plot(
+                        x_raw, y_raw, x_resampled, y_resampled, _cache_key=cache_key)
+                    st.image(
+                        spectrum_plot, caption="Raman Spectrum: Raw vs Processed", use_container_width=True)
 
             else:
                 st.error(