blip.py 11.6 KB
Newer Older
1
# SPDX-License-Identifier: Apache-2.0
2
# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3
"""Minimal implementation of BlipVisionModel intended to be only used
4
within a vision language model."""
5

6
from collections.abc import Iterable
7
8
9
10
11

import torch
import torch.nn as nn
from transformers import Blip2VisionConfig, BlipVisionConfig

12
from vllm.attention.layer import MultiHeadAttention
13
from vllm.distributed import divide, get_tensor_model_parallel_world_size
14
from vllm.model_executor.layers.activation import get_act_fn
15
16
17
18
19
from vllm.model_executor.layers.linear import (
    ColumnParallelLinear,
    QKVParallelLinear,
    RowParallelLinear,
)
20
from vllm.model_executor.layers.quantization import QuantizationConfig
21
from vllm.model_executor.model_loader.weight_utils import default_weight_loader
22

23
24
from .interfaces import SupportsQuant

25
26
27
28
29
30
31

def get_blip_patch_grid_length(*, image_size: int, patch_size: int) -> int:
    assert image_size % patch_size == 0
    return image_size // patch_size


def get_blip_num_patches(*, image_size: int, patch_size: int) -> int:
32
33
34
    grid_length = get_blip_patch_grid_length(
        image_size=image_size, patch_size=patch_size
    )
35
36
37
38
39
    return grid_length * grid_length


# Adapted from https://github.com/huggingface/transformers/blob/v4.39.0/src/transformers/models/blip/modeling_blip.py#L164 # noqa
class BlipVisionEmbeddings(nn.Module):
40
    def __init__(self, config: BlipVisionConfig | Blip2VisionConfig):
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
        super().__init__()

        self.config = config
        self.embed_dim = config.hidden_size
        self.image_size = config.image_size
        self.patch_size = config.patch_size

        self.class_embedding = nn.Parameter(torch.randn(1, 1, self.embed_dim))

        self.patch_embedding = nn.Conv2d(
            in_channels=3,
            out_channels=self.embed_dim,
            kernel_size=self.patch_size,
            stride=self.patch_size,
        )

57
58
59
        self.num_patches = get_blip_num_patches(
            image_size=self.image_size, patch_size=self.patch_size
        )
60
61
62
        self.num_positions = self.num_patches + 1

        self.position_embedding = nn.Parameter(
63
64
            torch.randn(1, self.num_positions, self.embed_dim)
        )
65
66
67
68

    def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
        batch_size = pixel_values.shape[0]
        target_dtype = self.patch_embedding.weight.dtype
69
70
71
        patch_embeds = self.patch_embedding(
            pixel_values.to(dtype=target_dtype)
        )  # shape = [*, width, grid, grid]
72
73
74
75
76
77
        patch_embeds = patch_embeds.flatten(2).transpose(1, 2)

        class_embeds = self.class_embedding.expand(batch_size, 1, -1)
        embeddings = torch.cat([class_embeds, patch_embeds], dim=1)

        position_embeds = self.position_embedding.to(target_dtype)
78
        embeddings = embeddings + position_embeds[:, : embeddings.size(1), :]
79
80
81
82

        return embeddings


83
class BlipAttention(nn.Module):
84
85
86
87
    """Multi-headed attention from 'Attention Is All You Need' paper"""

    def __init__(
        self,
88
89
        config: BlipVisionConfig | Blip2VisionConfig,
        quant_config: QuantizationConfig | None = None,
90
91
        prefix: str = "",
    ) -> None:
92
93
94
95
96
97
98
99
100
        super().__init__()
        self.config = config
        self.embed_dim = config.hidden_size
        self.num_heads = config.num_attention_heads
        self.head_dim = self.embed_dim // self.num_heads
        if self.head_dim * self.num_heads != self.embed_dim:
            raise ValueError(
                "embed_dim must be divisible by num_heads "
                f"(got `embed_dim`: {self.embed_dim} and `num_heads`:"
101
102
                f" {self.num_heads})."
            )
103
104
105
106
107
108
109
110
111
        self.scale = self.head_dim**-0.5
        self.dropout = config.attention_dropout

        self.qkv = QKVParallelLinear(
            self.embed_dim,
            self.head_dim,
            self.num_heads,
            bias=config.qkv_bias,
            quant_config=quant_config,
112
            prefix=f"{prefix}.qkv",
113
114
115
116
117
        )
        self.projection = RowParallelLinear(
            self.embed_dim,
            self.embed_dim,
            quant_config=quant_config,
118
            prefix=f"{prefix}.projection",
119
120
121
122
123
        )

        self.tp_size = get_tensor_model_parallel_world_size()
        self.num_heads_per_partition = divide(self.num_heads, self.tp_size)

124
125
126
        self.attn = MultiHeadAttention(
            self.num_heads_per_partition, self.head_dim, self.scale
        )
127

128
    def _shape(self, tensor: torch.Tensor, seq_len: int, bsz: int):
129
130
131
132
133
        return (
            tensor.view(bsz, seq_len, self.num_heads, self.head_dim)
            .transpose(1, 2)
            .contiguous()
        )
134
135
136
137
138
139
140
141
142

    def forward(
        self,
        hidden_states: torch.Tensor,
    ):
        """Input shape: Batch x Time x Channel"""

        qkv_states, _ = self.qkv(hidden_states)
        query_states, key_states, value_states = qkv_states.chunk(3, dim=-1)
143
        out = self.attn(query_states, key_states, value_states)
144
145
        attn_output, _ = self.projection(out)

146
        return attn_output, None
147
148


149
class BlipMLP(nn.Module):
150
151
152
    def __init__(
        self,
        config: BlipVisionConfig,
153
        quant_config: QuantizationConfig | None = None,
154
155
        prefix: str = "",
    ) -> None:
156
157
158
159
160
        super().__init__()

        self.config = config

        self.activation_fn = get_act_fn(config.hidden_act)
161
162
163
164
165
166
167
168
169
170
171
172
173
174
        self.fc1 = ColumnParallelLinear(
            config.hidden_size,
            config.intermediate_size,
            bias=True,
            quant_config=quant_config,
            prefix=f"{prefix}.fc1",
        )
        self.fc2 = RowParallelLinear(
            config.intermediate_size,
            config.hidden_size,
            bias=True,
            quant_config=quant_config,
            prefix=f"{prefix}.fc2",
        )
175
176
177
178
179
180
181
182
183
184

    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
        hidden_states, _ = self.fc1(hidden_states)
        hidden_states = self.activation_fn(hidden_states)
        hidden_states, _ = self.fc2(hidden_states)

        return hidden_states


class BlipEncoderLayer(nn.Module):
185
186
187
    def __init__(
        self,
        config: BlipVisionConfig,
188
        quant_config: QuantizationConfig | None = None,
189
190
        prefix: str = "",
    ) -> None:
191
192
        super().__init__()

193
        # fallback to sdpa attention if tp unavailable
194
195
196
197
198
        self.self_attn = BlipAttention(
            config,
            quant_config=quant_config,
            prefix=f"{prefix}.self_attn",
        )
199
200
201
        self.layer_norm1 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
        self.mlp = BlipMLP(config, quant_config=quant_config, prefix=f"{prefix}.mlp")
        self.layer_norm2 = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
202
203
204
205
206

    def forward(self, hidden_states: torch.Tensor) -> torch.Tensor:
        residual = hidden_states

        hidden_states = self.layer_norm1(hidden_states)
207
        hidden_states, _ = self.self_attn(hidden_states=hidden_states)
208
209
210
211
212
213
214
215
216
217
218
219
        hidden_states = residual + hidden_states

        residual = hidden_states
        hidden_states = self.layer_norm2(hidden_states)
        hidden_states = self.mlp(hidden_states)
        hidden_states = residual + hidden_states

        return hidden_states


class BlipEncoder(nn.Module):
    """
220
    Transformer encoder consisting of `config.num_hidden_layers` self
221
222
223
224
225
226
    attention layers. Each layer is a [`BlipEncoderLayer`].

    Args:
        config: BlipConfig
    """

227
228
229
    def __init__(
        self,
        config: BlipVisionConfig,
230
231
        quant_config: QuantizationConfig | None = None,
        num_hidden_layers_override: int | None = None,
232
233
        prefix: str = "",
    ) -> None:
234
235
236
237
238
239
240
241
242
        super().__init__()

        self.config = config

        if num_hidden_layers_override is None:
            num_hidden_layers = config.num_hidden_layers
        else:
            num_hidden_layers = num_hidden_layers_override

243
244
245
246
247
248
249
250
251
252
        self.layers = nn.ModuleList(
            [
                BlipEncoderLayer(
                    config=config,
                    quant_config=quant_config,
                    prefix=f"{prefix}.layers.{layer_idx}",
                )
                for layer_idx in range(num_hidden_layers)
            ]
        )
253
254
255
256
257
258
259
260
261

    def forward(self, inputs_embeds: torch.Tensor):
        hidden_states = inputs_embeds
        for encoder_layer in self.layers:
            hidden_states = encoder_layer(hidden_states)

        return hidden_states


262
class BlipVisionModel(nn.Module, SupportsQuant):
263
264
    config_class = BlipVisionConfig
    main_input_name = "pixel_values"
265
    packed_modules_mapping = {"qkv_proj": ["q_proj", "k_proj", "v_proj"]}
266

267
268
269
    def __init__(
        self,
        config: BlipVisionConfig,
270
        quant_config: QuantizationConfig | None = None,
271
        *,
272
273
        num_hidden_layers_override: int | None = None,
        require_post_norm: bool | None = None,
274
275
        prefix: str = "",
    ) -> None:
276
277
278
279
280
281
282
283
        super().__init__()
        self.config = config

        self.embeddings = BlipVisionEmbeddings(config)
        self.encoder = BlipEncoder(
            config=config,
            quant_config=quant_config,
            num_hidden_layers_override=num_hidden_layers_override,
284
            prefix=f"{prefix}.encoder",
285
        )
286

287
        num_hidden_layers = config.num_hidden_layers
288
289
        if len(self.encoder.layers) > config.num_hidden_layers:
            raise ValueError(
290
                f"The original encoder only has {num_hidden_layers} "
291
292
                f"layers, but you requested {len(self.encoder.layers)} layers."
            )
293
294
295
296
297
298

        # If possible, skip post_layernorm to conserve memory
        if require_post_norm is None:
            require_post_norm = len(self.encoder.layers) == num_hidden_layers

        if require_post_norm:
299
300
301
            self.post_layernorm = nn.LayerNorm(
                config.hidden_size, eps=config.layer_norm_eps
            )
302
303
        else:
            self.post_layernorm = None
304
305
306
307
308

    def forward(self, pixel_values: torch.Tensor) -> torch.Tensor:
        hidden_states = self.embeddings(pixel_values)
        hidden_states = self.encoder(inputs_embeds=hidden_states)

309
310
311
        if self.post_layernorm is None:
            return hidden_states

312
        return self.post_layernorm(hidden_states)
313

314
    def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
315
316
317
318
319
        stacked_params_mapping = [
            # (param_name, shard_name, shard_id)
            ("qkv_proj", "q_proj", "q"),
            ("qkv_proj", "k_proj", "k"),
            ("qkv_proj", "v_proj", "v"),
320
        ]
321
        params_dict = dict(self.named_parameters())
322
        loaded_params: set[str] = set()
323
324
325
326
        layer_count = len(self.encoder.layers)

        for name, loaded_weight in weights:
            # post_layernorm is not needed in BlipVisionModel
327
            if name.startswith("post_layernorm") and self.post_layernorm is None:
328
329
330
331
332
333
334
335
                continue

            # omit layers when num_hidden_layers_override is set
            if name.startswith("encoder.layers"):
                layer_idx = int(name.split(".")[2])
                if layer_idx >= layer_count:
                    continue

336
            for param_name, weight_name, shard_id in stacked_params_mapping:
337
338
                if weight_name not in name:
                    continue
339
340
                name = name.replace(weight_name, param_name)
                param = params_dict[name]
341
342
343
344
345
                weight_loader = param.weight_loader
                weight_loader(param, loaded_weight, shard_id)
                break
            else:
                param = params_dict[name]
346
                weight_loader = getattr(param, "weight_loader", default_weight_loader)
347
                weight_loader(param, loaded_weight)
348
349
            loaded_params.add(name)
        return loaded_params