Update app.py

app.py

@@ -147,6 +147,44 @@ Then upload 'best_model_cpu.pkl' to this Space and rename it to 'best_model.pkl'
             loaded_model.eval()
             device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
             loaded_model = loaded_model.to(device)
+            
+            # Fix generation config compatibility issues
+            if hasattr(loaded_model, 'generation_config'):
+                gen_config = loaded_model.generation_config
+                
+                # Remove problematic attributes that don't exist in current transformers version
+                problematic_attrs = [
+                    'forced_decoder_ids', 'forced_bos_token_id', 'forced_eos_token_id',
+                    'suppress_tokens', 'begin_suppress_tokens', 'decoder_start_token_id'
+                ]
+                
+                for attr in problematic_attrs:
+                    if hasattr(gen_config, attr):
+                        try:
+                            delattr(gen_config, attr)
+                        except:
+                            pass
+                
+                # Ensure required attributes exist with safe defaults
+                if not hasattr(gen_config, 'pad_token_id') or gen_config.pad_token_id is None:
+                    gen_config.pad_token_id = loaded_tokenizer.eos_token_id if loaded_tokenizer else 50256
+                
+                if not hasattr(gen_config, 'eos_token_id') or gen_config.eos_token_id is None:
+                    gen_config.eos_token_id = loaded_tokenizer.eos_token_id if loaded_tokenizer else 50256
+                
+                if not hasattr(gen_config, 'bos_token_id'):
+                    gen_config.bos_token_id = loaded_tokenizer.bos_token_id if loaded_tokenizer else 50256
+                    
+            else:
+                # Create a basic generation config if missing
+                from transformers import GenerationConfig
+                loaded_model.generation_config = GenerationConfig(
+                    pad_token_id=loaded_tokenizer.eos_token_id if loaded_tokenizer else 50256,
+                    eos_token_id=loaded_tokenizer.eos_token_id if loaded_tokenizer else 50256,
+                    do_sample=True,
+                    max_length=512
+                )
+                
         except Exception as e:
             return (f"❌ Error preparing model for inference: {str(e)}\n\n"
                     "This can happen if the saved object is not a proper torch.nn.Module or if tensors couldn't be mapped to the current device.")
@@ -264,19 +302,54 @@ def generate_code_from_pseudo(pseudo_code, max_length, temperature, top_k, top_p
         # Generate (ensure type safety for parameters)
         with torch.no_grad():
             try:
-                outputs = loaded_model.generate(
-                    **inputs,
-                    max_length=int(max_length),
-                    temperature=float(temperature),
-                    top_k=int(top_k),
-                    top_p=float(top_p),
-                    do_sample=True,
-                    num_return_sequences=int(num_sequences),
-                    pad_token_id=loaded_tokenizer.pad_token_id,
-                    eos_token_id=loaded_tokenizer.eos_token_id,
-                )
+                # Create generation kwargs with compatibility handling
+                generation_kwargs = {
+                    'max_length': int(max_length),
+                    'temperature': float(temperature),
+                    'top_k': int(top_k),
+                    'top_p': float(top_p),
+                    'do_sample': True,
+                    'num_return_sequences': int(num_sequences),
+                    'pad_token_id': loaded_tokenizer.pad_token_id,
+                    'eos_token_id': loaded_tokenizer.eos_token_id,
+                }
+                
+                # Remove any None values that might cause issues
+                generation_kwargs = {k: v for k, v in generation_kwargs.items() if v is not None}
+                
+                # Add input_ids explicitly
+                generation_kwargs.update(inputs)
+                
+                # Try generation with comprehensive error handling
+                try:
+                    outputs = loaded_model.generate(**generation_kwargs)
+                except Exception as gen_error:
+                    # First fallback: try without problematic parameters
+                    if 'forced_decoder_ids' in str(gen_error) or 'GenerationConfig' in str(gen_error):
+                        # Reset generation config to minimal safe version
+                        if hasattr(loaded_model, 'generation_config'):
+                            from transformers import GenerationConfig
+                            loaded_model.generation_config = GenerationConfig(
+                                pad_token_id=loaded_tokenizer.pad_token_id,
+                                eos_token_id=loaded_tokenizer.eos_token_id,
+                                do_sample=True
+                            )
+                        
+                        # Try again with minimal parameters
+                        minimal_kwargs = {
+                            'max_length': int(max_length),
+                            'do_sample': True,
+                            'temperature': float(temperature),
+                            'pad_token_id': loaded_tokenizer.pad_token_id,
+                            'eos_token_id': loaded_tokenizer.eos_token_id,
+                        }
+                        minimal_kwargs.update(inputs)
+                        outputs = loaded_model.generate(**minimal_kwargs)
+                    else:
+                        raise gen_error
+                        
             except Exception as generation_error:
-                return f"❌ Generation failed: {str(generation_error)}", "", "", ""
+                return f"❌ Generation failed: {str(generation_error)}\n\nTry using default parameters or check model compatibility.", "", "", ""
         
         generation_time = time.time() - start_time