LangChain文档摘要生成实战

发布时间: 2025-03-29 19:10

↑

# LangChain文档摘要生成实战

本文将详细介绍如何使用LangChain构建一个文档摘要生成系统，包括系统设计、代码实现和最佳实践。

## 系统架构

一个完整的文档摘要系统包含以下组件：
- 文档加载器
- 文本分割器
- 摘要生成链
- 结果优化器

## 基础实现

### 1. 文档加载

```python
from langchain.document_loaders import (
    TextLoader,
    PDFLoader,
    DirectoryLoader
)

# 加载单个文件
text_loader = TextLoader("document.txt")
text_doc = text_loader.load()

# 加载PDF文件
pdf_loader = PDFLoader("document.pdf")
pdf_doc = pdf_loader.load()

# 批量加载文件
dir_loader = DirectoryLoader(
    "./docs",
    glob="**/*.*",
    loader_cls=TextLoader
)
docs = dir_loader.load()
```

### 2. 文本分割

```python
from langchain.text_splitter import (
    CharacterTextSplitter,
    RecursiveCharacterTextSplitter
)

# 基础分割器
splitter = CharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separator="\n"
)
chunks = splitter.split_documents(docs)

# 递归分割器
recursive_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", " ", ""]
)
recursive_chunks = recursive_splitter.split_documents(docs)
```

### 3. 摘要生成

```python
from langchain.chains.summarize import load_summarize_chain
from langchain.llms import OpenAI

# 创建LLM
llm = OpenAI(temperature=0)

# 创建摘要链
chain = load_summarize_chain(
    llm,
    chain_type="map_reduce",
    verbose=True
)

# 生成摘要
summary = chain.run(chunks)
print(summary)
```

## 高级特性

### 1. 自定义提示模板

```python
from langchain.prompts import PromptTemplate

# 映射提示模板
map_template = """写出以下文本的要点总结：
{text}
要点："""
map_prompt = PromptTemplate(input_variables=["text"], template=map_template)

# 合并提示模板
combine_template = """将以下要点合并为一个连贯的总结：
{text}
总结："""
combine_prompt = PromptTemplate(input_variables=["text"], template=combine_template)

# 创建自定义摘要链
chain = load_summarize_chain(
    llm,
    chain_type="map_reduce",
    map_prompt=map_prompt,
    combine_prompt=combine_prompt,
    verbose=True
)
```

### 2. 多种摘要策略

```python
# stuff方法：适合短文档
stuff_chain = load_summarize_chain(
    llm,
    chain_type="stuff",
    verbose=True
)

# map_reduce方法：适合长文档
map_reduce_chain = load_summarize_chain(
    llm,
    chain_type="map_reduce",
    verbose=True
)

# refine方法：逐步优化
refine_chain = load_summarize_chain(
    llm,
    chain_type="refine",
    verbose=True
)
```

### 3. 结果优化

```python
from typing import List
from langchain.schema import Document

def optimize_summary(summary: str, docs: List[Document], llm) -> str:
    # 创建优化提示
    template = """根据原文优化以下摘要，确保：
    1. 保持关键信息
    2. 去除冗余内容
    3. 提高可读性
    
    原文：{context}
    摘要：{summary}
    
    优化后的摘要："""
    
    prompt = PromptTemplate(
        input_variables=["context", "summary"],
        template=template
    )
    
    # 创建优化链
    chain = LLMChain(llm=llm, prompt=prompt)
    
    # 运行优化
    result = chain.run({
        "context": docs[0].page_content,
        "summary": summary
    })
    
    return result
```

## 最佳实践

### 1. 摘要策略选择

根据文档特点选择合适的摘要策略：

1. **短文档（<2000字）**
   - 使用stuff方法
   - 直接处理全文

2. **中长文档（2000-10000字）**
   - 使用map_reduce方法
   - 并行处理提高效率

3. **超长文档（>10000字）**
   - 使用refine方法
   - 逐步优化保证质量

### 2. 错误处理

```python
from typing import Optional

def safe_summarize(docs, chain) -> Optional[str]:
    try:
        return chain.run(docs)
    except Exception as e:
        print(f"摘要生成错误：{e}")
        return None
```

### 3. 结果评估

```python
from rouge import Rouge

def evaluate_summary(original: str, summary: str) -> dict:
    # 创建评估器
    rouge = Rouge()
    
    # 计算ROUGE分数
    scores = rouge.get_scores(summary, original)
    
    return {
        "rouge-1": scores[0]["rouge-1"],
        "rouge-2": scores[0]["rouge-2"],
        "rouge-l": scores[0]["rouge-l"]
    }
```

## 应用示例

### 1. 新闻摘要器

```python
from langchain.document_loaders import WebBaseLoader

def create_news_summarizer():
    # 创建加载器
    loader = WebBaseLoader()
    
    # 创建分割器
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=2000,
        chunk_overlap=200
    )
    
    # 创建摘要链
    chain = load_summarize_chain(
        llm=OpenAI(temperature=0.3),
        chain_type="map_reduce"
    )
    
    def summarize_url(url: str) -> str:
        # 加载网页
        docs = loader.load(url)
        
        # 分割文本
        chunks = splitter.split_documents(docs)
        
        # 生成摘要
        summary = chain.run(chunks)
        
        return summary
    
    return summarize_url
```

### 2. 文档库摘要器

```python
class DocumentSummarizer:
    def __init__(self, llm):
        self.llm = llm
        self.loader = DirectoryLoader("./docs")
        self.splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200
        )
        self.chain = load_summarize_chain(
            llm=self.llm,
            chain_type="map_reduce"
        )
    
    def summarize_all(self) -> dict:
        # 加载所有文档
        docs = self.loader.load()
        
        # 按文档生成摘要
        summaries = {}
        for doc in docs:
            chunks = self.splitter.split_documents([doc])
            summary = self.chain.run(chunks)
            summaries[doc.metadata["source"]] = summary
        
        return summaries
```

## 总结

LangChain提供了强大的文档摘要生成能力：
- 支持多种文档格式
- 灵活的分割策略
- 多种摘要算法
- 结果优化机制

通过本文的学习，你应该能够使用LangChain构建出功能完善的文档摘要系统。

元素码农