Update app.py

app.py

@@ -4,9 +4,10 @@ import os
 import tempfile
 # First load unsloth
 from unsloth import FastVisionModel
-# Add configuration to fix TorchDynamo issues
+# Completely disable dynamic compilation due to compatibility issues
 import torch
-torch._dynamo.config.capture_scalar_outputs = True
+# Disable TorchDynamo completely to avoid optimization errors
+torch._dynamo.config.disable = True
 # Disable fallback warnings to reduce noise
 torch._dynamo.config.suppress_errors = True
 # Then transformers
@@ -559,30 +560,14 @@ def analyze_image_with_llm(image, gradcam_overlay, face_box, pred_label, confide
 
         # Generate response with error handling
         with st.spinner("Generating detailed analysis... (this may take 15-30 seconds)"):
-            try:
-                # First try with dynamic compilation (default)
-                with torch.no_grad():
-                    output_ids = model.generate(
-                        **inputs,
-                        max_new_tokens=max_tokens,
-                        use_cache=True,
-                        temperature=temperature,
-                        top_p=0.9
-                    )
-            except Exception as dynamo_error:
-                st.warning(f"Encountered optimization error, falling back to eager mode: {str(dynamo_error)}")
-                
-                # Try again with dynamo disabled
-                with torch.no_grad():
-                    # Temporarily disable dynamo
-                    with torch._dynamo.disable():
-                        output_ids = model.generate(
-                            **inputs,
-                            max_new_tokens=max_tokens,
-                            use_cache=True,
-                            temperature=temperature,
-                            top_p=0.9
-                        )
+            with torch.no_grad():
+                output_ids = model.generate(
+                    **inputs,
+                    max_new_tokens=max_tokens,
+                    use_cache=True,
+                    temperature=temperature,
+                    top_p=0.9
+                )
 
             # Decode the output
             response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
@@ -598,42 +583,43 @@ def analyze_image_with_llm(image, gradcam_overlay, face_box, pred_label, confide
     except Exception as e:
         st.error(f"Error during LLM analysis: {str(e)}")
         
-        # Try one more time with all optimizations disabled
+        # Try one more time with simpler input
         try:
-            st.info("Attempting fallback with all optimizations disabled...")
+            st.info("Attempting fallback with simplified input...")
+            
+            # Prepare a simpler prompt
+            simple_message = [{"role": "user", "content": [
+                {"type": "text", "text": "Analyze this image and tell if it's a deepfake."},
+                {"type": "image", "image": image}
+            ]}]
+            
+            # Apply simpler template
+            simple_text = tokenizer.apply_chat_template(simple_message, add_generation_prompt=True)
+            
+            # Generate with minimal settings
             with torch.no_grad():
-                with torch._dynamo.disable():
-                    # Prepare a simpler prompt
-                    simple_message = [{"role": "user", "content": [
-                        {"type": "text", "text": "Analyze this image and tell if it's a deepfake."}
-                    ]}]
-                    simple_image = image
-                    
-                    # Apply simpler template
-                    simple_text = tokenizer.apply_chat_template(simple_message, add_generation_prompt=True)
-                    
-                    # Tokenize with just the image
-                    simple_inputs = tokenizer(
-                        simple_image,
-                        simple_text,
-                        add_special_tokens=False,
-                        return_tensors="pt",
-                    ).to(model.device)
-                    
-                    # Generate with minimal settings
-                    output_ids = model.generate(
-                        **simple_inputs,
-                        max_new_tokens=200,
-                        use_cache=True,
-                        temperature=0.5,
-                        top_p=0.9
-                    )
-                    
-                    # Decode
-                    fallback_response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
-                    return "Error with optimized generation. Fallback analysis: " + fallback_response.split("Analyze this image and tell if it's a deepfake.")[-1].strip()
+                simple_inputs = tokenizer(
+                    image,
+                    simple_text,
+                    add_special_tokens=False,
+                    return_tensors="pt",
+                ).to(model.device)
+                
+                simple_inputs = fix_cross_attention_mask(simple_inputs)
+                
+                output_ids = model.generate(
+                    **simple_inputs,
+                    max_new_tokens=200,
+                    use_cache=True,
+                    temperature=0.5,
+                    top_p=0.9
+                )
+                
+            # Decode
+            fallback_response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
+            return "Error with primary analysis. Fallback result: " + fallback_response.split("Analyze this image and tell if it's a deepfake.")[-1].strip()
         except Exception as fallback_error:
-            return f"Error analyzing image. Primary error: {str(e)}\nFallback error: {str(fallback_error)}"
+            return f"Error analyzing image: {str(fallback_error)}"
 
 # Preprocess image for Xception
 def preprocess_image_xception(image):
@@ -1110,7 +1096,7 @@ def main():
             
             if clear_button:
                 st.session_state.chat_history = []
-                st.experimental_rerun()
+                st.rerun()
                 
             if analyze_button and new_question:
                 try:
@@ -1167,7 +1153,7 @@ def main():
                         st.markdown(result)
                     
                     # Rerun to update the chat history display
-                    st.experimental_rerun()
+                    st.rerun()
                     
                 except Exception as e:
                     st.error(f"Error during LLM analysis: {str(e)}")