from typing import List, Optional, Tuple, Type, overload import pytest from transformers import AutoConfig, AutoTokenizer from aphrodite.common.sequence import SampleLogprobs from aphrodite.multimodal.utils import rescale_image_size from ..conftest import IMAGE_ASSETS, AphroditeRunner, HfRunner, _ImageAssets from .utils import check_logprobs_close pytestmark = pytest.mark.vlm _PREFACE = ( "A chat between a curious human and an artificial intelligence assistant. " "The assistant gives helpful, detailed, and polite answers to the human's " "questions.") HF_IMAGE_PROMPTS = IMAGE_ASSETS.prompts({ "stop_sign": f"{_PREFACE} USER: \nWhat's the content of the image? ASSISTANT:", "cherry_blossom": f"{_PREFACE} USER: \nWhat is the season? ASSISTANT:", }) models = ["llava-hf/llava-v1.6-vicuna-7b-hf"] def aphrodite_to_hf_output(aphrodite_output: Tuple[List[int], str, Optional[SampleLogprobs]], model: str): """Sanitize aphrodite output to be comparable with hf output.""" output_ids, output_str, out_logprobs = aphrodite_output config = AutoConfig.from_pretrained(model) image_token_id = config.image_token_index tokenizer = AutoTokenizer.from_pretrained(model) eos_token_id = tokenizer.eos_token_id hf_output_ids = [ token_id for idx, token_id in enumerate(output_ids) if token_id != image_token_id or output_ids[idx - 1] != image_token_id ] assert output_str[0] == " " hf_output_str = output_str[1:] if hf_output_ids[-1] == eos_token_id: hf_output_str = hf_output_str + tokenizer.decode(eos_token_id) return hf_output_ids, hf_output_str, out_logprobs @overload def run_test( hf_runner: Type[HfRunner], aphrodite_runner: Type[AphroditeRunner], image_assets: _ImageAssets, model: str, *, size_factors: List[float], dtype: str, max_tokens: int, num_logprobs: int, tensor_parallel_size: int, distributed_executor_backend: Optional[str] = None, ): ... @overload def run_test( hf_runner: Type[HfRunner], aphrodite_runner: Type[AphroditeRunner], image_assets: _ImageAssets, model: str, *, sizes: List[Tuple[int, int]], dtype: str, max_tokens: int, num_logprobs: int, tensor_parallel_size: int, distributed_executor_backend: Optional[str] = None, ): ... def run_test( hf_runner: Type[HfRunner], aphrodite_runner: Type[AphroditeRunner], image_assets: _ImageAssets, model: str, *, size_factors: Optional[List[float]] = None, sizes: Optional[List[Tuple[int, int]]] = None, dtype: str, max_tokens: int, num_logprobs: int, tensor_parallel_size: int, distributed_executor_backend: Optional[str] = None, ): images = [asset.pil_image for asset in image_assets] if size_factors is not None: inputs_per_image = [( [prompt for _ in size_factors], [rescale_image_size(image, factor) for factor in size_factors], ) for image, prompt in zip(images, HF_IMAGE_PROMPTS)] elif sizes is not None: inputs_per_image = [( [prompt for _ in sizes], [image.resize(size) for size in sizes], ) for image, prompt in zip(images, HF_IMAGE_PROMPTS)] else: raise ValueError("You must provide either `size_factors` or `sizes`") # max_model_len should be greater than image_feature_size with aphrodite_runner(model, dtype=dtype, max_model_len=4096, tensor_parallel_size=tensor_parallel_size, distributed_executor_backend=distributed_executor_backend, enforce_eager=True) as aphrodite_model: aphrodite_outputs_per_image = [ aphrodite_model.generate_greedy_logprobs(prompts, max_tokens, num_logprobs=num_logprobs, images=images) for prompts, images in inputs_per_image ] with hf_runner(model, dtype=dtype, is_vision_model=True) as hf_model: hf_outputs_per_image = [ hf_model.generate_greedy_logprobs_limit(prompts, max_tokens, num_logprobs=num_logprobs, images=images) for prompts, images in inputs_per_image ] for hf_outputs, aphrodite_outputs in zip(hf_outputs_per_image, aphrodite_outputs_per_image): # TODO: Check whether using original CLIPVisionModel can improve # consistency against HF check_logprobs_close( outputs_0_lst=hf_outputs, outputs_1_lst=[ aphrodite_to_hf_output(aphrodite_output, model) for aphrodite_output in aphrodite_outputs ], name_0="hf", name_1="aphrodite", ) @pytest.mark.parametrize("model", models) @pytest.mark.parametrize( "size_factors", [ # No image [], # Single-scale [1.0], # Single-scale, batched [1.0, 1.0, 1.0], # Multi-scale [0.25, 0.5, 1.0], ], ) @pytest.mark.parametrize("dtype", ["half"]) @pytest.mark.parametrize("max_tokens", [128]) @pytest.mark.parametrize("num_logprobs", [5]) def test_models(hf_runner, aphrodite_runner, image_assets, model, size_factors, dtype, max_tokens, num_logprobs) -> None: """Inference result should be the same between hf and aphrodite. All the image fixtures for the test is under tests/images. For huggingface runner, we provide the PIL images as input. For aphrodite runner, we provide MultiModalDataDict objects and corresponding MultiModalConfig as input. Note, the text input is also adjusted to abide by aphrodite contract. The text output is sanitized to be able to compare with hf. """ run_test( hf_runner, aphrodite_runner, image_assets, model, size_factors=size_factors, dtype=dtype, max_tokens=max_tokens, num_logprobs=num_logprobs, tensor_parallel_size=1, ) @pytest.mark.parametrize("model", models) @pytest.mark.parametrize( "sizes", [[(1669, 2560), (2560, 1669), (183, 488), (488, 183)]], ) @pytest.mark.parametrize("dtype", ["half"]) @pytest.mark.parametrize("max_tokens", [128]) @pytest.mark.parametrize("num_logprobs", [5]) def test_models_fixed_sizes(hf_runner, aphrodite_runner, image_assets, model, sizes, dtype, max_tokens, num_logprobs) -> None: run_test( hf_runner, aphrodite_runner, image_assets, model, sizes=sizes, dtype=dtype, max_tokens=max_tokens, num_logprobs=num_logprobs, tensor_parallel_size=1, )