attempt transformers fix

app.py

@@ -18,6 +18,20 @@ import cv2
 import re
 import warnings
 
+# Check transformers version for compatibility
+try:
+    import transformers
+    transformers_version = transformers.__version__
+    print(f"Transformers version: {transformers_version}")
+    
+    # Check if we need to use legacy cache handling
+    if transformers_version.startswith(('4.4', '4.5', '4.6')):
+        USE_LEGACY_CACHE = True
+    else:
+        USE_LEGACY_CACHE = False
+except:
+    USE_LEGACY_CACHE = False
+
 # Try to import spaces module for ZeroGPU compatibility
 try:
     import spaces
@@ -35,6 +49,118 @@ warnings.filterwarnings("ignore", message="Setting `pad_token_id` to `eos_token_
 warnings.filterwarnings("ignore", message="The attention mask is not set and cannot be inferred")
 warnings.filterwarnings("ignore", message="The `seen_tokens` attribute is deprecated")
 
+class ModelCacheManager:
+    """
+    Manages model cache to prevent DynamicCache errors
+    """
+    def __init__(self, model):
+        self.model = model
+        self._clear_all_caches()
+    
+    def _clear_all_caches(self):
+        """Clear all possible caches"""
+        # Clear model cache
+        if hasattr(self.model, 'clear_cache'):
+            try:
+                self.model.clear_cache()
+            except:
+                pass
+        
+        if hasattr(self.model, '_clear_cache'):
+            try:
+                self.model._clear_cache()
+            except:
+                pass
+        
+        # Clear transformers cache based on version
+        try:
+            if USE_LEGACY_CACHE:
+                # Legacy cache clearing for older transformers versions
+                from transformers import GenerationConfig
+                if hasattr(GenerationConfig, 'clear_cache'):
+                    GenerationConfig.clear_cache()
+            else:
+                # New cache clearing for recent transformers versions
+                try:
+                    from transformers.cache_utils import clear_cache
+                    clear_cache()
+                except:
+                    pass
+                
+                # Also try the old method as fallback
+                try:
+                    from transformers import GenerationConfig
+                    if hasattr(GenerationConfig, 'clear_cache'):
+                        GenerationConfig.clear_cache()
+                except:
+                    pass
+        except:
+            pass
+        
+        # Clear torch cache
+        try:
+            import torch
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+        except:
+            pass
+    
+    def safe_call(self, method_name, *args, **kwargs):
+        """Safely call model methods with cache management"""
+        try:
+            # First attempt
+            method = getattr(self.model, method_name)
+            return method(*args, **kwargs)
+        except AttributeError as e:
+            if "get_max_length" in str(e):
+                # Clear cache and retry
+                self._clear_all_caches()
+                try:
+                    return method(*args, **kwargs)
+                except:
+                    # Try without cache
+                    kwargs_copy = kwargs.copy()
+                    kwargs_copy['use_cache'] = False
+                    return method(*args, **kwargs_copy)
+            else:
+                raise e
+    
+    def direct_call(self, method_name, *args, **kwargs):
+        """Direct call bypassing all cache mechanisms"""
+        try:
+            # Disable cache completely
+            kwargs_copy = kwargs.copy()
+            kwargs_copy['use_cache'] = False
+            
+            # Clear all caches first
+            self._clear_all_caches()
+            
+            # Make the call
+            method = getattr(self.model, method_name)
+            return method(*args, **kwargs_copy)
+        except Exception as e:
+            # If still failing, try the original safe_call as last resort
+            return self.safe_call(method_name, *args, **kwargs)
+    
+    def legacy_call(self, method_name, *args, **kwargs):
+        """Legacy call method for older transformers versions"""
+        try:
+            # For legacy versions, we need to handle cache differently
+            kwargs_copy = kwargs.copy()
+            
+            # Remove any cache-related parameters
+            if 'use_cache' in kwargs_copy:
+                del kwargs_copy['use_cache']
+            
+            # Clear caches
+            self._clear_all_caches()
+            
+            # Make the call
+            method = getattr(self.model, method_name)
+            return method(*args, **kwargs_copy)
+        except Exception as e:
+            # Fallback to direct call
+            return self.direct_call(method_name, *args, **kwargs)
 
 def initialize_model_safely():
     """
@@ -53,6 +179,7 @@ def initialize_model_safely():
         
         config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
         
+        # Initialize model with proper settings to avoid warnings
         model = AutoModel.from_pretrained(
             'ucaslcl/GOT-OCR2_0', 
             trust_remote_code=True, 
@@ -71,8 +198,11 @@ def initialize_model_safely():
         if hasattr(model, 'config'):
             model.config.pad_token_id = tokenizer.eos_token_id
             model.config.eos_token_id = tokenizer.eos_token_id
-            
-        return model, tokenizer
+        
+        # Create cache manager
+        cache_manager = ModelCacheManager(model)
+        
+        return model, tokenizer, cache_manager
         
     except Exception as e:
         print(f"Error initializing model: {str(e)}")
@@ -90,11 +220,16 @@ def initialize_model_safely():
                 use_safetensors=True
             )
             model = model.eval().to(device)
-            return model, tokenizer
+            
+            # Create cache manager for fallback model
+            cache_manager = ModelCacheManager(model)
+            
+            return model, tokenizer, cache_manager
         except Exception as fallback_error:
             raise Exception(f"Failed to initialize model: {str(e)}. Fallback also failed: {str(fallback_error)}")
 
-model, tokenizer = initialize_model_safely()
+# Initialize model, tokenizer, and cache manager
+model, tokenizer, cache_manager = initialize_model_safely()
 
 UPLOAD_FOLDER = "./uploads"
 RESULTS_FOLDER = "./results"
@@ -120,8 +255,20 @@ def safe_model_chat(model, tokenizer, image_path, **kwargs):
         if "get_max_length" in str(e):
             # Try to fix the cache issue by clearing it
             try:
+                # Clear any existing cache
                 if hasattr(model, 'clear_cache'):
                     model.clear_cache()
+                elif hasattr(model, '_clear_cache'):
+                    model._clear_cache()
+                
+                # Try to clear cache from transformers
+                try:
+                    from transformers import GenerationConfig
+                    if hasattr(GenerationConfig, 'clear_cache'):
+                        GenerationConfig.clear_cache()
+                except:
+                    pass
+                
                 # Retry the call
                 return model.chat(tokenizer, image_path, **kwargs)
             except:
@@ -131,9 +278,18 @@ def safe_model_chat(model, tokenizer, image_path, **kwargs):
                     kwargs_copy = kwargs.copy()
                     if 'use_cache' in kwargs_copy:
                         del kwargs_copy['use_cache']
+                    
+                    # Try with cache disabled
                     return model.chat(tokenizer, image_path, **kwargs_copy)
                 except:
-                    raise Exception("Model compatibility issue: DynamicCache error. Please try again.")
+                    # Last resort: try to recreate the model call without cache
+                    try:
+                        # Force cache clearing by setting use_cache=False
+                        kwargs_copy = kwargs.copy()
+                        kwargs_copy['use_cache'] = False
+                        return model.chat(tokenizer, image_path, **kwargs_copy)
+                    except:
+                        raise Exception("Model compatibility issue: DynamicCache error. Please try again.")
         else:
             raise e
     except Exception as e:
@@ -159,8 +315,20 @@ def safe_model_chat_crop(model, tokenizer, image_path, **kwargs):
         if "get_max_length" in str(e):
             # Try to fix the cache issue by clearing it
             try:
+                # Clear any existing cache
                 if hasattr(model, 'clear_cache'):
                     model.clear_cache()
+                elif hasattr(model, '_clear_cache'):
+                    model._clear_cache()
+                
+                # Try to clear cache from transformers
+                try:
+                    from transformers import GenerationConfig
+                    if hasattr(GenerationConfig, 'clear_cache'):
+                        GenerationConfig.clear_cache()
+                except:
+                    pass
+                
                 # Retry the call
                 return model.chat_crop(tokenizer, image_path, **kwargs)
             except:
@@ -170,9 +338,18 @@ def safe_model_chat_crop(model, tokenizer, image_path, **kwargs):
                     kwargs_copy = kwargs.copy()
                     if 'use_cache' in kwargs_copy:
                         del kwargs_copy['use_cache']
+                    
+                    # Try with cache disabled
                     return model.chat_crop(tokenizer, image_path, **kwargs_copy)
                 except:
-                    raise Exception("Model compatibility issue: DynamicCache error. Please try again.")
+                    # Last resort: try to recreate the model call without cache
+                    try:
+                        # Force cache clearing by setting use_cache=False
+                        kwargs_copy = kwargs.copy()
+                        kwargs_copy['use_cache'] = False
+                        return model.chat_crop(tokenizer, image_path, **kwargs_copy)
+                    except:
+                        raise Exception("Model compatibility issue: DynamicCache error. Please try again.")
         else:
             raise e
     except Exception as e:
@@ -218,19 +395,58 @@ def process_image(image, task, ocr_type=None, ocr_box=None, ocr_color=None):
         # Wrap model calls in try-except to handle DynamicCache errors
         try:
             if task == "Plain Text OCR":
-                res = safe_model_chat(model, tokenizer, image_path, ocr_type='ocr')
+                # Use cache manager for safer calls
+                try:
+                    res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='ocr')
+                except:
+                    try:
+                        # Fallback to direct call
+                        res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type='ocr')
+                    except:
+                        # Final fallback to legacy call
+                        res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type='ocr')
                 return res, None, unique_id
             else:
                 if task == "Format Text OCR":
-                    res = safe_model_chat(model, tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    try:
+                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    except:
+                        try:
+                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        except:
+                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 elif task == "Fine-grained OCR (Box)":
-                    res = safe_model_chat(model, tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
+                    try:
+                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
+                    except:
+                        try:
+                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
+                        except:
+                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_box=ocr_box, render=True, save_render_file=result_path)
                 elif task == "Fine-grained OCR (Color)":
-                    res = safe_model_chat(model, tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
+                    try:
+                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
+                    except:
+                        try:
+                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
+                        except:
+                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type=ocr_type, ocr_color=ocr_color, render=True, save_render_file=result_path)
                 elif task == "Multi-crop OCR":
-                    res = safe_model_chat_crop(model, tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    try:
+                        res = cache_manager.safe_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    except:
+                        try:
+                            res = cache_manager.direct_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        except:
+                            res = cache_manager.legacy_call('chat_crop', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 elif task == "Render Formatted OCR":
-                    res = safe_model_chat(model, tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    try:
+                        res = cache_manager.safe_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                    except:
+                        try:
+                            res = cache_manager.direct_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
+                        except:
+                            res = cache_manager.legacy_call('chat', tokenizer, image_path, ocr_type='format', render=True, save_render_file=result_path)
                 
                 if os.path.exists(result_path):
                     with open(result_path, 'r') as f: