【Transformers】第 7 章 ：问答

数据集

为了构建我们的 QA 系统，我们将使用 SubjQA 数据集2，其中包含 10,000 多条关于产品和服务的英文客户评论，内容涉及六个领域：TripAdvisor、餐厅、电影、书籍、电子产品和杂货店。如图7-2 所示，每条评论都与一个问题相关联，该问题可以使用评论中的一个或多个句子来回答。3

这个数据集的有趣之处在于大多数问题和答案都是主观的；也就是说，它们取决于用户的个人体验。图 7-2中的示例说明了为什么此功能使任务可能比寻找诸如“英国的货币是什么？”之类的事实问题的答案更困难。首先，查询是关于“质量差”的，这是主观的，取决于用户对质量的定义。其次，查询的重要部分根本不会出现在评论中，这意味着无法使用关键字搜索或解释输入问题等快捷方式来回答。这些特性使 SubjQA 成为一个真实的数据集，用于对我们基于评论的 QA 模型进行基准测试，因为用户生成的内容如图 7-2所示类似于我们在野外可能遇到的情况。

首先，让我们从 Hugging Face Hub下载数据集。正如我们在 第 4 章中所做的那样，我们可以使用该get_dataset_config_names() 函数来找出可用的子集：

from datasets import get_dataset_config_names
 
domains = get_dataset_config_names("subjqa")
domains

['books', 'electronics', 'grocery', 'movies', 'restaurants', 'tripadvisor']

对于我们的用例，我们将专注于为电子领域构建一个 QA 系统。要下载electronics子集，我们只需将此值传递给函数的name参数load_dataset() ：

from datasets import load_dataset
 
subjqa = load_dataset("subjqa", name="electronics")

与 Hub 上的其他问答数据集一样，SubjQA 将每个问题的答案存储为嵌套字典。例如，如果我们检查列中的某一行answers：

print(subjqa["train"]["answers"][1])

{'text': ['Bass is weak as expected', 'Bass is weak as expected, even with EQ
adjusted up'], 'answer_start': [1302, 1302], 'answer_subj_level': [1, 1],
'ans_subj_score': [0.5083333253860474, 0.5083333253860474], 'is_ans_subjective':
[True, True]}

我们可以看到答案存储在一个text字段中，而起始字符索引在answer_start. 为了更轻松地探索数据集，我们将使用该flatten()方法展平这些嵌套列，并将每个拆分转换为 Pandas DataFrame，如下所示：

import pandas as pd
 
dfs = {split: dset.to_pandas() for split, dset in subjqa.flatten().items()}
 
for split, df in dfs.items():
    print(f"Number of questions in {split}: {df['id'].nunique()}")

Number of questions in train: 1295
Number of questions in test: 358
Number of questions in validation: 255

请注意，数据集相对较小，总共只有 1,908 个示例。这模拟了现实世界的场景，因为让领域专家标记抽取的 QA 数据集是劳动密集型且昂贵的。例如，用于法律合同提取 QA 的 CUAD 数据集估计价值 200 万美元，以说明注释其 13,000 个示例所需的法律专业知识！4

SubjQA 数据集中有很多列，但用于构建我们的 QA 系统的最有趣的列如 表 7-1所示。

让我们关注这些专栏，并看一些训练示例。我们可以使用该sample()方法来选择一个随机样本：

qa_cols = ["title", "question", "answers.text",
           "answers.answer_start", "context"]
sample_df = dfs["train"][qa_cols].sample(2, random_state=7)
sample_df

从这些例子中，我们可以做出一些观察。首先，这些问题在语法上不正确，这在电子商务网站的常见问题解答部分中很常见。其次，空answers.text条目表示无法在评论中找到答案的“无法回答”的问题。最后，我们可以使用答案范围的起始索引和长度来切出评论中与答案相对应的文本范围：

start_idx = sample_df["answers.answer_start"].iloc[0][0]
end_idx = start_idx + len(sample_df["answers.text"].iloc[0][0])
sample_df["context"].iloc[0][start_idx:end_idx]

'this keyboard is compact'

接下来，让我们通过计算以几个常见起始词开头的问题，来了解一下训练集中有哪些类型的问题：

counts = {}
question_types = ["What", "How", "Is", "Does", "Do", "Was", "Where", "Why"]
 
for q in question_types:
    counts[q] = dfs["train"]["question"].str.startswith(q).value_counts()[True]
 
pd.Series(counts).sort_values().plot.barh()
plt.title("Frequency of Question Types")
plt.show()

我们可以看到以“How”、“What”和“Is”开头的问题是最常见的问题，让我们看一些例子：

for question_type in ["How", "What", "Is"]:
    for question in (
        dfs["train"][dfs["train"].question.str.startswith(question_type)]
        .sample(n=3, random_state=42)['question']):
        print(question)

How is the camera?
How do you like the control?
How fast is the charger?
What is direction?
What is the quality of the construction of the bag?
What is your impression of the product?
Is this how zoom works?
Is sound clear?
Is it a wireless keyboard?

现在我们已经稍微探索了我们的数据集，让我们深入了解转换器如何从文本中提取答案。

从文本中提取答案

我们的 QA 系统需要做的第一件事是找到一种方法，将潜在答案识别为客户评论中的一段文本。例如，如果我们有一个问题，比如“它防水吗？” 并且评论段落是“This watch is waterproof at 30m depth”，那么模型应该输出“waterproof at 30m”。为此，我们需要了解如何：

• 构建监督学习问题。

• 为 QA 任务标记和编码文本。

• 处理超过模型最大上下文大小的长段落。

让我们先来看看如何界定问题。

from transformers import AutoTokenizer
 
model_ckpt = "deepset/minilm-uncased-squad2"
tokenizer = AutoTokenizer.from_pretrained(model_ckpt)

question = "How much music can this hold?"
context = """An MP3 is about 1 MB/minute, so about 6000 hours depending on \
file size."""
inputs = tokenizer(question, context, return_tensors="pt")

print(tokenizer.decode(inputs["input_ids"][0]))

[CLS] how much music can this hold? [SEP] an mp3 is about 1 mb / minute, so
about 6000 hours depending on file size. [SEP]

[CLS] question tokens [SEP] context tokens [SEP]

import torch
from transformers import AutoModelForQuestionAnswering
 
model = AutoModelForQuestionAnswering.from_pretrained(model_ckpt)
 
with torch.no_grad():
    outputs = model(**inputs)
print(outputs)

QuestionAnsweringModelOutput(loss=None, start_logits=tensor([[-0.9862, -4.7750,
         -5.4025, -5.2378, -5.2863, -5.5117, -4.9819, -6.1880,
         -0.9862,  0.2596, -0.2144, -1.7136,  3.7806,  4.8561, -1.0546, -3.9097,
         -1.7374, -4.5944, -1.4278,  3.9949,  5.0390, -0.2018, -3.0193, -4.8549,
         -2.3107, -3.5110, -3.5713, -0.9862]]), end_logits=tensor([[-0.9623,
         -5.4733, -5.0326, -5.1639, -5.4278, -5.5151, -5.1749, -4.6233,
         -0.9623, -3.7855, -0.8715, -3.7745, -3.0161, -1.1780,  0.1758, -2.7365,
          4.8934,  0.3046, -3.1761, -3.2762,  0.8937,  5.6606, -0.3623, -4.9554,
         -3.2531, -0.0914,  1.6211, -0.9623]]), hidden_states=None,
attentions=None)

start_logits = outputs.start_logits
end_logits = outputs.end_logits

print(f"Input IDs shape: {inputs.input_ids.size()}")
print(f"Start logits shape: {start_logits.size()}")
print(f"End logits shape: {end_logits.size()}")

Input IDs shape: torch.Size([1, 28])
Start logits shape: torch.Size([1, 28])
End logits shape: torch.Size([1, 28])

import torch
 
start_idx = torch.argmax(start_logits)
end_idx = torch.argmax(end_logits) + 1
answer_span = inputs["input_ids"][0][start_idx:end_idx]
answer = tokenizer.decode(answer_span)
print(f"Question: {question}")
print(f"Answer: {answer}")

Question: How much music can this hold?
Answer: 6000 hours

from transformers import pipeline
 
pipe = pipeline("question-answering", model=model, tokenizer=tokenizer)
pipe(question=question, context=context, topk=3)

[{'score': 0.26516005396842957,
  'start': 38,
  'end': 48,
  'answer': '6000 hours'},
 {'score': 0.2208300083875656,
  'start': 16,
  'end': 48,
  'answer': '1 MB/minute, so about 6000 hours'},
 {'score': 0.10253632068634033,
  'start': 16,
  'end': 27,
  'answer': '1 MB/minute'}]

pipe(question="Why is there no data?", context=context,
     handle_impossible_answer=True)

{'score'：0.9068416357040405，'start'：0，'end'：0，'answer'：''}

example = dfs["train"].iloc[0][["question", "context"]]
tokenized_example = tokenizer(example["question"], example["context"],
                              return_overflowing_tokens=True, max_length=100,
                              stride=25)

for idx, window in enumerate(tokenized_example["input_ids"]):
    print(f"Window #{idx} has {len(window)} tokens")

Window #0 has 100 tokens
Window #1 has 88 tokens

for window in tokenized_example["input_ids"]:
    print(f"{tokenizer.decode(window)} \n")

[CLS] how is the bass? [SEP] i have had koss headphones in the past, pro 4aa and
qz - 99. the koss portapro is portable and has great bass response. the work
great with my android phone and can be " rolled up " to be carried in my
motorcycle jacket or computer bag without getting crunched. they are very light
and don't feel heavy or bear down on your ears even after listening to music
with them on all day. the sound is [SEP]

[CLS] how is the bass? [SEP] and don't feel heavy or bear down on your ears even
after listening to music with them on all day. the sound is night and day better
than any ear - bud could be and are almost as good as the pro 4aa. they are "
open air " headphones so you cannot match the bass to the sealed types, but it
comes close. for $ 32, you cannot go wrong. [SEP]

使用 Haystack 构建 QA 管道

在我们简单的答案提取示例中，我们为模型提供了问题和上下文。然而，实际上我们系统的用户只会提供关于产品的问题，因此我们需要某种方式从我们语料库中的所有评论中选择相关段落。一种方法是将给定产品的所有评论连接在一起，并将它们作为一个单一的长上下文提供给模型。虽然简单，但这种方法的缺点是上下文可能会变得非常长，从而为我们的用户查询引入不可接受的延迟。例如，假设平均每个产品有 30 条评论，每条评论需要 100 毫秒来处理。如果我们需要处理所有评论以获得答案，

为了解决这个问题，现代 QA 系统通常基于 检索器-阅读器架构，它有两个主要组件：

Retriever

负责检索给定查询的相关文档。检索器通常被分类为稀疏或密集。稀疏检索器使用词频将每个文档和查询表示为稀疏向量。11然后通过计算向量的内积来确定查询和文档的相关性。另一方面，密集检索器使用转换器之类的编码器将查询和文档表示为上下文嵌入（密集向量）。这些嵌入对语义进行编码，并允许密集检索器通过了解查询的内容来提高搜索准确性。

Reader

负责从检索器提供的文档中提取答案。读者通常是阅读理解模型，尽管在本章末尾我们会看到可以生成自由格式答案的模型示例。

如图7-9 所示，还可以有其他组件对检索器获取的文档或阅读器提取的答案进行后处理。例如，检索到的文档可能需要重新排序以消除可能使读者感到困惑的嘈杂或不相关的文档。同样，当正确答案来自长文档中的各个段落时，通常需要对读者的答案进行后处理。

为了构建我们的 QA 系统，我们将使用 由专注于 NLP 的德国公司deepset开发 的Haystack库。Haystack 基于检索器-阅读器架构，抽象了构建这些系统所涉及的大部分复杂性，并与Transformer 紧密集成。除了检索器和读取器之外，在使用 Haystack 构建 QA 管道时还涉及另外两个组件：

文档存储

一种面向文档的数据库，用于存储在查询时提供给检索器的文档和元数据

管道

结合 QA 系统的所有组件以启用自定义查询流、合并来自多个检索器的文档等

在本节中，我们将了解如何使用这些组件快速构建原型 QA 管道。稍后，我们将研究如何提高其性能。

url = """https://artifacts.elastic.co/downloads/elasticsearch/\
elasticsearch-7.9.2-linux-x86_64.tar.gz"""
!wget -nc -q {url}
!tar -xzf elasticsearch-7.9.2-linux-x86_64.tar.gz

import os
from subprocess import Popen, PIPE, STDOUT
 
# Run Elasticsearch as a background process
!chown -R daemon:daemon elasticsearch-7.9.2
es_server = Popen(args=['elasticsearch-7.9.2/bin/elasticsearch'],
                  stdout=PIPE, stderr=STDOUT, preexec_fn=lambda: os.setuid(1))
# Wait until Elasticsearch has started
!sleep 30

!curl -X GET "localhost:9200/?pretty"

{
  "name" : "96938eee37cd",
  "cluster_name" : "docker-cluster",
  "cluster_uuid" : "ABGDdvbbRWmMb9Umz79HbA",
  "version" : {
    "number" : "7.9.2",
    "build_flavor" : "default",
    "build_type" : "docker",
    "build_hash" : "d34da0ea4a966c4e49417f2da2f244e3e97b4e6e",
    "build_date" : "2020-09-23T00:45:33.626720Z",
    "build_snapshot" : false,
    "lucene_version" : "8.6.2",
    "minimum_wire_compatibility_version" : "6.8.0",
    "minimum_index_compatibility_version" : "6.0.0-beta1"
  },
  "tagline" : "You Know, for Search"
}

from haystack.document_store.elasticsearch import ElasticsearchDocumentStore
 
# Return the document embedding for later use with dense retriever
document_store = ElasticsearchDocumentStore(return_embedding=True)

{
    "text": "",
    "meta": {
        "field_01": "",
        "field_02": "",
        ...
    }
}

for split, df in dfs.items():
    # Exclude duplicate reviews
    docs = [{"text": row["context"],
             "meta":{"item_id": row["title"], "question_id": row["id"],
                     "split": split}}
        for _,row in df.drop_duplicates(subset="context").iterrows()]
    document_store.write_documents(docs, index="document")
 
print(f"Loaded {document_store.get_document_count()} documents")

Loaded 1615 documents

rom haystack.retriever.sparse import ElasticsearchRetriever
 
es_retriever = ElasticsearchRetriever(document_store=document_store)

item_id = "B0074BW614"
query = "Is it good for reading?"
retrieved_docs = es_retriever.retrieve(
    query=query, top_k=3, filters={"item_id":[item_id], "split":["train"]})

print(retrieved_docs[0])

{'text': 'This is a gift to myself.  I have been a kindle user for 4 years and
this is my third one.  I never thought I would want a fire for I mainly use it
for book reading.  I decided to try the fire for when I travel I take my laptop,
my phone and my iPod classic.  I love my iPod but watching movies on the plane
with it can be challenging because it is so small. Laptops battery life is not
as good as the Kindle.  So the Fire combines for me what I needed all three to
do. So far so good.', 'score': 6.243799, 'probability': 0.6857824513476455,
'question': None, 'meta': {'item_id': 'B0074BW614', 'question_id':
'868e311275e26dbafe5af70774a300f3', 'split': 'train'}, 'embedding': None, 'id':
'252e83e25d52df7311d597dc89eef9f6'}

from haystack.reader.farm import FARMReader
 
model_ckpt = "deepset/minilm-uncased-squad2"
max_seq_length, doc_stride = 384, 128
reader = FARMReader(model_name_or_path=model_ckpt, progress_bar=False,
                    max_seq_len=max_seq_length, doc_stride=doc_stride,
                    return_no_answer=True)

print(reader.predict_on_texts(question=question, texts=[context], top_k=1))

{'query': 'How much music can this hold?', 'no_ans_gap': 12.648084878921509,
'answers': [{'answer': '6000 hours', 'score': 10.69961929321289, 'probability':
0.3988136053085327, 'context': 'An MP3 is about 1 MB/minute, so about 6000 hours
depending on file size.', 'offset_start': 38, 'offset_end': 48,
'offset_start_in_doc': 38, 'offset_end_in_doc': 48, 'document_id':
'e344757014e804eff50faa3ecf1c9c75'}]}

from haystack.pipeline import ExtractiveQAPipeline
 
pipe = ExtractiveQAPipeline(reader, es_retriever)

n_answers = 3
preds = pipe.run(query=query, top_k_retriever=3, top_k_reader=n_answers,
                 filters={"item_id": [item_id], "split":["train"]})
 
print(f"Question: {preds['query']} \n")
for idx in range(n_answers):
    print(f"Answer {idx+1}: {preds['answers'][idx]['answer']}")
    print(f"Review snippet: ...{preds['answers'][idx]['context']}...")
    print("\n\n")

Question: Is it good for reading?

Answer 1: I mainly use it for book reading
Review snippet: ... is my third one.  I never thought I would want a fire for I
mainly use it for book reading.  I decided to try the fire for when I travel I
take my la...


Answer 2: the larger screen compared to the Kindle makes for easier reading
Review snippet: ...ght enough that I can hold it to read, but the larger screen
compared to the Kindle makes for easier reading. I love the color, something I
never thou...


Answer 3: it is great for reading books when no light is available
Review snippet: ...ecoming addicted to hers! Our son LOVES it and it is great
for reading books when no light is available. Amazing sound but I suggest good
headphones t...

评估Retriever

评估检索器的一个常用指标是召回率，它衡量所有相关文档被检索到的比例。在这种情况下，“相关”仅仅意味着答案是否存在于文本段落中，因此给定一组问题，我们可以通过计算答案出现在由返回的前 k个文档中的次数来计算召回率。猎犬。

在 Haystack 中，有两种评估检索器的方法：

• 使用检索器的内置eval()方法。这可用于开放域和封闭域 QA，但不适用于像 SubjQA 这样的数据集，其中每个文档都与单个产品配对，我们需要为每个查询按产品 ID 进行过滤。

• 构建一个Pipeline将检索器与 EvalRetriever类结合的自定义。这可以实现自定义指标和查询流。

由于我们需要评估每个产品的召回率，然后汇总所有产品，我们将选择第二种方法。图中的每个节点Pipeline代表一个类，该类接受一些输入并通过一种run()方法产生一些输出：

class PipelineNode:
    def __init__(self):
        self.outgoing_edges = 1
 
    def run(self, **kwargs):
        ...
        return (outputs, "outgoing_edge_name")

这里kwargs对应于图中前一个节点的输出，在run()方法中对其进行操作以返回下一个节点的输出元组，以及传出边的名称。唯一的其他要求是包含一个outgoing_edges 属性，该属性指示来自节点的输出数量（在大多数情况下outgoing_edges=1，除非您在管道中有根据某些标准路由输入的分支）。

在我们的例子中，我们需要一个节点来评估检索器，因此我们将使用EvalRetriever其run()方法跟踪哪些文档的答案与基本事实相匹配的类。Pipeline使用这个类，我们可以通过在代表检索器本身的节点之后添加评估节点来构建图：

from haystack.pipeline import Pipeline
from haystack.eval import EvalDocuments
 
class EvalRetrieverPipeline:
    def __init__(self, retriever):
        self.retriever = retriever
        self.eval_retriever = EvalDocuments()
        pipe = Pipeline()
        pipe.add_node(component=self.retriever, name="ESRetriever",
                      inputs=["Query"])
        pipe.add_node(component=self.eval_retriever, name="EvalRetriever",
                      inputs=["ESRetriever"])
        self.pipeline = pipe
 
 
pipe = EvalRetrieverPipeline(es_retriever)

请注意，每个节点都有一个name和一个 的列表inputs。在大多数情况下，每个节点都有一条出边，所以我们只需要将前一个节点的名称包含在inputs.

现在我们有了评估管道，我们需要传递一些查询及其相应的答案。为此，我们会将答案添加到label文档存储中的专用索引中。Haystack 提供了一个Label对象，该对象以标准化的方式表示答案范围及其元数据。为了填充label索引，我们将首先Label通过循环测试集中的每个问题并提取匹配的答案和其他元数据来创建一个对象列表：

from haystack import Label
 
labels = []
for i, row in dfs["test"].iterrows():
    # Metadata used for filtering in the Retriever
    meta = {"item_id": row["title"], "question_id": row["id"]}
    # Populate labels for questions with answers
    if len(row["answers.text"]):
        for answer in row["answers.text"]:
            label = Label(
                question=row["question"], answer=answer, id=i, origin=row["id"],
                meta=meta, is_correct_answer=True, is_correct_document=True,
                no_answer=False)
            labels.append(label)
    # Populate labels for questions without answers
    else:
        label = Label(
            question=row["question"], answer="", id=i, origin=row["id"],
            meta=meta, is_correct_answer=True, is_correct_document=True,
            no_answer=True)
        labels.append(label)

如果我们偷看这些标签之一：

print(labels[0])

{'id': 'e28f5e62-85e8-41b2-8a34-fbff63b7a466', 'created_at': None, 'updated_at':
None, 'question': 'What is the tonal balance of these headphones?', 'answer': 'I
have been a headphone fanatic for thirty years', 'is_correct_answer': True,
'is_correct_document': True, 'origin': 'd0781d13200014aa25860e44da9d5ea7',
'document_id': None, 'offset_start_in_doc': None, 'no_answer': False,
'model_id': None, 'meta': {'item_id': 'B00001WRSJ', 'question_id':
'd0781d13200014aa25860e44da9d5ea7'}}

我们可以看到问答对，以及origin包含唯一问题 ID 的字段，因此我们可以过滤每个问题的文档存储。我们还在该meta 字段中添加了产品 ID，以便我们可以按产品过滤标签。现在我们有了标签，我们可以将它们写入labelElasticsearch 的索引，如下所示：

document_store.write_labels(labels, index="label")
print(f"""Loaded {document_store.get_label_count(index="label")} \
question-answer pairs""")

Loaded 358 question-answer pairs

接下来，我们需要在我们的问题 ID 和我们可以传递给管道的相应答案之间建立一个映射。要获取所有标签，我们可以使用get_all_labels_aggregated()文档存储中的方法，该方法将聚合与唯一 ID 关联的所有问答对。这个方法返回一个MultiLabel对象列表，但在我们的例子中，我们只得到一个元素，因为我们是按问题 ID 过滤的。我们可以建立一个聚合标签列表，如下所示：

labels_agg = document_store.get_all_labels_aggregated(
    index="label",
    open_domain=True,
    aggregate_by_meta=["item_id"]
)
print(len(labels_agg))

330

通过查看这些标签之一，我们可以看到与给定问题相关的所有答案都汇总在一个 multiple_answers字段中：

print(labels_agg[109])

{'question': 'How does the fan work?', 'multiple_answers': ['the fan is really
really good', "the fan itself isn't super loud. There is an adjustable dial to
change fan speed"], 'is_correct_answer': True, 'is_correct_document': True,
'origin': '5a9b7616541f700f103d21f8ad41bc4b', 'multiple_document_ids': [None,
None], 'multiple_offset_start_in_docs': [None, None], 'no_answer': False,
'model_id': None, 'meta': {'item_id': 'B002MU1ZRS'}}

我们现在拥有评估检索器的所有要素，因此让我们定义一个函数，将与每个产品关联的每个问答对馈送到评估管道并跟踪我们pipe对象中的正确检索：

def run_pipeline(pipeline, top_k_retriever=10, top_k_reader=4):
    for l in labels_agg:
        _ = pipeline.pipeline.run(
            query=l.question,
            top_k_retriever=top_k_retriever,
            top_k_reader=top_k_reader,
            top_k_eval_documents=top_k_retriever,
            labels=l,
            filters={"item_id": [l.meta["item_id"]], "split": ["test"]})

run_pipeline(pipe, top_k_retriever=3)
print(f"Recall@3: {pipe.eval_retriever.recall:.2f}")

Recall@3: 0.95

太好了，它有效！请注意，我们选择了一个特定的值 top_k_retriever来指定要检索的文档数。一般来说，增加这个参数会提高召回率，但代价是向读者提供更多文档并减慢端到端管道。为了指导我们决定选择哪个值，我们将创建一个循环多个 k值的函数，并为每个k计算整个测试集的召回率：

def evaluate_retriever(retriever, topk_values = [1,3,5,10,20]):
    topk_results = {}
 
    for topk in topk_values:
        # Create Pipeline
        p = EvalRetrieverPipeline(retriever)
        # Loop over each question-answers pair in test set
        run_pipeline(p, top_k_retriever=topk)
        # Get metrics
        topk_results[topk] = {"recall": p.eval_retriever.recall}
 
    return pd.DataFrame.from_dict(topk_results, orient="index")
 
 
es_topk_df = evaluate_retriever(es_retriever)

如果我们绘制结果，我们可以看到随着k的增加召回率如何提高：

def plot_retriever_eval(dfs, retriever_names):
    fig, ax = plt.subplots()
    for df, retriever_name in zip(dfs, retriever_names):
        df.plot(y="recall", ax=ax, label=retriever_name)
    plt.xticks(df.index)
    plt.ylabel("Top-k Recall")
    plt.xlabel("k")
    plt.show()
 
plot_retriever_eval([es_topk_df], ["BM25"])

从图中，我们可以看到周围有一个拐点k=5我们得到了几乎完美的回忆 k=10向前。现在让我们看看使用密集向量技术检索文档。

from haystack.retriever.dense import DensePassageRetriever
 
dpr_retriever = DensePassageRetriever(document_store=document_store,
    query_embedding_model="facebook/dpr-question_encoder-single-nq-base",
    passage_embedding_model="facebook/dpr-ctx_encoder-single-nq-base",
    embed_title=False)

document_store.update_embeddings(retriever=dpr_retriever)

dpr_topk_df = evaluate_retriever(dpr_retriever)
plot_retriever_eval([es_topk_df, dpr_topk_df], ["BM25", "DPR"])

评估Reader

在抽取式 QA 中，有两个主要指标用于评估读者：

Exact Match  (EM)

如果预测和基本事实答案中的字符完全匹配，则给出 EM = 1 的二进制度量，否则 EM = 0。如果没有预期的答案，则如果模型预测任何文本，则 EM = 0。

F1-score

测量准确率和召回率的调和平均值。

让我们通过从 FARM 导入一些辅助函数并将它们应用于一个简单的示例来看看这些指标是如何工作的：

from farm.evaluation.squad_evaluation import compute_f1, compute_exact
 
pred = "about 6000 hours"
label = "6000 hours"
print(f"EM: {compute_exact(label, pred)}")
print(f"F1: {compute_f1(label, pred)}")

EM: 0
F1: 0.8

在后台，这些函数首先通过删除标点符号、修复空格和转换为小写来规范化预测和标签。然后，规范化的字符串被标记为词袋，然后最终在标记级别计算度量。从这个简单的例子中，我们可以看到 EM 是一个比 F 1 -score 更严格的度量：将单个标记添加到预测中会使 EM 为零。另一方面，F 1分数可能无法捕捉到真正不正确的答案。例如，如果我们预测的答案跨度是“大约 6000 美元”，那么我们得到：

pred = "about 6000 dollars"
print(f"EM: {compute_exact(label, pred)}")
print(f"F1: {compute_f1(label, pred)}")

EM: 0
F1: 0.4

因此，仅依赖F 1 -score 会产生误导，跟踪这两个指标是平衡低估 (EM) 和高估 ( F 1 -score) 模型性能之间的权衡的好策略。

现在一般来说，每个问题都有多个有效答案，因此这些指标是针对评估集中的每个问答对计算的，并在所有可能的答案中选择最佳分数。然后通过对每个问答对的各个分数进行平均来获得模型的总体 EM 和F 1分数。

为了评估阅读器，我们将创建一个带有两个节点的新管道：一个阅读器节点和一个用于评估阅读器的节点。我们将使用EvalReader从读者那里获取预测并计算相应的 EM 和F 1 分数的类。为了与 SQuAD 评估进行比较，我们将使用存储在中的top_1_em和指标为每个查询获取最佳答案：top_1_f1EvalAnswers

from haystack.eval import EvalAnswers
 
def evaluate_reader(reader):
    score_keys = ['top_1_em', 'top_1_f1']
    eval_reader = EvalAnswers(skip_incorrect_retrieval=False)
    pipe = Pipeline()
    pipe.add_node(component=reader, name="QAReader", inputs=["Query"])
    pipe.add_node(component=eval_reader, name="EvalReader", inputs=["QAReader"])
 
    for l in labels_agg:
        doc = document_store.query(l.question,
                                   filters={"question_id":[l.origin]})
        _ = pipe.run(query=l.question, documents=doc, labels=l)
 
    return {k:v for k,v in eval_reader.__dict__.items() if k in score_keys}
 
reader_eval = {}
reader_eval["Fine-tune on SQuAD"] = evaluate_reader(reader)

请注意，我们指定了skip_incorrect_retrieval=False. 这是为了确保检索器始终将上下文传递给阅读器（如在 SQuAD 评估中）。现在我们已经通过阅读器运行了每个问题，让我们打印分数：

def plot_reader_eval(reader_eval):
    fig, ax = plt.subplots()
    df = pd.DataFrame.from_dict(reader_eval)
    df.plot(kind="bar", ylabel="Score", rot=0, ax=ax)
    ax.set_xticklabels(["EM", "F1"])
    plt.legend(loc='upper left')
    plt.show()
 
plot_reader_eval(reader_eval)

好的，微调后的模型在 SubjQA 上的表现似乎比在 SQuAD 2.0 上的表现要差得多，在 SQuAD 2.0 上，MiniLM 的 EM 和F 1 分数分别为 76.1 和 79.5。性能下降的一个原因是客户评论与生成 SQuAD 2.0 数据集的 Wikipedia 文章完全不同，而且他们使用的语言通常是非正式的。另一个因素可能是我们数据集固有的主观性，其中问题和答案都与维基百科中包含的事实信息不同。让我们看看如何在数据集上微调模型，以通过域适应获得更好的结果。

领域适应

尽管在 SQuAD 上微调的模型通常可以很好地推广到其他领域，但我们已经看到，对于 SubjQA，我们模型的 EM 和 F 1分数比 SQuAD 差得多。在其他抽取式 QA 数据集中也观察到了这种泛化失败，这被认为是 Transformer 模型特别擅长过度拟合 SQuAD 的证据。15提高阅读器最直接的方法是在 SubjQA 训练集上进一步微调我们的 MiniLM 模型。FARMReader有一个 为此目的而设计的train()方法，并期望数据采用 SQuAD JSON 格式，其中所有问答对针对每个项目分组在一起， 如图 7-11 所示。

这是一种相当复杂的数据格式，所以我们需要一些函数和一些 Pandas 魔法来帮助我们进行转换。我们需要做的第一件事是实现一个函数，该函数可以创建 paragraphs与每个产品 ID 关联的数组。该数组中的每个元素都包含一个上下文（即评论）和一qas组问答对。这是一个构建 paragraphs数组的函数：

def create_paragraphs(df):
    paragraphs = []
    id2context = dict(zip(df["review_id"], df["context"]))
    for review_id, review in id2context.items():
        qas = []
        # Filter for all question-answer pairs about a specific context
        review_df = df.query(f"review_id == '{review_id}'")
        id2question = dict(zip(review_df["id"], review_df["question"]))
        # Build up the qas array
        for qid, question in id2question.items():
            # Filter for a single question ID
            question_df = df.query(f"id == '{qid}'").to_dict(orient="list")
            ans_start_idxs = question_df["answers.answer_start"][0].tolist()
            ans_text = question_df["answers.text"][0].tolist()
            # Fill answerable questions
            if len(ans_start_idxs):
                answers = [
                    {"text": text, "answer_start": answer_start}
                    for text, answer_start in zip(ans_text, ans_start_idxs)]
                is_impossible = False
            else:
                answers = []
                is_impossible = True
            # Add question-answer pairs to qas
            qas.append({"question": question, "id": qid,
                        "is_impossible": is_impossible, "answers": answers})
        # Add context and question-answer pairs to paragraphs
        paragraphs.append({"qas": qas, "context": review})
    return paragraphs

现在，当我们应用到DataFrame与单个产品 ID 关联的行时，我们得到 SQuAD 格式：

product = dfs["train"].query("title == 'B00001P4ZH'")
create_paragraphs(product)

[{'qas': [{'question': 'How is the bass?',
    'id': '2543d296da9766d8d17d040ecc781699',
    'is_impossible': True,
    'answers': []}],
  'context': 'I have had Koss headphones ...',
    'id': 'd476830bf9282e2b9033e2bb44bbb995',
    'is_impossible': False,
    'answers': [{'text': 'Bass is weak as expected', 'answer_start': 1302},
     {'text': 'Bass is weak as expected, even with EQ adjusted up',
      'answer_start': 1302}]}],
  'context': 'To anyone who hasn\'t tried all ...'},
 {'qas': [{'question': 'How is the bass?',
    'id': '455575557886d6dfeea5aa19577e5de4',
    'is_impossible': False,
    'answers': [{'text': 'The only fault in the sound is the bass',
      'answer_start': 650}]}],
  'context': "I have had many sub-$100 headphones ..."}]

最后一步是将此函数应用于 DataFrame每个拆分中的每个产品 ID。以下convert_to_squad()函数执行此技巧并将结果存储在电子-{split}.json 文件中：

import json
 
def convert_to_squad(dfs):
    for split, df in dfs.items():
        subjqa_data = {}
        # Create `paragraphs` for each product ID
        groups = (df.groupby("title").apply(create_paragraphs)
            .to_frame(name="paragraphs").reset_index())
        subjqa_data["data"] = groups.to_dict(orient="records")
        # Save the result to disk
        with open(f"electronics-{split}.json", "w+", encoding="utf-8") as f:
            json.dump(subjqa_data, f)
 
convert_to_squad(dfs)

现在我们有了正确格式的拆分，让我们通过指定训练和开发拆分的位置以及保存微调模型的位置来微调我们的阅读器：

train_filename = "electronics-train.json"
dev_filename = "electronics-validation.json"
 
reader.train(data_dir=".", use_gpu=True, n_epochs=1, batch_size=16,
             train_filename=train_filename, dev_filename=dev_filename)

随着阅读器的微调，现在让我们将其在测试集上的性能与我们的基线模型进行比较：

reader_eval["Fine-tune on SQuAD + SubjQA"] = evaluate_reader(reader)
plot_reader_eval(reader_eval)

哇，域适应使我们的 EM 分数提高了六倍，并且使F 1分数增加了一倍多！此时，您可能想知道为什么我们不直接在 SubjQA 训练集上微调预训练的语言模型。一个原因是我们在 SubjQA 中只有 1,295 个训练样例，而 SQuAD 有超过 100,000 个，因此我们可能会遇到过拟合的挑战。不过，让我们看看幼稚微调会产生什么。为了公平比较，我们将使用用于微调 SQuAD 基线的相同语言模型。和以前一样，我们将使用以下内容加载模型FARMReader：

minilm_ckpt = "microsoft/MiniLM-L12-H384-uncased"
minilm_reader = FARMReader(model_name_or_path=minilm_ckpt, progress_bar=False,
                           max_seq_len=max_seq_length, doc_stride=doc_stride,
                           return_no_answer=True)

接下来，我们微调一个 epoch：

minilm_reader.train(data_dir=".", use_gpu=True, n_epochs=1, batch_size=16,
             train_filename=train_filename, dev_filename=dev_filename)

并包括对测试集的评估：

reader_eval["Fine-tune on SubjQA"] = evaluate_reader(minilm_reader)
plot_reader_eval(reader_eval)

我们可以看到，直接在 SubjQA 上微调语言模型比在 SQuAD 和 SubjQA 上微调性能要差得多。

评估整个 QA 管道

现在我们已经了解了如何单独评估阅读器和检索器组件，让我们将它们联系在一起来衡量我们管道的整体性能。为此，我们需要使用 reader 及其 评估的节点来扩充我们的检索器管道。我们已经看到我们在 k=10，所以我们可以修复这个值并评估它对阅读器性能的影响（因为与 SQuAD 风格的评估相比，它现在每个查询都会接收多个上下文）：

# Initialize retriever pipeline
pipe = EvalRetrieverPipeline(es_retriever)
# Add nodes for reader
eval_reader = EvalAnswers()
pipe.pipeline.add_node(component=reader, name="QAReader",
              inputs=["EvalRetriever"])
pipe.pipeline.add_node(component=eval_reader, name="EvalReader",
              inputs=["QAReader"])
# Evaluate!
run_pipeline(pipe)
# Extract metrics from reader
reader_eval["QA Pipeline (top-1)"] = {
    k:v for k,v in eval_reader.__dict__.items()
    if k in ["top_1_em", "top_1_f1"]}

然后，我们可以比较模型的前 1 个 EM 和F 1分数，以预测图 7-12中检索器返回的文档中的答案。

从这个图中我们可以看到检索器对整体性能的影响。特别是，与匹配问题-上下文对相比，存在整体退化，就像在 SQuAD 风格的评估中所做的那样。这可以通过增加允许读者预测的可能答案的数量来规避。

到目前为止，我们只从上下文中提取了答案范围，但一般来说，答案的零碎部分可能分散在整个文档中，我们希望我们的模型将这些片段合成为一个连贯的答案。让我们看看如何使用生成式 QA 来成功完成这项任务。

图 7-13。用于端到端微调检索器和生成器的 RAG 架构（由 Ethan Perez 提供）

笔记

在 RAG 中，查询编码器和生成器都是端到端训练的，而上下文编码器是冻结的。在 Haystack 中，GenerativeQAPipeline使用来自 的查询编码器RAGenerator和来自 的上下文编码器DensePassageRetriever。

图 7-14。需求的质量保证层次结构