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 import gc import time import io from PIL import Image import matplotlib.pyplot as plt import matplotlib import numpy as np import torch import torch.nn.functional as F import streamlit as st import os import sys from pathlib import Path # Ensure 'utils' directory is in the Python path utils_path = Path(__file__).resolve().parent / "utils" 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== 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 "input_registry", # radio controlling Upload vs Sample } # ==Page Configuration== st.set_page_config( page_title="ML Polymer Classification", page_icon="๐Ÿ”ฌ", layout="wide", initial_sidebar_state="expanded", menu_items={ "Get help": "https://github.com/KLab-AI3/ml-polymer-recycling"} ) # ============================================================================== # THEME-AWARE CUSTOM CSS # ============================================================================== # This CSS block has been refactored to use Streamlit's internal theme # variables. This ensures that all custom components will automatically adapt # to both light and dark themes selected by the user in the settings menu. st.markdown(""" """, unsafe_allow_html=True) # ==CONSTANTS== TARGET_LEN = 500 SAMPLE_DATA_DIR = Path("sample_data") # Prefer env var, else 'model_weights' if present; else canonical 'outputs' MODEL_WEIGHTS_DIR = ( os.getenv("WEIGHTS_DIR") or ("model_weights" if os.path.isdir("model_weights") else "outputs") ) # Model configuration MODEL_CONFIG = { "Figure2CNN (Baseline)": { "class": Figure2CNN, "path": f"{MODEL_WEIGHTS_DIR}/figure2_model.pth", "emoji": "", "description": "Baseline CNN with standard filters", "accuracy": "94.80%", "f1": "94.30%" }, "ResNet1D (Advanced)": { "class": ResNet1D, "path": f"{MODEL_WEIGHTS_DIR}/resnet_model.pth", "emoji": "", "description": "Residual CNN with deeper feature learning", "accuracy": "96.20%", "f1": "95.90%" } } # ==Label mapping== LABEL_MAP = {0: "Stable (Unweathered)", 1: "Weathered (Degraded)"} # ==UTILITY FUNCTIONS== def init_session_state(): """Keep a persistent session state""" defaults = { "status_message": "Ready to analyze polymer spectra ๐Ÿ”ฌ", "status_type": "info", "input_text": None, "filename": None, "input_source": None, # "upload" or "sample" "sample_select": "-- Select Sample --", "input_mode": "Upload File", # controls which pane is visible "inference_run_once": False, "x_raw": None, "y_raw": None, "y_resampled": None, "log_messages": [], "uploader_version": 0, "current_upload_key": "upload_txt_0", "active_tab": "Details", "batch_mode": False # Track if in batch mode } for k, v in defaults.items(): st.session_state.setdefault(k, v) for key, default_value in defaults.items(): if key not in st.session_state: st.session_state[key] = default_value # ==Initialize results table== ResultsManager.init_results_table() def label_file(filename: str) -> int: """Extract label from filename based on naming convention""" name = Path(filename).name.lower() if name.startswith("sta"): return 0 elif name.startswith("wea"): return 1 else: # Return None for unknown patterns instead of raising error return -1 # Default value for unknown patterns @st.cache_data 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") except (FileNotFoundError, RuntimeError) as e: st.warning(f"Error loading state dict: {e}") return None @st.cache_resource def load_model(model_name): """Load and cache the specified model with error handling""" try: config = MODEL_CONFIG[model_name] model_class = config["class"] model_path = config["path"] # Initialize model model = model_class(input_length=TARGET_LEN) # Check if model file exists if not os.path.exists(model_path): st.warning(f"โš ๏ธ Model weights not found: {model_path}") st.info("Using randomly initialized model for demonstration purposes.") return model, False # Get mtime for cache invalidation mtime = os.path.getmtime(model_path) # Load weights state_dict = load_state_dict(mtime, model_path) if state_dict: model.load_state_dict(state_dict, strict=True) if model is None: raise ValueError( "Model is not loaded. Please check the model configuration or weights.") model.eval() return model, True else: return model, False except (FileNotFoundError, KeyError, RuntimeError) as e: st.error(f"โŒ Error loading model {model_name}: {str(e)}") return None, False def cleanup_memory(): """Clean up memory after inference""" gc.collect() 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""" model, model_loaded = load_model(model_choice) if not model_loaded: return None, None, None, None, None 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.") logits = model(input_tensor) prediction = torch.argmax(logits, dim=1).item() logits_list = logits.detach().numpy().tolist()[0] probs = F.softmax(logits.detach(), dim=1).cpu().numpy().flatten() inference_time = time.time() - start_time cleanup_memory() return prediction, logits_list, probs, inference_time, logits @st.cache_data def get_sample_files(): """Get list of sample files if available""" sample_dir = Path(SAMPLE_DATA_DIR) if sample_dir.exists(): return sorted(list(sample_dir.glob("*.txt"))) return [] def parse_spectrum_data(raw_text): """Parse spectrum data from text with robust error handling and validation""" x_vals, y_vals = [], [] for line in raw_text.splitlines(): line = line.strip() if not line or line.startswith('#'): # Skip empty lines and comments continue try: # Handle different separators parts = line.replace(",", " ").split() numbers = [p for p in parts if p.replace('.', '', 1).replace( '-', '', 1).replace('+', '', 1).isdigit()] if len(numbers) >= 2: x, y = float(numbers[0]), float(numbers[1]) x_vals.append(x) y_vals.append(y) except ValueError: # Skip problematic lines but don't fail completely continue if len(x_vals) < 10: # Minimum reasonable spectrum length raise ValueError( f"Insufficient data points: {len(x_vals)}. Need at least 10 points.") x = np.array(x_vals) y = np.array(y_vals) # Check for NaNs if np.any(np.isnan(x)) or np.any(np.isnan(y)): raise ValueError("Input data contains NaN values") # Check monotonic increasing x if not np.all(np.diff(x) > 0): raise ValueError("Wavenumbers must be strictly increasing") # Check reasonable range for Raman spectroscopy if min(x) < 0 or max(x) > 10000 or (max(x) - min(x)) < 100: raise ValueError( f"Invalid wavenumber range: {min(x)} - {max(x)}. Expected ~400-4000 cmโปยน with span >100") 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""" fig, ax = plt.subplots(1, 2, figsize=(13, 5), dpi=100) # == Raw spectrum == ax[0].plot(x_raw, y_raw, label="Raw", color="dimgray", linewidth=1) ax[0].set_title("Raw Input Spectrum") ax[0].set_xlabel("Wavenumber (cmโปยน)") ax[0].set_ylabel("Intensity") ax[0].grid(True, alpha=0.3) ax[0].legend() # == Resampled spectrum == 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") ax[1].grid(True, alpha=0.3) ax[1].legend() plt.tight_layout() # == Convert to image == buf = io.BytesIO() plt.savefig(buf, format='png', bbox_inches='tight', dpi=100) buf.seek(0) plt.close(fig) # Prevent memory leaks return Image.open(buf) def render_confidence_progress( probs: np.ndarray, labels: list[str] = ["Stable", "Weathered"], highlight_idx: Union[int, None] = None, side_by_side: bool = True ): """Render Streamlit native progress bars with scientific formatting.""" p = np.asarray(probs, dtype=float) p = np.clip(p, 0.0, 1.0) if side_by_side: cols = st.columns(len(labels)) for i, (lbl, val, col) in enumerate(zip(labels, p, cols)): with col: 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)): 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 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.caption(f"**{k}:** {v}") def render_model_meta(model_choice: str): info = MODEL_CONFIG.get(model_choice, {}) emoji = info.get("emoji", "") desc = info.get("description", "").strip() acc = info.get("accuracy", "-") f1 = info.get("f1", "-") st.caption(f"{emoji} **Model Snapshot** - {model_choice}") cols = st.columns(2) with cols[0]: st.metric("Accuracy", acc) with cols[1]: st.metric("F1 Score", f1) if desc: st.caption(desc) def get_confidence_description(logit_margin): """Get human-readable confidence description""" if logit_margin > 1000: return "VERY HIGH", "๐ŸŸข" elif logit_margin > 250: return "HIGH", "๐ŸŸก" elif logit_margin > 100: return "MODERATE", "๐ŸŸ " 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 --") if sel == "-- Select Sample --": return try: text = (Path(SAMPLE_DATA_DIR / sel).read_text(encoding="utf-8")) st.session_state["input_text"] = text st.session_state["filename"] = sel st.session_state["input_source"] = "sample" # ๐Ÿ”ง Clear previous results so right column resets immediately reset_results("New sample selected") st.session_state["status_message"] = f"๐Ÿ“ Sample '{sel}' ready for analysis" st.session_state["status_type"] = "success" except (FileNotFoundError, IOError) as e: 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 ==|| st.session_state["status_message"] = ( f"โ„น๏ธ {reason}" if reason else "Ready to analyze polymer spectra ๐Ÿ”ฌ" ) st.session_state["status_type"] = "info" def reset_ephemeral_state(): """Comprehensive reset for the entire app state.""" # Define keys that should NOT be cleared by a full reset keep_keys = {"model_select", "input_mode"} for k in list(st.session_state.keys()): if k not in keep_keys: st.session_state.pop(k, None) # Re-initialize the core state after clearing init_session_state() # CRITICAL: Bump the uploader version to force a widget reset st.session_state["uploader_version"] += 1 st.session_state["current_upload_key"] = f"upload_txt_{st.session_state['uploader_version']}" st.rerun() # --- START: BUG 2 FIX (Callback Function) --- def clear_batch_results(): """Callback to clear only the batch results and the results log table.""" if "batch_results" in st.session_state: del st.session_state["batch_files"] # Also clear the persistent table from the ResultsManager utility ResultsManager.clear_results() st.rerun() # --- END: BUG 2 FIX (Callback Function) --- st.rerun() # Main app def main(): init_session_state() # Sidebar 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) 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): st.markdown(""" AI-Driven Polymer Aging Prediction and Classification **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) **Links** [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") with col1: st.markdown("##### Data Input") mode = st.radio( "Input mode", ["Upload File", "Batch Upload", "Sample Data"], key="input_mode", horizontal=True, on_change=on_input_mode_change ) # ==Upload tab== if mode == "Upload File": upload_key = st.session_state["current_upload_key"] up = st.file_uploader( "Upload Raman spectrum (.txt)", type="txt", help="Upload a text file with wavenumber and intensity columns", key=upload_key, # โ† versioned key ) # ==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", None) st.session_state["input_source"] = "upload" # Ensure single file mode st.session_state["batch_mode"] = False st.session_state["status_message"] = f"File '{st.session_state['filename']}' ready for analysis" st.session_state["status_type"] = "success" reset_results("New file uploaded") # ==Batch Upload tab== elif mode == "Batch Upload": st.session_state["batch_mode"] = True # --- START: BUG 1 & 3 FIX --- # Use a versioned key to ensure the file uploader resets properly. batch_upload_key = f"batch_upload_{st.session_state['uploader_version']}" uploaded_files = st.file_uploader( "Upload multiple Raman spectrum files (.txt)", type="txt", accept_multiple_files=True, help="Upload one or more text files with wavenumber and intensity columns.", key=batch_upload_key ) # --- END: BUG 1 & 3 FIX --- if uploaded_files: # --- START: Bug 1 Fix --- # Use a dictionary to keep only unique files based on name and size unique_files = {(file.name, file.size): file for file in uploaded_files} unique_file_list = list(unique_files.values()) num_uploaded = len(uploaded_files) num_unique = len(unique_file_list) # Optionally, inform the user that duplicates were removed if num_uploaded > num_unique: st.info( f"โ„น๏ธ {num_uploaded - num_unique} duplicate file(s) were removed.") # Use the unique list st.session_state["batch_files"] = unique_file_list st.session_state["status_message"] = f"{num_unique} ready for batch analysis" st.session_state["status_type"] = "success" # --- END: Bug 1 Fix --- else: st.session_state["batch_files"] = [] # This check prevents resetting the status if files are already staged if not st.session_state.get("batch_files"): 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() if sample_files: options = ["-- Select Sample --"] + \ [p.name for p in sample_files] sel = st.selectbox( "Choose sample spectrum:", options, key="sample_select", on_change=on_sample_change, ) if sel != "-- Select Sample --": 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== msg = st.session_state.get("status_message", "Ready") typ = st.session_state.get("status_type", "info") if typ == "success": st.success(msg) elif typ == "error": st.error(msg) else: st.info(msg) # ==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==| 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) 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): submitted = st.form_submit_button( "Run Analysis", type="primary", disabled=not inference_ready, ) # Renamed for clarity and uses the robust on_click callback st.button("Reset All", on_click=reset_ephemeral_state, help="Clear all uploaded files and results.") if submitted and inference_ready: if is_batch_mode: with st.spinner(f"Processing {len(batch_files)} files ..."): try: batch_results = process_multiple_files( uploaded_files=batch_files, model_choice=model_choice, load_model_func=load_model, run_inference_func=run_inference, label_file_func=label_file ) st.session_state["batch_results"] = batch_results 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: try: 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 except (ValueError, TypeError) as e: st.error(f"Error processing spectrum data: {e}") st.session_state["status_message"] = f"โŒ Error: {e}" st.session_state["status_type"] = "error" # Results column with col2: # Check if we're in batch more or have batch results is_batch_mode = st.session_state.get("batch_mode", False) has_batch_results = "batch_results" in st.session_state if is_batch_mode and has_batch_results: # Display batch results st.markdown("##### Batch Analysis Results") batch_results = st.session_state["batch_results"] display_batch_results(batch_results) # Add session results table st.markdown("---") # --- START: BUG 2 FIX (Button) --- # This button will clear all results from col2 correctly. # st.button("Clear Results", on_click=clear_batch_results, # help="Clear all uploaded files and results.") # --- END: BUG 2 FIX (Button) --- ResultsManager.display_results_table() elif st.session_state.get("inference_run_once", False) and not is_batch_mode: st.markdown("##### Analysis Results") # Get data from session state x_raw = st.session_state.get('x_raw') y_raw = st.session_state.get('y_raw') x_resampled = st.session_state.get('x_resampled') # โ† NEW y_resampled = st.session_state.get('y_resampled') filename = st.session_state.get('filename', 'Unknown') 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() 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.stop() # prevents the rest of the code in this block from executing log_message( f"Inference completed in {inference_time:.2f}s, prediction: {prediction}") # ===Get ground truth=== true_label_idx = label_file(filename) true_label_str = LABEL_MAP.get( true_label_idx, "Unknown") if true_label_idx is not None else "Unknown" # ===Get prediction=== 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) 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 probs_np = np.array([]) # Store result in results manager for single file too ResultsManager.add_results( filename=filename, model_name=model_choice, prediction=int(prediction), predicted_class=predicted_class, confidence=max_confidence, logits=logits_list if logits_list else [], ground_truth=true_label_idx if true_label_idx >= 0 else None, processing_time=inference_time if inference_time is not None else 0.0, metadata={ "confidence_level": confidence_desc, "confidence_emoji": confidence_emoji } ) # ===Precompute Stats=== spec_stats = { "Original Length": len(x_raw) if x_raw is not None else 0, "Resampled Length": TARGET_LEN, "Wavenumber Range": f"{min(x_raw):.1f}-{max(x_raw):.1f} cmโปยน" if x_raw is not None else "N/A", "Intensity Range": f"{min(y_raw):.1f}-{max(y_raw):.1f} au" if y_raw is not None else "N/A", "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 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 = { "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", "Weights Hash (md5)": file_hash, "Input Shape": list(input_tensor.shape), "Output Shape": list(logits.shape) if logits is not None else "N/A", "Inference Time": f"{inference_time:.3f}s", "Device": "CPU", "Model Loaded": model_loaded, } start_render = time.time() active_tab = st.selectbox( "View Results", ["Details", "Technical", "Explanation"], key="active_tab", # reuse the key you were managing manually ) if active_tab == "Details": st.markdown('
', unsafe_allow_html=True) # Use a dynamic and informative title for the expander with st.expander(f"Results for {filename}", expanded=True): # --- START: STREAMLINED METRICS --- # A single, powerful row for the most important results. key_metric_cols = st.columns(3) # Metric 1: The Prediction key_metric_cols[0].metric( "Prediction", predicted_class) # Metric 2: The Confidence (with level in tooltip) confidence_icon = "๐ŸŸข" if max_confidence >= 0.8 else "๐ŸŸก" if max_confidence >= 0.6 else "๐Ÿ”ด" key_metric_cols[1].metric( "Confidence", f"{confidence_icon} {max_confidence:.1%}", help=f"Confidence Level: {confidence_desc}" ) # Metric 3: Ground Truth + Correctness (Combined) if true_label_idx is not None: is_correct = (predicted_class == true_label_str) delta_text = "โœ… Correct" if is_correct else "โŒ Incorrect" # Use delta_color="normal" to let the icon provide the visual cue key_metric_cols[2].metric( "Ground Truth", true_label_str, delta=delta_text, delta_color="normal") else: key_metric_cols[2].metric("Ground Truth", "N/A") st.divider() # --- END: STREAMLINED METRICS --- # --- START: CONSOLIDATED CONFIDENCE ANALYSIS --- st.markdown("##### Probability Breakdown") # This custom bullet bar logic remains as it is highly specific and valuable def create_bullet_bar(probability, width=20, predicted=False): filled_count = int(probability * width) bar = "โ–ˆ " * filled_count + \ "โ–‘" * (width - filled_count) percentage = f"{probability:.1%}" pred_marker = "โ†ฉ Predicted" if predicted else "" return f"{bar} {percentage} {pred_marker}" stable_prob, weathered_prob = probs[0], probs[1] is_stable_predicted, is_weathered_predicted = ( int(prediction) == 0), (int(prediction) == 1) st.markdown(f"""
Stable (Unweathered)
{create_bullet_bar(stable_prob, predicted=is_stable_predicted)}

Weathered (Degraded)
{create_bullet_bar(weathered_prob, predicted=is_weathered_predicted)}
""", unsafe_allow_html=True) # --- END: CONSOLIDATED CONFIDENCE ANALYSIS --- st.divider() # --- START: CLEAN METADATA FOOTER --- # Secondary info is now a clean, single-line caption st.caption( f"Analyzed with **{model_choice}** in **{inference_time:.2f}s**.") # --- END: CLEAN METADATA FOOTER --- st.markdown('
', unsafe_allow_html=True) elif active_tab == "Technical": with st.container(): 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: 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 # MODIFIED: Wrap the expander in a div with the 'expander-advanced' class st.markdown('
', unsafe_allow_html=True) with st.expander("๐Ÿ”ง Technical Details", expanded=False): st.markdown(""" **Model Architecture:** - Convolutional layers for feature extraction - Residual connections for gradient flow - Fully connected layers for classification - Softmax activation for probability distribution **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 **Data Processing:** - Input: Raman spectra (any length) - Resampling: Linear interpolation to 500 points - Normalization: None (preserves intensity relationships) """) st.markdown( '
', unsafe_allow_html=True) # Close the wrapper div render_time = time.time() - start_render log_message( f"col2 rendered in {render_time:.2f}s, active tab: {active_tab}") with st.expander("Spectrum Preprocessing Results", expanded=False): st.caption("
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'')}" f"{(y_raw.tobytes() if y_raw is not None else b'')}" 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="Raman Spectrum: Raw vs Processed", use_container_width=True) else: st.error( "โŒ Missing spectrum data. Please upload a file and run analysis.") else: # ===Getting Started=== st.markdown(""" ##### How to Get Started 1. **Select an AI Model:** Use the dropdown menu in the sidebar to choose a model. 2. **Provide Your Data:** Select one of the three input modes: - **Upload File:** Analyze a single spectrum. - **Batch Upload:** Process multiple files at once. - **Sample Data:** Explore functionality with pre-loaded examples. 3. **Run Analysis:** Click the "Run Analysis" button to generate the classification results. --- ##### Supported Data Format - **File Type:** Plain text (`.txt`) - **Content:** Must contain two columns: `wavenumber` and `intensity`. - **Separators:** Values can be separated by spaces or commas. - **Preprocessing:** Your spectrum will be automatically resampled to 500 data points to match the model's input requirements. --- ##### Example Applications - ๐Ÿ”ฌ Research on polymer degradation - โ™ป๏ธ Recycling feasibility assessment - ๐ŸŒฑ Sustainability impact studies - ๐Ÿญ Quality control in manufacturing """) # Run the application main()