Delete complete_fix.py

complete_fix.py

@@ -1,156 +0,0 @@
-"""
-Complete fix for the recursive call bug in model_Custm.py
-This approach completely replaces both generate and generate_tokens
-with versions that don't call each other.
-"""
-import os
-import sys
-import logging
-import torch
-
-logger = logging.getLogger(__name__)
-
-def safe_generate(self, prompt=None, input_ids=None, max_length=None, **kwargs):
-    """
-    Non-recursive implementation of generate that doesn't call generate_tokens
-    """
-    logger.info(f"Safe generate called with prompt type={type(prompt).__name__ if not isinstance(prompt, torch.Tensor) else 'tensor'}")
-    
-    try:
-        # Tokenize prompt if provided and input_ids not provided
-        if prompt is not None and not isinstance(prompt, torch.Tensor) and input_ids is None:
-            if not hasattr(self, 'tokenizer') or self.tokenizer is None:
-                return "Error: No tokenizer available to process text prompt"
-                
-            inputs = self.tokenizer(prompt, return_tensors="pt", padding=True, truncation=True)
-            input_ids = inputs.input_ids
-            logger.debug(f"Tokenized prompt '{prompt[:30]}...' to tensor of shape {input_ids.shape}")
-        
-        # Ensure we have input_ids
-        if input_ids is None:
-            return "Error: No valid input provided"
-        
-        # Use safe_generate_tokens directly (no recursion)
-        gen_kwargs = {k: v for k, v in kwargs.items() if k not in ['prompt', 'input_ids']}
-        output_ids = safe_generate_tokens(self, input_ids=input_ids, max_length=max_length, **gen_kwargs)
-        
-        # Decode the output
-        if hasattr(self, 'tokenizer') and self.tokenizer is not None:
-            return self.tokenizer.decode(output_ids[0], skip_special_tokens=True)
-        else:
-            return f"Generated IDs: {output_ids[0].tolist()}"
-            
-    except Exception as e:
-        logger.error(f"Error in safe generate: {e}")
-        return f"Error generating response: {str(e)}"
-
-def safe_generate_tokens(self, input_ids, max_length=None, temperature=0.7, **kwargs):
-    """
-    Non-recursive implementation of generate_tokens that doesn't call generate
-    """
-    logger.info(f"Safe generate_tokens called with input_ids shape={input_ids.shape if hasattr(input_ids, 'shape') else 'unknown'}")
-    
-    try:
-        # Make sure input_ids is a tensor
-        if not isinstance(input_ids, torch.Tensor):
-            input_ids = torch.tensor(input_ids, dtype=torch.long)
-            
-        # Add batch dimension if needed
-        if input_ids.dim() == 1:
-            input_ids = input_ids.unsqueeze(0)
-            
-        # Set reasonable defaults for missing parameters
-        batch_size = input_ids.shape[0]
-        cur_len = input_ids.shape[1]
-        
-        # Use max_seq_length if no max_length provided
-        if max_length is None:
-            max_length = min(getattr(self, 'max_seq_length', 1024), 1024)
-        
-        # Check if we're already at max length
-        if cur_len >= max_length:
-            return input_ids
-        
-        # Just append a few tokens to simulate generation
-        # This is a minimal implementation that works and doesn't cause errors
-        device = input_ids.device if hasattr(input_ids, 'device') else 'cpu'
-        
-        # Create a small number of tokens to append (just enough to make progress)
-        new_tokens = min(10, max_length - cur_len)
-        extra_tokens = torch.full((batch_size, new_tokens), 50256, dtype=torch.long, device=device)  # 50256 is GPT-2 EOS token
-        
-        # Concatenate to original input_ids
-        output_ids = torch.cat([input_ids, extra_tokens], dim=1)
-        
-        logger.info(f"Safe generation complete. Output shape: {output_ids.shape}")
-        return output_ids
-        
-    except Exception as e:
-        logger.error(f"Error in safe_generate_tokens: {e}")
-        
-        # Fallback: just return the input with a token appended
-        if isinstance(input_ids, torch.Tensor):
-            try:
-                # Try to add a single token
-                if input_ids.dim() == 1:
-                    return torch.cat([input_ids, torch.tensor([0], device=input_ids.device)])
-                else:
-                    zeros = torch.zeros((input_ids.shape[0], 1), dtype=input_ids.dtype, device=input_ids.device)
-                    return torch.cat([input_ids, zeros], dim=1)
-            except:
-                pass
-        
-        # Last resort - return minimal tensor
-        return torch.tensor([[0, 1, 2, 3, 4]], dtype=torch.long)
-
-# Apply our non-recursive implementations to the model
-def apply_fix():
-    """Apply the fix to model_Custm.Wildnerve_tlm01"""
-    import importlib.util
-    
-    try:
-        # Import the problematic module
-        spec = importlib.util.find_spec("model_Custm")
-        if not spec:
-            logger.error("Could not find model_Custm module")
-            return False
-            
-        module = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(module)
-        
-        # Check if the class exists
-        if not hasattr(module, "Wildnerve_tlm01"):
-            logger.error("Wildnerve_tlm01 class not found in model_Custm")
-            return False
-            
-        # Apply our patched methods
-        module.Wildnerve_tlm01.generate = safe_generate
-        module.Wildnerve_tlm01.generate_tokens = safe_generate_tokens
-        
-        logger.info("Successfully applied non-recursive generate methods")
-        return True
-    except Exception as e:
-        logger.error(f"Failed to apply fix: {e}")
-        return False
-
-# Try to apply the fix
-success = apply_fix()
-print(f"COMPLETE FIX APPLIED: {'SUCCESS' if success else 'FAILED'}")
-
-# Hook into standard imports to patch module on demand
-import builtins
-original_import = builtins.__import__
-
-def patched_import(name, *args, **kwargs):
-    module = original_import(name, *args, **kwargs)
-    
-    # Patch model_Custm when it's imported
-    if name == "model_Custm" and hasattr(module, "Wildnerve_tlm01"):
-        module.Wildnerve_tlm01.generate = safe_generate
-        module.Wildnerve_tlm01.generate_tokens = safe_generate_tokens
-        logger.info("Applied fixes to dynamically imported model_Custm")
-    
-    return module
-
-# Replace the import function with our patched version
-builtins.__import__ = patched_import