总结长文档

本笔记本的目的是演示如何以可控的详细程度来总结长文档。

如果你给 GPT 模型一个总结长文档（例如 10k 或更多 token）的任务，你通常会得到一个相对较短的摘要，这个摘要与文档的长度不成比例。例如，一个 20k token 文档的摘要不会是 10k token 文档摘要的两倍长。一种解决方法是将文档分成几块，然后逐块生成摘要。在多次查询 GPT 模型后，可以重建完整的摘要。通过控制文本块的数量和大小，我们可以最终控制输出的详细程度。

import os
from typing import List, Tuple, Optional
from openai import OpenAI
import tiktoken
from tqdm import tqdm

# 打开包含美国维基百科页面部分文本的数据集
with open("data/artificial_intelligence_wikipedia.txt", "r") as file:
    artificial_intelligence_wikipedia_text = file.read()

# 加载编码并检查数据集的长度
encoding = tiktoken.encoding_for_model('gpt-4-turbo')
len(encoding.encode(artificial_intelligence_wikipedia_text))

14630

我们将定义一个简单的实用程序来包装对 OpenAI API 的调用。

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def get_chat_completion(messages, model='gpt-4-turbo'):
    response = client.chat.completions.create(
        model=model,
        messages=messages,
        temperature=0,
    )
    return response.choices[0].message.content

接下来，我们将定义一些将长文档分块的实用程序。

def tokenize(text: str) -> List[str]:
    encoding = tiktoken.encoding_for_model('gpt-4-turbo')
    return encoding.encode(text)


# 此函数根据最大 token 数和分隔符将文本分块。
def chunk_on_delimiter(input_string: str,
                       max_tokens: int, delimiter: str) -> List[str]:
    chunks = input_string.split(delimiter)
    combined_chunks, _, dropped_chunk_count = combine_chunks_with_no_minimum(
        chunks, max_tokens, chunk_delimiter=delimiter, add_ellipsis_for_overflow=True
    )
    if dropped_chunk_count > 0:
        print(f"警告：由于溢出，已删除 {dropped_chunk_count} 个块")
    combined_chunks = [f"{chunk}{delimiter}" for chunk in combined_chunks]
    return combined_chunks


# 此函数将文本块合并成较大的块，同时不超过指定的 token 数。它返回合并后的文本块、它们的原始索引以及因溢出而删除的块数。
def combine_chunks_with_no_minimum(
        chunks: List[str],
        max_tokens: int,
        chunk_delimiter="\n\n",
        header: Optional[str] = None,
        add_ellipsis_for_overflow=False,
) -> Tuple[List[str], List[int]]:
    dropped_chunk_count = 0
    output = []  # 用于保存最终合并块的列表
    output_indices = []  # 用于保存最终合并块索引的列表
    candidate = (
        [] if header is None else [header]
    )  # 用于保存当前合并块候选的列表
    candidate_indices = []
    for chunk_i, chunk in enumerate(chunks):
        chunk_with_header = [chunk] if header is None else [header, chunk]
        if len(tokenize(chunk_delimiter.join(chunk_with_header))) > max_tokens:
            print(f"警告：块溢出")
            if (
                    add_ellipsis_for_overflow
                    and len(tokenize(chunk_delimiter.join(candidate + ["..."]))) <= max_tokens
            ):
                candidate.append("...")
                dropped_chunk_count += 1
            continue  # 此情况会破坏下游假设
        # 估计添加当前块后的 token 数
        extended_candidate_token_count = len(tokenize(chunk_delimiter.join(candidate + [chunk])))
        # 如果 token 数超过 max_tokens，则将当前候选添加到输出并开始新的候选
        if extended_candidate_token_count > max_tokens:
            output.append(chunk_delimiter.join(candidate))
            output_indices.append(candidate_indices)
            candidate = chunk_with_header  # 重新初始化候选
            candidate_indices = [chunk_i]
        # 否则继续扩展候选
        else:
            candidate.append(chunk)
            candidate_indices.append(chunk_i)
    # 如果剩余候选不为空，则将其添加到输出
    if (header is not None and len(candidate) > 1) or (header is None and len(candidate) > 0):
        output.append(chunk_delimiter.join(candidate))
        output_indices.append(candidate_indices)
    return output, output_indices, dropped_chunk_count

现在我们可以定义一个实用程序来以可控的详细程度进行摘要（注意 detail 参数）。

该函数首先根据可控的 detail 参数在最小和最大块计数之间进行插值来确定块的数量。然后，它将文本分割成块并单独总结每个块。

def summarize(text: str,
              detail: float = 0,
              model: str = 'gpt-4-turbo',
              additional_instructions: Optional[str] = None,
              minimum_chunk_size: Optional[int] = 500,
              chunk_delimiter: str = ".",
              summarize_recursively=False,
              verbose=False):
    """
    通过将文本分割成块来总结给定文本，每个块都会单独进行摘要。
    摘要的详细程度可以调整，并且该过程可以递归进行。

    参数：

    - text (str)：要摘要的文本。
    - detail (float, optional)：介于 0 和 1 之间的值，表示摘要所需的详细程度。
      0 产生更高层次的摘要，1 产生更详细的摘要。默认为 0。

    - model (str, optional)：用于生成摘要的模型。默认为 'gpt-3.5-turbo'。
    - additional_instructions (Optional[str], optional)：为定制摘要提供给模型的附加说明。
    - minimum_chunk_size (Optional[int], optional)：文本块的最小大小。默认为 500。
    - chunk_delimiter (str, optional)：用于将文本分割成块的分隔符。默认为“.”。
    - summarize_recursively (bool, optional)：如果为 True，则摘要是递归生成的，使用先前的摘要作为上下文。
    - verbose (bool, optional)：如果为 True，则打印有关分块过程的详细信息。

    返回：

    - str：文本的最终编译摘要。

    该函数首先根据 `detail` 参数在最小和最大块计数之间进行插值来确定块的数量。
    然后，它将文本分割成块并单独总结每个块。如果 `summarize_recursively` 为 True，则每个摘要都基于先前的摘要，
    为摘要过程添加更多上下文。该函数返回所有块的编译摘要。
    """

    # 检查 detail 是否设置正确
    assert 0 <= detail <= 1

    # 根据插值确定的块数来确定摘要的详细程度
    max_chunks = len(chunk_on_delimiter(text, minimum_chunk_size, chunk_delimiter))
    min_chunks = 1
    num_chunks = int(min_chunks + detail * (max_chunks - min_chunks))

    # 根据插值确定的块数调整 chunk_size
    document_length = len(tokenize(text))
    chunk_size = max(minimum_chunk_size, document_length // num_chunks)
    text_chunks = chunk_on_delimiter(text, chunk_size, chunk_delimiter)
    if verbose:
        print(f"将文本分割成 {len(text_chunks)} 个块进行摘要。")
        print(f"块的长度为 {[len(tokenize(x)) for x in text_chunks]}")

    # 设置系统消息
    system_message_content = "将此文本改写成摘要形式。"
    if additional_instructions is not None:
        system_message_content += f"\n\n{additional_instructions}"

    accumulated_summaries = []
    for chunk in tqdm(text_chunks):
        if summarize_recursively and accumulated_summaries:
            # 创建用于递归摘要的结构化提示
            accumulated_summaries_string = '\n\n'.join(accumulated_summaries)
            user_message_content = f"先前的摘要：\n\n{accumulated_summaries_string}\n\n下一个要摘要的文本：\n\n{chunk}"
        else:
            # 直接传递块进行摘要，无需递归上下文
            user_message_content = chunk

        # 根据是否应用了递归摘要来构建消息
        messages = [
            {"role": "system", "content": system_message_content},
            {"role": "user", "content": user_message_content}
        ]

        # 假设此函数获取完成并按预期工作
        response = get_chat_completion(messages, model=model)
        accumulated_summaries.append(response)

    # 从部分摘要编译最终摘要
    final_summary = '\n\n'.join(accumulated_summaries)

    return final_summary

现在我们可以使用此实用程序来生成不同详细程度的摘要。通过将 detail 从 0 增加到 1，我们可以获得越来越长的底层文档摘要。detail 参数的值越高，摘要就越详细，因为该实用程序首先将文档分割成更多块。然后对每个块进行摘要，最终摘要是所有块摘要的串联。

summary_with_detail_0 = summarize(artificial_intelligence_wikipedia_text, detail=0, verbose=True)

将文本分割成 1 个块进行摘要。块的长度为 [14631] 100%|██████████| 1/1 [00:09<00:00, 9.68s/it]

summary_with_detail_pt25 = summarize(artificial_intelligence_wikipedia_text, detail=0.25, verbose=True)

将文本分割成 9 个块进行摘要。块的长度为 [1817, 1807, 1823, 1810, 1806, 1827, 1814, 1829, 103] 100%|██████████| 9/9 [01:33<00:00, 10.39s/it]

summary_with_detail_pt5 = summarize(artificial_intelligence_wikipedia_text, detail=0.5, verbose=True)

将文本分割成 17 个块进行摘要。块的长度为 [897, 890, 914, 876, 893, 906, 893, 902, 909, 907, 905, 889, 902, 890, 901, 880, 287] 100%|██████████| 17/17 [02:26<00:00, 8.64s/it]

summary_with_detail_1 = summarize(artificial_intelligence_wikipedia_text, detail=1, verbose=True)

将文本分割成 31 个块进行摘要。块的长度为 [492, 427, 485, 490, 496, 478, 473, 497, 496, 501, 499, 497, 493, 470, 472, 494, 489, 492, 481, 485, 471, 500, 486, 498, 478, 469, 498, 468, 493, 478, 103] 100%|██████████| 31/31 [04:08<00:00, 8.02s/it]

原始文档接近 15k token。请注意 summary_with_detail_0 和 summary_with_detail_1 之间的长度差异有多大。它几乎长了 25 倍！

# 摘要的长度
[len(tokenize(x)) for x in
 [summary_with_detail_0, summary_with_detail_pt25, summary_with_detail_pt5, summary_with_detail_1]]

[235, 2529, 4336, 6742]

让我们检查一下摘要，看看当 detail 参数从 0 增加到 1 时详细程度如何变化。

print(summary_with_detail_0)

人工智能（AI）是指在机器中模拟人类智能，旨在执行通常需要人类智能的任务。这包括高级搜索引擎、推荐系统、语音交互、自动驾驶汽车等应用。AI 于 1956 年首次由艾伦·图灵进行了重要研究，并成为一门学术学科。该领域经历了高期望然后幻灭和资金减少的周期，被称为“AI 寒冬”。2012 年后，随着深度学习的进步，AI 的兴趣激增，2017 年后，随着 Transformer 架构的发展，AI 的兴趣再次激增，导致 2020 年代初 AI 研究和应用的繁荣。

AI 越来越多地融入各个行业，正在影响社会和经济向自动化和数据驱动决策的转变，影响就业、医疗保健和隐私等领域。对 AI 的伦理和安全担忧促使了对监管政策的讨论。

AI 研究涉及各种子领域，专注于推理、学习和感知等特定目标，并利用数学、逻辑和其他学科的技术。尽管 AI 有广泛的应用，但其复杂性和潜在风险，如隐私问题、错误信息和伦理挑战，仍然是积极调查和辩论的领域。

print(summary_with_detail_1)

人工智能（AI）是指在机器中模拟人类智能，旨在感知其环境并做出决策以实现特定目标。这项技术广泛应用于工业、政府和科学等各个领域，应用范围从网络搜索引擎和推荐系统到自动驾驶汽车和游戏中的 AI。尽管 AI 已成为许多工具和应用程序的常见功能，但当它变得足够集成和普及时，通常不会被识别为 AI。

AI 领域，作为一门学术学科始于 1956 年，经历了几个高期望然后失望的周期，被称为 AI 寒冬。2012 年后，随着深度学习的进步，AI 的兴趣激增，2017 年后，随着 Transformer 架构的发展，AI 的兴趣再次激增，导致 2020 年代初 AI 研究和应用大幅增长，主要在美国。

21 世纪 AI 的日益集成正在推动各行各业向自动化和数据驱动决策的转变，影响着就业市场、医疗保健和教育等领域。这引发了关于伦理影响、长期效应以及确保 AI 技术安全和效益的监管政策需求的重大问题。AI 研究本身是多样化的，专注于推理、学习和感知等目标，并利用各种工具和方法来实现这些目标。

通用智能，即能够至少像人类一样执行任何人类任务，是 AI 研究的长期目标。为了实现这一目标，AI 集成了搜索和优化、形式逻辑、神经网络和统计学等各种技术，以及来自心理学、语言学和神经科学的见解。AI 研究专注于推理和解决问题等特定特征，早期算法模仿人类的逐步推理。然而，由于组合爆炸，这些算法在处理大型复杂问题时会遇到困难，并且效率不如人类的直觉判断。知识表示是另一个关键领域，它利用本体来构建领域特定知识和关系，从而辅助智能查询、场景解释和数据挖掘等应用。

知识库必须包含广泛的元素，包括对象、属性、类别、关系、事件、状态、时间、原因、结果和元知识。它们还需要处理默认推理，即某些假设在未被矛盾的情况下得以维持。知识表示中的挑战包括常识知识的巨大范围及其通常的子符号、非语言性质，以及为 AI 使用获取这些知识的困难。

在 AI 领域，"代理"被定义为感知其环境并采取行动以实现目标或满足偏好的实体。在自动化规划中，代理追求特定目标，而在决策中，它根据预期效用评估行动以最大化偏好满足。经典规划假设代理对行动结果有完全的了解，但现实世界场景通常涉及对情况和结果的不确定性，需要概率决策。此外，代理可能需要适应或学习偏好，尤其是在涉及多个代理或人机交互的复杂环境中。

信息价值理论有助于评估在结果不确定的情况下探索性行动的价值。马尔可夫决策过程使用转移模型和奖励函数来指导决策，这些决策可以通过计算、启发式方法或学习来确定。博弈论分析了多个交互代理在涉及他人的决策场景中的理性行为。

机器学习是 AI 的组成部分，涉及自动改进任务性能的程序。它包括无监督学习，它在没有指导的情况下识别数据中的模式；以及监督学习，它需要标记数据并包括分类和回归任务。强化学习通过奖励或惩罚代理来塑造其响应，而迁移学习则将一个问题的知识应用于另一个问题。深度学习是机器学习的一个子集，它使用受生物过程启发的人工神经网络。

计算学习理论根据计算和样本复杂性等标准评估学习算法。自然语言处理（NLP）使程序能够使用人类语言进行交互，处理语音识别、合成、翻译等挑战。早期受乔姆斯基理论影响的 NLP 工作在处理受控环境之外的模糊语言时遇到了限制。

玛格丽特·马斯特曼强调了意义在语言理解中的重要性，主张在计算语言学中使用同义词词典而不是词典。现代 NLP 技术包括词嵌入、Transformer，到 2023 年，GPT 模型已能在各种测试中达到人类水平的分数。机器学习是 AI 的组成部分，涉及自动改进任务性能的程序。它包括无监督学习，它在没有指导的情况下识别数据中的模式；以及监督学习，它需要标记数据并包括分类和回归任务。强化学习通过奖励或惩罚代理来塑造其响应，而迁移学习则将一个问题的知识应用于另一个问题。深度学习是机器学习的一个子集，它使用受生物过程启发的人工神经网络。

机器学习是 AI 的组成部分，涉及自动改进任务性能的程序。它包括无监督学习，在没有指导的情况下识别数据中的模式；以及监督学习，它需要标记数据并包括分类和回归任务。强化学习通过奖励或惩罚代理来塑造其响应，而迁移学习则将一个问题的知识应用于另一个问题。深度学习是机器学习的一个子集，它使用受生物过程启发的人工神经网络。

机器学习是 AI 的组成部分，涉及自动改进任务性能的程序。它包括无监督学习，在没有指导的情况下识别数据中的模式；以及监督学习，它需要标记数据并包括分类和回归任务。强化学习通过奖励或惩罚代理来塑造其响应，而迁移学习则将一个问题的知识应用于另一个问题。深度学习是机器学习的一个子集，它使用受生物过程启