[None][feat] Upgrade transformers dependency to 5.3.0

ATTRIBUTIONS-Python.md

@@ -62159,7 +62159,7 @@ SOFTWARE.
   - `Homepage`: https://github.com/EleutherAI/tqdm-multiprocess
 
 
-## transformers (4.56.0)
+## transformers (5.3.0)
 
 ### Licenses
 License: `Apache 2.0 License`

examples/apps/chat.py

@@ -37,7 +37,8 @@ def runsource(self,
         self.history.append(message)
 
         input = self.tokenizer.apply_chat_template(self.history,
-                                                   add_generation_prompt=True)
+                                                   add_generation_prompt=True,
+                                                   return_dict=False)
 
         output = self.llm.generate([input],
                                    sampling_params=self.sampling_params)[0]

examples/eagle/convert_checkpoint.py

@@ -9,6 +9,7 @@
 
 import tensorrt_llm
 from tensorrt_llm._deprecation import emit_engine_arch_deprecation
+from tensorrt_llm._utils import get_hf_rope_theta
 from tensorrt_llm.mapping import Mapping
 from tensorrt_llm.models.eagle.config import EagleConfig
 from tensorrt_llm.models.eagle.model import EagleForCausalLM
@@ -293,7 +294,7 @@ def copy(tensors):
         args.rms_norm_eps = hf_config.rms_norm_eps
         args.vocab_size = hf_config.vocab_size
         args.rotary_scaling = hf_config.rope_scaling
-        args.rotary_base = hf_config.rope_theta
+        args.rotary_base = get_hf_rope_theta(hf_config, 10000.0)
         args.n_positions = hf_config.max_position_embeddings
         args.dtype = str(
             hf_config.torch_dtype)[6:] if args.dtype == 'auto' else args.dtype

examples/medusa/convert_checkpoint.py

@@ -13,7 +13,7 @@
 
 import tensorrt_llm
 from tensorrt_llm._deprecation import emit_engine_arch_deprecation
-from tensorrt_llm._utils import numpy_to_torch
+from tensorrt_llm._utils import get_hf_rope_theta, numpy_to_torch
 from tensorrt_llm.logger import logger
 from tensorrt_llm.mapping import Mapping
 from tensorrt_llm.models import (LLaMAForCausalLM, PretrainedConfig,
@@ -209,7 +209,7 @@ def main():
         args.rms_norm_eps = hf_config.rms_norm_eps
         args.vocab_size = hf_config.vocab_size
         args.n_positions = hf_config.max_position_embeddings
-        args.rotary_base = hf_config.rope_theta
+        args.rotary_base = get_hf_rope_theta(hf_config, 10000.0)
         args.rotary_scaling = hf_config.rope_scaling
 
     elif args.meta_ckpt_dir is not None:

examples/models/contrib/dbrx/convert_checkpoint.py

@@ -18,7 +18,7 @@
 
 import tensorrt_llm
 from tensorrt_llm._deprecation import emit_engine_arch_deprecation
-from tensorrt_llm._utils import release_gc
+from tensorrt_llm._utils import get_hf_rope_theta, release_gc
 from tensorrt_llm.layers import MoeConfig
 from tensorrt_llm.mapping import Mapping
 from tensorrt_llm.models.convert_utils import (generate_int8,
@@ -557,7 +557,7 @@ def execute(workers, func, hf_model):
             args.moe_top_k = 1
         args.clip_qkv = hf_config.attn_config.clip_qkv
         args.hidden_act = 'swiglu'
-        args.rotary_base = hf_config.attn_config.rope_theta
+        args.rotary_base = get_hf_rope_theta(hf_config.attn_config, 10000.0)
     args.moe_config = MoeConfig(
         num_experts=args.moe_num_experts,
         top_k=args.moe_top_k,

examples/models/core/enc_dec/convert_checkpoint.py

@@ -143,15 +143,17 @@ def parse_t5_config_by_component(config, component, args):
             component_config.encoder_head_size = config.getint(
                 'encoder', 'd_kv')
             component_config.decoder_start_token_id = config.getint(
-                'decoder', 'decoder_start_token_id')
-            component_config.eos_token_id = config.getint(
-                'decoder', 'eos_token_id')
-            bos_token_id = config.get('decoder', 'bos_token_id')
+                'decoder', 'decoder_start_token_id', fallback=0)
+            component_config.eos_token_id = config.getint('decoder',
+                                                          'eos_token_id',
+                                                          fallback=1)
+            bos_token_id = config.get('decoder', 'bos_token_id', fallback=None)
             # T5 does not have bos_token_id
             component_config.bos_token_id = int(
-                bos_token_id) if bos_token_id != "None" else None
-            component_config.pad_token_id = config.getint(
-                'decoder', 'pad_token_id')
+                bos_token_id) if bos_token_id not in (None, "None") else None
+            component_config.pad_token_id = config.getint('decoder',
+                                                          'pad_token_id',
+                                                          fallback=0)
 
         else:
             assert False, 'Unsupported component!'

examples/models/core/internlm2/convert_checkpoint.py

@@ -14,7 +14,7 @@
 
 import tensorrt_llm
 from tensorrt_llm._deprecation import emit_engine_arch_deprecation
-from tensorrt_llm._utils import release_gc
+from tensorrt_llm._utils import get_hf_rope_theta, release_gc
 from tensorrt_llm.mapping import Mapping
 from tensorrt_llm.models.llama import convert
 
@@ -480,7 +480,7 @@ def convert_from_hf(hf_model,
         'norm_epsilon': hf_config.rms_norm_eps,
         'vocab_size': hf_config.vocab_size,
         'position_embedding_type': 'rope_gpt_neox',
-        'rotary_base': hf_config.rope_theta,
+        'rotary_base': get_hf_rope_theta(hf_config, 10000.0),
         'max_position_embeddings': hf_config.max_position_embeddings,
         'hidden_act': hf_config.hidden_act,
         'use_parallel_embedding': args.use_parallel_embedding,

requirements.txt

@@ -30,7 +30,7 @@ nvidia-modelopt[torch]~=0.37.0
 # torch 2.10.0+cu130 depends on nvidia-nccl-cu13==2.28.9
 nvidia-nccl-cu13>=2.28.9,<=2.29.2
 nvidia-cuda-nvrtc
-transformers==4.57.3
+transformers==5.3.0
 prometheus_client
 prometheus_fastapi_instrumentator
 pydantic>=2.9.1
@@ -77,7 +77,7 @@ numexpr
 partial_json_parser
 apache-tvm-ffi==0.1.6 # used for reduce nvidia-cutlass-dsl host overhead
 torch-c-dlpack-ext==0.1.3 # used for reduce nvidia-cutlass-dsl host overhead, optional package for improved torch tensor calling perf
-mistral-common==1.8.6
+mistral-common==1.9.1
 torchao>=0.14.1,<0.16.0
 cuda-core
 llist

tensorrt_llm/_torch/attention_backend/interface.py

@@ -14,9 +14,10 @@
     from ..speculative.interface import SpecMetadata
     from ..speculative.spec_tree_manager import SpecTreeManager
 
-from tensorrt_llm._utils import maybe_pin_memory
+from tensorrt_llm._utils import get_hf_rope_theta, maybe_pin_memory
 from tensorrt_llm.functional import (PositionEmbeddingType, RopeEmbeddingUtils,
                                      RotaryScalingType)
+from tensorrt_llm.logger import logger
 from tensorrt_llm.mapping import Mapping
 from tensorrt_llm.models.modeling_utils import QuantConfig
 
@@ -483,10 +484,23 @@ def from_config(config) -> "RopeParams":
 
         hf_rope_parameters = getattr(config, 'rope_parameters', None)
         if hf_rope_parameters is not None:
-            assert not set(hf_rope_parameters.keys()).issubset(
-                ALLOWED_ATTENTION_LAYER_TYPES), (
-                    "Per-layer-type RoPE configuration is not supported yet.")
-            config.update(hf_rope_parameters)
+            if set(hf_rope_parameters.keys()).issubset(
+                    ALLOWED_ATTENTION_LAYER_TYPES):
+                # Per-layer-type RoPE config (e.g. Gemma3 in transformers 5.x).
+                # Pick "full_attention" as the default; callers override theta
+                # for sliding-window layers independently.
+                if "full_attention" in hf_rope_parameters:
+                    flat = hf_rope_parameters["full_attention"]
+                else:
+                    fallback_key = next(iter(hf_rope_parameters))
+                    logger.warning(
+                        f"Per-layer-type rope_parameters has no 'full_attention' entry; "
+                        f"falling back to '{fallback_key}'. Available layer types: "
+                        f"{list(hf_rope_parameters.keys())}.")
+                    flat = hf_rope_parameters[fallback_key]
+                config.update(flat)
+            else:
+                config.update(hf_rope_parameters)
 
         # get rotary parameters.
         hidden_size = config.hidden_size
@@ -496,7 +510,7 @@ def from_config(config) -> "RopeParams":
             head_dim = hidden_size // num_attention_heads
         rope_scaling = getattr(config, 'rope_scaling', None)
         rope_params.max_positions = config.max_position_embeddings
-        rope_params.theta = getattr(config, 'rope_theta', 10000.0)
+        rope_params.theta = get_hf_rope_theta(config, 10000.0)
         rope_percentage = (getattr(config, 'rotary_pct', None)
                            or getattr(config, 'partial_rotary_factor', None)
                            or 1.0)
@@ -534,7 +548,8 @@ def from_config(config) -> "RopeParams":
                 rope_params.short_factor = tuple(rope_scaling["short_factor"])
             if "long_factor" in rope_scaling:
                 rope_params.long_factor = tuple(rope_scaling["long_factor"])
-        # Workaround for DeepSeek V3 Lite since its rope_scaling is null in config.json.
+        # Workaround for DeepSeek V3 Lite since its rope_scaling is null in
+        # config.json.
         elif config.model_type == "deepseek_v3":
             rope_params.scale_type = RotaryScalingType.yarn
         # Other metdadata for RoPE.

tensorrt_llm/_torch/auto_deploy/export/library/autocast_noop.py

@@ -13,16 +13,36 @@ class AutocastNoopPatch(BaseExportPatch):
 
     This patch replaces torch.autocast with a null context manager
     that can interfere with export.
+
+    It also patches ``torch.is_autocast_enabled`` so that transformers 5.x
+    helpers like ``maybe_autocast`` (used in RoPE embeddings) do not call the
+    real function with an unknown/fake device type during ``torch.export``
+    tracing, which would raise a ``RuntimeError``.
     """
 
     def _apply_patch(self):
         """Apply the autocast no-op patch."""
-        # Store original function
+        # Store original functions
         self.original_values["torch.autocast"] = torch.autocast
+        self.original_values["torch.is_autocast_enabled"] = torch.is_autocast_enabled
 
-        # Apply patch
+        # Apply patches
         torch.autocast = lambda *args, **kwargs: nullcontext()
 
+        # torch.is_autocast_enabled(device_type) can fail during export when the
+        # device_type is unknown (e.g. fake/meta tensors).  Return False so that
+        # callers like transformers' ``maybe_autocast`` skip the autocast block.
+        original_is_autocast = self.original_values["torch.is_autocast_enabled"]
+
+        def _safe_is_autocast_enabled(*args, **kwargs):
+            try:
+                return original_is_autocast(*args, **kwargs)
+            except RuntimeError:
+                return False
+
+        torch.is_autocast_enabled = _safe_is_autocast_enabled
+
     def _revert_patch(self):
         """Revert the autocast no-op patch."""
         torch.autocast = self.original_values["torch.autocast"]
+        torch.is_autocast_enabled = self.original_values["torch.is_autocast_enabled"]

tensorrt_llm/_torch/auto_deploy/export/library/transformers_causal_mask.py

@@ -0,0 +1,87 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Patch for transformers causal mask to be export-compatible with meta tensors.
+
+Transformers 5.x's ``masking_utils.create_causal_mask`` calls
+``find_packed_sequence_indices`` which invokes ``.all()`` on the attention mask
+tensor.  During ``torch.export`` tracing on meta tensors this raises because
+``.item()`` / ``.all()`` are not supported on meta tensors.
+
+This patch replaces ``find_packed_sequence_indices`` with a version that returns
+early when the input tensors live on the meta device.
+"""
+
+import importlib.metadata
+
+from packaging import version
+
+from ..interface import BaseExportPatch, ExportPatchConfig, ExportPatchRegistry
+
+
+def _transformers_version() -> str:
+    """Get the version of transformers."""
+    return version.parse(importlib.metadata.version("transformers")).base_version
+
+
+@ExportPatchRegistry.register("transformers_causal_mask")
+class TransformersCausalMaskPatch(BaseExportPatch):
+    """Patch ``find_packed_sequence_indices`` to handle meta tensors during export."""
+
+    @classmethod
+    def get_config_class(cls):
+        return ExportPatchConfig
+
+    def _apply_patch(self):
+        """Apply the causal mask patch for meta-tensor compatibility."""
+        # Only needed for transformers >= 5.0.0 which introduced find_packed_sequence_indices
+        if version.parse(_transformers_version()) < version.parse("4.53.0"):
+            return
+
+        try:
+            from transformers import masking_utils
+
+            if not hasattr(masking_utils, "find_packed_sequence_indices"):
+                return
+
+            original_fn = masking_utils.find_packed_sequence_indices
+            self.original_values["find_packed_sequence_indices"] = original_fn
+
+            def _meta_safe_find_packed_sequence_indices(*args, **kwargs):
+                """Wrapper that returns None for meta tensors, delegates otherwise."""
+                # The first positional arg is the attention_mask tensor
+                mask = args[0] if args else kwargs.get("attention_mask")
+                if mask is not None and hasattr(mask, "device") and mask.device.type == "meta":
+                    return None
+                return original_fn(*args, **kwargs)
+
+            masking_utils.find_packed_sequence_indices = _meta_safe_find_packed_sequence_indices
+
+        except (ImportError, AttributeError):
+            pass
+
+    def _revert_patch(self):
+        """Revert the causal mask patch."""
+        if version.parse(_transformers_version()) < version.parse("4.53.0"):
+            return
+
+        try:
+            from transformers import masking_utils
+
+            if "find_packed_sequence_indices" in self.original_values:
+                masking_utils.find_packed_sequence_indices = self.original_values[
+                    "find_packed_sequence_indices"
+                ]
+        except ImportError:
+            pass