added debug to model workflow

dds a parallel debug column that shows:

Real-time Process Information:

Timestamped debug messages
Color-coded by message type (info, warning, error, success)
Model loading details
Image processing information


Resource Usage:

GPU memory usage (if available)
Model device information
Memory allocation tracking


Technical Details:

Image properties
Model configuration
Processing steps
Result type information


Error Handling:

Detailed error messages
Error types
Stack trace references

app.py

@@ -196,47 +196,117 @@ with col2:
         for use_case in model_info[selected_model]['best_for']:
             st.markdown(f"- {use_case}")
 
-# Analysis section with improved error handling and progress tracking
+# Inside the analysis section, replace the existing if-block with:
 if uploaded_file is not None and selected_model:
     if st.button("Analyze Document", help="Click to start document analysis"):
-        with st.spinner('Loading model and analyzing document...'):
+        # Create two columns for results and debug info
+        result_col, debug_col = st.columns([1, 1])
+        
+        with st.spinner('Processing...'):
             try:
-                # Create a progress bar
-                progress_bar = st.progress(0)
+                # Create a progress bar in results column
+                with result_col:
+                    st.markdown("### Analysis Progress")
+                    progress_bar = st.progress(0)
                 
+                # Initialize debug column
+                with debug_col:
+                    st.markdown("### Debug Information")
+                    debug_container = st.empty()
+                    
+                    def update_debug(message, level="info"):
+                        """Update debug information with timestamp"""
+                        timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
+                        color = {
+                            "info": "blue",
+                            "warning": "orange",
+                            "error": "red",
+                            "success": "green"
+                        }.get(level, "black")
+                        
+                        return f"<div style='color: {color};'>[{timestamp}] {message}</div>"
+                    
+                    debug_messages = []
+                    
+                    def add_debug(message, level="info"):
+                        debug_messages.append(update_debug(message, level))
+                        debug_container.markdown(
+                            "\n".join(debug_messages),
+                            unsafe_allow_html=True
+                        )
+
                 # Load model with progress update
-                progress_bar.progress(25)
-                st.info("Loading model...")
+                with result_col:
+                    progress_bar.progress(25)
+                    st.info("Loading model...")
+                
+                add_debug(f"Loading {selected_model} model and processor...")
                 model, processor = load_model(selected_model)
                 
                 if model is None or processor is None:
-                    st.error("Failed to load model. Please try again.")
+                    with result_col:
+                        st.error("Failed to load model. Please try again.")
+                    add_debug("Model loading failed!", "error")
                 else:
+                    add_debug("Model loaded successfully", "success")
+                    add_debug(f"Model device: {next(model.parameters()).device}")
+                    add_debug(f"Model memory usage: {torch.cuda.max_memory_allocated()/1024**2:.2f}MB") if torch.cuda.is_available() else None
+                    
                     # Update progress
-                    progress_bar.progress(50)
-                    st.info("Analyzing document...")
+                    with result_col:
+                        progress_bar.progress(50)
+                        st.info("Analyzing document...")
+                    
+                    # Log image details
+                    add_debug(f"Image size: {image.size}")
+                    add_debug(f"Image mode: {image.mode}")
                     
                     # Analyze document
+                    add_debug("Starting document analysis...")
                     results = analyze_document(image, selected_model, model, processor)
+                    add_debug("Analysis completed", "success")
                     
                     # Update progress
-                    progress_bar.progress(75)
-                    
-                    # Display results with proper formatting
-                    st.markdown("### Analysis Results")
-                    if isinstance(results, dict) and "error" in results:
-                        st.error(f"Analysis Error: {results['error']}")
-                    else:
-                        # Pretty print the results
-                        st.json(results)
-                    
-                    # Complete progress
-                    progress_bar.progress(100)
-                    st.success("Analysis completed!")
+                    with result_col:
+                        progress_bar.progress(75)
+                        st.markdown("### Analysis Results")
+                        
+                        if isinstance(results, dict) and "error" in results:
+                            st.error(f"Analysis Error: {results['error']}")
+                            add_debug(f"Analysis error: {results['error']}", "error")
+                        else:
+                            # Pretty print the results in results column
+                            st.json(results)
+                            
+                            # Show detailed results breakdown in debug column
+                            add_debug("Results breakdown:", "info")
+                            if isinstance(results, dict):
+                                for key, value in results.items():
+                                    add_debug(f"- {key}: {type(value)}")
+                            else:
+                                add_debug(f"Result type: {type(results)}")
+                            
+                            # Complete progress
+                            progress_bar.progress(100)
+                            st.success("Analysis completed!")
+                
+                # Final debug info
+                add_debug("Process completed successfully", "success")
+                with debug_col:
+                    if torch.cuda.is_available():
+                        st.markdown("### Resource Usage")
+                        st.markdown(f"""
+                        - GPU Memory: {torch.cuda.max_memory_allocated()/1024**2:.2f}MB
+                        - GPU Utilization: {torch.cuda.utilization()}%
+                        """)
                 
             except Exception as e:
-                st.error(f"Error during analysis: {str(e)}")
-                st.error("Please try with a different image or model.")
+                with result_col:
+                    st.error(f"Error during analysis: {str(e)}")
+                add_debug(f"Error: {str(e)}", "error")
+                add_debug(f"Error type: {type(e)}", "error")
+                if hasattr(e, '__traceback__'):
+                    add_debug("Traceback available in logs", "warning")
 
 # Add improved information about usage and limitations
 st.markdown("""