Update app.py

app.py

@@ -4,6 +4,11 @@ import os
 import tempfile
 # First load unsloth
 from unsloth import FastVisionModel
+# Add configuration to fix TorchDynamo issues
+import torch
+torch._dynamo.config.capture_scalar_outputs = True
+# Set a reasonable optimization level
+torch._dynamo.config.opt_level = "default"
 # Then transformers
 from transformers import BlipProcessor, BlipForConditionalGeneration
 import torch
@@ -552,16 +557,32 @@ def analyze_image_with_llm(image, gradcam_overlay, face_box, pred_label, confide
         # Fix cross-attention mask if needed
         inputs = fix_cross_attention_mask(inputs)
 
-        # Generate response
+        # Generate response with error handling
         with st.spinner("Generating detailed analysis... (this may take 15-30 seconds)"):
-            with torch.no_grad():
-                output_ids = model.generate(
-                    **inputs,
-                    max_new_tokens=max_tokens,
-                    use_cache=True,
-                    temperature=temperature,
-                    top_p=0.9
-                )
+            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
+                        )
 
             # Decode the output
             response = tokenizer.decode(output_ids[0], skip_special_tokens=True)
@@ -576,7 +597,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)}")
-        return f"Error analyzing image: {str(e)}"
+        
+        # Try one more time with all optimizations disabled
+        try:
+            st.info("Attempting fallback with all optimizations disabled...")
+            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()
+        except Exception as fallback_error:
+            return f"Error analyzing image. Primary error: {str(e)}\nFallback error: {str(fallback_error)}"
 
 # Preprocess image for Xception
 def preprocess_image_xception(image):