【亚马逊云科技】大模型选型实战（挑选和测评对比最适合业务的大模型）

文章目录

- 前言
- - 1、实验内容
  - 2、手册内容
- 一、环境准备
- 二、Prompt 实战与模型配置
- - 2.1 基于 Amazon Bedrock 对比测试不同模型的逻辑推理效果
  - 2.2 基于 Amazon Bedrock 对比测试不同模型知识问答能力
  - 2.3 Prompt 实战结果分析
- 三、基于 Amazon Bedrock Evaluations 进行模型评测与自动评估
- - 3.1 Amazon Bedrock Evaluations 简介
  - 3.2 内置数据对比测试
  - 3.3 结果分析
- 四、基于 MMLU 基准数据集评测模型
- - 4.1 环境准备
  - 4.2 基于 MMLU 基准数据集评测模型
- 五、总结

实验环境最新开放 DeepSeek-R1 全托管 Serverless 模型权限，欢迎体验试用

前言

1、实验内容

在人工智能领域，不同厂商的大语言模型（LLM）在特定任务上的表现各有千秋。Amazon Bedrock 作为一款强大的 AI 平台，集成了 Deepseek-R1 和 Amazon Nova Pro、Llama 3.3 等主流模型，提供了灵活的模型管理与评测环境。本实验基于 Bedrock 平台，旨在对这些模型进行知识问答及性能对比，分析它们在不同场景下的表现，为 AI 开发者提供科学的选型依据。

随着大语言模型技术的快速发展，市场上涌现出众多高性能方案，使开发者在选择时面临挑战。Bedrock 平台凭借强大的集成能力，为模型评测提供了理想环境。本实验将利用 MMLU（Massive Multitask Language Understanding）基准数据集，对 Deepseek-R1 和 Amazon Nova Pro、Llama 3.3 进行多维度评估。MMLU 涵盖57个学科领域，包括 STEM（科学、技术、工程、数学）、人文学科、社会科学和专业知识等，涉及从基础到专业级别的知识测试，可全面衡量模型的理解与推理能力。

本实验不仅有助于筛选最适合不同应用场景的模型，还能揭示各技术路线的核心优势，助力 AI 开发者在模型选型时做出更明智的决策。

2、手册内容

本手册的内容包括：

深度模型实验场探索 Bedrock 平台基础环境搭建与准备
利用 Prompt 实验与模型配置进行基础功能测试
基于 Bedrock 对比测试不同模型性能效果
基于 Bedrock Evaluations 进行模型效果测试与自动评估
基于 MMLU 基准数据集评测模型

一、环境准备

二、Prompt 实战与模型配置

2.1 基于 Amazon Bedrock 对比测试不同模型的逻辑推理效果

访问 Bedrock，选择 Chat/Text，点击比较模式，选择模型，点击"+"。

选择 Amazon Nova Pro、Llama 3.3 70B Instruct 和 Deepseek 的三个模型效果进行初步测试比较。

在进行模型测试时，为确保结果的公平性和可比性，需基于相同的初始化参数对不同模型进行评估。通过统一的初始化设置，可以排除参数差异对测试结果的影响，从而更准确地衡量各模型在相同条件下的性能表现，我们设定温度为0.7，排名前 P 为0.9，响应长度/最大长度为2048，其他默认。

我们选择了三种类型的题目进行测试：数学谜题（如数字大小比较）。借助 Bedrock 的对比测试功能，我们可以在对比模式中清晰地看到具体的输入、输出，以及模型生成每个 token 所花费的时间。

注意：每次推理完成后，若需进行新的推理，请点击清除内容。

Which is bigger, 8.15 or 8.2?

2.2 基于 Amazon Bedrock 对比测试不同模型知识问答能力

在进行知识问答测试之前，我们首先精心筛选了一系列涵盖历史、科普领域的问题，确保这些问题既具有代表性，又能够全面考察模型的知识储备和理解能力。这些问题包括但不限于历史事件的时间线、重要人物的生平事迹、科学原理的解释以及现代技术的应用等。例如以下问题：

2.3 Prompt 实战结果分析

在本研究中，我们基于 Amazon Bedrock 平台进行了两项小型实验，以对比不同模型在逻辑推理和知识问答方面的表现。第一个实验主要评估模型的逻辑推理能力，测试内容涵盖数字大小比较、汉字推理及知识推理，旨在考察模型对复杂任务的理解与推理能力。

实验结果显示，Amazon Nova Pro 和 Deepseek 在理解能力方面相较于 Llama 3.3 70B Instruct 具有一定优势。尤其是在中文理解上，Nova Pro 和 DeepSeek 表现突出，能够准确理解并回答中文问题。而 Llama 3.3 70B Instruct 在数字大小比较和汉字推理任务上的表现相对较弱，但在知识推理方面依然展现出较强的能力。

此外，在推理性能方面（即生成每个令牌所需的时间），Llama 3.3 70B Instruct 以 983ms 的平均速度远快于 Amazon Nova Pro（3164ms）和 Deepseek（12361ms）。这表明，尽管 Llama 3.3 70B Instruct 在部分推理任务上的表现逊色于另外两个模型，但其在生成速度上具备显著优势。 注意： 推理性能只是参考，每次模型输出的结果可能不一致。

整体来看，实验结果表明，不同模型在特定任务上的表现存在明显差异，尤其是在语言理解相关的任务上。实际应用中，回答的准确性与可读性是至关重要的考量因素。Amazon Nova Pro 在中文处理上的优势尤为明显，为多语言环境下的模型选择提供了有益参考。而对于需要快速响应的场景，推理性能同样不可忽视。因此，在选择模型时，需要根据具体应用需求权衡准确性与速度之间的平衡。

三、基于 Amazon Bedrock Evaluations 进行模型评测与自动评估

3.1 Amazon Bedrock Evaluations 简介

Amazon Bedrock 的模型评估功能使开发者能够为特定应用场景评估、比较和选择最适合的基础模型。该功能提供自动评估和人工评估选项，支持准确性、稳定性、毒性等指标的自动评估，以及友好度、风格、品牌一致性等主观指标的人工评估。用户可以使用内置精选数据集或自定义数据集进行评估。此外，模型评估功能还支持自定义模型的评估，帮助用户在选择、定制和评估模型的过程中，快速找到最适合其应用场景的模型。

3.2 内置数据对比测试

访问Bedrock，点击 Inference and Assessment—— Evaluations —— Create，选择创建评估作业。需要注意的是，由于是内置数据测试，我们可以设置评估名称为：evaluation-nova-pro-inter，来区分与自定义数据集的评估作业。

选择对应的模型，以 Amazon Nova Pro 为例，并将任务类型设置为“问题回答”，选择“可用的内置数据集”。为了节省时间成本，我们可以选择部分数据进行评估，例如 BoolQ 和 Natural Questions，取消勾选 Trivia QA。

其他指标，如毒性、稳健性，为可选内容，可保持不变。
注意：为了提高实验效率，大家实际实验过程中稳健性和毒性的数据集可不选，看手册内容即可。

设置完成后，我们需要指定评估模型结果的保存位置。在本实验环境中，已提前创建存储桶名为 modeldata-model-xxx。

注意：请根据具体已经创建的桶名称为准，这里的 Amazon 地区请选择弗吉尼亚北部(us-east-1)。

完成上述操作后，返回到 Amazon Bedrock 评估页面，在评估结果中点击浏览 S3，填写对应的评估结果 S3 位置，并选择刚才在桶中创建的 result 文件夹。

注意：请根据您创建的桶名进行修改，例如：

s3://modeldata-model-xxx/result/

s3://modeldata-model-123456789/result/

注意：评估 Llama 3.3 70B Instruct 与 Deepseek 使用内置数据集评估方式一样，使用相同的步骤创建，注意替换模型评估任务名称以及选择对应的模型。

Llama 3.3 70B Instruct评估任务名称为：evaluation-llama-inter
Deepseek 评估任务名称为：evaluation-deepseek-inter

3.3 结果分析

我们在构建的自定义数据集和内置数据集上分别测试了不同厂商的模型，具体结果可参考如下表格。我们可以通过点击 Bedrock —— evaluation —— "模型评估作业"查看最终结果。 **注意：**模型输出具有随机性，实验过程中输出的结果可能不一致。

通过分析实验结果，我们可以得出以下结论：
Deepseek 在 BoolQ 任务中展现出较高的鲁棒性，这表明它在面对输入扰动时具有较好的稳定性。
Amazon Nova Pro 在 TriviaQA 任务上的表现较为均衡，但其在 BoolQ 任务中的鲁棒性相对较弱，这可能影响其在需要高安全性场景下的应用。
Llama 3.3 70B Instruct 在不同任务间的稳定性差异较大，这可能意味着它对输入扰动较为敏感，从而影响其在复杂任务中的稳定性。

在优先考虑准确性和安全性的情况下：Amazon Nova Pro 是一个理想的选择，特别是在需要高安全性的场景，如用户交互系统。

在优先考虑鲁棒性和复杂任务处理能力的情况下：Deepseek 更适合那些需要强大抗干扰能力的场景，例如在噪声环境下的问答系统。

对于轻量级需求：虽然 Llama 3.3 70B Instruct 在资源受限的场景下是一个可考虑的选项，但用户需要接受其可能较低的准确性和潜在的安全风险。

四、基于 MMLU 基准数据集评测模型

4.1 环境准备

进入 Code Server 云上开发环境

在控制台左上方“服务”中选择并进入"EC2" - 并选择左侧"实例"，将目前处于”已停止“的实例“启动”，等待启动完成。

点击该实例，选择公有 IPv4 DNS，点击复制地址，在浏览器中手动配置协议和端口，即打开 Visual Studio Code Server。

注意：请在访问地址时使用 8090 端口，并采用 http 协议，即 http://xxx.compute-1.amazonaws.com:8090，而非 https。

在对话框中，输入密码：123456，然后选择提交。

激活虚拟环境

进入 vscode 后，打开 Terminal。
输入以下命令，激活虚拟环境。

source modelenv/bin/activate

4.2 基于 MMLU 基准数据集评测模型

在针对 Amazon Bedrock 的模型评估功能中，通过精心构建的数据集，例如，按照 MMLU 的多样化学科分类对数据集进行组织，并确保每个学科领域包含足够多的样本以保证评估的代表性，来展现出模型卓越的语言理解和生成能力。MMLU 涵盖了57个不同学科的任务，跨越多个知识领域。当然您也可以使用您自己构建的数据进行测试，具体操作步骤如下。如果要评估有关问答任务的模型，则应将数据格式化为如下格式：

{"referenceResponse":"B","category":"abstract_algebra","prompt":"Find the degree for the given field extension Q(sqrt(2), sqrt(3), sqrt(18)) over Q.____.\nA. 0\nB. 4\nC. 2\nD. 6"}

注意：鉴于实验的时间成本，请根据实际情况选择合适的数据量进行统一测试。我们为您准备了100条精心构建的数据，您可以从中选取20条用于测试。

Amazon Nova Pro：

nova.py 使用 Amazon Bedrock 和 LangChain 开发的 MMLU 评测程序。主要流程包括：首先列出可用的 Bedrock 模型，然后创建一个自定义的 ChatModelNova 类来与 Amazon Nova 模型交互；接着使用预定义的系统提示和用户提示，通过 LangChain 构建一个分类链，将基于 MMLU 基准构建的 data.json 文件的问题进行测试输出；最后根据标准答案计算准确率，并将结果保存到 nova.csv 文件中。整个过程展示了如何利用大语言模型进行文本逻辑推理的任务。

import boto3
import json
import copy
import pandas as pd
from termcolor import colored
# create clients of bedrock
bedrock = boto3.client(service_name='bedrock', region_name = 'us-east-1')
bedrock_runtime = boto3.client(service_name='bedrock-runtime', region_name = 'us-east-1') 
pd.set_option('display.max_rows', None)
results = []

available_models = bedrock.list_foundation_models()
for model in available_models['modelSummaries']:
    if '`Amazon`' in model['providerName'] and 'TEXT' in model['outputModalities']: 
        results.append({
            'Model Name': model['modelName'],
            'Model ID': model['modelId'],  # Add Model ID column
            'Provider': model['providerName'],
            'Input Modalities': ', '.join(model['inputModalities']),
            'Output Modalities': ', '.join(model['outputModalities']),
            'Streaming': model.get('responseStreamingSupported', 'N/A'),
            'Status': model['modelLifecycle']['status']
        })

df = pd.DataFrame(results)

pd.reset_option('display.max_rows')
# print(df)

import boto3
import json
from botocore.exceptions import ClientError
import dotenv
import os
dotenv.load_dotenv()

from typing import Any, AsyncIterator, Dict, Iterator, List, Optional

from langchain_core.callbacks import (
    AsyncCallbackManagerForLLMRun,
    CallbackManagerForLLMRun,
)
from langchain_core.language_models import BaseChatModel, SimpleChatModel
from langchain_core.messages import AIMessageChunk, BaseMessage, HumanMessage,AIMessage,SystemMessage
from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
from langchain_core.runnables import run_in_executor
from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
from langchain_core.output_parsers import StrOutputParser,XMLOutputParser
from langchain_core.prompts import ChatPromptTemplate,MessagesPlaceholder,HumanMessagePromptTemplate


class ChatModelNova(BaseChatModel):

    model_name: str
    br_runtime : Any = None
    ak: str = None
    sk: str = None
    region:str = "us-east-1"

    def _generate(
        self,
        messages: List[BaseMessage],
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
        **kwargs: Any,
    ) -> ChatResult:

        if not self.br_runtime:
            if self.ak and self.sk:
                self.br_runtime = boto3.client(service_name = 'bedrock-runtime',
                                               region_name = self.region,
                                              aws_access_key_id = self.ak,
                                               aws_secret_access_key = self.sk
                                              )
            else:
                self.br_runtime = boto3.client(region_name = self.region, service_name = 'bedrock-runtime')
            
        
        new_messages = []
        system_message = ''
        for msg in messages:
            if isinstance(msg,SystemMessage):
                system_message = msg.content
            elif isinstance(msg,HumanMessage):
                new_messages.append({
                        "role": "user",
                        "content": [ {"text": msg.content}]
                    })
            elif isinstance(msg,AIMessage):
                new_messages.append({
                        "role": "assistant",
                        "content": [ {"text": msg.content}]
                    })

        
        temperature = kwargs.get('temperature',0.1)
        maxTokens = kwargs.get('max_tokens',3000)

        #Base inference parameters to use.
        inference_config = {"temperature": temperature,"maxTokens":maxTokens}


        # Send the message.
        response = self.br_runtime.converse(
            modelId=self.model_name,
            messages=new_messages,
            system=[{"text" : system_message}] if system_message else [],
            inferenceConfig=inference_config
        )
        output_message = response['output']['message']

        message = AIMessage(
            content=output_message['content'][0]['text'],
            additional_kwargs={},  # Used to add additional payload (e.g., function calling request)
            response_metadata={  # Use for response metadata
                **response['usage']
            },
        )
        generation = ChatGeneration(message=message)
        return ChatResult(generations=[generation])


    def _stream(
        self,
        messages: List[BaseMessage],
        stop: Optional[List[str]] = None,
        run_manager: Optional[CallbackManagerForLLMRun] = None,
        **kwargs: Any,
    ) -> Iterator[ChatGenerationChunk]:
        if not self.br_runtime:
            if self.ak and self.sk:
                self.br_runtime = boto3.client(service_name = 'bedrock-runtime',
                                               region_name = self.region,
                                              aws_access_key_id = self.ak,
                                               aws_secret_access_key = self.sk
                                              )

            else:
                self.br_runtime = boto3.client(service_name = 'bedrock-runtime', region_name = self.region)
            
        
        new_messages = []
        system_message = ''
        for msg in messages:
            if isinstance(msg,SystemMessage):
                system_message = msg.content
            elif isinstance(msg,HumanMessage):
                new_messages.append({
                        "role": "user",
                        "content": [ {"text": msg.content}]
                    })
            elif isinstance(msg,AIMessage):
                new_messages.append({
                        "role": "assistant",
                        "content": [ {"text": msg.content}]
                    })

        
        temperature = kwargs.get('temperature',0.1)
        maxTokens = kwargs.get('max_tokens',3000)

        #Base inference parameters to use.
        inference_config = {"temperature": temperature,"maxTokens":maxTokens}

        # Send the message.
        streaming_response = self.br_runtime.converse_stream(
            modelId=self.model_name,
            messages=new_messages,
            system=[{"text" : system_message}] if system_message else [],
            inferenceConfig=inference_config
        )
        # Extract and print the streamed response text in real-time.
        for event in streaming_response["stream"]:
            if "contentBlockDelta" in event:
                text = event["contentBlockDelta"]["delta"]["text"]
                # print(text, end="")
                chunk = ChatGenerationChunk(message=AIMessageChunk(content=[{"type":"text","text":text}]))

                if run_manager:
                    # This is optional in newer versions of LangChain
                    # The on_llm_new_token will be called automatically
                    run_manager.on_llm_new_token(text, chunk=chunk)

                yield chunk
            if 'metadata' in event:
                metadata = event['metadata']
                # Let's add some other information (e.g., response metadata)
                chunk = ChatGenerationChunk(
                    message=AIMessageChunk(content="", response_metadata={**metadata})
                )
                if run_manager:

                    run_manager.on_llm_new_token('', chunk=chunk)
                yield chunk

    @property
    def _llm_type(self) -> str:
        """Get the type of language model used by this chat model."""
        return "echoing-chat-model-advanced"

    @property
    def _identifying_params(self) -> Dict[str, Any]:
        """Return a dictionary of identifying parameters.

        This information is used by the LangChain callback system, which
        is used for tracing purposes make it possible to monitor LLMs.
        """
        return {
            "model_name": self.model_name,
        }

llm = ChatModelNova(region_name="us-east-1", model_name="us.amazon.nova-pro-v1:0")


import pandas as pd
import time
df = pd.read_json("data/data.json", lines=True)

def get_response(prompt):
    message = [
        {"role": "system", "content": "直接返回正确答案选项，不要解释。"},
        {"role": "user", "content": prompt}
    ]
    answer = llm.invoke(message)
    print(answer)
    time.sleep(10)
    return answer.content[0]

df['answer'] = df['prompt'].apply(get_response)
accuracy = sum(df['answer'] == df['referenceResponse']) / len(df)
df.to_csv("data/nova.csv", index=False)
print(accuracy)

在激活虚拟环境后，在 Terminal 中执行命令 python nova.py，在终端输出大模型的结果、 accuracy 和文件nova.csv，表示执行成功。

代码解释1：这段代码通过连接 Amazon Bedrock，获取所有 基础模型（Foundation Models） ，并筛选出 ** 由 Amazon 提供且支持文本输出的模型。筛选后，模型信息（名称、ID、输入/输出类型、是否支持流式响应、状态等）被存入 Pandas DataFrame，方便后续分析和查看。最终，代码确保 Pandas 显示设置不会影响其他部分。

代码解释2：这段代码定义了 LangChain 自定义聊天模型 ChatModelNova，用于与 Amazon Bedrock 的 Amazon Nova Pro 模型交互，支持同步和流式请求。

核心功能包括：

初始化 Amazon Bedrock 客户端（支持 access key 认证或默认认证）。
处理用户和 AI 消息，转换为 API 兼容格式。
调用 Amazon Bedrock API 进行文本生成，支持完整和流式输出。
集成 LangChain，可用于 AI 聊天机器人或其他自然语言处理任务。

代码解释3：在配置好 Amazon Bedrock API 调用方式后，使用 LLM（大语言模型）对 JSON 数据集中的问题 (prompt) 进行批量推理，然后计算模型回答的准确率并保存结果。

核心流程：

读取 JSON 数据，加载 prompt 和 referenceResponse（参考答案）。
定义 get_response 方法，使用 LLM 生成答案，并在 5 秒后返回。
批量处理 prompt，将 LLM 预测的答案存入 df[‘answer’]。
计算准确率（LLM 预测答案与参考答案匹配的比例）。
保存结果为 CSV 文件并打印准确率。

实验结果如下表所示：

从准确率与推理性能的综合角度来看，这三款模型各具优势。Amazon Nova Pro 和 Deepseek 在准确率方面表现最佳，均达到 0.87，展现出较强的知识应用能力。然而，Deepseek 的推理时间较长，这可能意味着其在深度推理和复杂任务处理上更为慎重。而 Amazon Nova Pro 则在保持较高准确率的同时，推理速度更快，实现了性能与效率的良好平衡。
这一结果揭示了在模型选择时的关键权衡：

Deepseek 适用于对准确率要求极高、但对推理时间不敏感的任务，如深度问答或高精度内容生成。
Amazon Nova Pro 在准确率和推理速度之间取得了较好的平衡，是大多数实际应用的理想选择。
Llama 3.3 70B Instruct 在需要快速响应的场景中更具优势，尽管其准确率相对较低，但仍可在对速度敏感的应用中发挥作用。
此外，这一分析强调了在模型部署过程中，不应仅关注单一性能指标，而应综合考量准确率、推理速度以及模型的适应性和优化潜力。未来的研究可以进一步探索这些模型在更广泛任务中的表现，并通过优化调整提升其整体性能，以便更好地满足不同应用场景的需求。

五、总结

通过这些实验，不仅深入体验了 Amazon Bedrock 提供的统一访问方式，更重要的是，亲身感受到了不同基础模型（Foundation Models, FMs）的独特优势。通过 Amazon Bedrock 的 Evaluations 功能，我们可以系统地评估和比较各个模型的表现。Amazon Bedrock 的强大之处在于它支持创建多样化的环境，如开发、测试和生产环境，这为团队在不同阶段的迭代和部署提供了极大的便利。此外，Amazon Bedrock 提供了一系列广泛的功能，以建置具有安全性、隐私性和负责任的生成式 AI 应用程序。通过这些实验，你已经能够利用 Amazon Bedrock 的无服务器体验，快速开始使用、使用自己的数据私人定制基础模型，并使用熟悉的 Amazon 工具轻松安全地将它们整合并部署到你的应用程序中。