Update app.py

app.py

@@ -178,20 +178,80 @@ def check_gpu():
         return False
 
 # Sidebar components
-st.sidebar.title("About")
-st.sidebar.markdown("""
-This tool detects deepfakes using three AI models:
-- **Xception**: Initial Real/Fake classification
-- **BLIP**: Describes image content
-- **Llama 3.2**: Explains potential manipulations
+st.sidebar.title("Model Controls")
 
-### Quick Start
-1. **Load Models** - Start with Xception, add others as needed
-2. **Upload Image** - View classification and heat map
-3. **Analyze** - Get explanations and ask questions
-
-*GPU recommended for better performance*
-""")
+# Model loading buttons in sidebar
+with st.sidebar:
+    st.write("### Load Models")
+    
+    # Xception model loading
+    if 'xception_model_loaded' not in st.session_state:
+        st.session_state.xception_model_loaded = False
+        st.session_state.xception_model = None
+    
+    if not st.session_state.xception_model_loaded:
+        if st.button("📥 Load Xception Model", type="primary"):
+            # Load Xception model
+            model, device = load_detection_model_xception()
+            if model is not None:
+                st.session_state.xception_model = model
+                st.session_state.device = device
+                st.session_state.xception_model_loaded = True
+                st.success("✅ Xception model loaded!")
+            else:
+                st.error("❌ Failed to load Xception model.")
+    else:
+        st.success("✅ Xception model loaded")
+    
+    # BLIP model loading
+    if 'blip_model_loaded' not in st.session_state:
+        st.session_state.blip_model_loaded = False
+        st.session_state.original_processor = None
+        st.session_state.original_model = None
+        st.session_state.finetuned_processor = None
+        st.session_state.finetuned_model = None
+    
+    if not st.session_state.blip_model_loaded:
+        if st.button("📥 Load BLIP Models", type="primary"):
+            # Load BLIP models
+            original_processor, original_model, finetuned_processor, finetuned_model = load_blip_models()
+            if all([original_processor, original_model, finetuned_processor, finetuned_model]):
+                st.session_state.original_processor = original_processor
+                st.session_state.original_model = original_model
+                st.session_state.finetuned_processor = finetuned_processor
+                st.session_state.finetuned_model = finetuned_model
+                st.session_state.blip_model_loaded = True
+                st.success("✅ BLIP models loaded!")
+            else:
+                st.error("❌ Failed to load BLIP models.")
+    else:
+        st.success("✅ BLIP models loaded")
+    
+    # LLM model loading
+    if 'llm_model_loaded' not in st.session_state:
+        st.session_state.llm_model_loaded = False
+        st.session_state.llm_model = None
+        st.session_state.tokenizer = None
+    
+    if not st.session_state.llm_model_loaded:
+        if st.button("📥 Load Vision LLM", type="primary"):
+            # Load LLM model
+            model, tokenizer = load_llm_model()
+            if model is not None and tokenizer is not None:
+                st.session_state.llm_model = model
+                st.session_state.tokenizer = tokenizer
+                st.session_state.llm_model_loaded = True
+                st.success("✅ Vision LLM loaded!")
+            else:
+                st.error("❌ Failed to load Vision LLM.")
+    else:
+        st.success("✅ Vision LLM loaded")
+    
+    # Debug toggle
+    st.session_state.debug = st.toggle("Enable Debug Mode", value=debug_mode)
+    
+    # Display model info
+    st.info("Using Xception + deepfake-explainer-new models")
 
 # Fixed values for temperature and max tokens
 temperature = 0.7
@@ -296,7 +356,7 @@ def process_image_with_xception_gradcam(image, model, device, pred_class):
         _, _, _, _, face_box, _ = dataset[0]
         
         return raw_cam, overlay, comparison, face_box
-    else:
+                else:
         st.error("Failed to generate GradCAM visualization")
         return None, None, None, None
 
@@ -375,18 +435,18 @@ def generate_gradcam_caption(image, processor, model, max_length=60):
         # Try to parse the caption based on different possible formats
         try:
             # Original format with "high activation:" etc.
-            formatted_text = ""
+        formatted_text = ""
             if "high activation :" in caption:
                 high_match = caption.split("high activation :")[1].split("moderate")[0]
-                formatted_text += f"**High activation**:\n{high_match.strip()}\n\n"
+            formatted_text += f"**High activation**:\n{high_match.strip()}\n\n"
             
             if "moderate activation :" in caption:
                 moderate_match = caption.split("moderate activation :")[1].split("low")[0]
-                formatted_text += f"**Moderate activation**:\n{moderate_match.strip()}\n\n"
+            formatted_text += f"**Moderate activation**:\n{moderate_match.strip()}\n\n"
             
             if "low activation :" in caption:
                 low_match = caption.split("low activation :")[1]
-                formatted_text += f"**Low activation**:\n{low_match.strip()}"
+            formatted_text += f"**Low activation**:\n{low_match.strip()}"
             
             # If nothing was extracted using the original format, try alternative formats
             if not formatted_text.strip():
@@ -663,7 +723,7 @@ def preprocess_image_xception(image):
 
 # Main app
 def main():
-    # Initialize session state variables
+    # Initialize session state variables if not present
     if 'xception_model_loaded' not in st.session_state:
         st.session_state.xception_model_loaded = False
         st.session_state.xception_model = None
@@ -687,276 +747,240 @@ def main():
     # Create multi-tab interface
     tab1, tab2, tab3 = st.tabs(["Deepfake Detection", "Image Captions", "LLM Analysis"])
     
-    # Tab 1: Deepfake Detection with Model Loading and Image Upload
+    # Tab 1: Deepfake Detection
     with tab1:
         st.header("Deepfake Detection")
         
-        # Model Loading section
-        with st.expander("Load Detection Model", expanded=True):
-            st.write("Please load the Xception model for deepfake detection:")
-            if not st.session_state.xception_model_loaded:
-                if st.button("📥 Load Xception Model", type="primary"):
-                    # Load Xception model
-                    model, device = load_detection_model_xception()
-                    if model is not None:
-                        st.session_state.xception_model = model
-                        st.session_state.device = device
-                        st.session_state.xception_model_loaded = True
-                        st.success("✅ Xception model loaded successfully!")
-                    else:
-                        st.error("❌ Failed to load Xception model.")
-            else:
-                st.success("✅ Xception model loaded and ready!")
-        
         # Image upload section
-        with st.expander("Upload and Analyze Image", expanded=True):
-            st.subheader("Upload an Image")
-            
-            # Add alternative upload methods
-            upload_tab1, upload_tab2 = st.tabs(["File Upload", "URL Input"])
-            
-            uploaded_image = None
-            
-            with upload_tab1:
-                uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
-                if uploaded_file is not None:
-                    try:
-                        # Simple direct approach - load the image directly
-                        image = Image.open(uploaded_file).convert("RGB")
-                        uploaded_image = image
-                        st.session_state.upload_method = "file"
-                    except Exception as e:
-                        st.error(f"Error loading image: {str(e)}")
+        st.subheader("Upload an Image")
+        
+        # Add alternative upload methods
+        upload_tab1, upload_tab2 = st.tabs(["File Upload", "URL Input"])
+        
+        uploaded_image = None
+        
+        with upload_tab1:
+            uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+            if uploaded_file is not None:
+                try:
+                    # Simple direct approach - load the image directly
+                    image = Image.open(uploaded_file).convert("RGB")
+                    uploaded_image = image
+                    st.session_state.upload_method = "file"
+                except Exception as e:
+                    st.error(f"Error loading image: {str(e)}")
+                    import traceback
+                    st.error(traceback.format_exc())
+        
+        with upload_tab2:
+            url = st.text_input("Enter image URL:")
+            if url and url.strip():
+                try:
+                    import requests
+                    # Simplified URL handling with more robust approach
+                    headers = {
+                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+                        'Accept': 'image/jpeg, image/png, image/*, */*',
+                        'Referer': 'https://huggingface.co/'
+                    }
+                    
+                    # Try three different methods to handle various API restrictions
+                    try_methods = True
+                    
+                    # Method 1: Direct requests
+                    if try_methods:
+                        try:
+                            response = requests.get(url, stream=True, headers=headers, timeout=10)
+                            if response.status_code == 200 and 'image' in response.headers.get('Content-Type', ''):
+                                try:
+                                    image = Image.open(io.BytesIO(response.content)).convert("RGB")
+                                    uploaded_image = image
+                                    st.session_state.upload_method = "url_direct"
+                                    try_methods = False
+                                    st.success("✅ Image loaded via direct request")
+                                except Exception as e:
+                                    st.warning(f"Direct method received data but couldn't process as image: {str(e)}")
+                            else:
+                                st.info(f"Direct method failed: Status {response.status_code}, trying alternative method...")
+                        except Exception as e:
+                            st.info(f"Direct method error: {str(e)}, trying alternative method...")
+                    
+                    # Method 2: Use Python's urllib as fallback
+                    if try_methods:
+                        try:
+                            import urllib.request
+                            from urllib.error import HTTPError
+                            
+                            opener = urllib.request.build_opener()
+                            opener.addheaders = [('User-agent', headers['User-Agent'])]
+                            urllib.request.install_opener(opener)
+                            
+                            with urllib.request.urlopen(url, timeout=10) as response:
+                                image_data = response.read()
+                                image = Image.open(io.BytesIO(image_data)).convert("RGB")
+                                uploaded_image = image
+                                st.session_state.upload_method = "url_urllib"
+                                try_methods = False
+                                st.success("✅ Image loaded via urllib")
+                        except HTTPError as e:
+                            st.info(f"urllib method failed: HTTP error {e.code}, trying next method...")
+                        except Exception as e:
+                            st.info(f"urllib method error: {str(e)}, trying next method...")
+                    
+                    # Method 3: Use a proxy service as last resort
+                    if try_methods:
+                        try:
+                            # This uses an image proxy service to bypass CORS issues
+                            # Only as last resort since it depends on external service
+                            proxy_url = f"https://images.weserv.nl/?url={url}"
+                            response = requests.get(proxy_url, stream=True, timeout=10)
+                            if response.status_code == 200:
+                                image = Image.open(io.BytesIO(response.content)).convert("RGB")
+                                uploaded_image = image
+                                st.session_state.upload_method = "url_proxy"
+                                try_methods = False
+                                st.success("✅ Image loaded via proxy service")
+                            else:
+                                st.error(f"All methods failed to load the image from URL. Last status: {response.status_code}")
+                        except Exception as e:
+                            st.error(f"All methods failed. Final error: {str(e)}")
+                    
+                    if not uploaded_image:
+                        st.error("Failed to load image using all available methods.")
+                        
+                except Exception as e:
+                    st.error(f"Error processing URL: {str(e)}")
+                    if st.session_state.debug:
                         import traceback
                         st.error(traceback.format_exc())
+        
+        # If we have an uploaded image, process it
+        if uploaded_image is not None:
+            # Display the image
+            image = uploaded_image
+            col1, col2 = st.columns([1, 2])
+            with col1:
+                st.image(image, caption="Uploaded Image", width=300)
             
-            with upload_tab2:
-                url = st.text_input("Enter image URL:")
-                if url and url.strip():
-                    try:
-                        import requests
-                        # Simplified URL handling with more robust approach
-                        headers = {
-                            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
-                            'Accept': 'image/jpeg, image/png, image/*, */*',
-                            'Referer': 'https://huggingface.co/'
-                        }
+            # Continue with Xception model analysis
+            if st.session_state.xception_model_loaded:
+                try:
+                    with st.spinner("Analyzing image with Xception model..."):
+                        # Preprocess image for Xception
+                        input_tensor, original_image, face_box = preprocess_image_xception(image)
                         
-                        # Try three different methods to handle various API restrictions
-                        try_methods = True
+                        if input_tensor is None:
+                            st.error("Failed to preprocess image. Please try another image.")
+                            st.stop()
+                            
+                        # Get device and model
+                        device = st.session_state.device
+                        model = st.session_state.xception_model
                         
-                        # Method 1: Direct requests
-                        if try_methods:
-                            try:
-                                response = requests.get(url, stream=True, headers=headers, timeout=10)
-                                if response.status_code == 200 and 'image' in response.headers.get('Content-Type', ''):
-                                    try:
-                                        image = Image.open(io.BytesIO(response.content)).convert("RGB")
-                                        uploaded_image = image
-                                        st.session_state.upload_method = "url_direct"
-                                        try_methods = False
-                                        st.success("✅ Image loaded via direct request")
-                                    except Exception as e:
-                                        st.warning(f"Direct method received data but couldn't process as image: {str(e)}")
-                                else:
-                                    st.info(f"Direct method failed: Status {response.status_code}, trying alternative method...")
-                            except Exception as e:
-                                st.info(f"Direct method error: {str(e)}, trying alternative method...")
+                        # Ensure model is in eval mode
+                        model.eval()
                         
-                        # Method 2: Use Python's urllib as fallback
-                        if try_methods:
-                            try:
-                                import urllib.request
-                                from urllib.error import HTTPError
-                                
-                                opener = urllib.request.build_opener()
-                                opener.addheaders = [('User-agent', headers['User-Agent'])]
-                                urllib.request.install_opener(opener)
-                                
-                                with urllib.request.urlopen(url, timeout=10) as response:
-                                    image_data = response.read()
-                                    image = Image.open(io.BytesIO(image_data)).convert("RGB")
-                                    uploaded_image = image
-                                    st.session_state.upload_method = "url_urllib"
-                                    try_methods = False
-                                    st.success("✅ Image loaded via urllib")
-                            except HTTPError as e:
-                                st.info(f"urllib method failed: HTTP error {e.code}, trying next method...")
-                            except Exception as e:
-                                st.info(f"urllib method error: {str(e)}, trying next method...")
+                        # Move tensor to device
+                        input_tensor = input_tensor.to(device)
                         
-                        # Method 3: Use a proxy service as last resort
-                        if try_methods:
-                            try:
-                                # This uses an image proxy service to bypass CORS issues
-                                # Only as last resort since it depends on external service
-                                proxy_url = f"https://images.weserv.nl/?url={url}"
-                                response = requests.get(proxy_url, stream=True, timeout=10)
-                                if response.status_code == 200:
-                                    image = Image.open(io.BytesIO(response.content)).convert("RGB")
-                                    uploaded_image = image
-                                    st.session_state.upload_method = "url_proxy"
-                                    try_methods = False
-                                    st.success("✅ Image loaded via proxy service")
-                                else:
-                                    st.error(f"All methods failed to load the image from URL. Last status: {response.status_code}")
-                            except Exception as e:
-                                st.error(f"All methods failed. Final error: {str(e)}")
-                        
-                        if not uploaded_image:
-                            st.error("Failed to load image using all available methods.")
-                            
-                    except Exception as e:
-                        st.error(f"Error processing URL: {str(e)}")
-                        if st.session_state.debug:
+                        # Forward pass with proper error handling
+                        try:
+                            with torch.no_grad():
+                                logits = model(input_tensor)
+                                probabilities = torch.softmax(logits, dim=1)[0]
+                                pred_class = torch.argmax(probabilities).item()
+                                confidence = probabilities[pred_class].item()
+                                
+                                # Explicit class mapping - adjust if needed based on your model
+                                pred_label = "Fake" if pred_class == 0 else "Real"
+                        except Exception as e:
+                            st.error(f"Error in model inference: {str(e)}")
                             import traceback
                             st.error(traceback.format_exc())
-            
-            # If we have an uploaded image, process it
-            if uploaded_image is not None:
-                # Display the image
-                image = uploaded_image
-                col1, col2 = st.columns([1, 2])
-                with col1:
-                    st.image(image, caption="Uploaded Image", width=300)
-                
-                # Continue with Xception model analysis
-                if st.session_state.xception_model_loaded:
-                    try:
-                        with st.spinner("Analyzing image with Xception model..."):
-                            # Preprocess image for Xception
-                            input_tensor, original_image, face_box = preprocess_image_xception(image)
-                            
-                            if input_tensor is None:
-                                st.error("Failed to preprocess image. Please try another image.")
-                                st.stop()
-                                
-                            # Get device and model
-                            device = st.session_state.device
-                            model = st.session_state.xception_model
-                            
-                            # Ensure model is in eval mode
-                            model.eval()
-                            
-                            # Move tensor to device
-                            input_tensor = input_tensor.to(device)
-                            
-                            # Forward pass with proper error handling
-                            try:
-                                with torch.no_grad():
-                                    logits = model(input_tensor)
-                                    probabilities = torch.softmax(logits, dim=1)[0]
-                                    pred_class = torch.argmax(probabilities).item()
-                                    confidence = probabilities[pred_class].item()
-                                    
-                                    # Explicit class mapping - adjust if needed based on your model
-                                    pred_label = "Fake" if pred_class == 0 else "Real"
-                            except Exception as e:
-                                st.error(f"Error in model inference: {str(e)}")
-                                import traceback
-                                st.error(traceback.format_exc())
-                                # Set default values
-                                pred_class = 0
-                                confidence = 0.5
-                                pred_label = "Error in prediction"
+                            # Set default values
+                            pred_class = 0
+                            confidence = 0.5
+                            pred_label = "Error in prediction"
+                        
+                        # Display results
+                        with col2:
+                            st.markdown("### Detection Result")
+                            st.markdown(f"**Classification:** {pred_label} (Confidence: {confidence:.2%})")
                             
-                            # Display results
-                            with col2:
-                                st.markdown("### Detection Result")
-                                st.markdown(f"**Classification:** {pred_label} (Confidence: {confidence:.2%})")
-                                
-                                # Display face box on image if detected
-                                if face_box:
-                                    img_to_show = original_image.copy()
-                                    img_draw = np.array(img_to_show)
-                                    x, y, w, h = face_box
-                                    cv2.rectangle(img_draw, (x, y), (x + w, y + h), (0, 255, 0), 2)
-                                    st.image(Image.fromarray(img_draw), caption="Detected Face", width=300)
+                            # Display face box on image if detected
+                            if face_box:
+                                img_to_show = original_image.copy()
+                                img_draw = np.array(img_to_show)
+                                x, y, w, h = face_box
+                                cv2.rectangle(img_draw, (x, y), (x + w, y + h), (0, 255, 0), 2)
+                                st.image(Image.fromarray(img_draw), caption="Detected Face", width=300)
+                        
+                        # GradCAM visualization with error handling
+                        st.subheader("GradCAM Visualization")
+                        try:
+                            cam, overlay, comparison, detected_face_box = process_image_with_xception_gradcam(
+                                image, model, device, pred_class
+                            )
                             
-                            # GradCAM visualization with error handling
-                            st.subheader("GradCAM Visualization")
-                            try:
-                                cam, overlay, comparison, detected_face_box = process_image_with_xception_gradcam(
-                                    image, model, device, pred_class
-                                )
+                            if comparison:
+                                # Display GradCAM results (controlled size)
+                                st.image(comparison, caption="Original | CAM | Overlay", width=700)
                                 
-                                if comparison:
-                                    # Display GradCAM results (controlled size)
-                                    st.image(comparison, caption="Original | CAM | Overlay", width=700)
+                                # Save for later use
+                                st.session_state.comparison_image = comparison
+                            else:
+                                st.error("GradCAM visualization failed - comparison image not generated")
+                        
+                            # Generate caption for GradCAM overlay image if BLIP model is loaded
+                            if st.session_state.blip_model_loaded and overlay:
+                                with st.spinner("Analyzing GradCAM visualization..."):
+                                    gradcam_caption = generate_gradcam_caption(
+                                        overlay,
+                                        st.session_state.finetuned_processor,
+                                        st.session_state.finetuned_model
+                                    )
+                                    st.session_state.gradcam_caption = gradcam_caption
                                     
-                                    # Save for later use
-                                    st.session_state.comparison_image = comparison
-                                else:
-                                    st.error("GradCAM visualization failed - comparison image not generated")
-                                
-                                # Generate caption for GradCAM overlay image if BLIP model is loaded
-                                if st.session_state.blip_model_loaded and overlay:
-                                    with st.spinner("Analyzing GradCAM visualization..."):
-                                        gradcam_caption = generate_gradcam_caption(
-                                            overlay,
-                                            st.session_state.finetuned_processor,
-                                            st.session_state.finetuned_model
-                                        )
-                                        st.session_state.gradcam_caption = gradcam_caption
-                                        
-                                        # Display the caption directly here as well for immediate feedback
-                                        st.markdown("### GradCAM Analysis")
-                                        st.markdown(gradcam_caption)
-                            except Exception as e:
-                                st.error(f"Error generating GradCAM: {str(e)}")
-                                import traceback
-                                st.error(traceback.format_exc())
-                            
-                            # Save results in session state for use in other tabs
-                            st.session_state.current_image = image
-                            st.session_state.current_overlay = overlay if 'overlay' in locals() else None
-                            st.session_state.current_face_box = detected_face_box if 'detected_face_box' in locals() else None
-                            st.session_state.current_pred_label = pred_label
-                            st.session_state.current_confidence = confidence
-                            
-                            st.success("✅ Initial detection and GradCAM visualization complete!")
-                    except Exception as e:
-                        st.error(f"Overall error in Xception processing: {str(e)}")
-                        import traceback
-                        st.error(traceback.format_exc())
-                else:
-                    st.warning("⚠️ Please load the Xception model first to perform initial detection.")
+                                    # Display the caption directly here
+                                    st.markdown("### GradCAM Analysis")
+                                    st.markdown(gradcam_caption)
+                        except Exception as e:
+                            st.error(f"Error generating GradCAM: {str(e)}")
+                            import traceback
+                            st.error(traceback.format_exc())
+                        
+                        # Save results in session state for use in other tabs
+                        st.session_state.current_image = image
+                        st.session_state.current_overlay = overlay if 'overlay' in locals() else None
+                        st.session_state.current_face_box = detected_face_box if 'detected_face_box' in locals() else None
+                        st.session_state.current_pred_label = pred_label
+                        st.session_state.current_confidence = confidence
+                        
+                        st.success("✅ Initial detection and GradCAM visualization complete!")
+                except Exception as e:
+                    st.error(f"Overall error in Xception processing: {str(e)}")
+                    import traceback
+                    st.error(traceback.format_exc())
+            else:
+                st.warning("⚠️ Please load the Xception model from the sidebar first.")
     
     # Tab 2: Image Captions with BLIP models
     with tab2:
         st.header("Image Captions")
         
-        # Model Loading section
-        with st.expander("Load Captioning Models", expanded=True):
-            if not st.session_state.blip_model_loaded:
-                if st.button("📥 Load BLIP for Captioning", type="primary"):
-                    # Load BLIP models
-                    original_processor, original_model, finetuned_processor, finetuned_model = load_blip_models()
-                    if all([original_processor, original_model, finetuned_processor, finetuned_model]):
-                        st.session_state.original_processor = original_processor
-                        st.session_state.original_model = original_model
-                        st.session_state.finetuned_processor = finetuned_processor
-                        st.session_state.finetuned_model = finetuned_model
-                        st.session_state.blip_model_loaded = True
-                        st.success("✅ BLIP captioning models loaded successfully!")
-                    else:
-                        st.error("❌ Failed to load BLIP models.")
-            else:
-                st.success("✅ BLIP captioning models loaded and ready!")
-        
         # Image Caption Display
         if hasattr(st.session_state, 'current_image'):
             col1, col2 = st.columns([1, 2])
             
             with col1:
-                st.image(st.session_state.current_image, caption="Image", width=300)
+                st.image(st.session_state.current_image, caption="Original Image", width=300)
                 
                 if hasattr(st.session_state, 'current_overlay'):
                     st.image(st.session_state.current_overlay, caption="GradCAM Visualization", width=300)
             
             with col2:
                 if not st.session_state.blip_model_loaded:
-                    st.warning("⚠️ Please load the BLIP models first to see captions.")
+                    st.warning("⚠️ Please load the BLIP models from the sidebar first.")
                 else:
                     # Button to generate captions if not already generated
                     if not hasattr(st.session_state, 'image_caption') or st.button("Regenerate Image Caption"):
@@ -990,7 +1014,18 @@ def main():
                                 st.session_state.gradcam_caption = gradcam_caption
                                 st.rerun()
                     else:
-                        st.info("GradCAM caption not available. Visit the Detection tab to generate it.")
+                        if hasattr(st.session_state, 'current_overlay'):
+                            if st.button("Generate GradCAM Caption"):
+                                with st.spinner("Analyzing GradCAM visualization..."):
+                                    gradcam_caption = generate_gradcam_caption(
+                                        st.session_state.current_overlay,
+                                        st.session_state.finetuned_processor,
+                                        st.session_state.finetuned_model
+                                    )
+                                    st.session_state.gradcam_caption = gradcam_caption
+                                    st.rerun()
+                        else:
+                            st.info("GradCAM visualization not available. Visit the Detection tab to generate it.")
         else:
             st.info("Please upload and analyze an image in the Detection tab first.")
     
@@ -998,22 +1033,6 @@ def main():
     with tab3:
         st.header("LLM Analysis")
         
-        # Model Loading section
-        with st.expander("Load LLM Model", expanded=True):
-            if not st.session_state.llm_model_loaded:
-                if st.button("📥 Load Vision LLM", type="primary"):
-                    # Load LLM model
-                    model, tokenizer = load_llm_model()
-                    if model is not None and tokenizer is not None:
-                        st.session_state.llm_model = model
-                        st.session_state.tokenizer = tokenizer
-                        st.session_state.llm_model_loaded = True
-                        st.success("✅ Vision LLM loaded successfully!")
-                    else:
-                        st.error("❌ Failed to load Vision LLM.")
-            else:
-                st.success("✅ Vision LLM loaded and ready!")
-        
         # Chat Interface
         if hasattr(st.session_state, 'current_image') and st.session_state.llm_model_loaded:
             st.subheader("Deepfake Analysis Chat")
@@ -1140,7 +1159,7 @@ def main():
             if not hasattr(st.session_state, 'current_image'):
                 st.warning("⚠️ Please upload an image in the Detection tab first.")
             else:
-                st.warning("⚠️ Please load the Vision LLM to perform detailed analysis.")
+                st.warning("⚠️ Please load the Vision LLM from the sidebar to perform detailed analysis.")
     
     # Footer
     st.markdown("---")