| from __future__ import annotations |
|
|
| import os |
| import warnings |
|
|
| from vlmeval.smp import * |
| from vlmeval.api.base import BaseAPI |
| from vlmeval.vlm.qwen2_vl.prompt import Qwen2VLPromptMixin |
|
|
|
|
| def ensure_image_url(image: str) -> str: |
| prefixes = ['http://', 'https://', 'file://', 'data:image;'] |
| if any(image.startswith(prefix) for prefix in prefixes): |
| return image |
| if os.path.exists(image): |
| return 'file://' + image |
| raise ValueError(f'Invalid image: {image}') |
|
|
|
|
| class Qwen2VLAPI(Qwen2VLPromptMixin, BaseAPI): |
| is_api: bool = True |
|
|
| def __init__( |
| self, |
| model: str = 'qwen-vl-max-0809', |
| key: str | None = None, |
| min_pixels: int | None = None, |
| max_pixels: int | None = None, |
| max_length=1024, |
| top_p=0.001, |
| top_k=1, |
| temperature=0.01, |
| repetition_penalty=1.0, |
| presence_penalty=0.0, |
| seed=3407, |
| use_custom_prompt: bool = True, |
| **kwargs, |
| ): |
| import dashscope |
|
|
| self.model = model |
| self.min_pixels = min_pixels |
| self.max_pixels = max_pixels |
| self.generate_kwargs = dict( |
| max_length=max_length, |
| top_p=top_p, |
| top_k=top_k, |
| temperature=temperature, |
| repetition_penalty=repetition_penalty, |
| presence_penalty=presence_penalty, |
| seed=seed, |
| ) |
|
|
| key = os.environ.get('DASHSCOPE_API_KEY', None) if key is None else key |
| assert key is not None, ( |
| 'Please set the API Key (obtain it here: ' |
| 'https://help.aliyun.com/zh/dashscope/developer-reference/vl-plus-quick-start)' |
| ) |
| dashscope.api_key = key |
| super().__init__(use_custom_prompt=use_custom_prompt, **kwargs) |
|
|
| def _prepare_content(self, inputs: list[dict[str, str]], dataset: str | None = None) -> list[dict[str, str]]: |
| """ |
| inputs list[dict[str, str]], each dict has keys: ['type', 'value'] |
| """ |
| content = [] |
| for s in inputs: |
| if s['type'] == 'image': |
| item = {'type': 'image', 'image': ensure_image_url(s['value'])} |
| if dataset == 'OCRBench': |
| item['min_pixels'] = 10 * 10 * 28 * 28 |
| warnings.warn(f"OCRBench dataset uses custom min_pixels={item['min_pixels']}") |
| if self.max_pixels is not None: |
| item['max_pixels'] = self.max_pixels |
| else: |
| if self.min_pixels is not None: |
| item['min_pixels'] = self.min_pixels |
| if self.max_pixels is not None: |
| item['max_pixels'] = self.max_pixels |
| elif s['type'] == 'text': |
| item = {'type': 'text', 'text': s['value']} |
| else: |
| raise ValueError(f"Invalid message type: {s['type']}, {s}") |
| content.append(item) |
| return content |
|
|
| def generate_inner(self, inputs, **kwargs) -> str: |
| import dashscope |
|
|
| messages = [] |
| if self.system_prompt is not None: |
| messages.append({'role': 'system', 'content': self.system_prompt}) |
| messages.append( |
| {'role': 'user', 'content': self._prepare_content(inputs, dataset=kwargs.get('dataset', None))} |
| ) |
| if self.verbose: |
| print(f'\033[31m{messages}\033[0m') |
|
|
| |
| generation_kwargs = self.generate_kwargs.copy() |
| kwargs.pop('dataset', None) |
| generation_kwargs.update(kwargs) |
| try: |
| response = dashscope.MultiModalConversation.call( |
| model=self.model, |
| messages=messages, |
| **generation_kwargs, |
| ) |
| if self.verbose: |
| print(response) |
| answer = response.output.choices[0]['message']['content'][0]['text'] |
| return 0, answer, 'Succeeded! ' |
| except Exception as err: |
| if self.verbose: |
| self.logger.error(f'{type(err)}: {err}') |
| self.logger.error(f'The input messages are {inputs}.') |
| return -1, '', '' |
|
|
|
|
| class QwenVLWrapper(BaseAPI): |
|
|
| is_api: bool = True |
|
|
| def __init__(self, |
| model: str = 'qwen-vl-plus', |
| retry: int = 5, |
| key: str = None, |
| verbose: bool = True, |
| temperature: float = 0.0, |
| system_prompt: str = None, |
| max_tokens: int = 2048, |
| proxy: str = None, |
| **kwargs): |
|
|
| assert model in ['qwen-vl-plus', 'qwen-vl-max'] |
| self.model = model |
| import dashscope |
| self.fail_msg = 'Failed to obtain answer via API. ' |
| self.max_tokens = max_tokens |
| self.temperature = temperature |
| if key is None: |
| key = os.environ.get('DASHSCOPE_API_KEY', None) |
| assert key is not None, ( |
| 'Please set the API Key (obtain it here: ' |
| 'https://help.aliyun.com/zh/dashscope/developer-reference/vl-plus-quick-start)' |
| ) |
| dashscope.api_key = key |
| if proxy is not None: |
| proxy_set(proxy) |
| super().__init__(retry=retry, system_prompt=system_prompt, verbose=verbose, **kwargs) |
|
|
| |
| |
| def prepare_itlist(self, inputs): |
| assert np.all([isinstance(x, dict) for x in inputs]) |
| has_images = np.sum([x['type'] == 'image' for x in inputs]) |
| if has_images: |
| content_list = [] |
| for msg in inputs: |
| if msg['type'] == 'text': |
| content_list.append(dict(text=msg['value'])) |
| elif msg['type'] == 'image': |
| content_list.append(dict(image='file://' + msg['value'])) |
| else: |
| assert all([x['type'] == 'text' for x in inputs]) |
| text = '\n'.join([x['value'] for x in inputs]) |
| content_list = [dict(text=text)] |
| return content_list |
|
|
| def prepare_inputs(self, inputs): |
| input_msgs = [] |
| if self.system_prompt is not None: |
| input_msgs.append(dict(role='system', content=self.system_prompt)) |
| assert isinstance(inputs, list) and isinstance(inputs[0], dict) |
| assert np.all(['type' in x for x in inputs]) or np.all(['role' in x for x in inputs]), inputs |
| if 'role' in inputs[0]: |
| assert inputs[-1]['role'] == 'user', inputs[-1] |
| for item in inputs: |
| input_msgs.append(dict(role=item['role'], content=self.prepare_itlist(item['content']))) |
| else: |
| input_msgs.append(dict(role='user', content=self.prepare_itlist(inputs))) |
| return input_msgs |
|
|
| def generate_inner(self, inputs, **kwargs) -> str: |
| from dashscope import MultiModalConversation |
| assert isinstance(inputs, str) or isinstance(inputs, list) |
|
|
| if 'type' in inputs[0]: |
| pure_text = np.all([x['type'] == 'text' for x in inputs]) |
| else: |
| pure_text = True |
| for inp in inputs: |
| if not np.all([x['type'] == 'text' for x in inp['content']]): |
| pure_text = False |
| break |
|
|
| assert not pure_text |
| messages = self.prepare_inputs(inputs) |
| gen_config = dict(max_output_tokens=self.max_tokens, temperature=self.temperature) |
| gen_config.update(kwargs) |
| try: |
| response = MultiModalConversation.call(model=self.model, messages=messages) |
| if self.verbose: |
| print(response) |
| answer = response.output.choices[0]['message']['content'][0]['text'] |
| return 0, answer, 'Succeeded! ' |
| except Exception as err: |
| if self.verbose: |
| self.logger.error(f'{type(err)}: {err}') |
| self.logger.error(f'The input messages are {inputs}.') |
|
|
| return -1, '', '' |
|
|
|
|
| class QwenVLAPI(QwenVLWrapper): |
|
|
| def generate(self, message, dataset=None): |
| return super(QwenVLAPI, self).generate(message) |
|
|
