Convert formatting to use ruff instead of yapf + isort (#26247)
Signed-off-by: Harry Mellor <19981378+hmellor@users.noreply.github.com>
This commit is contained in:
+254
-214
@@ -13,8 +13,7 @@ from einops import rearrange
|
||||
from transformers import PretrainedConfig
|
||||
from transformers.activations import GELUActivation
|
||||
from transformers.feature_extraction_utils import BatchFeature
|
||||
from transformers.modeling_outputs import (BaseModelOutput,
|
||||
BaseModelOutputWithPooling)
|
||||
from transformers.modeling_outputs import BaseModelOutput, BaseModelOutputWithPooling
|
||||
from transformers.utils import torch_int
|
||||
|
||||
from vllm.attention.backends.registry import _Backend
|
||||
@@ -23,33 +22,57 @@ from vllm.config import VllmConfig
|
||||
from vllm.config.multimodal import BaseDummyOptions
|
||||
from vllm.distributed import get_tensor_model_parallel_world_size
|
||||
from vllm.logger import init_logger
|
||||
from vllm.model_executor.layers.linear import (ColumnParallelLinear,
|
||||
QKVParallelLinear,
|
||||
RowParallelLinear)
|
||||
from vllm.model_executor.layers.linear import (
|
||||
ColumnParallelLinear,
|
||||
QKVParallelLinear,
|
||||
RowParallelLinear,
|
||||
)
|
||||
from vllm.model_executor.layers.quantization import QuantizationConfig
|
||||
from vllm.model_executor.model_loader.weight_utils import (
|
||||
default_weight_loader, maybe_remap_kv_scale_name)
|
||||
default_weight_loader,
|
||||
maybe_remap_kv_scale_name,
|
||||
)
|
||||
from vllm.model_executor.models.module_mapping import MultiModelKeys
|
||||
from vllm.multimodal import MULTIMODAL_REGISTRY
|
||||
from vllm.multimodal.inputs import (ImageItem, ModalityData,
|
||||
MultiModalDataDict, MultiModalFieldConfig,
|
||||
MultiModalKwargsItems, VideoItem)
|
||||
from vllm.multimodal.parse import (DictEmbeddingItems, ImageSize,
|
||||
ModalityDataItems, MultiModalDataItems,
|
||||
MultiModalDataParser)
|
||||
from vllm.multimodal.processing import (BaseMultiModalProcessor,
|
||||
BaseProcessingInfo, PromptReplacement,
|
||||
PromptUpdate)
|
||||
from vllm.multimodal.inputs import (
|
||||
ImageItem,
|
||||
ModalityData,
|
||||
MultiModalDataDict,
|
||||
MultiModalFieldConfig,
|
||||
MultiModalKwargsItems,
|
||||
VideoItem,
|
||||
)
|
||||
from vllm.multimodal.parse import (
|
||||
DictEmbeddingItems,
|
||||
ImageSize,
|
||||
ModalityDataItems,
|
||||
MultiModalDataItems,
|
||||
MultiModalDataParser,
|
||||
)
|
||||
from vllm.multimodal.processing import (
|
||||
BaseMultiModalProcessor,
|
||||
BaseProcessingInfo,
|
||||
PromptReplacement,
|
||||
PromptUpdate,
|
||||
)
|
||||
from vllm.multimodal.profiling import BaseDummyInputsBuilder
|
||||
from vllm.sequence import IntermediateTensors
|
||||
from vllm.utils.tensor_schema import TensorSchema, TensorShape
|
||||
|
||||
from .interfaces import (MultiModalEmbeddings, SupportsLoRA,
|
||||
SupportsMultiModal, SupportsPP)
|
||||
from .interfaces import (
|
||||
MultiModalEmbeddings,
|
||||
SupportsLoRA,
|
||||
SupportsMultiModal,
|
||||
SupportsPP,
|
||||
)
|
||||
from .siglip import SiglipMLP
|
||||
from .utils import (AutoWeightsLoader, WeightsMapper,
|
||||
init_vllm_registered_model, is_pp_missing_parameter,
|
||||
maybe_prefix)
|
||||
from .utils import (
|
||||
AutoWeightsLoader,
|
||||
WeightsMapper,
|
||||
init_vllm_registered_model,
|
||||
is_pp_missing_parameter,
|
||||
maybe_prefix,
|
||||
)
|
||||
from .vision import get_vit_attn_backend
|
||||
|
||||
logger = init_logger(__name__)
|
||||
@@ -81,8 +104,10 @@ def smart_resize(
|
||||
width = factor
|
||||
|
||||
if max(height, width) / min(height, width) > 200:
|
||||
raise ValueError("absolute aspect ratio must be smaller than 200, got "
|
||||
"{max(height, width) / min(height, width)}")
|
||||
raise ValueError(
|
||||
"absolute aspect ratio must be smaller than 200, got "
|
||||
"{max(height, width) / min(height, width)}"
|
||||
)
|
||||
h_bar = round(height / factor) * factor
|
||||
w_bar = round(width / factor) * factor
|
||||
if h_bar * w_bar > max_pixels:
|
||||
@@ -105,10 +130,11 @@ class KeyeImagePixelInputs(TensorSchema):
|
||||
- ni: Number of images
|
||||
- g: Grid dimensions (3 for t, h, w)
|
||||
"""
|
||||
|
||||
type: Literal["pixel_values"]
|
||||
pixel_values: Annotated[
|
||||
torch.Tensor,
|
||||
TensorShape("bnp", 3, "ps", "ps", dynamic_dims={"bnp"})]
|
||||
torch.Tensor, TensorShape("bnp", 3, "ps", "ps", dynamic_dims={"bnp"})
|
||||
]
|
||||
image_grid_thw: Annotated[torch.Tensor, TensorShape("ni", 3)]
|
||||
|
||||
|
||||
@@ -116,11 +142,12 @@ class KeyeImageEmbeddingInputs(TensorSchema):
|
||||
"""
|
||||
Dimensions:
|
||||
- nf: Number of image features
|
||||
- hs: Hidden size (must match the hidden size of language model
|
||||
- hs: Hidden size (must match the hidden size of language model
|
||||
backbone)
|
||||
- ni: Number of images
|
||||
- g: Grid dimensions (3 for t, h, w)
|
||||
"""
|
||||
|
||||
type: Literal["image_embeds"]
|
||||
image_embeds: Annotated[torch.Tensor, TensorShape("nf", "hs")]
|
||||
image_grid_thw: Annotated[torch.Tensor, TensorShape("ni", 3)]
|
||||
@@ -138,10 +165,11 @@ class KeyeVideoPixelInputs(TensorSchema):
|
||||
- ni: Number of images
|
||||
- g: Grid dimensions (3 for t, h, w)
|
||||
"""
|
||||
|
||||
type: Literal["pixel_values_videos"]
|
||||
pixel_values_videos: Annotated[
|
||||
torch.Tensor,
|
||||
TensorShape("bnp", 3, "ps", "ps", dynamic_dims={"bnp"})]
|
||||
torch.Tensor, TensorShape("bnp", 3, "ps", "ps", dynamic_dims={"bnp"})
|
||||
]
|
||||
video_grid_thw: Annotated[torch.Tensor, TensorShape("nv", 3)]
|
||||
|
||||
|
||||
@@ -149,11 +177,12 @@ class KeyeVideoEmbeddingInputs(TensorSchema):
|
||||
"""
|
||||
Dimensions:
|
||||
- nf: Number of video features
|
||||
- hs: Hidden size (must match the hidden size of language model
|
||||
- hs: Hidden size (must match the hidden size of language model
|
||||
backbone)
|
||||
- nv: Number of videos
|
||||
- g: Grid dimensions (3 for t, h, w)
|
||||
"""
|
||||
|
||||
type: Literal["video_embeds"]
|
||||
video_embeds: Annotated[torch.Tensor, TensorShape("nf", "hs")]
|
||||
video_grid_thw: Annotated[torch.Tensor, TensorShape("nv", 3)]
|
||||
@@ -163,7 +192,6 @@ KeyeVideoInputs = Union[KeyeVideoPixelInputs, KeyeVideoEmbeddingInputs]
|
||||
|
||||
|
||||
class KeyeVisionEmbeddings(nn.Module):
|
||||
|
||||
def __init__(self, config: PretrainedConfig):
|
||||
super().__init__()
|
||||
self.config = config
|
||||
@@ -179,12 +207,11 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
padding="valid",
|
||||
)
|
||||
|
||||
self.num_patches = (self.image_size // self.patch_size)**2
|
||||
self.num_patches = (self.image_size // self.patch_size) ** 2
|
||||
self.num_positions = self.num_patches
|
||||
self.cache_position_embedding = dict()
|
||||
self.cache_position_count = dict()
|
||||
self.position_embedding = nn.Embedding(self.num_positions,
|
||||
self.embed_dim)
|
||||
self.position_embedding = nn.Embedding(self.num_positions, self.embed_dim)
|
||||
self.packing_position_embedding = nn.Embedding(32768, self.embed_dim)
|
||||
|
||||
self.register_buffer(
|
||||
@@ -200,7 +227,6 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
width: int,
|
||||
is_after_patchify: bool = False,
|
||||
) -> torch.Tensor:
|
||||
|
||||
num_positions = self.position_embedding.weight.shape[0]
|
||||
|
||||
patch_pos_embed = self.position_embedding.weight.unsqueeze(0)
|
||||
@@ -215,8 +241,9 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
new_width = width // self.patch_size
|
||||
|
||||
sqrt_num_positions = torch_int(num_positions**0.5)
|
||||
patch_pos_embed = patch_pos_embed.reshape(1, sqrt_num_positions,
|
||||
sqrt_num_positions, dim)
|
||||
patch_pos_embed = patch_pos_embed.reshape(
|
||||
1, sqrt_num_positions, sqrt_num_positions, dim
|
||||
)
|
||||
patch_pos_embed = patch_pos_embed.permute(0, 3, 1, 2)
|
||||
|
||||
patch_pos_embed = nn.functional.interpolate(
|
||||
@@ -229,11 +256,7 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
patch_pos_embed = patch_pos_embed.permute(0, 2, 3, 1).view(1, -1, dim)
|
||||
return patch_pos_embed
|
||||
|
||||
def fetch_position_embedding_lfu_cache(self,
|
||||
embeddings,
|
||||
h,
|
||||
w,
|
||||
max_cache: int = 20):
|
||||
def fetch_position_embedding_lfu_cache(self, embeddings, h, w, max_cache: int = 20):
|
||||
grid = (h, w)
|
||||
if grid in self.cache_position_embedding:
|
||||
self.cache_position_count[grid] += 1
|
||||
@@ -247,8 +270,7 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
self.cache_position_count.pop(min_hit_grid)
|
||||
self.cache_position_embedding.pop(min_hit_grid)
|
||||
|
||||
position_embedding = self.interpolate_pos_encoding(
|
||||
embeddings, h, w, True)
|
||||
position_embedding = self.interpolate_pos_encoding(embeddings, h, w, True)
|
||||
self.cache_position_count[grid] = 1
|
||||
self.cache_position_embedding[grid] = position_embedding
|
||||
return position_embedding
|
||||
@@ -257,10 +279,14 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
self,
|
||||
pixel_values: torch.FloatTensor,
|
||||
position_ids: Optional[torch.Tensor] = None,
|
||||
image_grid_thw: Optional[list[Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]]] = None,
|
||||
image_grid_thw: Optional[
|
||||
list[
|
||||
Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]
|
||||
]
|
||||
] = None,
|
||||
interpolate_pos_encoding=False,
|
||||
) -> torch.Tensor:
|
||||
if pixel_values.dim() == 4:
|
||||
@@ -279,8 +305,7 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
) = pixel_values.shape
|
||||
target_dtype = self.patch_embedding.weight.dtype
|
||||
pixel_values = rearrange(pixel_values, "b l c h w -> (b l) c h w")
|
||||
patch_embeds = self.patch_embedding(
|
||||
pixel_values.to(dtype=target_dtype))
|
||||
patch_embeds = self.patch_embedding(pixel_values.to(dtype=target_dtype))
|
||||
embeddings = patch_embeds.flatten(-2).squeeze(-1)
|
||||
|
||||
if interpolate_pos_encoding and image_grid_thw is not None:
|
||||
@@ -290,19 +315,23 @@ class KeyeVisionEmbeddings(nn.Module):
|
||||
t, h, w = image_grid
|
||||
end = start + t * h * w
|
||||
image_embeddings = embeddings[start:end, :]
|
||||
position_embedding = (self.interpolate_pos_encoding(
|
||||
image_embeddings, h, w, True).squeeze(0).repeat(t, 1))
|
||||
position_embedding = (
|
||||
self.interpolate_pos_encoding(image_embeddings, h, w, True)
|
||||
.squeeze(0)
|
||||
.repeat(t, 1)
|
||||
)
|
||||
image_embeddings = image_embeddings + position_embedding
|
||||
tmp_embeddings.append(image_embeddings)
|
||||
start = end
|
||||
embeddings = torch.concat(tmp_embeddings, dim=0).unsqueeze(0)
|
||||
else:
|
||||
embeddings = embeddings + self.packing_position_embedding(
|
||||
position_ids)
|
||||
embeddings = embeddings + self.packing_position_embedding(position_ids)
|
||||
return embeddings
|
||||
else:
|
||||
raise ValueError("Unsupported pixel_values dimension:"
|
||||
f" {pixel_values.dim()}. Expected 4 or 5.")
|
||||
raise ValueError(
|
||||
"Unsupported pixel_values dimension:"
|
||||
f" {pixel_values.dim()}. Expected 4 or 5."
|
||||
)
|
||||
|
||||
|
||||
def apply_rotary_pos_emb_flashatt(
|
||||
@@ -369,18 +398,20 @@ class KeyeSiglipAttention(nn.Module):
|
||||
|
||||
# Detect attention implementation.
|
||||
self.attn_backend = get_vit_attn_backend(
|
||||
head_size=self.head_dim, dtype=torch.get_default_dtype())
|
||||
head_size=self.head_dim, dtype=torch.get_default_dtype()
|
||||
)
|
||||
|
||||
self.use_upstream_fa = False
|
||||
if self.attn_backend != _Backend.FLASH_ATTN and \
|
||||
check_upstream_fa_availability(
|
||||
torch.get_default_dtype()):
|
||||
if self.attn_backend != _Backend.FLASH_ATTN and check_upstream_fa_availability(
|
||||
torch.get_default_dtype()
|
||||
):
|
||||
self.attn_backend = _Backend.FLASH_ATTN
|
||||
self.use_upstream_fa = True
|
||||
|
||||
if self.attn_backend not in {_Backend.FLASH_ATTN, _Backend.XFORMERS}:
|
||||
raise RuntimeError(
|
||||
f"Keye-VL does not support {self.attn_backend} backend now.")
|
||||
f"Keye-VL does not support {self.attn_backend} backend now."
|
||||
)
|
||||
|
||||
def forward(
|
||||
self,
|
||||
@@ -414,8 +445,7 @@ class KeyeSiglipAttention(nn.Module):
|
||||
)
|
||||
else:
|
||||
if cu_seqlens is None:
|
||||
raise ValueError(
|
||||
"cu_seqlens cannot be None when rope_emb is not None.")
|
||||
raise ValueError("cu_seqlens cannot be None when rope_emb is not None.")
|
||||
cos, sin = rope_emb
|
||||
q = q.view(*q.shape[:-1], self.num_heads, self.head_dim)
|
||||
k = k.view(
|
||||
@@ -449,29 +479,26 @@ class KeyeSiglipAttention(nn.Module):
|
||||
causal=False,
|
||||
softmax_scale=self.scale,
|
||||
)
|
||||
context_layer = rearrange(output,
|
||||
"(b s) ... -> b s ...",
|
||||
b=batch_size)
|
||||
context_layer = rearrange(output, "(b s) ... -> b s ...", b=batch_size)
|
||||
elif self.attn_backend == _Backend.XFORMERS:
|
||||
from xformers import ops as xops
|
||||
from xformers.ops.fmha.attn_bias import BlockDiagonalMask
|
||||
|
||||
attn_bias = BlockDiagonalMask.from_seqlens(q_seqlen=seqlens,
|
||||
kv_seqlen=None,
|
||||
device=q.device)
|
||||
attn_bias = BlockDiagonalMask.from_seqlens(
|
||||
q_seqlen=seqlens, kv_seqlen=None, device=q.device
|
||||
)
|
||||
|
||||
context_layer = xops.memory_efficient_attention_forward(
|
||||
q, k, v, attn_bias=attn_bias, p=0, scale=None)
|
||||
q, k, v, attn_bias=attn_bias, p=0, scale=None
|
||||
)
|
||||
|
||||
context_layer = rearrange(context_layer,
|
||||
"b s h d -> b s (h d)").contiguous()
|
||||
context_layer = rearrange(context_layer, "b s h d -> b s (h d)").contiguous()
|
||||
|
||||
output, _ = self.out_proj(context_layer)
|
||||
return output
|
||||
|
||||
|
||||
class SigLIPRotaryEmbedding(nn.Module):
|
||||
|
||||
def __init__(self, dim: int, theta: float = 10000.0) -> None:
|
||||
super().__init__()
|
||||
self.dim = dim
|
||||
@@ -479,8 +506,9 @@ class SigLIPRotaryEmbedding(nn.Module):
|
||||
self.rope_init()
|
||||
|
||||
def rope_init(self):
|
||||
inv_freq = 1.0 / (self.theta**(
|
||||
torch.arange(0, self.dim, 2, dtype=torch.float) / self.dim))
|
||||
inv_freq = 1.0 / (
|
||||
self.theta ** (torch.arange(0, self.dim, 2, dtype=torch.float) / self.dim)
|
||||
)
|
||||
self.register_buffer("inv_freq", inv_freq, persistent=False)
|
||||
|
||||
def forward(self, seqlen: int) -> torch.Tensor:
|
||||
@@ -494,7 +522,6 @@ class SigLIPRotaryEmbedding(nn.Module):
|
||||
|
||||
|
||||
class KeyeSiglipEncoderLayer(nn.Module):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
config: Union[PretrainedConfig],
|
||||
@@ -503,15 +530,13 @@ class KeyeSiglipEncoderLayer(nn.Module):
|
||||
):
|
||||
super().__init__()
|
||||
self.embed_dim = config.hidden_size
|
||||
self.layer_norm1 = nn.LayerNorm(self.embed_dim,
|
||||
eps=config.layer_norm_eps)
|
||||
self.layer_norm1 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
|
||||
self.self_attn = KeyeSiglipAttention(
|
||||
config,
|
||||
quant_config=quant_config,
|
||||
prefix=f"{prefix}.self_attn",
|
||||
)
|
||||
self.layer_norm2 = nn.LayerNorm(self.embed_dim,
|
||||
eps=config.layer_norm_eps)
|
||||
self.layer_norm2 = nn.LayerNorm(self.embed_dim, eps=config.layer_norm_eps)
|
||||
self.mlp = SiglipMLP(
|
||||
config,
|
||||
quant_config=quant_config,
|
||||
@@ -526,7 +551,6 @@ class KeyeSiglipEncoderLayer(nn.Module):
|
||||
cu_seqlens: Optional[list[torch.Tensor]] = None,
|
||||
rope_emb: Optional[tuple[torch.Tensor, torch.Tensor]] = None,
|
||||
) -> tuple[torch.FloatTensor]:
|
||||
|
||||
residual = hidden_states
|
||||
|
||||
hidden_states = self.layer_norm1(hidden_states)
|
||||
@@ -550,7 +574,6 @@ class KeyeSiglipEncoderLayer(nn.Module):
|
||||
|
||||
|
||||
class KeyeSiglipEncoder(nn.Module):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
config: PretrainedConfig,
|
||||
@@ -562,13 +585,16 @@ class KeyeSiglipEncoder(nn.Module):
|
||||
embed_dim = config.hidden_size
|
||||
num_heads = config.num_attention_heads
|
||||
head_dim = embed_dim // num_heads
|
||||
self.layers = nn.ModuleList([
|
||||
KeyeSiglipEncoderLayer(
|
||||
config,
|
||||
quant_config=quant_config,
|
||||
prefix=f"{prefix}.layers.{layer_idx}",
|
||||
) for layer_idx in range(config.num_hidden_layers)
|
||||
])
|
||||
self.layers = nn.ModuleList(
|
||||
[
|
||||
KeyeSiglipEncoderLayer(
|
||||
config,
|
||||
quant_config=quant_config,
|
||||
prefix=f"{prefix}.layers.{layer_idx}",
|
||||
)
|
||||
for layer_idx in range(config.num_hidden_layers)
|
||||
]
|
||||
)
|
||||
self.rotary_pos_emb = SigLIPRotaryEmbedding(head_dim // 2)
|
||||
|
||||
@staticmethod
|
||||
@@ -588,10 +614,14 @@ class KeyeSiglipEncoder(nn.Module):
|
||||
output_attentions: Optional[bool] = None,
|
||||
output_hidden_states: Optional[bool] = None,
|
||||
cu_seqlens: Optional[list[torch.Tensor]] = None,
|
||||
image_grid_thw: Optional[list[Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]]] = None,
|
||||
image_grid_thw: Optional[
|
||||
list[
|
||||
Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]
|
||||
]
|
||||
] = None,
|
||||
height_position_ids: Optional[torch.Tensor] = None,
|
||||
width_position_ids: Optional[torch.Tensor] = None,
|
||||
use_rope: Optional[bool] = False,
|
||||
@@ -607,8 +637,7 @@ class KeyeSiglipEncoder(nn.Module):
|
||||
split_hids = list()
|
||||
split_wids = list()
|
||||
for t, h, w in flatten_image_grid_thw:
|
||||
image_pids = torch.arange(t * h * w,
|
||||
device=device) % (h * w)
|
||||
image_pids = torch.arange(t * h * w, device=device) % (h * w)
|
||||
sample_hids = image_pids // w
|
||||
sample_wids = image_pids % w
|
||||
split_hids.append(sample_hids)
|
||||
@@ -644,7 +673,6 @@ class KeyeSiglipEncoder(nn.Module):
|
||||
|
||||
|
||||
class KeyeSiglipVisionTransformer(nn.Module):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
config: PretrainedConfig,
|
||||
@@ -661,8 +689,7 @@ class KeyeSiglipVisionTransformer(nn.Module):
|
||||
quant_config=quant_config,
|
||||
prefix=f"{prefix}.encoder",
|
||||
)
|
||||
self.post_layernorm = nn.LayerNorm(embed_dim,
|
||||
eps=config.layer_norm_eps)
|
||||
self.post_layernorm = nn.LayerNorm(embed_dim, eps=config.layer_norm_eps)
|
||||
|
||||
def forward(
|
||||
self,
|
||||
@@ -679,15 +706,18 @@ class KeyeSiglipVisionTransformer(nn.Module):
|
||||
cu_seqlens: Optional[list[torch.Tensor]] = None,
|
||||
padding_mask: Optional[torch.Tensor] = None,
|
||||
vision_return_embed_list: Optional[bool] = False,
|
||||
image_grid_thw: Optional[list[Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]]] = None,
|
||||
image_grid_thw: Optional[
|
||||
list[
|
||||
Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]
|
||||
]
|
||||
] = None,
|
||||
return_pooler_output: Optional[bool] = True,
|
||||
use_rope: Optional[bool] = False,
|
||||
window_size: Optional[bool] = -1,
|
||||
) -> BaseModelOutputWithPooling:
|
||||
|
||||
hidden_states = self.embeddings(
|
||||
pixel_values,
|
||||
interpolate_pos_encoding=interpolate_pos_encoding,
|
||||
@@ -713,8 +743,10 @@ class KeyeSiglipVisionTransformer(nn.Module):
|
||||
|
||||
sample_hidden_state = list()
|
||||
if cu_seqlens is None:
|
||||
raise ValueError("cu_seqlens cannot be None for "
|
||||
"SiglipVisionTransformer output processing.")
|
||||
raise ValueError(
|
||||
"cu_seqlens cannot be None for "
|
||||
"SiglipVisionTransformer output processing."
|
||||
)
|
||||
for i in range(cu_seqlens.shape[0] - 1):
|
||||
start = cu_seqlens[i]
|
||||
end = cu_seqlens[i + 1]
|
||||
@@ -763,16 +795,19 @@ class KeyeSiglipVisionModel(nn.Module):
|
||||
interpolate_pos_encoding: bool = False,
|
||||
position_ids: Optional[torch.Tensor] = None,
|
||||
vision_return_embed_list: Optional[bool] = False,
|
||||
image_grid_thw: Optional[list[Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]]] = None,
|
||||
image_grid_thw: Optional[
|
||||
list[
|
||||
Union[
|
||||
tuple[int, int, int],
|
||||
list[tuple[int, int, int]],
|
||||
]
|
||||
]
|
||||
] = None,
|
||||
cu_seqlens: Optional[list[torch.Tensor]] = None,
|
||||
return_pooler_output: Optional[bool] = True,
|
||||
use_rope: Optional[bool] = False,
|
||||
window_size: Optional[bool] = -1,
|
||||
) -> BaseModelOutputWithPooling:
|
||||
|
||||
return self.vision_model(
|
||||
pixel_values=pixel_values,
|
||||
output_attentions=output_attentions,
|
||||
@@ -788,8 +823,7 @@ class KeyeSiglipVisionModel(nn.Module):
|
||||
window_size=window_size,
|
||||
)
|
||||
|
||||
def load_weights(self, weights: Iterable[tuple[str,
|
||||
torch.Tensor]]) -> set[str]:
|
||||
def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
|
||||
stacked_params_mapping = [
|
||||
("qkv_proj", "q_proj", "q"),
|
||||
("qkv_proj", "k_proj", "k"),
|
||||
@@ -805,22 +839,24 @@ class KeyeSiglipVisionModel(nn.Module):
|
||||
if "head.mlp" in name or "head.probe" in name:
|
||||
continue
|
||||
if self.quant_config is not None and (
|
||||
scale_name := self.quant_config.get_cache_scale(name)):
|
||||
scale_name := self.quant_config.get_cache_scale(name)
|
||||
):
|
||||
param = params_dict[scale_name]
|
||||
weight_loader = getattr(
|
||||
param,
|
||||
"weight_loader",
|
||||
default_weight_loader,
|
||||
)
|
||||
loaded_weight = (loaded_weight if loaded_weight.dim() == 0 else
|
||||
loaded_weight[0])
|
||||
loaded_weight = (
|
||||
loaded_weight if loaded_weight.dim() == 0 else loaded_weight[0]
|
||||
)
|
||||
weight_loader(param, loaded_weight)
|
||||
loaded_params.add(scale_name)
|
||||
continue
|
||||
for (
|
||||
param_name,
|
||||
weight_name,
|
||||
shard_id,
|
||||
param_name,
|
||||
weight_name,
|
||||
shard_id,
|
||||
) in stacked_params_mapping:
|
||||
if weight_name not in name:
|
||||
continue
|
||||
@@ -853,7 +889,6 @@ class KeyeSiglipVisionModel(nn.Module):
|
||||
|
||||
|
||||
class Projector(nn.Module):
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
text_config: PretrainedConfig,
|
||||
@@ -866,12 +901,13 @@ class Projector(nn.Module):
|
||||
self.vision_config = vision_config
|
||||
self.merge_kernel_size = (2, 2)
|
||||
|
||||
self.hidden_size = (self.vision_config.hidden_size *
|
||||
self.merge_kernel_size[0] *
|
||||
self.merge_kernel_size[1])
|
||||
self.hidden_size = (
|
||||
self.vision_config.hidden_size
|
||||
* self.merge_kernel_size[0]
|
||||
* self.merge_kernel_size[1]
|
||||
)
|
||||
|
||||
self.pre_norm = torch.nn.LayerNorm(self.vision_config.hidden_size,
|
||||
eps=1e-05)
|
||||
self.pre_norm = torch.nn.LayerNorm(self.vision_config.hidden_size, eps=1e-05)
|
||||
self.act = GELUActivation()
|
||||
|
||||
self.linear_1 = ColumnParallelLinear(
|
||||
@@ -897,8 +933,7 @@ class Projector(nn.Module):
|
||||
m1, m2 = self.merge_kernel_size
|
||||
if isinstance(image_features, (list, tuple)):
|
||||
processed_features = list()
|
||||
for image_feature, image_grid in zip(image_features,
|
||||
image_grid_thw):
|
||||
for image_feature, image_grid in zip(image_features, image_grid_thw):
|
||||
image_feature = self.pre_norm(image_feature)
|
||||
t, h, w = image_grid
|
||||
|
||||
@@ -921,8 +956,7 @@ class Projector(nn.Module):
|
||||
dims = image_features.shape[:-1]
|
||||
dim = image_features.shape[-1]
|
||||
image_features = image_features.view(np.prod(dims), dim)
|
||||
hidden_states = self.pre_norm(image_features).view(
|
||||
-1, self.hidden_size)
|
||||
hidden_states = self.pre_norm(image_features).view(-1, self.hidden_size)
|
||||
hidden_states = self.linear_1(hidden_states)
|
||||
hidden_states = self.act(hidden_states)
|
||||
hidden_states = self.linear_2(hidden_states)
|
||||
@@ -930,7 +964,9 @@ class Projector(nn.Module):
|
||||
return hidden_states.view(*dims, -1)
|
||||
|
||||
|
||||
def _keye_field_config(hf_inputs: Mapping[str, torch.Tensor], ):
|
||||
def _keye_field_config(
|
||||
hf_inputs: Mapping[str, torch.Tensor],
|
||||
):
|
||||
image_grid_thw = hf_inputs.get("image_grid_thw", torch.empty((0, 3)))
|
||||
image_grid_sizes = image_grid_thw.prod(-1)
|
||||
|
||||
@@ -938,21 +974,18 @@ def _keye_field_config(hf_inputs: Mapping[str, torch.Tensor], ):
|
||||
video_grid_sizes = video_grid_thw.prod(-1)
|
||||
|
||||
return dict(
|
||||
pixel_values=MultiModalFieldConfig.flat_from_sizes(
|
||||
"image", image_grid_sizes),
|
||||
image_embeds=MultiModalFieldConfig.flat_from_sizes(
|
||||
"image", image_grid_sizes),
|
||||
pixel_values=MultiModalFieldConfig.flat_from_sizes("image", image_grid_sizes),
|
||||
image_embeds=MultiModalFieldConfig.flat_from_sizes("image", image_grid_sizes),
|
||||
image_grid_thw=MultiModalFieldConfig.batched("image"),
|
||||
pixel_values_videos=MultiModalFieldConfig.flat_from_sizes(
|
||||
"video", video_grid_sizes),
|
||||
video_embeds=MultiModalFieldConfig.flat_from_sizes(
|
||||
"video", video_grid_sizes),
|
||||
"video", video_grid_sizes
|
||||
),
|
||||
video_embeds=MultiModalFieldConfig.flat_from_sizes("video", video_grid_sizes),
|
||||
video_grid_thw=MultiModalFieldConfig.batched("video"),
|
||||
)
|
||||
|
||||
|
||||
class KeyeMultiModalDataParser(MultiModalDataParser):
|
||||
|
||||
def _parse_image_data(
|
||||
self,
|
||||
data: Union[dict[str, torch.Tensor], ModalityData[ImageItem]],
|
||||
@@ -989,17 +1022,18 @@ class KeyeMultiModalDataParser(MultiModalDataParser):
|
||||
|
||||
|
||||
class KeyeProcessingInfo(BaseProcessingInfo):
|
||||
|
||||
def get_max_image_size(self) -> int:
|
||||
return 9999999 #_MAX_IMAGE_SIZE
|
||||
return 9999999 # _MAX_IMAGE_SIZE
|
||||
|
||||
def get_max_frame_per_video(self) -> int:
|
||||
return 16 #_MAX_FRAMES_PER_VIDEO
|
||||
return 16 # _MAX_FRAMES_PER_VIDEO
|
||||
|
||||
def get_image_processor(self, **kwargs: object):
|
||||
return self.get_hf_processor(**kwargs).image_processor
|
||||
|
||||
def get_supported_mm_limits(self, ) -> Mapping[str, Optional[int]]:
|
||||
def get_supported_mm_limits(
|
||||
self,
|
||||
) -> Mapping[str, Optional[int]]:
|
||||
return {"image": None, "video": None}
|
||||
|
||||
def get_mm_max_tokens_per_item(
|
||||
@@ -1038,11 +1072,9 @@ class KeyeProcessingInfo(BaseProcessingInfo):
|
||||
min_pixels=image_processor.min_pixels,
|
||||
max_pixels=image_processor.max_pixels,
|
||||
)
|
||||
preprocessed_size = ImageSize(width=resized_width,
|
||||
height=resized_height)
|
||||
preprocessed_size = ImageSize(width=resized_width, height=resized_height)
|
||||
else:
|
||||
preprocessed_size = ImageSize(width=image_width,
|
||||
height=image_height)
|
||||
preprocessed_size = ImageSize(width=image_width, height=image_height)
|
||||
|
||||
padded_num_frames = num_frames + num_frames % temporal_patch_size
|
||||
|
||||
@@ -1085,7 +1117,9 @@ class KeyeProcessingInfo(BaseProcessingInfo):
|
||||
)
|
||||
return num_video_tokens
|
||||
|
||||
def get_image_size_with_most_features(self, ) -> ImageSize:
|
||||
def get_image_size_with_most_features(
|
||||
self,
|
||||
) -> ImageSize:
|
||||
max_image_size, _ = self._get_vision_info(
|
||||
image_width=self.get_max_image_size(),
|
||||
image_height=self.get_max_image_size(),
|
||||
@@ -1129,8 +1163,7 @@ class KeyeProcessingInfo(BaseProcessingInfo):
|
||||
max_videos = mm_config.get_limit_per_prompt("video")
|
||||
|
||||
max_image_tokens = self.get_max_image_tokens() * max_images
|
||||
max_total_frames = self._get_max_video_frames(seq_len -
|
||||
max_image_tokens)
|
||||
max_total_frames = self._get_max_video_frames(seq_len - max_image_tokens)
|
||||
max_frames_per_video = min(
|
||||
max_total_frames // max(max_videos, 1),
|
||||
self.get_max_frame_per_video(),
|
||||
@@ -1153,7 +1186,6 @@ _I = TypeVar("_I", bound=KeyeProcessingInfo)
|
||||
|
||||
|
||||
class KeyeBaseDummyInputsBuilder(BaseDummyInputsBuilder[_I]):
|
||||
|
||||
def get_dummy_text(self, mm_counts: Mapping[str, int]) -> str:
|
||||
num_images = mm_counts.get("image", 0)
|
||||
num_videos = mm_counts.get("video", 0)
|
||||
@@ -1173,24 +1205,20 @@ class KeyeBaseDummyInputsBuilder(BaseDummyInputsBuilder[_I]):
|
||||
num_images = mm_counts.get("image", 0)
|
||||
num_videos = mm_counts.get("video", 0)
|
||||
|
||||
target_width, target_height = (
|
||||
self.info.get_image_size_with_most_features())
|
||||
target_num_frames = self.info.get_num_frames_with_most_features(
|
||||
seq_len)
|
||||
target_width, target_height = self.info.get_image_size_with_most_features()
|
||||
target_num_frames = self.info.get_num_frames_with_most_features(seq_len)
|
||||
|
||||
image_overrides = mm_options.get("image") if mm_options else None
|
||||
video_overrides = mm_options.get("video") if mm_options else None
|
||||
|
||||
mm_data = {
|
||||
"image":
|
||||
self._get_dummy_images(
|
||||
"image": self._get_dummy_images(
|
||||
width=target_width,
|
||||
height=target_height,
|
||||
num_images=num_images,
|
||||
overrides=image_overrides,
|
||||
),
|
||||
"video":
|
||||
self._get_dummy_videos(
|
||||
"video": self._get_dummy_videos(
|
||||
width=target_width,
|
||||
height=target_height,
|
||||
num_frames=target_num_frames,
|
||||
@@ -1202,12 +1230,10 @@ class KeyeBaseDummyInputsBuilder(BaseDummyInputsBuilder[_I]):
|
||||
return mm_data
|
||||
|
||||
|
||||
class KeyeDummyInputsBuilder(KeyeBaseDummyInputsBuilder[KeyeProcessingInfo]):
|
||||
...
|
||||
class KeyeDummyInputsBuilder(KeyeBaseDummyInputsBuilder[KeyeProcessingInfo]): ...
|
||||
|
||||
|
||||
class KeyeMultiModalProcessor(BaseMultiModalProcessor[KeyeProcessingInfo]):
|
||||
|
||||
def _get_data_parser(self) -> MultiModalDataParser:
|
||||
return KeyeMultiModalDataParser()
|
||||
|
||||
@@ -1218,8 +1244,7 @@ class KeyeMultiModalProcessor(BaseMultiModalProcessor[KeyeProcessingInfo]):
|
||||
out_mm_kwargs: MultiModalKwargsItems,
|
||||
) -> Sequence[PromptUpdate]:
|
||||
hf_processor = self.info.get_hf_processor(**hf_processor_mm_kwargs)
|
||||
image_processor = self.info.get_image_processor(
|
||||
**hf_processor_mm_kwargs)
|
||||
image_processor = self.info.get_image_processor(**hf_processor_mm_kwargs)
|
||||
tokenizer = self.info.get_tokenizer()
|
||||
vocab = tokenizer.get_vocab()
|
||||
|
||||
@@ -1243,7 +1268,8 @@ class KeyeMultiModalProcessor(BaseMultiModalProcessor[KeyeProcessingInfo]):
|
||||
modality=modality,
|
||||
target=[placeholder[modality]],
|
||||
replacement=partial(get_replacement_keye, modality=modality),
|
||||
) for modality in ("image", "video")
|
||||
)
|
||||
for modality in ("image", "video")
|
||||
]
|
||||
|
||||
def _get_mm_fields_config(
|
||||
@@ -1269,10 +1295,12 @@ class BaseKeyeModule(nn.Module):
|
||||
],
|
||||
}
|
||||
|
||||
hf_to_vllm_mapper = WeightsMapper(orig_to_new_prefix={
|
||||
"lm_head.": "language_model.lm_head.",
|
||||
"model.": "language_model.model.",
|
||||
})
|
||||
hf_to_vllm_mapper = WeightsMapper(
|
||||
orig_to_new_prefix={
|
||||
"lm_head.": "language_model.lm_head.",
|
||||
"model.": "language_model.model.",
|
||||
}
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def get_placeholder_str(cls, modality: str, i: int) -> Optional[str]:
|
||||
@@ -1312,18 +1340,20 @@ class BaseKeyeModule(nn.Module):
|
||||
)
|
||||
|
||||
self.make_empty_intermediate_tensors = (
|
||||
self.language_model.make_empty_intermediate_tensors)
|
||||
self.language_model.make_empty_intermediate_tensors
|
||||
)
|
||||
|
||||
@abstractmethod
|
||||
def _build_projector(self,
|
||||
text_config: PretrainedConfig,
|
||||
vision_config: PretrainedConfig,
|
||||
quant_config: Optional[QuantizationConfig] = None,
|
||||
prefix: str = "") -> nn.Module:
|
||||
def _build_projector(
|
||||
self,
|
||||
text_config: PretrainedConfig,
|
||||
vision_config: PretrainedConfig,
|
||||
quant_config: Optional[QuantizationConfig] = None,
|
||||
prefix: str = "",
|
||||
) -> nn.Module:
|
||||
raise ValueError("Need projector")
|
||||
|
||||
def _process_image_input(self,
|
||||
image_input: Any) -> tuple[torch.Tensor, ...]:
|
||||
def _process_image_input(self, image_input: Any) -> tuple[torch.Tensor, ...]:
|
||||
siglip_position_ids = list()
|
||||
image_grid_hws = list()
|
||||
sample_indices = list()
|
||||
@@ -1338,21 +1368,22 @@ class BaseKeyeModule(nn.Module):
|
||||
image_grid_hws.append(thw_tuple)
|
||||
image_position_ids = torch.arange(numel) % np.prod(thw_tuple[1:])
|
||||
siglip_position_ids.append(image_position_ids)
|
||||
sample_indices.append(torch.full((numel, ), idx,
|
||||
dtype=torch.int64))
|
||||
sample_indices.append(torch.full((numel,), idx, dtype=torch.int64))
|
||||
cu_seqlens.append(cu_seqlens[-1] + numel)
|
||||
|
||||
if image_input["type"] == "image_embeds":
|
||||
raise ValueError(
|
||||
"Image embeddings are not supported for this processing path.")
|
||||
"Image embeddings are not supported for this processing path."
|
||||
)
|
||||
else:
|
||||
pixel_values = image_input["pixel_values"].type(self.visual.dtype)
|
||||
siglip_position_ids = torch.concat(siglip_position_ids,
|
||||
dim=0).to(pixel_values.device)
|
||||
siglip_position_ids = torch.concat(siglip_position_ids, dim=0).to(
|
||||
pixel_values.device
|
||||
)
|
||||
cu_seqlens = torch.tensor(cu_seqlens, dtype=torch.int32).to(
|
||||
pixel_values.device)
|
||||
sample_indices = torch.concat(sample_indices,
|
||||
dim=0).to(pixel_values.device)
|
||||
pixel_values.device
|
||||
)
|
||||
sample_indices = torch.concat(sample_indices, dim=0).to(pixel_values.device)
|
||||
|
||||
image_embeds = self.visual(
|
||||
pixel_values=pixel_values,
|
||||
@@ -1372,7 +1403,7 @@ class BaseKeyeModule(nn.Module):
|
||||
self,
|
||||
video_type: Literal["video_embeds", "pixel_values_videos"],
|
||||
video_grid_thw: list[torch.Tensor],
|
||||
pixel_values_videos: Optional[torch.Tensor] = None
|
||||
pixel_values_videos: Optional[torch.Tensor] = None,
|
||||
) -> Union[torch.Tensor, list[torch.Tensor]]:
|
||||
siglip_position_ids = list()
|
||||
video_grid_hws = list()
|
||||
@@ -1387,21 +1418,24 @@ class BaseKeyeModule(nn.Module):
|
||||
video_grid_hws.append(thw_tuple)
|
||||
video_position_ids = torch.arange(numel) % np.prod(thw_tuple[1:])
|
||||
siglip_position_ids.append(video_position_ids)
|
||||
sample_indices.append(torch.full((numel, ), idx,
|
||||
dtype=torch.int64))
|
||||
sample_indices.append(torch.full((numel,), idx, dtype=torch.int64))
|
||||
cu_seqlens.append(cu_seqlens[-1] + numel)
|
||||
|
||||
if video_type == "video_embeds":
|
||||
raise ValueError(
|
||||
"Video embeddings are not supported for this processing path.")
|
||||
"Video embeddings are not supported for this processing path."
|
||||
)
|
||||
else:
|
||||
pixel_values_videos = pixel_values_videos.type(self.visual.dtype)
|
||||
siglip_position_ids = torch.concat(siglip_position_ids, dim=0).to(
|
||||
pixel_values_videos.device)
|
||||
pixel_values_videos.device
|
||||
)
|
||||
cu_seqlens = torch.tensor(cu_seqlens, dtype=torch.int32).to(
|
||||
pixel_values_videos.device)
|
||||
sample_indices = torch.concat(sample_indices,
|
||||
dim=0).to(pixel_values_videos.device)
|
||||
pixel_values_videos.device
|
||||
)
|
||||
sample_indices = torch.concat(sample_indices, dim=0).to(
|
||||
pixel_values_videos.device
|
||||
)
|
||||
|
||||
video_embeds = self.visual(
|
||||
pixel_values=pixel_values_videos,
|
||||
@@ -1421,14 +1455,16 @@ class BaseKeyeModule(nn.Module):
|
||||
modalities = {}
|
||||
|
||||
for input_key in kwargs:
|
||||
if (input_key in ("pixel_values", "image_embeds")
|
||||
and "images" not in modalities):
|
||||
modalities["images"] = self._parse_and_validate_image_input(
|
||||
**kwargs)
|
||||
if (input_key in ("pixel_values_videos", "video_embeds")
|
||||
and "videos" not in modalities):
|
||||
modalities["videos"] = self._parse_and_validate_video_input(
|
||||
**kwargs)
|
||||
if (
|
||||
input_key in ("pixel_values", "image_embeds")
|
||||
and "images" not in modalities
|
||||
):
|
||||
modalities["images"] = self._parse_and_validate_image_input(**kwargs)
|
||||
if (
|
||||
input_key in ("pixel_values_videos", "video_embeds")
|
||||
and "videos" not in modalities
|
||||
):
|
||||
modalities["videos"] = self._parse_and_validate_video_input(**kwargs)
|
||||
|
||||
return modalities
|
||||
|
||||
@@ -1436,8 +1472,8 @@ class BaseKeyeModule(nn.Module):
|
||||
return self.language_model
|
||||
|
||||
def get_multimodal_embeddings(
|
||||
self, **kwargs: object) -> Optional[MultiModalEmbeddings]:
|
||||
|
||||
self, **kwargs: object
|
||||
) -> Optional[MultiModalEmbeddings]:
|
||||
modalities = self._parse_and_validate_multimodal_inputs(**kwargs)
|
||||
if not modalities:
|
||||
return None
|
||||
@@ -1494,8 +1530,7 @@ class BaseKeyeModule(nn.Module):
|
||||
) -> Optional[torch.Tensor]:
|
||||
return self.language_model.compute_logits(hidden_states)
|
||||
|
||||
def load_weights(self, weights: Iterable[tuple[str,
|
||||
torch.Tensor]]) -> set[str]:
|
||||
def load_weights(self, weights: Iterable[tuple[str, torch.Tensor]]) -> set[str]:
|
||||
loader = AutoWeightsLoader(self)
|
||||
return loader.load_weights(weights, mapper=self.hf_to_vllm_mapper)
|
||||
|
||||
@@ -1513,18 +1548,21 @@ class BaseKeyeModule(nn.Module):
|
||||
info=KeyeProcessingInfo,
|
||||
dummy_inputs=KeyeDummyInputsBuilder,
|
||||
)
|
||||
class KeyeForConditionalGeneration(BaseKeyeModule, SupportsMultiModal,
|
||||
SupportsLoRA, SupportsPP):
|
||||
|
||||
def _build_projector(self,
|
||||
text_config: PretrainedConfig,
|
||||
vision_config: PretrainedConfig,
|
||||
quant_config: Optional[QuantizationConfig] = None,
|
||||
prefix: str = "") -> nn.Module:
|
||||
class KeyeForConditionalGeneration(
|
||||
BaseKeyeModule, SupportsMultiModal, SupportsLoRA, SupportsPP
|
||||
):
|
||||
def _build_projector(
|
||||
self,
|
||||
text_config: PretrainedConfig,
|
||||
vision_config: PretrainedConfig,
|
||||
quant_config: Optional[QuantizationConfig] = None,
|
||||
prefix: str = "",
|
||||
) -> nn.Module:
|
||||
return Projector(text_config, vision_config, quant_config, prefix)
|
||||
|
||||
def _parse_and_validate_image_input(
|
||||
self, **kwargs: object) -> Optional[KeyeImageInputs]:
|
||||
self, **kwargs: object
|
||||
) -> Optional[KeyeImageInputs]:
|
||||
pixel_values = kwargs.pop("pixel_values", None)
|
||||
image_embeds = kwargs.pop("image_embeds", None)
|
||||
image_grid_thw = kwargs.pop("image_grid_thw", None)
|
||||
@@ -1547,7 +1585,8 @@ class KeyeForConditionalGeneration(BaseKeyeModule, SupportsMultiModal,
|
||||
)
|
||||
|
||||
def _parse_and_validate_video_input(
|
||||
self, **kwargs: object) -> Optional[KeyeVideoInputs]:
|
||||
self, **kwargs: object
|
||||
) -> Optional[KeyeVideoInputs]:
|
||||
pixel_values_videos = kwargs.pop("pixel_values_videos", None)
|
||||
video_embeds = kwargs.pop("video_embeds", None)
|
||||
video_grid_thw = kwargs.pop("video_grid_thw", None)
|
||||
@@ -1570,11 +1609,12 @@ class KeyeForConditionalGeneration(BaseKeyeModule, SupportsMultiModal,
|
||||
)
|
||||
|
||||
def _process_video_input(
|
||||
self, video_input: KeyeVideoInputs) -> tuple[torch.Tensor, ...]:
|
||||
self, video_input: KeyeVideoInputs
|
||||
) -> tuple[torch.Tensor, ...]:
|
||||
video_type = video_input["type"]
|
||||
video_grid_thw = video_input["video_grid_thw"]
|
||||
pixel_values_videos = video_input.get("pixel_values_videos", None)
|
||||
|
||||
return tuple(
|
||||
self._process_video_embeds(video_type, video_grid_thw,
|
||||
pixel_values_videos))
|
||||
self._process_video_embeds(video_type, video_grid_thw, pixel_values_videos)
|
||||
)
|
||||
|
||||
Reference in New Issue
Block a user