"vllm/vscode:/vscode.git/clone" did not exist on "bdce64f2365b39335141f8efcb3a0a8ecc559153"
config.py 39.8 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 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
71
class LazyConfigDict(dict):
    def __getitem__(self, key):
        import vllm.transformers_utils.configs as configs
72

73
74
75
76
77
78
        return getattr(configs, super().__getitem__(key))


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

102
103
104
105
_CONFIG_ATTRS_MAPPING: dict[str, str] = {
    "llm_config": "text_config",
}

106
_AUTO_CONFIG_KWARGS_OVERRIDES: dict[str, dict[str, Any]] = {
107
108
    "internvl_chat": {"has_no_defaults_at_init": True},
    "NVLM_D": {"has_no_defaults_at_init": True},
109
110
}

111

112
class HFConfigParser(ConfigParserBase):
113
114
    def parse(
        self,
115
        model: str | Path,
116
        trust_remote_code: bool,
117
118
        revision: str | None = None,
        code_revision: str | None = None,
119
120
        **kwargs,
    ) -> tuple[dict, PretrainedConfig]:
121
122
123
124
125
126
127
128
129
130
131
        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:
132
133
134
135
136
            model_type = (
                "speculators"
                if config_dict.get("speculators_config") is not None
                else model_type
            )
137
138
139
140
141
142
143
144
145
146
147
148

        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:
149
                kwargs = _maybe_update_auto_config_kwargs(kwargs, model_type=model_type)
150
151
152
153
154
155
156
157
158
                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:
159
160
161
162
                if (
                    not trust_remote_code
                    and "requires you to execute the configuration file" in str(e)
                ):
163
164
165
166
167
                    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 "
168
169
                        "`--trust-remote-code` flag in the CLI."
                    )
170
171
172
173
174
175
176
177
                    raise RuntimeError(err_msg) from e
                else:
                    raise e
        config = _maybe_remap_hf_config_attrs(config)
        return config_dict, config


class MistralConfigParser(ConfigParserBase):
178
179
    def parse(
        self,
180
        model: str | Path,
181
        trust_remote_code: bool,
182
183
        revision: str | None = None,
        code_revision: str | None = None,
184
185
        **kwargs,
    ) -> tuple[dict, PretrainedConfig]:
186
187
188
        # 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)
189
190
191
        if (
            max_position_embeddings := config_dict.get("max_position_embeddings")
        ) is None:
192
            max_position_embeddings = _maybe_retrieve_max_pos_from_hf(
193
194
                model, revision, **kwargs
            )
195
196
197
198
199
200
201
202
            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
203
204
205
        if (sliding_window := getattr(config, "sliding_window", None)) and isinstance(
            sliding_window, list
        ):
206
207
208
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
            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.
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
     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,
254
255
         ...         revision: str | None = None,
         ...         code_revision: str | None = None,
256
257
258
259
260
261
         ...         **kwargs,
         ...     ) -> tuple[dict, PretrainedConfig]:
         ...         raise NotImplementedError
         >>>
         >>> type(get_config_parser("custom_config_parser"))
         <class 'CustomConfigParser'>
262
263
264
265
266
267
    """  # 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 "
268
269
270
271
                "overwritten by the new parser class `%s`.",
                config_format,
                config_parser_cls,
            )
272
        if not issubclass(config_parser_cls, ConfigParserBase):
273
274
275
            raise ValueError(
                "The config parser must be a subclass of `ConfigParserBase`."
            )
276
        _CONFIG_FORMAT_TO_CONFIG_PARSER[config_format] = config_parser_cls
277
278
279
280
281
        logger.info(
            "Registered config parser `%s` with config format `%s`",
            config_parser_cls,
            config_format,
        )
282
283
284
        return config_parser_cls

    return _wrapper
285
286


287
288
289
290
291
292
293
294
295
_R = TypeVar("_R")


def with_retry(
    func: Callable[[], _R],
    log_msg: str,
    max_retries: int = 2,
    retry_delay: int = 2,
) -> _R:
296
297
298
299
300
301
302
    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
303
304
305
            logger.error(
                "%s: %s, retrying %d of %d", log_msg, e, attempt + 1, max_retries
            )
306
307
308
            time.sleep(retry_delay)
            retry_delay *= 2

309
310
    raise AssertionError("Should not be reached")

311
312
313
314
315
316

# @cache doesn't cache exceptions
@cache
def list_repo_files(
    repo_id: str,
    *,
317
318
319
    revision: str | None = None,
    repo_type: str | None = None,
    token: str | bool | None = None,
320
) -> list[str]:
321
322
323
324
325
    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))
326
327
                for file in local_path.rglob("*")
                if file.is_file()
328
329
            ]
        # if model is remote, use hf_hub api to list files
330
        try:
331
            if envs.VLLM_USE_MODELSCOPE:
332
333
334
335
336
337
338
339
340
341
                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
            )
342
343
344
345
346
347
348
349
350
351
352
353
354
        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,
    *,
355
356
357
    repo_type: str | None = None,
    revision: str | None = None,
    token: str | bool | None = None,
358
) -> bool:
359
360
361
    file_list = list_repo_files(
        repo_id, repo_type=repo_type, revision=revision, token=token
    )
362
363
364
365
    return file_name in file_list


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

Joe Runde's avatar
Joe Runde committed
372
    # Offline mode support: Check if config file is cached already
373
374
375
    cached_filepath = try_to_load_from_cache(
        repo_id=model, filename=config_name, revision=revision
    )
Joe Runde's avatar
Joe Runde committed
376
377
378
379
380
381
    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.
382
383

    # Call HF to check if the file exists
384
385
386
    return file_exists(
        str(model), config_name, revision=revision, token=_get_hf_token()
    )
387
388


389
390
391
392
393
394
395
396
397
398
399
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)


400
def patch_rope_scaling_dict(rope_scaling: dict[str, Any]) -> None:
401
402
403
404
405
406
407
    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). "
408
409
                "You should only specify one of them."
            )
410

411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
    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'")


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

    return "mrope_section" in rope_scaling


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


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)


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

460
461
462
    def _is_encoder_decoder(config: PretrainedConfig) -> bool:
        return getattr(config, "is_encoder_decoder", False)

463
    return _is_encoder_decoder(config) or _is_encoder_decoder(config.get_text_config())
464
465


466
467
468
469
470
471
472
473
474
475
476
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):
        interleaved_types = {"full_attention", "sliding_attention"}
        return interleaved_types.issubset(layer_types)
    return False


477
478
479
480
481
482
483
484
485
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


486
487
488
489
490
491
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)})
492
            logger.debug("Remapped config attribute '%s' to '%s'", old_attr, new_attr)
493
494
495
    return config


496
def maybe_override_with_speculators(
497
498
499
    model: str,
    tokenizer: str,
    trust_remote_code: bool,
500
501
    revision: str | None = None,
    vllm_speculative_config: dict[str, Any] | None = None,
502
    **kwargs,
503
) -> tuple[str, str, dict[str, Any] | None]:
504
    """
505
506
507
508
509
510
511
512
513
514
515
516
517
518
    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)
519
    """
520
521
522
523
524
525
    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
526
    kwargs["local_files_only"] = huggingface_hub.constants.HF_HUB_OFFLINE
527
    config_dict, _ = PretrainedConfig.get_config_dict(
528
        model if gguf_model_repo is None else gguf_model_repo,
529
530
531
        revision=revision,
        trust_remote_code=trust_remote_code,
        token=_get_hf_token(),
532
        **kwargs,
533
    )
534
535
536
537
538
539
540
    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
541
    from vllm.transformers_utils.configs.speculators.base import SpeculatorsConfig
542

543
    speculative_config = SpeculatorsConfig.extract_vllm_speculative_config(
544
545
        config_dict=config_dict
    )
546
547

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

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

554
    return model, tokenizer, speculative_config
555
556


557
def get_config(
558
    model: str | Path,
559
    trust_remote_code: bool,
560
561
562
563
564
    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,
565
566
567
    **kwargs,
) -> PretrainedConfig:
    # Separate model folder from file path for GGUF models
568

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

574
    if config_format == "auto":
575
        try:
576
            if is_gguf or file_or_path_exists(model, HF_CONFIG_NAME, revision=revision):
577
                config_format = "hf"
578
            elif file_or_path_exists(model, MISTRAL_CONFIG_NAME, revision=revision):
579
                config_format = "mistral"
580
581
582
            else:
                raise ValueError(
                    "Could not detect config format for no config file found. "
583
584
585
                    "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 "
586
587
                    "in engine args for customized config parser."
                )
588
589
590
591
592
593
594
595
596
597
598

        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 "
599
600
601
                "'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 "
602
603
                "supported.\n"
            ).format(model=model)
604
605

            raise ValueError(error_message) from e
606

607
608
609
610
611
612
613
614
    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,
    )
615
616
617
    # Special architecture mapping check for GGUF models
    if is_gguf:
        if config.model_type not in MODEL_FOR_CAUSAL_LM_MAPPING_NAMES:
618
            raise RuntimeError(f"Can't get gguf config for {config.model_type}.")
619
620
621
        model_type = MODEL_FOR_CAUSAL_LM_MAPPING_NAMES[config.model_type]
        config.update({"architectures": [model_type]})

622
623
624
625
626
627
628
    # Architecture mapping for models without explicit architectures field
    if not config.architectures:
        if config.model_type not in MODEL_MAPPING_NAMES:
            raise ValueError(f"Cannot find architecture name for {config.model_type}")
        model_type = MODEL_MAPPING_NAMES[config.model_type]
        config.update({"architectures": [model_type]})

629
630
631
632
633
634
    # 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.
635
636
637
638
639
640
    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
        )
641
642
643

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

667
668
669
670
671
672
673
    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)

674
675
    patch_rope_scaling(config)

676
677
678
    if trust_remote_code:
        maybe_register_config_serialize_by_value()

679
    return config
680
681


682
def try_get_local_file(
683
684
    model: str | Path, file_name: str, revision: str | None = "main"
) -> Path | None:
685
686
687
688
689
    file_path = Path(model) / file_name
    if file_path.is_file():
        return file_path
    else:
        try:
690
691
692
            cached_filepath = try_to_load_from_cache(
                repo_id=model, filename=file_name, revision=revision
            )
693
694
            if isinstance(cached_filepath, str):
                return Path(cached_filepath)
695
        except ValueError:
696
697
698
699
            ...
    return None


700
def get_hf_file_to_dict(
701
    file_name: str, model: str | Path, revision: str | None = "main"
702
):
703
    """
704
    Downloads a file from the Hugging Face Hub and returns
705
706
707
708
709
    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.
710
    - revision (str): The specific version of the model.
711
712

    Returns:
713
    - config_dict (dict): A dictionary containing
714
715
716
    the contents of the downloaded file.
    """

717
    file_path = try_get_local_file(model=model, file_name=file_name, revision=revision)
718

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

    if file_path is not None and file_path.is_file():
742
743
        with open(file_path) as file:
            return json.load(file)
744

745
746
747
    return None


748
@cache
749
def get_pooling_config(model: str, revision: str | None = "main") -> dict | None:
750
    """
751
752
753
    This function gets the pooling and normalize
    config from the model - only applies to
    sentence-transformers models.
754
755

    Args:
756
        model: The name of the Hugging Face model.
757
        revision: The specific version of the model to use.
758
            Defaults to 'main'.
759
760

    Returns:
761
        A dictionary containing the pooling type and whether
762
            normalization is used, or None if no pooling configuration is found.
763
764
765
    """

    modules_file_name = "modules.json"
766
767

    modules_dict = None
768
769
770
    if file_or_path_exists(
        model=model, config_name=modules_file_name, revision=revision
    ):
771
        modules_dict = get_hf_file_to_dict(modules_file_name, model, revision)
772
773
774
775

    if modules_dict is None:
        return None

776
777
    logger.info("Found sentence-transformers modules configuration.")

778
779
780
781
782
783
784
785
    pooling = next(
        (
            item
            for item in modules_dict
            if item["type"] == "sentence_transformers.models.Pooling"
        ),
        None,
    )
786
    normalize = bool(
787
788
789
790
791
792
793
794
795
        next(
            (
                item
                for item in modules_dict
                if item["type"] == "sentence_transformers.models.Normalize"
            ),
            False,
        )
    )
796
797
798

    if pooling:
        pooling_file_name = "{}/config.json".format(pooling["path"])
799
        pooling_dict = get_hf_file_to_dict(pooling_file_name, model, revision)
800
        pooling_type_name = next(
801
802
            (item for item, val in pooling_dict.items() if val is True), None
        )
803
804
805
806

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

807
        logger.info("Found pooling configuration.")
808
809
810
811
812
        return {"pooling_type": pooling_type_name, "normalize": normalize}

    return None


813
def get_pooling_config_name(pooling_name: str) -> str | None:
814
815
816
817
818
819
820
821
822
    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"

823
    supported_pooling_types = ["LAST", "ALL", "CLS", "STEP", "MEAN"]
824
825
    pooling_type_name = pooling_name.upper()

826
827
828
    if pooling_type_name in supported_pooling_types:
        return pooling_type_name

829
    raise NotImplementedError(f"Pooling type {pooling_type_name} not supported")
830
831


832
@cache
833
def get_sentence_transformer_tokenizer_config(
834
    model: str | Path, revision: str | None = "main"
835
):
836
    """
837
    Returns the tokenization configuration dictionary for a
838
839
840
    given Sentence Transformer BERT model.

    Parameters:
841
    - model (str|Path): The name of the Sentence Transformer
842
843
844
845
846
    BERT model.
    - revision (str, optional): The revision of the m
    odel to use. Defaults to 'main'.

    Returns:
847
    - dict: A dictionary containing the configuration parameters
848
849
    for the Sentence Transformer BERT model.
    """
850
851
852
853
854
855
856
857
858
859
    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
860
861

    for config_file in sentence_transformer_config_files:
862
863
864
865
        if (
            try_get_local_file(model=model, file_name=config_file, revision=revision)
            is not None
        ):
866
            encoder_dict = get_hf_file_to_dict(config_file, model, revision)
867
868
            if encoder_dict:
                break
869

870
    if not encoder_dict and not Path(model).is_absolute():
871
872
        try:
            # If model is on HuggingfaceHub, get the repo files
873
874
875
            repo_files = list_repo_files(
                model, revision=revision, token=_get_hf_token()
            )
876
        except Exception:
877
878
879
880
            repo_files = []

        for config_name in sentence_transformer_config_files:
            if config_name in repo_files:
881
                encoder_dict = get_hf_file_to_dict(config_name, model, revision)
882
883
884
                if encoder_dict:
                    break

885
886
887
    if not encoder_dict:
        return None

888
889
    logger.info("Found sentence-transformers tokenize configuration.")

890
891
892
893
894
    if all(k in encoder_dict for k in ("max_seq_length", "do_lower_case")):
        return encoder_dict
    return None


895
def maybe_register_config_serialize_by_value() -> None:
896
897
    """Try to register HF model configuration class to serialize by value

898
899
900
    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.
901

902
    Examples:
903

904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
    >>> 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
928
929
    try:
        import transformers_modules
930

931
        transformers_modules_available = True
932
    except ImportError:
933
        transformers_modules_available = False
934
935
936
937
938

    try:
        import multiprocessing
        import pickle

939
940
        import cloudpickle

941
        from vllm.config import VllmConfig
942

943
944
945
        # Register multiprocessing reducers to handle cross-process
        # serialization of VllmConfig objects that may contain custom configs
        # from transformers_modules
946
        def _reduce_config(config: VllmConfig):
947
            return (pickle.loads, (cloudpickle.dumps(config),))
948

949
        multiprocessing.reducer.register(VllmConfig, _reduce_config)
950

951
952
953
954
955
        # 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
956
            from vllm.v1.executor.ray_utils import ray
957

958
959
960
            if ray:
                ray.cloudpickle.register_pickle_by_value(transformers_modules)

961
962
963
964
965
966
    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`",
967
968
            exc_info=e,
        )
969
970


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


988
989
def get_hf_text_config(config: PretrainedConfig):
    """Get the "sub" config relevant to llm for multi modal models.
990
    No op for pure text models.
991
    """
992
993
994
995
996
997
998
999
1000
    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
1001
1002
1003
1004
1005


def try_get_generation_config(
    model: str,
    trust_remote_code: bool,
1006
1007
1008
    revision: str | None = None,
    config_format: str | ConfigFormat = "auto",
) -> GenerationConfig | None:
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
    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,
1020
                config_format=config_format,
1021
1022
1023
1024
            )
            return GenerationConfig.from_model_config(config)
        except OSError:  # Not found
            return None
1025
1026


1027
1028
1029
def try_get_safetensors_metadata(
    model: str,
    *,
1030
    revision: str | None = None,
1031
1032
1033
1034
1035
):
    get_safetensors_metadata_partial = partial(
        get_safetensors_metadata,
        model,
        revision=revision,
1036
        token=_get_hf_token(),
1037
1038
1039
    )

    try:
1040
1041
1042
        return with_retry(
            get_safetensors_metadata_partial, "Error retrieving safetensors"
        )
1043
1044
    except Exception:
        return None
1045
1046
1047


def try_get_tokenizer_config(
1048
    pretrained_model_name_or_path: str | os.PathLike,
1049
    trust_remote_code: bool,
1050
1051
    revision: str | None = None,
) -> dict[str, Any] | None:
1052
1053
1054
1055
1056
1057
1058
1059
    try:
        return get_tokenizer_config(
            pretrained_model_name_or_path,
            trust_remote_code=trust_remote_code,
            revision=revision,
        )
    except Exception:
        return None
1060
1061


1062
1063
1064
1065
1066
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
@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


1096
1097
1098
def get_safetensors_params_metadata(
    model: str,
    *,
1099
    revision: str | None = None,
1100
1101
1102
1103
1104
1105
1106
1107
1108
) -> 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
1109
1110
1111
            for file_path in safetensors_to_check
            if file_path.is_file()
            for param_name, info in parse_safetensors_file_metadata(file_path).items()
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
        }
    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


1124
1125
1126
1127
1128
1129
1130
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 "
1131
1132
            f"and if the config file exists."
        )
1133
1134
1135
1136
1137
1138
1139
1140
    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)
1141
1142
1143
1144
1145
1146
        hf_config = get_config(
            model=model,
            trust_remote_code=trust_remote_code_val,
            revision=revision,
            config_format="hf",
        )
1147
1148
1149
1150
1151
1152
1153
        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",
1154
1155
            exc_info=e,
        )
1156
1157

    return max_position_embeddings
1158
1159


1160
def get_model_path(model: str | Path, revision: str | None = None):
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
    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
1171

1172
1173
1174
        return snapshot_download(model_id=model, **common_kwargs)

    from huggingface_hub import snapshot_download
1175

1176
    return snapshot_download(repo_id=model, **common_kwargs)
1177
1178


1179
def get_hf_file_bytes(
1180
1181
    file_name: str, model: str | Path, revision: str | None = "main"
) -> bytes | None:
1182
    """Get file contents from HuggingFace repository as bytes."""
1183
    file_path = try_get_local_file(model=model, file_name=file_name, revision=revision)
1184
1185

    if file_path is None:
1186
1187
1188
        hf_hub_file = hf_hub_download(
            model, file_name, revision=revision, token=_get_hf_token()
        )
1189
1190
1191
        file_path = Path(hf_hub_file)

    if file_path is not None and file_path.is_file():
1192
        with open(file_path, "rb") as file:
1193
1194
1195
            return file.read()

    return None