minicpmv.py 41.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# Adapted from
# https://github.com/huggingface/transformers/blob/v4.28.0/src/transformers/models/llama/modeling_llama.py
# Copyright 2023 The vLLM team.
# Copyright 2022 EleutherAI and the HuggingFace Inc. team. All rights reserved.
#
# This code is based on EleutherAI's GPT-NeoX library and the GPT-NeoX
# and OPT implementations in this library. It has been modified from its
# original forms to accommodate minor architectural differences compared
# to GPT-NeoX and OPT used by the Meta AI team that trained the model.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
Alphi's avatar
Alphi committed
22
"""Inference-only MiniCPM-V model compatible with HuggingFace weights."""
23
24
25
import math
import re
from functools import partial
26
27
from typing import (Any, Callable, Iterable, List, Literal, Mapping, Optional,
                    Tuple, TypedDict, Union)
28
29

import torch
Alphi's avatar
Alphi committed
30
import torch.types
31
32
from PIL import Image
from torch import nn
33
from transformers import PretrainedConfig
34
from typing_extensions import NotRequired
35
36

from vllm.attention import AttentionMetadata
37
from vllm.config import VllmConfig
38
39
from vllm.inputs import (INPUT_REGISTRY, DecoderOnlyInputs, DummyData,
                         InputContext, token_inputs)
Alphi's avatar
Alphi committed
40
from vllm.model_executor.layers.logits_processor import LogitsProcessor
41
from vllm.model_executor.layers.quantization import QuantizationConfig
42
from vllm.model_executor.layers.resampler import (BaseResampler, Resampler2,
43
                                                  get_2d_sincos_pos_embed)
Joe Runde's avatar
Joe Runde committed
44
from vllm.model_executor.layers.sampler import SamplerOutput, get_sampler
Alphi's avatar
Alphi committed
45
from vllm.model_executor.layers.vocab_parallel_embedding import ParallelLMHead
Jee Jee Li's avatar
Jee Jee Li committed
46
from vllm.model_executor.model_loader.utils import set_default_torch_dtype
47
from vllm.model_executor.model_loader.weight_utils import default_weight_loader
Alphi's avatar
Alphi committed
48
49
from vllm.model_executor.models.llama import LlamaModel
from vllm.model_executor.models.minicpm import MiniCPMModel
50
from vllm.model_executor.models.module_mapping import MultiModelKeys
Alphi's avatar
Alphi committed
51
from vllm.model_executor.models.qwen2 import Qwen2Model
52
from vllm.model_executor.models.utils import LLMWrapper
53
from vllm.model_executor.sampling_metadata import SamplingMetadata
54
from vllm.multimodal import MULTIMODAL_REGISTRY, MultiModalKwargs
55
56
from vllm.multimodal.image import cached_get_image_processor
from vllm.multimodal.utils import cached_get_tokenizer
57
from vllm.sequence import IntermediateTensors, SequenceData
58

Jee Jee Li's avatar
Jee Jee Li committed
59
from .idefics2_vision_model import Idefics2VisionTransformer
60
from .interfaces import SupportsLoRA, SupportsMultiModal, SupportsPP
61
from .utils import is_pp_missing_parameter, maybe_prefix
Jee Jee Li's avatar
Jee Jee Li committed
62

63
_KEYS_TO_MODIFY_MAPPING = {
Alphi's avatar
Alphi committed
64
    "llm.lm_head": "lm_head",
65
66
}

67
RawImageType = Union[Image.Image, torch.Tensor]
68

69
70

class MiniCPMVRawImageInput(TypedDict):
71
    """Input mapper input with auxiliary data for computing image bounds."""
72
    image: RawImageType
73
74
75
76
77
78
79
80

    # Image bounds token ids in 0-dim scaler tensor.
    im_start_id: torch.Tensor
    im_end_id: torch.Tensor
    slice_start_id: NotRequired[torch.Tensor]
    slice_end_id: NotRequired[torch.Tensor]


Jee Jee Li's avatar
Jee Jee Li committed
81
class MiniCPMVImagePixelInputs(TypedDict):
82
83
    type: Literal["pixel_values"]
    data: List[torch.Tensor]
Jee Jee Li's avatar
Jee Jee Li committed
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
    """
    Shape: `(batch_size * num_images, num_channels, height, width)`

    Note that the image size may vary, so we pass it as a list
    instead of a batched tensor.
    """

    image_bounds: torch.Tensor
    """
    Shape: `(batch_size * num_images, 2)`

    This should be in `(start, stop)` format.
    """

    tgt_sizes: torch.Tensor
    """
    Shape: `(batch_size * num_images, 2)`

    This should be in `(height, width)` format.
    """


106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
class MiniCPMVImageEmbeddingInputs(TypedDict):
    type: Literal["image_embeds"]
    data: torch.Tensor
    """
    Shape: `(batch_size * num_images, image_feature_size, hidden_size)`

    `hidden_size` must match the hidden size of language model backbone.
    instead of a batched tensor.
    """

    image_bounds: torch.Tensor
    """
    Shape: `(batch_size * num_images, 2)`

    This should be in `(start, stop)` format.
    """


MiniCPMVImageInputs = Union[MiniCPMVImagePixelInputs,
                            MiniCPMVImageEmbeddingInputs]

Jee Jee Li's avatar
Jee Jee Li committed
127
128
129
130
131
DEFAULT_LN = partial(nn.LayerNorm, eps=1e-6)


class Resampler2_5(BaseResampler):

132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
    def __init__(self,
                 num_queries: int,
                 embed_dim: int,
                 num_heads: int,
                 kv_dim: Optional[int] = None,
                 norm_layer: Callable[[int], nn.LayerNorm] = DEFAULT_LN,
                 max_size: Tuple[int, int] = (70, 70),
                 quant_config: Optional[QuantizationConfig] = None,
                 prefix: str = "") -> None:
        super().__init__(num_queries,
                         embed_dim,
                         num_heads,
                         kv_dim,
                         norm_layer,
                         quant_config=quant_config,
                         prefix=prefix)
Jee Jee Li's avatar
Jee Jee Li committed
148
149
150

        self.max_size = max_size
        self._set_2d_pos_cache(self.max_size)
151
152
153

        self.apply(self._init_weights)

Alphi's avatar
Alphi committed
154
155
    def _set_2d_pos_cache(self,
                          max_size: Tuple[int, int],
Jee Jee Li's avatar
Jee Jee Li committed
156
157
158
159
160
                          device: torch.types.Device = "cpu") -> None:
        pos_embed_arr = get_2d_sincos_pos_embed(self.embed_dim,
                                                max_size,
                                                version=(2, 5))
        pos_embed = torch.from_numpy(pos_embed_arr).float().to(device)
161
162
        self.register_buffer("pos_embed", pos_embed, persistent=False)

Alphi's avatar
Alphi committed
163
    def _adjust_pos_cache(self, tgt_sizes: torch.Tensor,
Jee Jee Li's avatar
Jee Jee Li committed
164
165
166
167
168
                          device: torch.types.Device) -> None:
        max_h = tgt_sizes[:, 0].max().item()
        max_w = tgt_sizes[:, 1].max().item()
        assert isinstance(max_h, int) and isinstance(max_w, int)

169
        if max_h > self.max_size[0] or max_w > self.max_size[1]:
Jee Jee Li's avatar
Jee Jee Li committed
170
            self.max_size = (
171
                max(max_h, self.max_size[0]),
Jee Jee Li's avatar
Jee Jee Li committed
172
173
                max(max_w, self.max_size[1]),
            )
174
175
            self._set_2d_pos_cache(self.max_size, device)

Jee Jee Li's avatar
Jee Jee Li committed
176
177
    def forward(self, x: torch.Tensor,
                tgt_sizes: torch.Tensor) -> torch.Tensor:
178
179
180
181
182
183
184
185
186
187
        assert x.shape[0] == tgt_sizes.shape[0]
        bs = x.shape[0]

        device = x.device
        dtype = x.dtype

        patch_len = tgt_sizes[:, 0] * tgt_sizes[:, 1]

        self._adjust_pos_cache(tgt_sizes, device=device)

Jee Jee Li's avatar
Jee Jee Li committed
188
189
190
        max_patch_len = patch_len.max().item()
        assert isinstance(max_patch_len, int)

191
192
193
194
195
196
        key_padding_mask = torch.zeros((bs, max_patch_len),
                                       dtype=torch.bool,
                                       device=device)

        pos_embed = []
        for i in range(bs):
Jee Jee Li's avatar
Jee Jee Li committed
197
            tgt_h, tgt_w = tgt_sizes[i].tolist()
198
199
200
201
202
203
204
205
            pos_embed.append(self.pos_embed[:tgt_h, :tgt_w, :].reshape(
                (tgt_h * tgt_w, -1)).to(dtype))  # patches * D
            key_padding_mask[i, patch_len[i]:] = True
        pos_embed = torch.nn.utils.rnn.pad_sequence(pos_embed,
                                                    batch_first=True,
                                                    padding_value=0.0).permute(
                                                        1, 0,
                                                        2)  # BLD => L * B * D
Jee Jee Li's avatar
Jee Jee Li committed
206
        x, _ = self.kv_proj(x)  # B * L * D
207
208
209
210
211
212
213
214
        x = self.ln_kv(x).permute(1, 0, 2)  # L * B * D

        q = self.ln_q(self.query)  # Q * D

        out = self.attn(
            self._repeat(q, bs),  # Q * B * D
            x + pos_embed,  # L * B * D +  L * B * D
            x,
Jee Jee Li's avatar
Jee Jee Li committed
215
216
            key_padding_mask=key_padding_mask,
        )[0]
217
218
219
220
221
222
223
224
        #  out: Q * B * D
        x = out.permute(1, 0, 2)  # B * Q * D

        x = self.ln_post(x)
        x = x @ self.proj
        return x


225
def _build_image_input(ctx: InputContext,
226
                       image: RawImageType) -> MiniCPMVRawImageInput:
227
228
229
230
    tokenizer = cached_get_tokenizer(
        ctx.model_config.tokenizer,
        trust_remote_code=ctx.model_config.trust_remote_code)
    if hasattr(tokenizer, "slice_start_id"):
231
        return MiniCPMVRawImageInput(
232
233
234
235
236
237
            image=image,
            im_start_id=torch.tensor(tokenizer.im_start_id),
            im_end_id=torch.tensor(tokenizer.im_end_id),
            slice_start_id=torch.tensor(tokenizer.slice_start_id),
            slice_end_id=torch.tensor(tokenizer.slice_end_id))
    else:
238
239
240
241
        return MiniCPMVRawImageInput(
            image=image,
            im_start_id=torch.tensor(tokenizer.im_start_id),
            im_end_id=torch.tensor(tokenizer.im_end_id))
242
243


244
245
246
247
248
249
250
251
252
253
254
255
256
257
def get_version_by_config(config: PretrainedConfig) -> Tuple[int, ...]:
    version_float = getattr(config, "version", None)

    # The old configs do not include version number
    # TODO: Remove this after the HF repos are updated
    if version_float is None:
        if config.hidden_size == 2304 and config.query_num == 64:
            return (2, 0)
        return (2, 5)

    version_str = str(version_float)
    return tuple(int(x) for x in version_str.split("."))


258
def get_max_minicpmv_image_tokens(ctx: InputContext):
259
    hf_config = ctx.get_hf_config()
260
261
262
    return getattr(hf_config, "query_num", 64)


263
def dummy_seq_data_for_minicpmv(seq_len: int, num_images: int):
264
    return SequenceData.from_prompt_token_counts((0, seq_len))
265
266


267
268
def dummy_image_for_minicpmv(ctx: InputContext, hf_config: PretrainedConfig,
                             num_images: int):
269
    width = height = hf_config.image_size
270
271
272
273
    image = _build_image_input(ctx,
                               image=Image.new("RGB", (width, height),
                                               color=0))
    return {"image": [image] if num_images == 1 else [image] * num_images}
274
275


276
277
def dummy_data_for_minicpmv(ctx: InputContext, seq_len: int,
                            mm_counts: Mapping[str, int]):
278
    hf_config = ctx.get_hf_config()
279
    num_images = mm_counts["image"]
280

281
    seq_data = dummy_seq_data_for_minicpmv(seq_len, num_images)
282
    mm_data = dummy_image_for_minicpmv(ctx, hf_config, num_images)
283

284
    return DummyData(seq_data, mm_data)
285
286


287
288
def input_processor_for_minicpmv(ctx: InputContext, inputs: DecoderOnlyInputs):
    multi_modal_data = inputs.get("multi_modal_data")
289
    if multi_modal_data is None or "image" not in multi_modal_data:
290
        return inputs
291
    model_config = ctx.model_config
292
    version = get_version_by_config(model_config.hf_config)
293
294
295
    tokenizer = cached_get_tokenizer(
        model_config.tokenizer,
        trust_remote_code=model_config.trust_remote_code)
296
297
298
299
300
301
302
303
    image_processor = cached_get_image_processor(model_config.tokenizer)

    def get_placeholder(image_size: Tuple[int, int], num_image: int):
        if version == (2, 0) or version == (2, 5):
            return image_processor. \
                get_slice_image_placeholder(image_size)
        return image_processor. \
            get_slice_image_placeholder(image_size, num_image)
304

305
306
    prompt = inputs.get("prompt")
    token_ids = inputs.get("prompt_token_ids")
307
308
309
310
    if prompt is None:
        prompt = tokenizer.decode(token_ids)

    pattern = "(<image>./</image>)"
311
    images = multi_modal_data["image"]
312
    image_tags = re.findall(pattern, prompt)
Jee Jee Li's avatar
Jee Jee Li committed
313
314
315
316
    if len(image_tags) == 0:
        new_token_ids = token_ids
        new_prompt = prompt
    else:
317
318
319
320
321
322
323
324
        if isinstance(images, dict):
            image_size_list = images.get("image_size_list")
            images = [images.get("image_embeds")]
        else:
            if isinstance(images, Image.Image):
                images = [images]
            image_size_list = [image.size for image in images]

Jee Jee Li's avatar
Jee Jee Li committed
325
        text_chunks = prompt.split(pattern)
326
        new_prompt_chunks: List[str] = []
327
        for i in range(len(image_size_list)):
328
329
            new_prompt_chunks += [
                text_chunks[i],
330
                get_placeholder(image_size_list[i], i)
331
332
333
            ]
        new_prompt_chunks.append(text_chunks[-1])
        new_prompt = "".join(new_prompt_chunks)
Jee Jee Li's avatar
Jee Jee Li committed
334
335
        new_token_ids = tokenizer.encode(new_prompt)

336
337
338
339
    multi_modal_data["image"] = [
        _build_image_input(ctx, image) for image in images
    ]

340
    return token_inputs(
Jee Jee Li's avatar
Jee Jee Li committed
341
342
343
344
        prompt_token_ids=new_token_ids,
        prompt=new_prompt,
        multi_modal_data=multi_modal_data,
    )
345
346


347
348
349
350
351
352
353
354
355
356
357
358
def input_mapper_for_minicpmv(ctx: InputContext, data: object):
    model_config = ctx.model_config

    image_processor = cached_get_image_processor(
        model_config.model, trust_remote_code=model_config.trust_remote_code)
    if image_processor is None:
        raise RuntimeError("No HuggingFace processor is available "
                           "to process the image object")

    if not isinstance(data, list):
        raise ValueError(
            "Image input must be list of MiniCPMVImageInput, got (%s)", data)
359
360
361
362
363
364
365
366
367

    if len(data) > 0 and isinstance(data[0]['image'], torch.Tensor):
        batch_data = {
            "image_embeds": data[0]['image'],
        }
    else:
        batch_data = image_processor \
            .preprocess([img["image"] for img in data], return_tensors="pt") \
            .data
368
369
370
371
372
373
374
375

    if len(data) > 0:
        batch_data["im_start_id"] = data[0]["im_start_id"]
        batch_data["im_end_id"] = data[0]["im_end_id"]
        if "slice_start_id" in data[0]:
            batch_data["slice_start_id"] = data[0]["slice_start_id"]
            batch_data["slice_end_id"] = data[0]["slice_end_id"]

376
    return MultiModalKwargs(batch_data)
377
378


379
class MiniCPMVBaseModel(nn.Module, SupportsMultiModal, SupportsPP):
Jee Jee Li's avatar
Jee Jee Li committed
380
381
382
383
    """
    The abstract class of MiniCPMV can only be inherited, but cannot be
    instantiated.
    """
384
385
386

    def __init__(
        self,
387
388
        vllm_config: VllmConfig,
        prefix: str = "",
389
    ):
390
391
392
        config = vllm_config.model_config.hf_config
        multimodal_config = vllm_config.model_config.multimodal_config
        quant_config = vllm_config.quant_config
393
        super().__init__()
394
395
396
397
        # All MiniCPM-V models disable `tie_word_embeddings` but
        # `PretrainedConfig.tie_word_embeddings` defaults to True; we cannot
        # check `tie_word_embeddings` until vLLM integrate MiniCPM-V model
        # and config class
398
399
400
        self.config = config
        self.multimodal_config = multimodal_config

401
        self.version = get_version_by_config(self.config)
402
403
404
405
406
        self.llm = self.init_llm(vllm_config=vllm_config,
                                 prefix=maybe_prefix(prefix, "llm"))
        self.vpm = self.init_vision_module(config,
                                           quant_config,
                                           prefix=maybe_prefix(prefix, "vpm"))
407
408
        param_dtype = torch.get_default_dtype()
        self.vpm.to(dtype=param_dtype)
Jee Jee Li's avatar
Jee Jee Li committed
409
410
        self.vision_dim = (self.vpm.embed_dim if self.version == (2, 0) else
                           self.vpm.embeddings.embed_dim)
Alphi's avatar
Alphi committed
411
        self.embed_dim = self.config.hidden_size
412
413
414
        self.resampler = self.init_resampler(self.embed_dim,
                                             self.vision_dim,
                                             quant_config=quant_config,
415
416
                                             prefix=maybe_prefix(
                                                 prefix, "resampler"))
417
        self.resampler.to(device="cuda", dtype=param_dtype)
418
        # TODO: why is there _KEYS_TO_MODIFY_MAPPING? lm_head should be in llm
Alphi's avatar
Alphi committed
419
420
        self.lm_head = ParallelLMHead(config.vocab_size,
                                      config.hidden_size,
421
                                      quant_config=quant_config,
422
423
                                      prefix=maybe_prefix(
                                          prefix, "llm.lm_head"))
Alphi's avatar
Alphi committed
424
        self.logits_processor = LogitsProcessor(config.vocab_size)
Joe Runde's avatar
Joe Runde committed
425
        self.sampler = get_sampler()
426

427
428
429
        self.make_empty_intermediate_tensors = (
            self.llm.make_empty_intermediate_tensors)

Jee Jee Li's avatar
Jee Jee Li committed
430
431
432
    def get_embedding(
        self,
        input_ids: torch.Tensor,
433
        image_inputs: Optional[MiniCPMVImageInputs],
Jee Jee Li's avatar
Jee Jee Li committed
434
435
436
437
438
439
440
    ) -> Tuple[torch.Tensor, torch.Tensor]:
        vlm_embedding: torch.Tensor = self.llm.embed_tokens(input_ids)
        if hasattr(self.config, "scale_emb"):
            vlm_embedding *= self.config.scale_emb

        if image_inputs is None:  # No image
            vision_hidden_states = torch.tensor([], device=input_ids.device)
441
        else:
442
443
444
445
446
447
            if image_inputs["type"] == "image_embeds":
                vision_hidden_states = (image_inputs["data"].type(
                    vlm_embedding.dtype).to(vlm_embedding.device))
            else:
                vision_hidden_states = self.get_vision_hidden_states(
                    image_inputs)
Jee Jee Li's avatar
Jee Jee Li committed
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462

            # See NOTE in _parse_and_validate_inputs
            image_bounds = image_inputs["image_bounds"]
            if len(image_bounds) > 0:
                image_indices = torch.stack([
                    torch.arange(start, end, dtype=torch.long)
                    for start, end in image_bounds.tolist()
                ]).to(vlm_embedding.device)
                vlm_embedding.scatter_(
                    0,
                    image_indices.view(-1, 1).repeat(1,
                                                     vlm_embedding.shape[-1]),
                    vision_hidden_states.view(-1,
                                              vision_hidden_states.shape[-1]),
                )
463

Jee Jee Li's avatar
Jee Jee Li committed
464
        return vlm_embedding, vision_hidden_states
465

466
467
468
469
470
471
472
473
474
475
476
477
478
479
    def _get_image_bounds(
            self,
            input_ids: torch.Tensor,
            im_start_id: torch.Tensor,
            im_end_id: torch.Tensor,
            slice_start_id: Optional[torch.Tensor] = None,
            slice_end_id: Optional[torch.Tensor] = None) -> torch.Tensor:
        # All the images in the batch should share the same special image
        # bound token ids.
        start_cond = input_ids == im_start_id[0]
        end_cond = input_ids == im_end_id[0]
        if slice_start_id is not None:
            start_cond |= (input_ids == slice_start_id[0])
            end_cond |= (input_ids == slice_end_id[0])
Alphi's avatar
Alphi committed
480

Jee Jee Li's avatar
Jee Jee Li committed
481
        image_start_tokens, = torch.where(start_cond)
482
        image_start_tokens += 1
Jee Jee Li's avatar
Jee Jee Li committed
483
        image_end_tokens, = torch.where(end_cond)
Alphi's avatar
Alphi committed
484
        valid_image_nums = max(len(image_start_tokens), len(image_end_tokens))
Jee Jee Li's avatar
Jee Jee Li committed
485

486
        if valid_image_nums == 0:
Jee Jee Li's avatar
Jee Jee Li committed
487
488
489
            return torch.zeros((0, 2), device=input_ids.device)

        return torch.hstack([
490
491
492
493
            image_start_tokens[:valid_image_nums].unsqueeze(-1),
            image_end_tokens[:valid_image_nums].unsqueeze(-1),
        ])

Jee Jee Li's avatar
Jee Jee Li committed
494
495
496
497
    def _parse_and_validate_inputs(
        self,
        input_ids: torch.Tensor,
        **kwargs: object,
498
    ) -> Optional[MiniCPMVImageInputs]:
Jee Jee Li's avatar
Jee Jee Li committed
499
500
        pixel_values = kwargs.pop("pixel_values", [])
        tgt_sizes = kwargs.pop("tgt_sizes", [])
501
502
503
504
505
506
507
508
509
510
511
512
513
514
        im_start_id = kwargs.pop("im_start_id", None)
        im_end_id = kwargs.pop("im_end_id", None)
        slice_start_id = kwargs.pop("slice_start_id", None)
        slice_end_id = kwargs.pop("slice_end_id", None)
        image_embeds = kwargs.pop("image_embeds", None)

        if image_embeds is not None:
            return MiniCPMVImageEmbeddingInputs(
                image_bounds=self._get_image_bounds(input_ids, im_start_id,
                                                    im_end_id, slice_start_id,
                                                    slice_end_id),
                data=image_embeds,
                type="image_embeds",
            )
Jee Jee Li's avatar
Jee Jee Li committed
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529

        if not isinstance(pixel_values, (torch.Tensor, list)):
            raise ValueError("Incorrect type of pixel values. "
                             f"Got type: {type(pixel_values)}")

        if not isinstance(tgt_sizes, (torch.Tensor, list)):
            raise ValueError("Incorrect type of target sizes. "
                             f"Got type: {type(tgt_sizes)}")

        if len(pixel_values) != len(tgt_sizes):
            raise ValueError("Inconsistent batch lengths, found: "
                             f"{len(pixel_values)} vs. {len(tgt_sizes)}")

        pixel_values_flat: List[torch.Tensor] = []
        tgt_sizes_flat: List[torch.Tensor] = []
530
531
532
533
534
535
536
537
        for pixel_b, tgt_b in zip(pixel_values, tgt_sizes):
            if len(pixel_b) != len(tgt_b):
                raise ValueError("Inconsistent N lengths, found: "
                                 f"{len(pixel_b)} vs {len(tgt_b)}")

            for pixel_n, tgt_n in zip(pixel_b, tgt_b):
                pixel_values_flat += pixel_n
                tgt_sizes_flat += tgt_n
Jee Jee Li's avatar
Jee Jee Li committed
538
539
540
541
542
543
544
545
546
547
548

        # NOTE: Input IDs does not contain image tokens during memory profiling,
        # so we allow it to be empty
        if len(pixel_values_flat) != len(tgt_sizes_flat):
            raise ValueError("Inconsistent flattened lengths, found: "
                             f"{len(pixel_values_flat)} vs. "
                             f"{len(tgt_sizes_flat)}")

        if len(pixel_values_flat) == 0:
            return None

549
550
551
552
553
554
555
        if im_start_id is None:
            return None

        return MiniCPMVImagePixelInputs(
            image_bounds=self._get_image_bounds(input_ids, im_start_id,
                                                im_end_id, slice_start_id,
                                                slice_end_id),
556
            data=pixel_values_flat,
Jee Jee Li's avatar
Jee Jee Li committed
557
            tgt_sizes=torch.stack(tgt_sizes_flat),
558
            type="pixel_values",
Jee Jee Li's avatar
Jee Jee Li committed
559
        )
560
561
562
563
564
565
566
567

    def forward(
        self,
        input_ids: torch.Tensor,
        positions: torch.Tensor,
        kv_caches: List[torch.Tensor],
        attn_metadata: AttentionMetadata,
        intermediate_tensors: Optional[IntermediateTensors] = None,
Jee Jee Li's avatar
Jee Jee Li committed
568
569
        **kwargs: Any,
    ) -> torch.Tensor:
570
571
572
573
        if intermediate_tensors is not None:
            vlm_embeddings = None
        else:
            image_inputs = self._parse_and_validate_inputs(input_ids, **kwargs)
Jee Jee Li's avatar
Jee Jee Li committed
574

575
            vlm_embeddings, _ = self.get_embedding(input_ids, image_inputs)
Jee Jee Li's avatar
Jee Jee Li committed
576

577
578
579
580
581
        # always pass the input via `inputs_embeds`
        # to make sure the computation graph is consistent
        # for `torch.compile` integration
        input_ids = None

Jee Jee Li's avatar
Jee Jee Li committed
582
        output = self.llm(
583
            input_ids=input_ids,
Jee Jee Li's avatar
Jee Jee Li committed
584
585
586
587
588
589
            positions=positions,
            kv_caches=kv_caches,
            attn_metadata=attn_metadata,
            intermediate_tensors=intermediate_tensors,
            inputs_embeds=vlm_embeddings,
        )
590
591
        return output

592
593
594
595
596
    def compute_logits(
        self,
        hidden_states: torch.Tensor,
        sampling_metadata: SamplingMetadata,
    ) -> Optional[torch.Tensor]:
Alphi's avatar
Alphi committed
597
598
599
        logits = self.logits_processor(self.lm_head, hidden_states,
                                       sampling_metadata)
        return logits
600
601
602
603
604
605

    def sample(
        self,
        logits: torch.Tensor,
        sampling_metadata: SamplingMetadata,
    ) -> Optional[SamplerOutput]:
Alphi's avatar
Alphi committed
606
        next_tokens = self.sampler(logits, sampling_metadata)
607
608
609
610
611
612
613
614
615
616
617
618
619
        return next_tokens

    def load_weights(self, weights: Iterable[Tuple[str, torch.Tensor]]):
        stacked_params_mapping = [
            # (param_name, shard_name, shard_id)
            ("qkv_proj", "q_proj", "q"),
            ("qkv_proj", "k_proj", "k"),
            ("qkv_proj", "v_proj", "v"),
            ("gate_up_proj", "gate_proj", 0),
            ("gate_up_proj", "up_proj", 1),
        ]
        params_dict = dict(self.named_parameters())
        for name, loaded_weight in weights:
Alphi's avatar
Alphi committed
620
621
622
            for key_to_modify, new_key in _KEYS_TO_MODIFY_MAPPING.items():
                if key_to_modify in name:
                    name = name.replace(key_to_modify, new_key)
623
624
625
626
627
628
629
630
            if "rotary_emb.inv_freq" in name:
                continue
            if ("rotary_emb.cos_cached" in name
                    or "rotary_emb.sin_cached" in name):
                # Models trained using ColossalAI may include these tensors in
                # the checkpoint. Skip them.
                continue
            use_default_weight_loading = False
Jee Jee Li's avatar
Jee Jee Li committed
631
            if self.is_default_weight_loading(name):
632
633
                use_default_weight_loading = True
            else:
Jee Jee Li's avatar
Jee Jee Li committed
634
                for param_name, weight_name, shard_id in stacked_params_mapping:
635
636
                    if weight_name not in name:
                        continue
637
638
639
                    if is_pp_missing_parameter(
                            name.replace(weight_name, param_name), self):
                        continue
640
641
642
643
644
645
646
                    param = params_dict[name.replace(weight_name, param_name)]
                    weight_loader = param.weight_loader
                    weight_loader(param, loaded_weight, shard_id)
                    break
                else:
                    use_default_weight_loading = True
            if use_default_weight_loading:
647
648
                if is_pp_missing_parameter(name, self):
                    continue
649
650
651
652
                param = params_dict[name]
                weight_loader = getattr(param, "weight_loader",
                                        default_weight_loader)
                weight_loader(param, loaded_weight)
Jee Jee Li's avatar
Jee Jee Li committed
653

654
655
656
657
658
659
660
661
    def get_mm_mapping(self) -> MultiModelKeys:
        """
        Get the module prefix in multimodal models
        """
        return MultiModelKeys.from_string_field(language_model="llm",
                                                connector="resampler",
                                                tower_model="vpm")

Jee Jee Li's avatar
Jee Jee Li committed
662
663
    def init_llm(
        self,
664
        vllm_config: VllmConfig,
665
        prefix: str = "",
Jee Jee Li's avatar
Jee Jee Li committed
666
667
668
    ) -> nn.Module:
        raise NotImplementedError

669
670
671
672
    def init_vision_module(
        self,
        config: PretrainedConfig,
        quant_config: Optional[QuantizationConfig],
673
        prefix: str = "",
674
    ) -> nn.Module:
Jee Jee Li's avatar
Jee Jee Li committed
675
676
        raise NotImplementedError

677
678
679
680
681
    def init_resampler(self,
                       embed_dim: int,
                       vision_dim: int,
                       quant_config: Optional[QuantizationConfig] = None,
                       prefix: str = "") -> nn.Module:
Jee Jee Li's avatar
Jee Jee Li committed
682
683
684
685
686
687
688
689
690
691
        raise NotImplementedError

    def get_vision_embedding(
        self,
        pixel_values: List[torch.Tensor],
        patch_attn_mask: Optional[torch.Tensor] = None,
        tgt_sizes: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        raise NotImplementedError

692
693
    def get_vision_hidden_states(self,
                                 data: MiniCPMVImageInputs) -> torch.Tensor:
Jee Jee Li's avatar
Jee Jee Li committed
694
695
696
697
698
699
        raise NotImplementedError

    def is_default_weight_loading(self, name: str) -> bool:
        raise NotImplementedError


700
class MiniCPMV2_0(MiniCPMVBaseModel):
Jee Jee Li's avatar
Jee Jee Li committed
701
702
703

    def __init__(
        self,
704
705
        vllm_config: VllmConfig,
        prefix: str = "",
Jee Jee Li's avatar
Jee Jee Li committed
706
    ):
707
        super().__init__(vllm_config)
Jee Jee Li's avatar
Jee Jee Li committed
708
709
710
711
        assert self.version == (2, 0)

    def init_llm(
        self,
712
        vllm_config: VllmConfig,
713
        prefix: str = "",
Jee Jee Li's avatar
Jee Jee Li committed
714
    ) -> nn.Module:
715
        return LLMWrapper(MiniCPMModel(vllm_config=vllm_config, prefix=prefix),
716
                          name="model")
Jee Jee Li's avatar
Jee Jee Li committed
717

718
719
720
721
    def init_vision_module(
        self,
        config: PretrainedConfig,
        quant_config: Optional[QuantizationConfig],
722
        prefix: str = "",
723
    ) -> nn.Module:
Jee Jee Li's avatar
Jee Jee Li committed
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
        # TODO :refactor this vision model
        try:
            import timm
        except ImportError:
            raise ImportError("Please install timm==0.9.10") from ImportError
        with set_default_torch_dtype(torch.float16):
            model = timm.create_model(
                "vit_so400m_patch14_siglip_384.webli",
                pretrained=False,
                num_classes=0,
                dynamic_img_size=True,
                dynamic_img_pad=True,
            )

        if (isinstance(model, timm.models.VisionTransformer)
                and model.attn_pool is not None):
            model.attn_pool = torch.nn.Identity()

        if self.config.drop_vision_last_layer:
            model.blocks = model.blocks[:-1]

        return model

747
748
749
    def get_input_embeddings(self, input_ids: torch.Tensor) -> torch.Tensor:
        return self.model.embed_tokens(input_ids)

750
751
752
753
754
    def init_resampler(self,
                       embed_dim: int,
                       vision_dim: int,
                       quant_config: Optional[QuantizationConfig] = None,
                       prefix: str = "") -> nn.Module:
Jee Jee Li's avatar
Jee Jee Li committed
755
        with set_default_torch_dtype(torch.float16):
756
757
758
759
760
761
762
763
764
            resampler = Resampler2(embed_dim=embed_dim,
                                   num_heads=embed_dim // 128,
                                   grid_size=int(
                                       math.sqrt(self.config.query_num)),
                                   kv_dim=vision_dim,
                                   adaptive=False,
                                   do_post_projection=True,
                                   quant_config=quant_config,
                                   prefix=prefix)
Jee Jee Li's avatar
Jee Jee Li committed
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790

        return resampler

    def get_vision_embedding(
        self,
        pixel_values: List[torch.Tensor],
        patch_attn_mask: Optional[torch.Tensor] = None,
        tgt_sizes: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        res = []
        dtype = self.vpm.pos_embed.data.dtype
        for pixel_value in pixel_values:
            H, W = pixel_value[0].shape[-2:]
            tgt_size = (
                math.ceil(H / self.vpm.patch_embed.patch_size[0]),
                math.ceil(W / self.vpm.patch_embed.patch_size[0]),
            )
            vision_embedding = self.vpm.forward_features(
                pixel_value.unsqueeze(0).type(dtype))
            if (hasattr(self.vpm, "num_prefix_tokens")
                    and self.vpm.num_prefix_tokens > 0):
                vision_embedding = vision_embedding[:, self.vpm.
                                                    num_prefix_tokens:]
            res.append(self.resampler(vision_embedding, tgt_size))
        return torch.vstack(res)

791
792
793
    def get_vision_hidden_states(self,
                                 data: MiniCPMVImageInputs) -> torch.Tensor:
        pixel_values = data["data"]
Jee Jee Li's avatar
Jee Jee Li committed
794
795
796
797
798
799
800

        return self.get_vision_embedding(pixel_values)

    def is_default_weight_loading(self, name: str) -> bool:
        return "resampler" in name or "vpm" in name


801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
class MiniCPMV2_5(MiniCPMVBaseModel, SupportsLoRA):
    packed_modules_mapping = {
        "qkv_proj": [
            "q_proj",
            "k_proj",
            "v_proj",
        ],
        "gate_up_proj": [
            "gate_proj",
            "up_proj",
        ],
    }
    # LoRA specific attributes
    supported_lora_modules = [
        # vision encoder
        "fc1",
        "fc2",
        "out_proj",
        # language model
        "qkv_proj",  # same name with vision encoder
        "o_proj",
        "gate_up_proj",
        "down_proj",
        # resampler
        "kv_proj",
    ]
827
828
829
830
831
832
833
834
835
836

    # BitandBytes specific attributes
    default_bitsandbytes_target_modules = [
        ".gate_proj.",
        ".down_proj.",
        ".up_proj.",
        ".q_proj.",
        ".k_proj.",
        ".v_proj.",
        ".o_proj.",
837
838
839
840
841
842
843
844
845
846
        # vision encoder
        ".fc1.",
        ".fc2.",
        # Currently, vllm does not support BNB quantization for the `out_proj`
        # of the resampler, so it's necessary to distinguish between the
        # vision encoder and the resampler's out_proj. The same applies to
        # MiniCPMV2_6.
        ".self_attn.out_proj.",  #  vision encoder out_proj
        # resampler
        ".kv_proj.",
847
848
849
850
851
852
853
854
855
856
    ]
    bitsandbytes_stacked_params_mapping = {
        # shard_name, weight_name, index
        "q_proj": ("qkv_proj", 0),
        "k_proj": ("qkv_proj", 1),
        "v_proj": ("qkv_proj", 2),
        "gate_proj": ("gate_up_proj", 0),
        "up_proj": ("gate_up_proj", 1),
    }

857
858
    embedding_modules = {}
    embedding_padding_modules = []
Jee Jee Li's avatar
Jee Jee Li committed
859
860
861

    def __init__(
        self,
862
863
        vllm_config: VllmConfig,
        prefix: str = "",
Jee Jee Li's avatar
Jee Jee Li committed
864
    ):
865
        super().__init__(vllm_config)
Jee Jee Li's avatar
Jee Jee Li committed
866
867
868
869
        assert self.version == (2, 5)

    def init_llm(
        self,
870
        vllm_config: VllmConfig,
871
        prefix: str = "",
Jee Jee Li's avatar
Jee Jee Li committed
872
    ) -> nn.Module:
873
        return LLMWrapper(LlamaModel(vllm_config=vllm_config, prefix=prefix),
874
                          name="model")
Jee Jee Li's avatar
Jee Jee Li committed
875

876
877
878
879
    def init_vision_module(
        self,
        config: PretrainedConfig,
        quant_config: Optional[QuantizationConfig],
880
        prefix: str = "",
881
882
    ) -> nn.Module:
        model = Idefics2VisionTransformer(config.vision_config,
883
884
                                          quant_config=quant_config,
                                          prefix=prefix)
Jee Jee Li's avatar
Jee Jee Li committed
885
886
887
888
        if self.config.drop_vision_last_layer:
            model.encoder.layers = model.encoder.layers[:-1]
        return model

889
890
891
892
893
    def init_resampler(self,
                       embed_dim: int,
                       vision_dim: int,
                       quant_config: Optional[QuantizationConfig] = None,
                       prefix: str = "") -> nn.Module:
Jee Jee Li's avatar
Jee Jee Li committed
894
        with set_default_torch_dtype(torch.float16):
895
896
897
898
899
900
            resampler = Resampler2_5(num_queries=self.config.query_num,
                                     embed_dim=embed_dim,
                                     num_heads=embed_dim // 128,
                                     kv_dim=vision_dim,
                                     quant_config=quant_config,
                                     prefix=prefix)
Jee Jee Li's avatar
Jee Jee Li committed
901
902
903
904
905
906
907
908
909
910
911
912
913
        return resampler

    def get_vision_embedding(
        self,
        pixel_values: List[torch.Tensor],
        patch_attn_mask: Optional[torch.Tensor] = None,
        tgt_sizes: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        vision_embedding = self.vpm(pixel_values,
                                    patch_attention_mask=patch_attn_mask)
        vision_embedding = self.resampler(vision_embedding, tgt_sizes)
        return vision_embedding

914
915
916
    def get_vision_hidden_states(self,
                                 data: MiniCPMVImageInputs) -> torch.Tensor:
        pixel_values = data["data"]
Jee Jee Li's avatar
Jee Jee Li committed
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
        tgt_sizes = data["tgt_sizes"]

        device = self.vpm.embeddings.position_embedding.weight.device
        dtype = self.vpm.embeddings.position_embedding.weight.dtype
        all_pixel_values_lst = [
            i.flatten(end_dim=1).permute(1, 0) for i in pixel_values
        ]

        max_patches = (tgt_sizes[:, 0] * tgt_sizes[:, 1]).max().item()
        assert isinstance(max_patches, int)

        all_pixel_values = torch.nn.utils.rnn.pad_sequence(
            all_pixel_values_lst, batch_first=True, padding_value=0.0)
        B, L, _ = all_pixel_values.shape
        all_pixel_values = all_pixel_values.permute(0, 2,
                                                    1).reshape(B, 3, -1, L)

        patch_attn_mask = torch.zeros((B, 1, max_patches),
                                      dtype=torch.bool,
                                      device=device)
        for i in range(B):
            patch_attn_mask[i, :tgt_sizes[i][0] * tgt_sizes[i][1]] = True

        return self.get_vision_embedding(all_pixel_values.type(dtype),
                                         patch_attn_mask, tgt_sizes)

    def is_default_weight_loading(self, name: str) -> bool:
        return "resampler" in name


947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
class MiniCPMV2_6(MiniCPMVBaseModel, SupportsLoRA):
    packed_modules_mapping = {
        "qkv_proj": [
            "q_proj",
            "k_proj",
            "v_proj",
        ],
        "gate_up_proj": [
            "gate_proj",
            "up_proj",
        ],
    }
    # LoRA specific attributes
    supported_lora_modules = [
        # vision encoder
        "fc1",
        "fc2",
        "out_proj",
        # language model
        "qkv_proj",  # same name with vision encoder
        "o_proj",
        "gate_up_proj",
        "down_proj",
        # resampler
        "kv_proj",
    ]

974
975
976
977
978
979
980
981
982
    # BitandBytes specific attributes
    default_bitsandbytes_target_modules = [
        ".gate_proj.",
        ".down_proj.",
        ".up_proj.",
        ".q_proj.",
        ".k_proj.",
        ".v_proj.",
        ".o_proj.",
983
984
985
986
987
988
        # vision encoder
        ".fc1.",
        ".fc2.",
        ".self_attn.out_proj.",
        # resampler
        ".kv_proj.",
989
990
991
992
993
994
995
996
997
998
    ]
    bitsandbytes_stacked_params_mapping = {
        # shard_name, weight_name, index
        "q_proj": ("qkv_proj", 0),
        "k_proj": ("qkv_proj", 1),
        "v_proj": ("qkv_proj", 2),
        "gate_proj": ("gate_up_proj", 0),
        "up_proj": ("gate_up_proj", 1),
    }

999
1000
    embedding_modules = {}
    embedding_padding_modules = []
Jee Jee Li's avatar
Jee Jee Li committed
1001
1002
1003

    def __init__(
        self,
1004
1005
        vllm_config: VllmConfig,
        prefix: str = "",
Jee Jee Li's avatar
Jee Jee Li committed
1006
    ):
1007
        super().__init__(vllm_config)
1008
        assert self.version == (2, 6)
Jee Jee Li's avatar
Jee Jee Li committed
1009
1010
1011

    def init_llm(
        self,
1012
        vllm_config: VllmConfig,
1013
        prefix: str = "",
Jee Jee Li's avatar
Jee Jee Li committed
1014
    ) -> nn.Module:
1015
        return LLMWrapper(Qwen2Model(vllm_config=vllm_config, prefix=prefix),
1016
                          name="model")
Jee Jee Li's avatar
Jee Jee Li committed
1017

1018
1019
1020
1021
    def init_vision_module(
        self,
        config: PretrainedConfig,
        quant_config: Optional[QuantizationConfig],
1022
        prefix: str = "",
1023
1024
    ) -> nn.Module:
        model = Idefics2VisionTransformer(config.vision_config,
1025
1026
                                          quant_config=quant_config,
                                          prefix=prefix)
Jee Jee Li's avatar
Jee Jee Li committed
1027
1028
1029
1030
        if self.config.drop_vision_last_layer:
            model.encoder.layers = model.encoder.layers[:-1]
        return model

1031
1032
1033
1034
1035
    def init_resampler(self,
                       embed_dim: int,
                       vision_dim: int,
                       quant_config: Optional[QuantizationConfig] = None,
                       prefix: str = "") -> nn.Module:
Jee Jee Li's avatar
Jee Jee Li committed
1036
        with set_default_torch_dtype(torch.float16):
1037
            # The resampler in 2.6 remains consistent with the one in 2.5.
1038
1039
1040
1041
1042
1043
            resampler = Resampler2_5(num_queries=self.config.query_num,
                                     embed_dim=embed_dim,
                                     num_heads=embed_dim // 128,
                                     kv_dim=vision_dim,
                                     quant_config=quant_config,
                                     prefix=prefix)
Jee Jee Li's avatar
Jee Jee Li committed
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
        return resampler

    def get_vision_embedding(
        self,
        pixel_values: List[torch.Tensor],
        patch_attn_mask: Optional[torch.Tensor] = None,
        tgt_sizes: Optional[torch.Tensor] = None,
    ) -> torch.Tensor:
        vision_embedding = self.vpm(
            pixel_values,
            patch_attention_mask=patch_attn_mask,
            tgt_sizes=tgt_sizes,
1056
        )
Jee Jee Li's avatar
Jee Jee Li committed
1057
1058
        return vision_embedding

1059
1060
1061
    def get_vision_hidden_states(self,
                                 data: MiniCPMVImageInputs) -> torch.Tensor:
        pixel_values = data["data"]
Jee Jee Li's avatar
Jee Jee Li committed
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
        tgt_sizes = data["tgt_sizes"]

        device = self.vpm.embeddings.position_embedding.weight.device
        dtype = self.vpm.embeddings.position_embedding.weight.dtype
        all_pixel_values_lst = [
            i.flatten(end_dim=1).permute(1, 0) for i in pixel_values
        ]

        max_patches = (tgt_sizes[:, 0] * tgt_sizes[:, 1]).max().item()
        assert isinstance(max_patches, int)

        all_pixel_values = torch.nn.utils.rnn.pad_sequence(
            all_pixel_values_lst, batch_first=True, padding_value=0.0)
        B, L, _ = all_pixel_values.shape
        all_pixel_values = all_pixel_values.permute(0, 2,
                                                    1).reshape(B, 3, -1, L)

        patch_attn_mask = torch.zeros((B, 1, max_patches),
                                      dtype=torch.bool,
                                      device=device)
        for i in range(B):
            patch_attn_mask[i, 0, :tgt_sizes[i][0] * tgt_sizes[i][1]] = True
        vision_embedding = self.vpm(
            all_pixel_values.type(dtype),
            patch_attention_mask=patch_attn_mask,
            tgt_sizes=tgt_sizes,
1088
        )
Jee Jee Li's avatar
Jee Jee Li committed
1089
1090
1091
1092

        return self.resampler(vision_embedding, tgt_sizes)

    def is_default_weight_loading(self, name: str) -> bool:
1093
        return "resampler" in name
Jee Jee Li's avatar
Jee Jee Li committed
1094
1095


1096
1097
1098
1099
1100
1101
1102
_SUPPORT_VERSION = {
    (2, 0): MiniCPMV2_0,
    (2, 5): MiniCPMV2_5,
    (2, 6): MiniCPMV2_6
}


1103
@MULTIMODAL_REGISTRY.register_image_input_mapper(input_mapper_for_minicpmv)
Jee Jee Li's avatar
Jee Jee Li committed
1104
1105
1106
@MULTIMODAL_REGISTRY.register_max_image_tokens(get_max_minicpmv_image_tokens)
@INPUT_REGISTRY.register_dummy_data(dummy_data_for_minicpmv)
@INPUT_REGISTRY.register_input_processor(input_processor_for_minicpmv)
1107
class MiniCPMV(MiniCPMVBaseModel, SupportsLoRA):
Jee Jee Li's avatar
Jee Jee Li committed
1108
1109
1110
1111
1112
    """
    Different versions of MiniCPMV use different visual encoders and LLMs,
    which is not conducive to the current integration logic of LoRA and
    bitsandbytes in vLLM. Therefore, it is necessary to separate them.
    """
1113
1114
1115
1116
1117
1118
1119
    # Ensure that the LoRA support check passes when the class is not
    # initialized, but set all these attributes to empty.
    packed_modules_mapping = {}
    supported_lora_modules = []
    embedding_modules = {}
    embedding_padding_modules = []

1120
1121
    def __new__(cls, vllm_config: VllmConfig, prefix: str = ""):
        config = vllm_config.model_config.hf_config
Jee Jee Li's avatar
Jee Jee Li committed
1122
1123
1124
1125
1126
1127
1128
1129
1130
        if not hasattr(config, "version"):
            if config.hidden_size == 2304 and config.query_num == 64:
                version = (2, 0)
            else:
                version = (2, 5)
        else:
            version = str(config.version).split(".")
            version = tuple([int(x) for x in version])
        # Dispatch class based on version
1131
        instance_class = _SUPPORT_VERSION.get(version)
1132
1133
1134
        if instance_class is None:
            raise ValueError(
                "Currently, MiniCPMV only supports versions 2.0, 2.5, and 2.6")
1135
        return instance_class(vllm_config=vllm_config, prefix=prefix)