Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

Author: Aishwarya-Tonpe

examples/benchmarks/tensorrt_inference_performance.py

@@ -91,6 +91,12 @@ def run_huggingface_benchmark(model_identifier, precision='fp16', batch_size=32,
     parser.add_argument('--iterations', type=int, default=2048)
     args = parser.parse_args()
 
+    if args.model_source == 'huggingface' and args.precision == 'int8':
+        parser.error(
+            '--precision int8 is not supported with --model_source huggingface '
+            '(no calibration data / Q-DQ ONNX is generated). Use fp16 or fp32.'
+        )
+
     if args.model_source == 'huggingface':
         run_huggingface_benchmark(
             args.model_identifier, args.precision, args.batch_size, args.seq_length, args.iterations

superbench/benchmarks/micro_benchmarks/_export_torch_to_onnx.py

@@ -18,7 +18,6 @@
 
 class torch2onnxExporter():
     """PyTorch model to ONNX exporter."""
-
     def __init__(self):
         """Constructor."""
         from transformers import BertConfig, GPT2Config, LlamaConfig
@@ -360,7 +359,6 @@ def _build_vision_export_inputs(self, model, batch_size, model_dtype, device):
         dynamic_axes = {'pixel_values': {0: 'batch_size'}, 'output': {0: 'batch_size'}}
 
         class VisionModelWrapper(torch.nn.Module):
-
             def __init__(self, model):
                 super().__init__()
                 self.model = model
@@ -398,7 +396,6 @@ def _build_nlp_export_inputs(self, model, batch_size, seq_length, device):
         }
 
         class NLPModelWrapper(torch.nn.Module):
-
             def __init__(self, model):
                 super().__init__()
                 self.model = model

superbench/benchmarks/micro_benchmarks/huggingface_model_loader.py

@@ -89,7 +89,6 @@ class HuggingFaceModelLoader:
             ``False``; enabling this turns ``--model_identifier`` into an RCE
             sink, so it is opt-in only.
     """
-
     def __init__(
         self,
         cache_dir: Optional[str] = None,
@@ -154,6 +153,11 @@ def load_model(
         # Reject malformed / path-like identifiers before any network or disk activity.
         validate_model_identifier(model_identifier)
 
+        # Fall back to CPU on hosts without CUDA so default device='cuda' callers don't fail.
+        if device == 'cuda' and not torch.cuda.is_available():
+            logger.warning('CUDA not available; falling back to CPU.')
+            device = 'cpu'
+
         try:
             load_kwargs = self._build_load_kwargs(torch_dtype, revision, kwargs)
 
@@ -211,10 +215,12 @@ def _build_load_kwargs(self, torch_dtype, revision, extra_kwargs):
 
     def _try_load_tokenizer(self, model_identifier, load_kwargs):
         """Attempt to load a tokenizer; return None if the model has no associated tokenizer."""
+        # Tokenizers don't accept model-only kwargs like torch_dtype/device_map; strip before passing.
+        tokenizer_kwargs = {k: v for k, v in load_kwargs.items() if k not in ('torch_dtype', 'device_map')}
         try:
             logger.info('Loading tokenizer...')
             return AutoTokenizer.from_pretrained(
-                model_identifier, trust_remote_code=self.allow_remote_code, **load_kwargs
+                model_identifier, trust_remote_code=self.allow_remote_code, **tokenizer_kwargs
             )
         except Exception as e:
             logger.warning(f'Could not load tokenizer: {e}. Continuing without tokenizer.')
@@ -373,7 +379,15 @@ def estimate_param_count_from_config(hf_config) -> Optional[int]:
 
             # Embeddings: token + (optional) position
             max_pos = getattr(hf_config, 'max_position_embeddings', 0)
-            has_pos_embed = getattr(hf_config, 'position_embedding_type', None) not in ('rotary', None)
+            pos_embed_type = getattr(hf_config, 'position_embedding_type', None)
+            # When position_embedding_type is missing/None, default to assuming learned
+            # position embeddings exist (common for BERT-style configs that omit the field).
+            # Only skip the term when the type is explicitly rotary, or the config clearly
+            # indicates RoPE/rotary via rope_theta/rotary_pct/rotary_emb_base.
+            uses_rotary = pos_embed_type == 'rotary' or any(
+                getattr(hf_config, attr, None) is not None for attr in ('rope_theta', 'rotary_pct', 'rotary_emb_base')
+            )
+            has_pos_embed = not uses_rotary
             embed_params = vocab * hidden
             if has_pos_embed and max_pos > 0:
                 embed_params += max_pos * hidden

superbench/benchmarks/micro_benchmarks/ort_inference_performance.py

@@ -145,7 +145,7 @@ def add_parser_arguments(self):
             default=False,
             required=False,
             help='Allow HuggingFace to execute model-repo Python (trust_remote_code=True). '
-            'SECURITY: enables RCE from --model_identifier. Pin --revision <sha> when used.',
+            'SECURITY: enables RCE from --model_identifier; only enable for trusted model identifiers.',
         )
 
     def _preprocess(self):

superbench/benchmarks/micro_benchmarks/tensorrt_inference_performance.py

@@ -104,7 +104,7 @@ def add_parser_arguments(self):
             default=False,
             required=False,
             help='Allow HuggingFace to execute model-repo Python (trust_remote_code=True). '
-            'SECURITY: enables RCE from --model_identifier. Pin --revision <sha> when used.',
+            'SECURITY: enables RCE from --model_identifier; only enable for trusted model identifiers.',
         )
 
     @staticmethod
@@ -238,9 +238,10 @@ def _preprocess_huggingface_models(self):
             hf_config = AutoConfig.from_pretrained(
                 self._args.model_identifier, trust_remote_code=allow_remote_code, **load_kwargs
             )
-            precision_str = self._args.precision    # already a string: 'fp16', 'fp32', 'int8'
+            # ONNX export is always done in float32 (see _build_trtexec_command_for_hf), so gate
+            # the pre-download check on fp32 memory regardless of the requested runtime precision.
             fits, _, _, _ = HuggingFaceModelLoader.check_memory_fits(
-                self._args.model_identifier, hf_config, precision_str, mode='inference', token=hf_token
+                self._args.model_identifier, hf_config, 'fp32', mode='inference', token=hf_token
             )
             if not fits:
                 self._result.set_return_code(ReturnCode.MICROBENCHMARK_EXECUTION_FAILURE)

tests/benchmarks/micro_benchmarks/test_huggingface_e2e.py

@@ -28,7 +28,6 @@
 )
 class TestHuggingFaceE2E:
     """End-to-end tests for HuggingFace model loading."""
-
     @pytest.fixture
     def loader(self, tmp_path):
         """Create a loader instance with an isolated per-test cache dir."""