自定义模型评测

EvalScope 基于 ModelAPI 抽象接口支持各种模型的评测。本文将介绍如何参考 MockLLM 实现自定义模型适配器。

什么情况下需要自定义模型适配器？

在以下情况下，您可能需要创建自定义模型适配器：

• 您的模型不支持标准的 OpenAI API 格式

• 您需要对模型输入输出进行特殊处理

• 您需要使用特定的推理参数或配置

ModelAPI 接口定义

所有模型都需要实现 ModelAPI 抽象基类：

from abc import ABC, abstractmethod
from typing import List, Optional
from evalscope.api.messages import ChatMessage
from evalscope.api.model import GenerateConfig, ModelOutput
from evalscope.api.tool import ToolChoice, ToolInfo

class ModelAPI(ABC):
    """模型API提供者的基础接口"""
    
    def __init__(
        self,
        model_name: str,
        base_url: Optional[str] = None,
        api_key: Optional[str] = None,
        config: GenerateConfig = GenerateConfig(),
        **kwargs
    ) -> None:
        self.model_name = model_name
        self.base_url = base_url
        self.api_key = api_key
        self.config = config

    @abstractmethod
    def generate(
        self,
        input: List[ChatMessage],
        tools: List[ToolInfo],
        tool_choice: ToolChoice,
        config: GenerateConfig,
    ) -> ModelOutput:
        """生成模型输出（必须实现）"""
        pass

MockLLM 参考实现

MockLLM 是一个简单的测试模型实现，展示了 ModelAPI 的基本结构：

from typing import Any, Dict, List, Optional
from evalscope.api.messages import ChatMessage
from evalscope.api.model import GenerateConfig, ModelAPI, ModelOutput
from evalscope.api.tool import ToolChoice, ToolInfo

class MockLLM(ModelAPI):
    """测试用的模拟模型实现"""
    
    default_output = 'Default output from mockllm/model'

    def __init__(
        self,
        model_name: str,
        base_url: Optional[str] = None,
        api_key: Optional[str] = None,
        config: GenerateConfig = GenerateConfig(),
        custom_output: Optional[str] = None,
        **model_args: Dict[str, Any],
    ) -> None:
        super().__init__(model_name, base_url, api_key, config)
        self.model_args = model_args
        self.custom_output = custom_output

    def generate(
        self,
        input: List[ChatMessage],
        tools: List[ToolInfo],
        tool_choice: ToolChoice,
        config: GenerateConfig,
    ) -> ModelOutput:
        # 使用自定义输出（如果提供），否则使用默认输出
        output_text = self.custom_output if self.custom_output is not None else self.default_output
        
        return ModelOutput.from_content(
            model=self.model_name,
            content=output_text
        )

自定义模型实现

参考 MockLLM 的结构创建您的模型：

from typing import List, Optional, Dict, Any
from evalscope.api.model import ModelAPI, GenerateConfig, ModelOutput
from evalscope.api.messages import ChatMessage
from evalscope.api.tool import ToolChoice, ToolInfo
from evalscope.api.registry import register_model_api

# 1. 使用register_model_api注册模型
@register_model_api(name='my_custom_model')
class MyCustomModel(ModelAPI):
    """自定义模型实现"""

    def __init__(
        self,
        model_name: str,
        base_url: Optional[str] = None,
        api_key: Optional[str] = None,
        config: GenerateConfig = GenerateConfig(),
        **model_args: Dict[str, Any],
    ) -> None:
        super().__init__(model_name, base_url, api_key, config)
        self.model_args = model_args
        print(self.model_args)
        
        # 2. 在这里初始化您的模型
        # 例如：加载模型文件、建立连接等

    def generate(
        self,
        input: List[ChatMessage],
        tools: List[ToolInfo],
        tool_choice: ToolChoice,
        config: GenerateConfig,
    ) -> ModelOutput:
        # 3. 实现模型推理逻辑

        # 3.1 处理输入消息
        input_text = self._process_messages(input)
        
        # 3.2 调用您的模型
        response = self._call_model(input_text, config)
        
        # 3.3 返回标准化输出
        return ModelOutput.from_content(
            model=self.model_name,
            content=response
        )

    def _process_messages(self, messages: List[ChatMessage]) -> str:
        """将聊天消息转换为文本"""
        text_parts = []
        for message in messages:
            role = getattr(message, 'role', 'user')
            content = getattr(message, 'content', str(message))
            text_parts.append(f"{role}: {content}")
        return '\n'.join(text_parts)

    def _call_model(self, input_text: str, config: GenerateConfig) -> str:
        """调用您的模型进行推理"""
        # 在这里实现您的模型调用逻辑
        # 例如：调用 API、本地模型推理等
        return f"Response to: {input_text}"

使用自定义模型

直接使用

from evalscope import run_task, TaskConfig

# 创建模型实例
custom_model = MyCustomModel(
    model_name='my-model',
    model_args={'test': 'test'}
)

# 配置评测任务
task_config = TaskConfig(
    model=custom_model,
    datasets=['gsm8k'],
    limit=5
)

# 运行评测
results = run_task(task_cfg=task_config)

通过注册使用

from evalscope import run_task, TaskConfig
from xxx import MyCustomModel # 需预先import模型，实现自动注册

# 使用注册的模型
task_config = TaskConfig(
    model='my-model',
    eval_type='my_custom_model', # register_model_api 使用的名称
    datasets=['gsm8k'],
    model_args={'test': 'test'},
    limit=5
)

results = run_task(task_cfg=task_config)

关键要点

1. 继承 ModelAPI 并实现 generate 方法

2. 返回 ModelOutput 对象，可以使用 ModelOutput.from_content() 创建

3. 处理异常 确保模型调用的稳定性

4. 注册模型 以便在配置中使用