fix: compute stochastic-depth rates in pure Python for transformers 5.x meta-device init

configuration_h2ovl_chat.py

@@ -46,7 +46,31 @@ class H2OVLChatConfig(PretrainedConfig):
             self.llm_config = CONFIG_MAPPING[llm_config["model_type"]](**llm_config)
         else:
             self.llm_config = AutoConfig.from_pretrained(llm_config["_name_or_path"], trust_remote_code=True)
-        self.llm_config.update(llm_config)
+        # transformers>=5 derives rope_parameters in the sub-config __init__;
+        # re-applying the legacy rope_theta/rope_scaling (or a stale
+        # rope_parameters) via update() would reset it to None. Filter those keys
+        # so the v5-derived rope config is preserved.
+        self.llm_config.update({
+            k: v for k, v in llm_config.items()
+            if k not in ("rope_parameters", "rope_theta", "rope_scaling")
+        })
+
+        # transformers>=5 no longer permits generation-control parameters to live
+        # on the model config (they must be on generation_config). This llm_config
+        # was saved under transformers 4.x with legacy generation defaults baked
+        # in; v5 dropped these attrs from PretrainedConfig, so even their old
+        # defaults now read as "non-default" and language_model.generate() raises
+        # "This strategy to control generation is not supported anymore". The model
+        # ships a proper generation_config.json, so strip the stale attrs here.
+        for _gen_attr in (
+            "length_penalty",
+            "encoder_no_repeat_ngram_size",
+            "output_scores",
+            "return_dict_in_generate",
+            "remove_invalid_values",
+        ):
+            if hasattr(self.llm_config, _gen_attr):
+                delattr(self.llm_config, _gen_attr)
 
         self.use_backbone_lora = use_backbone_lora
         self.use_llm_lora = use_llm_lora

modeling_intern_vit.py

@@ -312,7 +312,20 @@ class InternVisionEncoder(nn.Module):
         super().__init__()
         self.config = config
         # stochastic depth decay rule
-        dpr = [x.item() for x in torch.linspace(0, config.drop_path_rate, config.num_hidden_layers)]
+        # Computed in pure Python (equivalent to
+        # `torch.linspace(0, config.drop_path_rate, config.num_hidden_layers)`)
+        # so it works under transformers 5.x meta-device init: model __init__ now
+        # runs inside a `with torch.device("meta")` context, under which
+        # torch.linspace() yields a meta tensor and `.item()` raises
+        # "Tensor.item() cannot be called on meta tensors".
+        num_layers = config.num_hidden_layers
+        if num_layers > 1:
+            dpr = [
+                config.drop_path_rate * i / (num_layers - 1)
+                for i in range(num_layers)
+            ]
+        else:
+            dpr = [0.0] * num_layers
         self.layers = nn.ModuleList([
             InternVisionEncoderLayer(config, dpr[idx]) for idx in range(config.num_hidden_layers)])
         self.gradient_checkpointing = True
@@ -336,7 +349,7 @@ class InternVisionEncoder(nn.Module):
         output_hidden_states = (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
 
         encoder_states = () if output_hidden_states else None
         hidden_states = inputs_embeds
@@ -366,7 +379,11 @@ class InternVisionEncoder(nn.Module):
 
 class InternVisionModel(PreTrainedModel):
     main_input_name = 'pixel_values'
+    # transformers>=5 checks _supports_flash_attn; transformers<5 checks
+    # _supports_flash_attn_2. Set both so flash-attention support is advertised
+    # on either version (the 5.x path treats _supports_flash_attn_2 as a fallback).
     _supports_flash_attn_2 = True
+    _supports_flash_attn = True
     config_class = InternVisionConfig
     _no_split_modules = ['InternVisionEncoderLayer']
 
@@ -402,7 +419,7 @@ class InternVisionModel(PreTrainedModel):
         output_hidden_states = (
             output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
         )
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
 
         if pixel_values is None and pixel_embeds is None:
             raise ValueError('You have to specify pixel_values or pixel_embeds')

modelling_h2ovl_chat.py

@@ -29,7 +29,11 @@ def version_cmp(v1, v2, op='eq'):
 class H2OVLChatModel(PreTrainedModel):
     config_class = H2OVLChatConfig
     main_input_name = 'pixel_values'
+    # transformers>=5 checks _supports_flash_attn; transformers<5 checks
+    # _supports_flash_attn_2. Set both so flash-attention support is advertised
+    # on either version (the 5.x path treats _supports_flash_attn_2 as a fallback).
     _supports_flash_attn_2 = True
+    _supports_flash_attn = True
 
     def __init__(self, config: H2OVLChatConfig, vision_model=None, language_model=None):
         super().__init__(config)
@@ -80,6 +84,9 @@ class H2OVLChatModel(PreTrainedModel):
         if config.use_llm_lora:
             self.wrap_llm_lora(r=config.use_llm_lora, lora_alpha=2 * config.use_llm_lora)
 
+        # transformers>=5 populates all_tied_weights_keys during post_init().
+        self.post_init()
+
     def wrap_backbone_lora(self, r=128, lora_alpha=256, lora_dropout=0.05):
         lora_config = LoraConfig(
             r=r,
@@ -126,7 +133,7 @@ class H2OVLChatModel(PreTrainedModel):
             output_hidden_states: Optional[bool] = None,
             return_dict: Optional[bool] = None,
     ) -> Union[Tuple, CausalLMOutputWithPast]:
-        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+        return_dict = return_dict if return_dict is not None else self.config.return_dict
 
         image_flags = image_flags.squeeze(-1)
         input_embeds = self.language_model.get_input_embeddings()(input_ids).clone()