AI 处理长文本时出现丢信息问题的分段推理优化策略

AI 处理长文本时出现丢信息问题的分段推理优化策略

大家好，今天我们来聊聊在使用 AI，特别是大型语言模型 (LLM) 处理长文本时，一个常见且令人头疼的问题：信息丢失。这个问题在许多应用场景中都会出现，比如文档摘要、问答系统、代码生成等。当文本长度超过模型的上下文窗口限制时，模型往往无法完整地理解整个文档，从而导致推理结果不准确，甚至遗漏关键信息。

今天，我们将深入探讨这个问题，并着重介绍一种有效的解决方案：分段推理优化策略。我会从问题的根源入手，逐步讲解分段推理的原理，并通过具体的代码示例，演示如何在实际项目中应用这种策略，以提高 LLM 处理长文本的能力。

问题根源：上下文窗口限制与信息衰减

LLM 的核心是 Transformer 架构，其计算复杂度与序列长度呈平方关系。因此，为了控制计算成本和内存占用，大多数 LLM 都设置了上下文窗口的限制，即模型能够处理的最大文本长度。

当输入文本超过上下文窗口时，最简单的处理方式是截断，但这会直接导致信息丢失。更复杂的情况是，即使文本在上下文窗口内，由于 Transformer 的注意力机制存在衰减现象，模型对文本开头部分的信息关注度会逐渐降低，这也会导致信息丢失。

这种信息丢失问题主要体现在以下几个方面：

• 细节遗漏： 模型可能无法记住文本中所有的细节信息，导致摘要不完整或问答不准确。
• 逻辑断裂： 模型可能无法理解文本中长距离的依赖关系，导致推理逻辑出现断裂。
• 主题偏移： 模型可能只关注文本末尾的信息，忽略文本开头的重要信息，导致主题偏移。

分段推理：化整为零，逐层递进

分段推理的核心思想是将长文本分割成多个段落，分别对每个段落进行推理，然后将各个段落的推理结果进行整合，最终得到完整的推理结果。这种方法可以将长文本处理问题转化为多个短文本处理问题，从而缓解上下文窗口限制和信息衰减带来的影响。

分段推理的具体步骤如下：

1. 文本分割： 将长文本分割成多个段落。分割方法可以根据具体任务和文本特点进行选择，例如按句子分割、按段落分割或按章节分割。
2. 段落编码： 将每个段落输入 LLM，得到每个段落的向量表示（embedding）。
3. 段落推理： 对每个段落的向量表示进行推理，得到每个段落的推理结果。推理任务可以是摘要生成、问答、情感分析等。
4. 结果整合： 将各个段落的推理结果进行整合，得到最终的推理结果。整合方法可以根据具体任务和推理结果的类型进行选择，例如拼接、平均、加权平均或使用另一个 LLM 进行总结。

分段推理的具体实现：代码示例

下面，我们以一个简单的文档摘要任务为例，演示如何使用 Python 和 OpenAI API 实现分段推理。

1. 准备工作

首先，我们需要安装必要的库：

pip install openai tiktoken

2. 文本分割

我们将使用一个简单的文本分割函数，按句子分割文本。

import re

def split_text_into_sentences(text, max_length=500):
    """
    将文本分割成句子，并限制每个句子的最大长度。
    """
    sentences = re.split(r'(?<!w.w.)(?<![A-Z][a-z].)(?<=.|?)s', text)

    # 合并过短的句子
    merged_sentences = []
    temp_sentence = ""
    for sentence in sentences:
        if len(temp_sentence + sentence) < max_length:
            temp_sentence += sentence + " "
        else:
            if temp_sentence:
                merged_sentences.append(temp_sentence.strip())
            temp_sentence = sentence + " "
    if temp_sentence:
        merged_sentences.append(temp_sentence.strip())

    return merged_sentences

3. 段落编码

我们将使用 OpenAI API 获取每个段落的向量表示。

import openai
import os

# 设置 OpenAI API 密钥
openai.api_key = os.getenv("OPENAI_API_KEY") # 确保你设置了环境变量 OPENAI_API_KEY

def get_embedding(text, model="text-embedding-ada-002"):
   text = text.replace("n", " ")
   return openai.Embedding.create(input = [text], model=model)['data'][0]['embedding']

4. 段落推理

我们将使用 OpenAI API 对每个段落进行摘要生成。

def summarize_paragraph(text, model="gpt-3.5-turbo"):
    """
    使用 OpenAI API 对段落进行摘要生成。
    """
    messages = [
        {"role": "system", "content": "你是一个专业的文本摘要生成器。请用简洁的语言概括以下文本的核心内容。"},
        {"role": "user", "content": text}
    ]
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0.7,
        max_tokens=200
    )
    return response['choices'][0]['message']['content']

5. 结果整合

我们将使用另一个 LLM 对各个段落的摘要进行总结，得到最终的摘要。

def combine_summaries(summaries, model="gpt-3.5-turbo"):
    """
    使用 OpenAI API 对多个摘要进行总结，得到最终的摘要。
    """
    combined_text = "n".join(summaries)
    messages = [
        {"role": "system", "content": "你是一个专业的文本摘要生成器。请用简洁的语言概括以下多个文本摘要的核心内容，生成一份最终摘要。"},
        {"role": "user", "content": combined_text}
    ]
    response = openai.ChatCompletion.create(
        model=model,
        messages=messages,
        temperature=0.7,
        max_tokens=300
    )
    return response['choices'][0]['message']['content']

6. 主函数

将以上函数组合起来，实现完整的分段推理流程。

def long_text_summarization(text):
    """
    对长文本进行分段摘要。
    """
    sentences = split_text_into_sentences(text)

    # 如果句子数量很少，则直接总结
    if len(sentences) < 3:
        return summarize_paragraph(text)

    paragraph_summaries = []
    for sentence in sentences:
        summary = summarize_paragraph(sentence)
        paragraph_summaries.append(summary)

    final_summary = combine_summaries(paragraph_summaries)
    return final_summary

7. 测试代码

# 示例文本（可以替换成任何长文本）
text = """
The use of Machine Learning (ML) algorithms is rapidly increasing across various industries. However, the effectiveness of these algorithms heavily relies on the quality and quantity of data they are trained on. One of the key challenges in real-world ML applications is dealing with imbalanced datasets, where the number of instances belonging to one class significantly outweighs the number of instances belonging to another class. This imbalance can lead to biased models that perform poorly on the minority class, which is often the class of interest. For example, in fraud detection, the number of fraudulent transactions is typically much smaller than the number of legitimate transactions.

Several techniques have been developed to address the class imbalance problem. These techniques can be broadly classified into three categories: data-level approaches, algorithm-level approaches, and cost-sensitive learning approaches. Data-level approaches involve resampling the dataset to balance the class distribution. This can be achieved by either oversampling the minority class or undersampling the majority class. Oversampling techniques, such as Synthetic Minority Oversampling Technique (SMOTE), generate synthetic instances of the minority class by interpolating between existing instances. Undersampling techniques, on the other hand, randomly remove instances from the majority class.

Algorithm-level approaches modify the ML algorithms to be less sensitive to class imbalance. This can be done by adjusting the decision threshold of the classifier or by using ensemble methods that combine multiple classifiers trained on different subsets of the data. Cost-sensitive learning approaches assign different misclassification costs to different classes, giving higher costs to misclassifying the minority class. This encourages the model to pay more attention to the minority class and improve its performance on that class.

Evaluating the performance of ML models on imbalanced datasets requires careful consideration. Traditional evaluation metrics, such as accuracy, can be misleading as they tend to favor the majority class. Therefore, it is important to use more appropriate metrics, such as precision, recall, F1-score, and area under the receiver operating characteristic curve (AUC-ROC). These metrics provide a more comprehensive assessment of the model's performance on both the majority and minority classes.
"""

# 调用分段摘要函数
summary = long_text_summarization(text)
print(summary)

代码解释：

• split_text_into_sentences 函数用于将长文本分割成多个句子，并限制每个句子的最大长度，避免单个句子过长，超出模型的上下文窗口。
• get_embedding 函数用于获取每个句子的向量表示，用于后续的推理任务。
• summarize_paragraph 函数使用 OpenAI API 对单个句子进行摘要生成。
• combine_summaries 函数使用 OpenAI API 对多个句子摘要进行总结，得到最终的摘要。
• long_text_summarization 函数将以上函数组合起来，实现完整的分段摘要流程。

注意：

• 你需要将 os.getenv("OPENAI_API_KEY") 替换成你自己的 OpenAI API 密钥。
• 你可以根据自己的需求调整 temperature 和 max_tokens 参数。
• 这个示例只是一个简单的演示，你可以根据自己的任务需求进行修改和扩展。

分段推理的优化策略

虽然分段推理可以缓解上下文窗口限制和信息衰减带来的影响，但仍然存在一些问题，例如段落之间的信息割裂和推理结果的不一致性。为了进一步提高分段推理的性能，可以采用以下优化策略：

• 重叠分割： 在分割文本时，可以采用重叠分割的方法，即让相邻的段落之间有一定的重叠部分。这样可以保证段落之间信息的连续性，避免信息割裂。
• 上下文传递： 在对每个段落进行推理时，可以将前一个段落的推理结果作为当前段落的上下文信息。这样可以帮助模型更好地理解当前段落的含义，提高推理的准确性。
• 迭代推理： 可以多次迭代进行分段推理，每次迭代都对上一次迭代的结果进行改进。这样可以逐步提高推理的质量，最终得到更准确的结果。
• 知识图谱增强： 可以将文本信息与知识图谱进行关联，利用知识图谱的结构化信息来辅助推理。这样可以提高推理的逻辑性和准确性。

下面我们针对重叠分割，提供一个代码示例：

def split_text_into_sentences_with_overlap(text, max_length=500, overlap_length=50):
    """
    将文本分割成句子，并限制每个句子的最大长度，并添加重叠部分。
    """
    sentences = re.split(r'(?<!w.w.)(?<![A-Z][a-z].)(?<=.|?)s', text)

    merged_sentences = []
    temp_sentence = ""
    for sentence in sentences:
        if len(temp_sentence + sentence) < max_length:
            temp_sentence += sentence + " "
        else:
            if temp_sentence:
                merged_sentences.append(temp_sentence.strip())
            temp_sentence = sentence + " "
    if temp_sentence:
        merged_sentences.append(temp_sentence.strip())

    # 添加重叠部分
    overlapped_sentences = []
    for i in range(len(merged_sentences)):
        if i > 0:
            # 添加重叠部分，取前一个句子的后overlap_length个字符
            overlap = merged_sentences[i-1][-overlap_length:]
            overlapped_sentences.append(overlap + " " + merged_sentences[i])
        else:
            overlapped_sentences.append(merged_sentences[i])

    return overlapped_sentences

在这个函数中，我们添加了 overlap_length 参数，用于指定重叠部分的长度。在分割文本时，我们将前一个句子的后 overlap_length 个字符添加到当前句子的开头，从而实现重叠分割。在 long_text_summarization 函数中，将 split_text_into_sentences 替换为 split_text_into_sentences_with_overlap 即可。

优化策略对比表格

| 优化策略 | 优点
| 重叠分割 | 保留相邻段落间的信息连续性，减少信息割裂，提高推理准确性。