config.py 40 KB
Newer Older
1
# SPDX-License-Identifier: Apache-2.0
2
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3

4
import json
5
import os
6
import time
7
from collections.abc import Callable
8
from dataclasses import asdict
9
from functools import cache, partial
10
from pathlib import Path
11
from typing import Any, Literal, TypeVar
Jasmond L's avatar
Jasmond L committed
12

Joe Runde's avatar
Joe Runde committed
13
import huggingface_hub
14
15
16
17
18
from huggingface_hub import (
    get_safetensors_metadata,
    hf_hub_download,
    try_to_load_from_cache,
)
19
from huggingface_hub import list_repo_files as hf_list_repo_files
20
21
22
23
24
25
26
from huggingface_hub.utils import (
    EntryNotFoundError,
    HfHubHTTPError,
    LocalEntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
)
27
from transformers import DeepseekV3Config, GenerationConfig, PretrainedConfig
28
from transformers.models.auto.image_processing_auto import get_image_processor_config
29
30
31
32
from transformers.models.auto.modeling_auto import (
    MODEL_FOR_CAUSAL_LM_MAPPING_NAMES,
    MODEL_MAPPING_NAMES,
)
33
from transformers.models.auto.tokenization_auto import get_tokenizer_config
34
from transformers.utils import CONFIG_NAME as HF_CONFIG_NAME
35

36
from vllm import envs
37
from vllm.logger import init_logger
38
from vllm.transformers_utils.config_parser_base import ConfigParserBase
39
40
41
42
from vllm.transformers_utils.utils import (
    check_gguf_file,
    parse_safetensors_file_metadata,
)
43

44
if envs.VLLM_USE_MODELSCOPE:
45
46
47
    from modelscope import AutoConfig
else:
    from transformers import AutoConfig
48

49
50
MISTRAL_CONFIG_NAME = "params.json"

51
52
logger = init_logger(__name__)

53

54
def _get_hf_token() -> str | None:
55
56
57
    """
    Get the HuggingFace token from environment variable.

58
    Returns None if the token is not set, is an empty string,
59
60
61
62
    or contains only whitespace.
    This follows the same pattern as huggingface_hub library which
    treats empty string tokens as None to avoid authentication errors.
    """
63
    token = os.getenv("HF_TOKEN")
64
65
66
67
68
    if token and token.strip():
        return token
    return None


69
70
class LazyConfigDict(dict):
    def __getitem__(self, key):
71
72
73
        if isinstance(value := super().__getitem__(key), type):
            return value

74
        import vllm.transformers_utils.configs as configs
75

76
        return getattr(configs, value)
77
78
79
80
81


_CONFIG_REGISTRY: dict[str, type[PretrainedConfig]] = LazyConfigDict(
    chatglm="ChatGLMConfig",
    deepseek_vl_v2="DeepseekVLV2Config",
82
    deepseek_v32=DeepseekV3Config,
83
    flex_olmo="FlexOlmoConfig",
84
    kimi_linear="KimiLinearConfig",
85
86
87
88
89
90
    kimi_vl="KimiVLConfig",
    RefinedWeb="RWConfig",  # For tiiuae/falcon-40b(-instruct)
    RefinedWebModel="RWConfig",  # For tiiuae/falcon-7b(-instruct)
    jais="JAISConfig",
    mlp_speculator="MLPSpeculatorConfig",
    medusa="MedusaConfig",
91
    midashenglm="MiDashengLMConfig",
92
93
94
    eagle="EAGLEConfig",
    speculators="SpeculatorsConfig",
    nemotron="NemotronConfig",
95
    olmo3="Olmo3Config",
96
97
98
99
    ovis="OvisConfig",
    ultravox="UltravoxConfig",
    step3_vl="Step3VLConfig",
    step3_text="Step3TextConfig",
100
    qwen3_next="Qwen3NextConfig",
Paul Pak's avatar
Paul Pak committed
101
    lfm2_moe="Lfm2MoeConfig",
102
)
103

104
105
106
107
_CONFIG_ATTRS_MAPPING: dict[str, str] = {
    "llm_config": "text_config",
}

108
_AUTO_CONFIG_KWARGS_OVERRIDES: dict[str, dict[str, Any]] = {
109
    "internvl_chat": {"has_no_defaults_at_init": True},
110
    "Llama_Nemotron_Nano_VL": {"attn_implementation": "eager"},
111
    "NVLM_D": {"has_no_defaults_at_init": True},
112
113
}

114

115
class HFConfigParser(ConfigParserBase):
116
117
    def parse(
        self,
118
        model: str | Path,
119
        trust_remote_code: bool,
120
121
        revision: str | None = None,
        code_revision: str | None = None,
122
123
        **kwargs,
    ) -> tuple[dict, PretrainedConfig]:
124
125
126
127
128
129
130
131
132
133
134
        kwargs["local_files_only"] = huggingface_hub.constants.HF_HUB_OFFLINE
        config_dict, _ = PretrainedConfig.get_config_dict(
            model,
            revision=revision,
            code_revision=code_revision,
            token=_get_hf_token(),
            **kwargs,
        )
        # Use custom model class if it's in our registry
        model_type = config_dict.get("model_type")
        if model_type is None:
135
136
137
138
139
            model_type = (
                "speculators"
                if config_dict.get("speculators_config") is not None
                else model_type
            )
140
141
142
143
144
145
146
147
148
149
150
151

        if model_type in _CONFIG_REGISTRY:
            config_class = _CONFIG_REGISTRY[model_type]
            config = config_class.from_pretrained(
                model,
                revision=revision,
                code_revision=code_revision,
                token=_get_hf_token(),
                **kwargs,
            )
        else:
            try:
152
                kwargs = _maybe_update_auto_config_kwargs(kwargs, model_type=model_type)
153
154
155
156
157
158
159
160
161
                config = AutoConfig.from_pretrained(
                    model,
                    trust_remote_code=trust_remote_code,
                    revision=revision,
                    code_revision=code_revision,
                    token=_get_hf_token(),
                    **kwargs,
                )
            except ValueError as e:
162
163
164
165
                if (
                    not trust_remote_code
                    and "requires you to execute the configuration file" in str(e)
                ):
166
167
168
169
170
                    err_msg = (
                        "Failed to load the model config. If the model "
                        "is a custom model not yet available in the "
                        "HuggingFace transformers library, consider setting "
                        "`trust_remote_code=True` in LLM or using the "
171
172
                        "`--trust-remote-code` flag in the CLI."
                    )
173
174
175
176
177
178
179
180
                    raise RuntimeError(err_msg) from e
                else:
                    raise e
        config = _maybe_remap_hf_config_attrs(config)
        return config_dict, config


class MistralConfigParser(ConfigParserBase):
181
182
    def parse(
        self,
183
        model: str | Path,
184
        trust_remote_code: bool,
185
186
        revision: str | None = None,
        code_revision: str | None = None,
187
188
        **kwargs,
    ) -> tuple[dict, PretrainedConfig]:
189
190
191
        # This function loads a params.json config which
        # should be used when loading models in mistral format
        config_dict = _download_mistral_config_file(model, revision)
192
193
194
        if (
            max_position_embeddings := config_dict.get("max_position_embeddings")
        ) is None:
195
            max_position_embeddings = _maybe_retrieve_max_pos_from_hf(
196
197
                model, revision, **kwargs
            )
198
199
200
201
202
203
204
205
            config_dict["max_position_embeddings"] = max_position_embeddings

        from vllm.transformers_utils.configs.mistral import adapt_config_dict

        config = adapt_config_dict(config_dict)

        # Mistral configs may define sliding_window as list[int]. Convert it
        # to int and add the layer_types list[str] to make it HF compatible
206
207
208
        if (sliding_window := getattr(config, "sliding_window", None)) and isinstance(
            sliding_window, list
        ):
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
            pattern_repeats = config.num_hidden_layers // len(sliding_window)
            layer_types = sliding_window * pattern_repeats
            config.layer_types = [
                "full_attention" if layer_type is None else "sliding_attention"
                for layer_type in layer_types
            ]
            config.sliding_window = next(filter(None, sliding_window), None)

        return config_dict, config


_CONFIG_FORMAT_TO_CONFIG_PARSER: dict[str, type[ConfigParserBase]] = {
    "hf": HFConfigParser,
    "mistral": MistralConfigParser,
}

ConfigFormat = Literal[
    "auto",
    "hf",
    "mistral",
]


def get_config_parser(config_format: str) -> ConfigParserBase:
    """Get the config parser for a given config format."""
    if config_format not in _CONFIG_FORMAT_TO_CONFIG_PARSER:
        raise ValueError(f"Unknown config format `{config_format}`.")
    return _CONFIG_FORMAT_TO_CONFIG_PARSER[config_format]()


def register_config_parser(config_format: str):
    """Register a customized vllm config parser.
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
     When a config format is not supported by vllm, you can register a customized
    config parser to support it.
     Args:
         config_format (str): The config parser format name.
     Examples:

         >>> from vllm.transformers_utils.config import (get_config_parser,
                                                         register_config_parser)
         >>> from vllm.transformers_utils.config_parser_base import ConfigParserBase
         >>>
         >>> @register_config_parser("custom_config_parser")
         ... class CustomConfigParser(ConfigParserBase):
         ...     def parse(
         ...         self,
         ...         model: Union[str, Path],
         ...         trust_remote_code: bool,
257
258
         ...         revision: str | None = None,
         ...         code_revision: str | None = None,
259
260
261
262
263
264
         ...         **kwargs,
         ...     ) -> tuple[dict, PretrainedConfig]:
         ...         raise NotImplementedError
         >>>
         >>> type(get_config_parser("custom_config_parser"))
         <class 'CustomConfigParser'>
265
266
267
268
269
270
    """  # noqa: E501

    def _wrapper(config_parser_cls):
        if config_format in _CONFIG_FORMAT_TO_CONFIG_PARSER:
            logger.warning(
                "Config format `%s` is already registered, and will be "
271
272
273
274
                "overwritten by the new parser class `%s`.",
                config_format,
                config_parser_cls,
            )
275
        if not issubclass(config_parser_cls, ConfigParserBase):
276
277
278
            raise ValueError(
                "The config parser must be a subclass of `ConfigParserBase`."
            )
279
        _CONFIG_FORMAT_TO_CONFIG_PARSER[config_format] = config_parser_cls
280
281
282
283
284
        logger.info(
            "Registered config parser `%s` with config format `%s`",
            config_parser_cls,
            config_format,
        )
285
286
287
        return config_parser_cls

    return _wrapper
288
289


290
291
292
293
294
295
296
297
298
_R = TypeVar("_R")


def with_retry(
    func: Callable[[], _R],
    log_msg: str,
    max_retries: int = 2,
    retry_delay: int = 2,
) -> _R:
299
300
301
302
303
304
305
    for attempt in range(max_retries):
        try:
            return func()
        except Exception as e:
            if attempt == max_retries - 1:
                logger.error("%s: %s", log_msg, e)
                raise
306
307
308
            logger.error(
                "%s: %s, retrying %d of %d", log_msg, e, attempt + 1, max_retries
            )
309
310
311
            time.sleep(retry_delay)
            retry_delay *= 2

312
313
    raise AssertionError("Should not be reached")

314
315
316
317
318
319

# @cache doesn't cache exceptions
@cache
def list_repo_files(
    repo_id: str,
    *,
320
321
322
    revision: str | None = None,
    repo_type: str | None = None,
    token: str | bool | None = None,
323
) -> list[str]:
324
325
326
327
328
    def lookup_files() -> list[str]:
        # directly list files if model is local
        if (local_path := Path(repo_id)).exists():
            return [
                str(file.relative_to(local_path))
329
330
                for file in local_path.rglob("*")
                if file.is_file()
331
332
            ]
        # if model is remote, use hf_hub api to list files
333
        try:
334
            if envs.VLLM_USE_MODELSCOPE:
335
336
337
338
339
340
341
342
343
344
                from vllm.transformers_utils.utils import modelscope_list_repo_files

                return modelscope_list_repo_files(
                    repo_id,
                    revision=revision,
                    token=os.getenv("MODELSCOPE_API_TOKEN", None),
                )
            return hf_list_repo_files(
                repo_id, revision=revision, repo_type=repo_type, token=token
            )
345
346
347
348
349
350
351
352
353
354
355
356
357
        except huggingface_hub.errors.OfflineModeIsEnabled:
            # Don't raise in offline mode,
            # all we know is that we don't have this
            # file cached.
            return []

    return with_retry(lookup_files, "Error retrieving file list")


def file_exists(
    repo_id: str,
    file_name: str,
    *,
358
359
360
    repo_type: str | None = None,
    revision: str | None = None,
    token: str | bool | None = None,
361
) -> bool:
362
363
364
    file_list = list_repo_files(
        repo_id, repo_type=repo_type, revision=revision, token=token
    )
365
366
367
368
    return file_name in file_list


# In offline mode the result can be a false negative
369
def file_or_path_exists(
370
    model: str | Path, config_name: str, revision: str | None
371
) -> bool:
372
373
    if (local_path := Path(model)).exists():
        return (local_path / config_name).is_file()
374

Joe Runde's avatar
Joe Runde committed
375
    # Offline mode support: Check if config file is cached already
376
377
378
    cached_filepath = try_to_load_from_cache(
        repo_id=model, filename=config_name, revision=revision
    )
Joe Runde's avatar
Joe Runde committed
379
380
381
382
383
384
    if isinstance(cached_filepath, str):
        # The config file exists in cache- we can continue trying to load
        return True

    # NB: file_exists will only check for the existence of the config file on
    # hf_hub. This will fail in offline mode.
385
386

    # Call HF to check if the file exists
387
388
389
    return file_exists(
        str(model), config_name, revision=revision, token=_get_hf_token()
    )
390
391


392
393
394
395
396
397
398
399
400
401
402
def patch_rope_scaling(config: PretrainedConfig) -> None:
    """Provide backwards compatibility for RoPE."""
    text_config = getattr(config, "text_config", None)
    if text_config is not None:
        patch_rope_scaling(text_config)

    rope_scaling = getattr(config, "rope_scaling", None)
    if rope_scaling is not None:
        patch_rope_scaling_dict(rope_scaling)


403
def patch_rope_scaling_dict(rope_scaling: dict[str, Any]) -> None:
404
405
406
407
408
409
410
    if "rope_type" in rope_scaling and "type" in rope_scaling:
        rope_type = rope_scaling["rope_type"]
        rope_type_legacy = rope_scaling["type"]
        if rope_type != rope_type_legacy:
            raise ValueError(
                f"Found conflicts between 'rope_type={rope_type}' (modern "
                f"field) and 'type={rope_type_legacy}' (legacy field). "
411
412
                "You should only specify one of them."
            )
413

414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
    if "rope_type" not in rope_scaling and "type" in rope_scaling:
        rope_scaling["rope_type"] = rope_scaling["type"]
        logger.info("Replacing legacy 'type' key with 'rope_type'")

    if "rope_type" not in rope_scaling:
        raise ValueError("rope_scaling should have a 'rope_type' key")

    if rope_scaling["rope_type"] == "su":
        rope_scaling["rope_type"] = "longrope"
        logger.warning("Replacing legacy rope_type 'su' with 'longrope'")
    elif rope_scaling["rope_type"] == "mrope":
        assert "mrope_section" in rope_scaling
        rope_scaling["rope_type"] = "default"
        logger.warning("Replacing legacy rope_type 'mrope' with 'default'")


430
def _uses_mrope(config: PretrainedConfig) -> bool:
431
432
433
434
435
436
437
    rope_scaling = getattr(config, "rope_scaling", None)
    if rope_scaling is None:
        return False

    return "mrope_section" in rope_scaling


438
439
def uses_mrope(config: PretrainedConfig) -> bool:
    """Detect if the model with this config uses M-ROPE."""
440
441
442
443
444
    return (
        _uses_mrope(config)
        or _uses_mrope(config.get_text_config())
        or thinker_uses_mrope(config)
    )
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459


def thinker_uses_mrope(config: PretrainedConfig) -> bool:
    """Detect if the model contains a thinker config and it uses M-ROPE."""
    thinker_config = getattr(config, "thinker_config", None)
    if thinker_config is None:
        return False

    thinker_text_config = getattr(thinker_config, "text_config", None)
    if thinker_text_config is None:
        return False

    return uses_mrope(thinker_text_config)


460
461
462
def is_encoder_decoder(config: PretrainedConfig) -> bool:
    """Detect if the model with this config is used as an encoder/decoder."""

463
464
465
    def _is_encoder_decoder(config: PretrainedConfig) -> bool:
        return getattr(config, "is_encoder_decoder", False)

466
    return _is_encoder_decoder(config) or _is_encoder_decoder(config.get_text_config())
467
468


469
470
471
472
473
474
def is_interleaved(config: PretrainedConfig) -> bool:
    """
    Detect if the model with this config is used with interleaved attention.
    """
    text_config = config.get_text_config()
    if layer_types := getattr(text_config, "layer_types", None):
475
        return len(set(layer_types)) > 1
476
477
478
    return False


479
480
481
482
483
484
485
486
487
def _maybe_update_auto_config_kwargs(kwargs: dict[str, Any], model_type: str):
    """
    Update kwargs for AutoConfig initialization based on model_type
    """
    if model_type in _AUTO_CONFIG_KWARGS_OVERRIDES:
        kwargs.update(_AUTO_CONFIG_KWARGS_OVERRIDES[model_type])
    return kwargs


488
489
490
491
492
493
def _maybe_remap_hf_config_attrs(config: PretrainedConfig) -> PretrainedConfig:
    """Remap config attributes to match the expected names."""
    for old_attr, new_attr in _CONFIG_ATTRS_MAPPING.items():
        if hasattr(config, old_attr):
            if not hasattr(config, new_attr):
                config.update({new_attr: getattr(config, old_attr)})
494
            logger.debug("Remapped config attribute '%s' to '%s'", old_attr, new_attr)
495
496
497
    return config


498
def maybe_override_with_speculators(
499
500
501
    model: str,
    tokenizer: str,
    trust_remote_code: bool,
502
503
    revision: str | None = None,
    vllm_speculative_config: dict[str, Any] | None = None,
504
    **kwargs,
505
) -> tuple[str, str, dict[str, Any] | None]:
506
    """
507
508
509
510
511
512
513
514
515
516
517
518
519
520
    Resolve model configuration when speculators are detected.

    Checks if the provided model is a speculators model and if so, extracts
    the target model configuration and builds the speculative config.

    Args:
        model: Model name or path
        tokenizer: Tokenizer name or path
        trust_remote_code: Whether to trust remote code
        revision: Model revision
        vllm_speculative_config: Existing vLLM speculative config

    Returns:
        Tuple of (resolved_model, resolved_tokenizer, speculative_config)
521
    """
522
523
524
525
526
527
    is_gguf = check_gguf_file(model)
    if is_gguf:
        kwargs["gguf_file"] = Path(model).name
        gguf_model_repo = Path(model).parent
    else:
        gguf_model_repo = None
528
    kwargs["local_files_only"] = huggingface_hub.constants.HF_HUB_OFFLINE
529
    config_dict, _ = PretrainedConfig.get_config_dict(
530
        model if gguf_model_repo is None else gguf_model_repo,
531
532
533
        revision=revision,
        trust_remote_code=trust_remote_code,
        token=_get_hf_token(),
534
        **kwargs,
535
    )
536
537
538
539
540
541
542
    speculators_config = config_dict.get("speculators_config")

    if speculators_config is None:
        # No speculators config found, return original values
        return model, tokenizer, vllm_speculative_config

    # Speculators format detected - process overrides
543
    from vllm.transformers_utils.configs.speculators.base import SpeculatorsConfig
544

545
    speculative_config = SpeculatorsConfig.extract_vllm_speculative_config(
546
547
        config_dict=config_dict
    )
548
549

    # Set the draft model to the speculators model
550
    speculative_config["model"] = model
551
552
553
554
555

    # Override model and tokenizer with the verifier model from config
    verifier_model = speculators_config["verifier"]["name_or_path"]
    model = tokenizer = verifier_model

556
    return model, tokenizer, speculative_config
557
558


559
def get_config(
560
    model: str | Path,
561
    trust_remote_code: bool,
562
563
564
565
566
    revision: str | None = None,
    code_revision: str | None = None,
    config_format: str | ConfigFormat = "auto",
    hf_overrides_kw: dict[str, Any] | None = None,
    hf_overrides_fn: Callable[[PretrainedConfig], PretrainedConfig] | None = None,
567
568
569
    **kwargs,
) -> PretrainedConfig:
    # Separate model folder from file path for GGUF models
570

571
    is_gguf = check_gguf_file(model)
572
573
574
575
    if is_gguf:
        kwargs["gguf_file"] = Path(model).name
        model = Path(model).parent

576
    if config_format == "auto":
577
        try:
578
            if is_gguf or file_or_path_exists(model, HF_CONFIG_NAME, revision=revision):
579
                config_format = "hf"
580
            elif file_or_path_exists(model, MISTRAL_CONFIG_NAME, revision=revision):
581
                config_format = "mistral"
582
583
584
            else:
                raise ValueError(
                    "Could not detect config format for no config file found. "
585
586
587
                    "With config_format 'auto', ensure your model has either "
                    "config.json (HF format) or params.json (Mistral format). "
                    "Otherwise please specify your_custom_config_format "
588
589
                    "in engine args for customized config parser."
                )
590
591
592
593
594
595
596
597
598
599
600

        except Exception as e:
            error_message = (
                "Invalid repository ID or local directory specified:"
                " '{model}'.\nPlease verify the following requirements:\n"
                "1. Provide a valid Hugging Face repository ID.\n"
                "2. Specify a local directory that contains a recognized "
                "configuration file.\n"
                "   - For Hugging Face models: ensure the presence of a "
                "'config.json'.\n"
                "   - For Mistral models: ensure the presence of a "
601
602
603
                "'params.json'.\n"
                "3. For GGUF: pass the local path of the GGUF checkpoint.\n"
                "   Loading GGUF from a remote repo directly is not yet "
604
605
                "supported.\n"
            ).format(model=model)
606
607

            raise ValueError(error_message) from e
608

609
610
611
612
613
614
615
616
    config_parser = get_config_parser(config_format)
    config_dict, config = config_parser.parse(
        model,
        trust_remote_code=trust_remote_code,
        revision=revision,
        code_revision=code_revision,
        **kwargs,
    )
617
618
619
    # Special architecture mapping check for GGUF models
    if is_gguf:
        if config.model_type not in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES:
620
            raise RuntimeError(f"Can't get gguf config for {config.model_type}.")
621
622
623
        model_type = MODEL_FOR_CAUSAL_LM_MAPPING_NAMES[config.model_type]
        config.update({"architectures": [model_type]})

624
625
626
    # Architecture mapping for models without explicit architectures field
    if not config.architectures:
        if config.model_type not in MODEL_MAPPING_NAMES:
627
628
629
630
631
632
633
634
            logger.warning(
                "Model config does not have a top-level 'architectures' field: "
                "expecting `hf_overrides={'architectures': ['...']}` to be passed "
                "in engine args."
            )
        else:
            model_type = MODEL_MAPPING_NAMES[config.model_type]
            config.update({"architectures": [model_type]})
635

636
637
638
639
640
641
    # ModelOpt 0.31.0 and after saves the quantization config in the model
    # config file.
    quantization_config = config_dict.get("quantization_config", None)

    # ModelOpt 0.29.0 and before saves the quantization config in a separate
    # "hf_quant_config.json" in the same directory as the model config file.
642
643
644
645
646
647
    if quantization_config is None and file_or_path_exists(
        model, "hf_quant_config.json", revision
    ):
        quantization_config = get_hf_file_to_dict(
            "hf_quant_config.json", model, revision
        )
648
649
650

    if quantization_config is not None:
        config.quantization_config = quantization_config
651
        # auto-enable DeepGEMM UE8M0 if model config requests it
652
        scale_fmt = quantization_config.get("scale_fmt", None)
653
        if scale_fmt in ("ue8m0",):
654
655
            if not envs.is_set("VLLM_USE_DEEP_GEMM_E8M0"):
                os.environ["VLLM_USE_DEEP_GEMM_E8M0"] = "1"
656
                logger.info_once(
657
658
                    (
                        "Detected quantization_config.scale_fmt=%s; "
659
                        "enabling UE8M0 for DeepGEMM."
660
                    ),
661
662
                    scale_fmt,
                )
663
            elif not envs.VLLM_USE_DEEP_GEMM_E8M0:
664
                logger.warning_once(
665
666
667
                    (
                        "Model config requests UE8M0 "
                        "(quantization_config.scale_fmt=%s), but "
668
669
                        "VLLM_USE_DEEP_GEMM_E8M0=0 is set; "
                        "UE8M0 for DeepGEMM disabled."
670
                    ),
671
672
                    scale_fmt,
                )
673

674
675
676
677
678
679
680
    if hf_overrides_kw:
        logger.debug("Overriding HF config with %s", hf_overrides_kw)
        config.update(hf_overrides_kw)
    if hf_overrides_fn:
        logger.debug("Overriding HF config with %s", hf_overrides_fn)
        config = hf_overrides_fn(config)

681
682
    patch_rope_scaling(config)

683
684
685
    if trust_remote_code:
        maybe_register_config_serialize_by_value()

686
    return config
687
688


689
def try_get_local_file(
690
691
    model: str | Path, file_name: str, revision: str | None = "main"
) -> Path | None:
692
693
694
695
696
    file_path = Path(model) / file_name
    if file_path.is_file():
        return file_path
    else:
        try:
697
698
699
            cached_filepath = try_to_load_from_cache(
                repo_id=model, filename=file_name, revision=revision
            )
700
701
            if isinstance(cached_filepath, str):
                return Path(cached_filepath)
702
        except ValueError:
703
704
705
706
            ...
    return None


707
def get_hf_file_to_dict(
708
    file_name: str, model: str | Path, revision: str | None = "main"
709
):
710
    """
711
    Downloads a file from the Hugging Face Hub and returns
712
713
714
715
716
    its contents as a dictionary.

    Parameters:
    - file_name (str): The name of the file to download.
    - model (str): The name of the model on the Hugging Face Hub.
717
    - revision (str): The specific version of the model.
718
719

    Returns:
720
    - config_dict (dict): A dictionary containing
721
722
723
    the contents of the downloaded file.
    """

724
    file_path = try_get_local_file(model=model, file_name=file_name, revision=revision)
725

726
    if file_path is None:
727
728
        try:
            hf_hub_file = hf_hub_download(model, file_name, revision=revision)
729
730
        except huggingface_hub.errors.OfflineModeIsEnabled:
            return None
731
732
733
734
735
736
        except (
            RepositoryNotFoundError,
            RevisionNotFoundError,
            EntryNotFoundError,
            LocalEntryNotFoundError,
        ) as e:
737
738
739
740
            logger.debug("File or repository not found in hf_hub_download", e)
            return None
        except HfHubHTTPError as e:
            logger.warning(
741
                "Cannot connect to Hugging Face Hub. Skipping file download for '%s':",
742
                file_name,
743
744
                exc_info=e,
            )
745
746
747
748
            return None
        file_path = Path(hf_hub_file)

    if file_path is not None and file_path.is_file():
749
750
        with open(file_path) as file:
            return json.load(file)
751

752
753
754
    return None


755
@cache
756
def get_pooling_config(model: str, revision: str | None = "main") -> dict | None:
757
    """
758
759
760
    This function gets the pooling and normalize
    config from the model - only applies to
    sentence-transformers models.
761
762

    Args:
763
        model: The name of the Hugging Face model.
764
        revision: The specific version of the model to use.
765
            Defaults to 'main'.
766
767

    Returns:
768
        A dictionary containing the pooling type and whether
769
            normalization is used, or None if no pooling configuration is found.
770
771
772
    """

    modules_file_name = "modules.json"
773
774

    modules_dict = None
775
776
777
    if file_or_path_exists(
        model=model, config_name=modules_file_name, revision=revision
    ):
778
        modules_dict = get_hf_file_to_dict(modules_file_name, model, revision)
779
780
781
782

    if modules_dict is None:
        return None

783
784
    logger.info("Found sentence-transformers modules configuration.")

785
786
787
788
789
790
791
792
    pooling = next(
        (
            item
            for item in modules_dict
            if item["type"] == "sentence_transformers.models.Pooling"
        ),
        None,
    )
793
    normalize = bool(
794
795
796
797
798
799
800
801
802
        next(
            (
                item
                for item in modules_dict
                if item["type"] == "sentence_transformers.models.Normalize"
            ),
            False,
        )
    )
803
804
805

    if pooling:
        pooling_file_name = "{}/config.json".format(pooling["path"])
806
        pooling_dict = get_hf_file_to_dict(pooling_file_name, model, revision)
807
        pooling_type_name = next(
808
809
            (item for item, val in pooling_dict.items() if val is True), None
        )
810
811
812
813

        if pooling_type_name is not None:
            pooling_type_name = get_pooling_config_name(pooling_type_name)

814
        logger.info("Found pooling configuration.")
815
816
817
818
819
        return {"pooling_type": pooling_type_name, "normalize": normalize}

    return None


820
def get_pooling_config_name(pooling_name: str) -> str | None:
821
822
823
824
825
826
827
828
829
    if "pooling_mode_" in pooling_name:
        pooling_name = pooling_name.replace("pooling_mode_", "")

    if "_" in pooling_name:
        pooling_name = pooling_name.split("_")[0]

    if "lasttoken" in pooling_name:
        pooling_name = "last"

830
    supported_pooling_types = ["LAST", "ALL", "CLS", "STEP", "MEAN"]
831
832
    pooling_type_name = pooling_name.upper()

833
834
835
    if pooling_type_name in supported_pooling_types:
        return pooling_type_name

836
    raise NotImplementedError(f"Pooling type {pooling_type_name} not supported")
837
838


839
@cache
840
def get_sentence_transformer_tokenizer_config(
841
    model: str | Path, revision: str | None = "main"
842
):
843
    """
844
    Returns the tokenization configuration dictionary for a
845
846
847
    given Sentence Transformer BERT model.

    Parameters:
848
    - model (str|Path): The name of the Sentence Transformer
849
850
851
852
853
    BERT model.
    - revision (str, optional): The revision of the m
    odel to use. Defaults to 'main'.

    Returns:
854
    - dict: A dictionary containing the configuration parameters
855
856
    for the Sentence Transformer BERT model.
    """
857
858
859
860
861
862
863
864
865
866
    sentence_transformer_config_files = [
        "sentence_bert_config.json",
        "sentence_roberta_config.json",
        "sentence_distilbert_config.json",
        "sentence_camembert_config.json",
        "sentence_albert_config.json",
        "sentence_xlm-roberta_config.json",
        "sentence_xlnet_config.json",
    ]
    encoder_dict = None
867
868

    for config_file in sentence_transformer_config_files:
869
870
871
872
        if (
            try_get_local_file(model=model, file_name=config_file, revision=revision)
            is not None
        ):
873
            encoder_dict = get_hf_file_to_dict(config_file, model, revision)
874
875
            if encoder_dict:
                break
876

877
    if not encoder_dict and not Path(model).is_absolute():
878
879
        try:
            # If model is on HuggingfaceHub, get the repo files
880
881
882
            repo_files = list_repo_files(
                model, revision=revision, token=_get_hf_token()
            )
883
        except Exception:
884
885
886
887
            repo_files = []

        for config_name in sentence_transformer_config_files:
            if config_name in repo_files:
888
                encoder_dict = get_hf_file_to_dict(config_name, model, revision)
889
890
891
                if encoder_dict:
                    break

892
893
894
    if not encoder_dict:
        return None

895
896
    logger.info("Found sentence-transformers tokenize configuration.")

897
898
899
900
901
    if all(k in encoder_dict for k in ("max_seq_length", "do_lower_case")):
        return encoder_dict
    return None


902
def maybe_register_config_serialize_by_value() -> None:
903
904
    """Try to register HF model configuration class to serialize by value

905
906
907
    If trust_remote_code is set, and the model's config file specifies an
    `AutoConfig` class, then the config class is typically an instance of
    a custom class imported from the HF modules cache.
908

909
    Examples:
910

911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
    >>> from transformers import AutoConfig
    >>> klass = AutoConfig.from_pretrained(
    ...     "meta-llama/Meta-Llama-3-8B", trust_remote_code=True
    ... )
    >>> klass.__class__  # transformers.models.llama.configuration_llama.LlamaConfig
    >>> import transformers_modules  # error, not initialized
    >>> klass = AutoConfig.from_pretrained(
    ...     "deepseek-ai/DeepSeek-V2.5", trust_remote_code=True
    ... )
    >>> import transformers_modules  # success, initialized
    >>> klass.__class__  # transformers_modules.deepseek-ai.DeepSeek-V2.5.98b11844770b2c3ffc18b175c758a803640f4e77.configuration_deepseek.DeepseekV2Config

    In the DeepSeek example, the config class is an instance of a custom
    class that is not serializable by default. This class will not be
    importable in spawned workers, and won't exist at all on
    other nodes, which breaks serialization of the config.

    In this function we tell the cloudpickle serialization library to pass
    instances of these generated classes by value instead of by reference,
    i.e. the class definition is serialized along with its data so that the
    class module does not need to be importable on the receiving end.

    See: https://github.com/cloudpipe/cloudpickle?tab=readme-ov-file#overriding-pickles-serialization-mechanism-for-importable-constructs
    """  # noqa
935
936
    try:
        import transformers_modules
937

938
        transformers_modules_available = True
939
    except ImportError:
940
        transformers_modules_available = False
941
942
943
944
945

    try:
        import multiprocessing
        import pickle

946
947
        import cloudpickle

948
        from vllm.config import VllmConfig
949

950
951
952
        # Register multiprocessing reducers to handle cross-process
        # serialization of VllmConfig objects that may contain custom configs
        # from transformers_modules
953
        def _reduce_config(config: VllmConfig):
954
            return (pickle.loads, (cloudpickle.dumps(config),))
955

956
        multiprocessing.reducer.register(VllmConfig, _reduce_config)
957

958
959
960
961
962
        # Register transformers_modules with cloudpickle if available
        if transformers_modules_available:
            cloudpickle.register_pickle_by_value(transformers_modules)

            # ray vendors its own version of cloudpickle
963
            from vllm.v1.executor.ray_utils import ray
964

965
966
967
            if ray:
                ray.cloudpickle.register_pickle_by_value(transformers_modules)

968
969
970
971
972
973
    except Exception as e:
        logger.warning(
            "Unable to register remote classes used by"
            " trust_remote_code with by-value serialization. This may"
            " lead to a later error. If remote code is not needed"
            " remove `--trust-remote-code`",
974
975
            exc_info=e,
        )
976
977


978
def get_hf_image_processor_config(
979
980
981
    model: str | Path,
    hf_token: bool | str | None = None,
    revision: str | None = None,
982
    **kwargs,
983
) -> dict[str, Any]:
984
    # ModelScope does not provide an interface for image_processor
985
    if envs.VLLM_USE_MODELSCOPE:
986
        return dict()
987
    # Separate model folder from file path for GGUF models
988
    if check_gguf_file(model):
989
        model = Path(model).parent
990
991
992
    return get_image_processor_config(
        model, token=hf_token, revision=revision, **kwargs
    )
993
994


995
996
def get_hf_text_config(config: PretrainedConfig):
    """Get the "sub" config relevant to llm for multi modal models.
997
    No op for pure text models.
998
    """
999
1000
1001
1002
1003
1004
1005
1006
1007
    text_config = config.get_text_config()

    if text_config is not config:
        # The code operates under the assumption that text_config should have
        # `num_attention_heads` (among others). Assert here to fail early
        # if transformers config doesn't align with this assumption.
        assert hasattr(text_config, "num_attention_heads")

    return text_config
1008
1009
1010
1011
1012


def try_get_generation_config(
    model: str,
    trust_remote_code: bool,
1013
1014
1015
    revision: str | None = None,
    config_format: str | ConfigFormat = "auto",
) -> GenerationConfig | None:
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
    try:
        return GenerationConfig.from_pretrained(
            model,
            revision=revision,
        )
    except OSError:  # Not found
        try:
            config = get_config(
                model,
                trust_remote_code=trust_remote_code,
                revision=revision,
1027
                config_format=config_format,
1028
1029
1030
1031
            )
            return GenerationConfig.from_model_config(config)
        except OSError:  # Not found
            return None
1032
1033


1034
1035
1036
def try_get_safetensors_metadata(
    model: str,
    *,
1037
    revision: str | None = None,
1038
1039
1040
1041
1042
):
    get_safetensors_metadata_partial = partial(
        get_safetensors_metadata,
        model,
        revision=revision,
1043
        token=_get_hf_token(),
1044
1045
1046
    )

    try:
1047
1048
1049
        return with_retry(
            get_safetensors_metadata_partial, "Error retrieving safetensors"
        )
1050
1051
    except Exception:
        return None
1052
1053
1054


def try_get_tokenizer_config(
1055
    pretrained_model_name_or_path: str | os.PathLike,
1056
    trust_remote_code: bool,
1057
1058
    revision: str | None = None,
) -> dict[str, Any] | None:
1059
1060
1061
1062
1063
1064
1065
1066
    try:
        return get_tokenizer_config(
            pretrained_model_name_or_path,
            trust_remote_code=trust_remote_code,
            revision=revision,
        )
    except Exception:
        return None
1067
1068


1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
@cache
def try_get_dense_modules(
    model: str | Path,
    revision: str | None = None,
) -> list[dict[str, Any]] | None:
    try:
        modules = get_hf_file_to_dict("modules.json", model, revision)
        if not modules:
            return None

        if isinstance(modules, dict):
            modules = modules.get("modules", [])

        dense_modules = [
            m for m in modules if m.get("type") == "sentence_transformers.models.Dense"
        ]
        if not dense_modules:
            return None

        layer_configs = []
        for module in dense_modules:
            folder = module.get("path", "")

            config_path = f"{folder}/config.json" if folder else "config.json"
            layer_config = get_hf_file_to_dict(config_path, model, revision)
            if not layer_config:
                continue
            layer_config["folder"] = folder
            layer_configs.append(layer_config)
        return layer_configs
    except Exception:
        return None


1103
1104
1105
def get_safetensors_params_metadata(
    model: str,
    *,
1106
    revision: str | None = None,
1107
1108
1109
1110
1111
1112
1113
1114
1115
) -> dict[str, Any]:
    """
    Get the safetensors metadata for remote model repository.
    """
    full_metadata = {}
    if (model_path := Path(model)).exists():
        safetensors_to_check = model_path.glob("*.safetensors")
        full_metadata = {
            param_name: info
1116
1117
1118
            for file_path in safetensors_to_check
            if file_path.is_file()
            for param_name, info in parse_safetensors_file_metadata(file_path).items()
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
        }
    else:
        repo_mt = try_get_safetensors_metadata(model, revision=revision)
        if repo_mt and (files_mt := repo_mt.files_metadata):
            full_metadata = {
                param_name: asdict(info)
                for file_mt in files_mt.values()
                for param_name, info in file_mt.tensors.items()
            }
    return full_metadata


1131
1132
1133
1134
1135
1136
1137
def _download_mistral_config_file(model, revision) -> dict:
    config_file_name = "params.json"
    config_dict = get_hf_file_to_dict(config_file_name, model, revision)
    if config_dict is None:
        raise ValueError(
            f"Failed to load mistral '{config_file_name}' config for model "
            f"{model}. Please check if the model is a mistral-format model "
1138
1139
            f"and if the config file exists."
        )
1140
1141
1142
1143
1144
1145
1146
1147
    assert isinstance(config_dict, dict)
    return config_dict


def _maybe_retrieve_max_pos_from_hf(model, revision, **kwargs) -> int:
    max_position_embeddings = 128_000
    try:
        trust_remote_code_val = kwargs.get("trust_remote_code", False)
1148
1149
1150
1151
1152
1153
        hf_config = get_config(
            model=model,
            trust_remote_code=trust_remote_code_val,
            revision=revision,
            config_format="hf",
        )
1154
1155
1156
1157
1158
1159
1160
        if hf_value := hf_config.get_text_config().max_position_embeddings:
            max_position_embeddings = hf_value
    except Exception as e:
        logger.warning(
            "The params.json file is missing 'max_position_embeddings'"
            " and could not get a value from the HF config."
            " Defaulting to 128000",
1161
1162
            exc_info=e,
        )
1163
1164

    return max_position_embeddings
1165
1166


1167
def get_model_path(model: str | Path, revision: str | None = None):
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
    if os.path.exists(model):
        return model
    assert huggingface_hub.constants.HF_HUB_OFFLINE
    common_kwargs = {
        "local_files_only": huggingface_hub.constants.HF_HUB_OFFLINE,
        "revision": revision,
    }

    if envs.VLLM_USE_MODELSCOPE:
        from modelscope.hub.snapshot_download import snapshot_download
1178

1179
1180
1181
        return snapshot_download(model_id=model, **common_kwargs)

    from huggingface_hub import snapshot_download
1182

1183
    return snapshot_download(repo_id=model, **common_kwargs)
1184
1185


1186
def get_hf_file_bytes(
1187
1188
    file_name: str, model: str | Path, revision: str | None = "main"
) -> bytes | None:
1189
    """Get file contents from HuggingFace repository as bytes."""
1190
    file_path = try_get_local_file(model=model, file_name=file_name, revision=revision)
1191
1192

    if file_path is None:
1193
1194
1195
        hf_hub_file = hf_hub_download(
            model, file_name, revision=revision, token=_get_hf_token()
        )
1196
1197
1198
        file_path = Path(hf_hub_file)

    if file_path is not None and file_path.is_file():
1199
        with open(file_path, "rb") as file:
1200
1201
1202
            return file.read()

    return None