白山市网站建设_网站建设公司_SEO优化_seo优化

在之前，我们主要完成了数据检索阶段， 但是完整的RAG流程还需要有emedding阶段， 即：

提取（读取）、转换（分隔）和加载（写入）

Document Loaders

Document Loaders 文档读取器

springai提供了以下文档阅读器

JSON

文本

HTML（JSoup）

Markdown

PDF页面

PDF段落

Tika（DOCX、PPTX、HTML……）

alibaba ai也提供了很多阅读器

https://github.com/alibaba/spring-ai-alibaba/tree/main/community/document-parsers

document-parser-apache-pdfbox：用于解析 PDF 格式文档。

document-parser-bshtml：用于解析基于 BSHTML 格式的文档。

document-parser-pdf-tables：专门用于从 PDF 文档中提取表格数据。

document-parser-bibtex：用于解析 BibTeX 格式的参考文献数据。

document-parser-markdown：用于解析 Markdown 格式的文档。

document-parser-tika：一个多功能文档解析器，支持多种文档格式。

以及网络来源文档读取器：

https://github.com/alibaba/spring-ai-alibaba/tree/main/community/document-readers

读取Text

@Test

public void testReaderText(@Value("classpath:rag/terms-of-service.txt") Resource resource) {

TextReader textReader = new TextReader(resource);

List<Document> documents = textReader.read();

for (Document document : documents) {

System.out.println(document.getText());

}

}

读取markdown

<dependency>

<groupId>org.springframework.ai</groupId>

<artifactId>spring-ai-markdown-document-reader</artifactId>

</dependency>

@Test

public void testReaderMD(@Value("classpath:rag/9_横店影视股份有限公司_0.md") Resource resource) {

MarkdownDocumentReaderConfig config = MarkdownDocumentReaderConfig.builder()

.withHorizontalRuleCreateDocument(true) // 分割线创建新document

.withIncludeCodeBlock(false) // 代码创建新document false 会创建

.withIncludeBlockquote(false) // 引用创建新document false 会创建

.withAdditionalMetadata("filename", resource.getFilename()) // 每个document添加的元数据

.build();

MarkdownDocumentReader markdownDocumentReader = new MarkdownDocumentReader(resource, config);

List<Document> documents = markdownDocumentReader.read();

for (Document document : documents) {

System.out.println(document.getText());

}

}

pdf

● PagePdfDocumentReader一页1个document

● ParagraphPdfDocumentReader 按pdf目录分成一个个document

<dependency>

<groupId>org.springframework.ai</groupId>

<artifactId>spring-ai-markdown-document-reader</artifactId>

</dependency>

@Test

public void testReaderPdf(@Value("classpath:rag/平安银行2023年半年度报告摘要.pdf") Resource resource) {

PagePdfDocumentReader pdfReader = new PagePdfDocumentReader(resource,

PdfDocumentReaderConfig.builder()

.withPageTopMargin(0)

.withPageExtractedTextFormatter(ExtractedTextFormatter.builder()

.withNumberOfTopTextLinesToDelete(0)

.build())

.withPagesPerDocument(1)

.build());

List<Document> documents = pdfReader.read();

for (Document document : documents) {

System.out.println(document.getText());

}

}

// 必需要带目录， 按pdf的目录分document

@Test

public void testReaderParagraphPdf(@Value("classpath:rag/平安银行2023年半年度报告.pdf") Resource resource) {

ParagraphPdfDocumentReader pdfReader = new ParagraphPdfDocumentReader(resource,

PdfDocumentReaderConfig.builder()

// 不同的PDF生成工具可能使用不同的坐标系 ， 如果内容识别有问题， 可以设置该属性为true

.withReversedParagraphPosition(true)

.withPageTopMargin(0) // 上边距

.withPageExtractedTextFormatter(ExtractedTextFormatter.builder()

// 从页面文本中删除前 N 行

.withNumberOfTopTextLinesToDelete(0)

.build())

.build());

List<Document> documents = pdfReader.read();

for (Document document : documents) {

System.out.println(document.getText());

}

}

B站：

<dependency>

<groupId>com.alibaba.cloud.ai</groupId>

<artifactId>spring-ai-alibaba-starter-document-reader-bilibili</artifactId>

</dependency>

@Test

void bilibiliDocumentReaderTest() {

BilibiliDocumentReader bilibiliDocumentReader = new BilibiliDocumentReader(

"https://www.bilibili.com/video/BV1C5UxYuEc2/?spm_id_from=333.1387.upload.video_card.click&vd_source=fa810d8b8d6765676cb343ada918d6eb");

List<Document> documents = bilibiliDocumentReader.get();

System.out.println(documents);

}

DocumentSplitter‌

DocumentSplitter‌文档拆分器（转换器）

由于文本读取过来后， 还需要分成一段一段的片段(分块chunk)， 分块是为了更好地拆分语义单元，这样在后面可以更精确地进行语义相似性检索，也可以避免LLM的Token限制。

SpringAi就提供了一个文档拆分器：

TextSplitter 抽象类

TokenTextSplitter 按token分隔

TokenTextSplitter

chunkSize (默认值: 800) 100

○ 每个文本块的目标大小，以token为单位

minChunkSizeChars (默认值: 350) 建议小一点

○ 如果块超过最小块字符数( 按照块的最后. ! ? \n 符号截取)

○ 如果块没超过最小块字符数， 不会按照符号截取(保留原块）。

本服务条款适用于您对图灵航空 的体验。预订航班，即表示您同意这些条款。

1. 预订航班

- 通过我们的网站或移动应用程序预订。

- 预订时需要全额付款。 \n

- 确保个人信息（姓名、ID 等）的准确性，因为更正可能会产生 25

minChunkLengthToEmbed (默认值: 5) 5

○ 丢弃短于此长度的文本块(如果去掉\r\n， 只剩5个有效文本， 那就丢掉）

本服务条

maxNumChunks(默认值: 10000)

○ 最多能分多少个块， 超过了就不管了

keepSeparator(默认值: true)

○ 是否在块中保留分隔符、换行符 \r\n

@Test

public void testTokenTextSplitter(@Value("classpath:rag/terms-of-service.txt") Resource resource) {

TextReader textReader = new TextReader(resource);

textReader.getCustomMetadata().put("filename", resource.getFilename());

List<Document> documents = textReader.read();

TokenTextSplitter splitter = new TokenTextSplitter(1000, 400, 10, 5000, true);

List<Document> apply = splitter.apply(documents);

apply.forEach(System.out::println);

}

整个流程如下：

自定分割器：

支持中英文：同时支持中文和英文标点符号

package com.xushu.springai.rag.ELT;

public class ChineseTokenTextSplitter extends TextSplitter {

private static final int DEFAULT_CHUNK_SIZE = 800;

private static final int MIN_CHUNK_SIZE_CHARS = 350;

private static final int MIN_CHUNK_LENGTH_TO_EMBED = 5;

private static final int MAX_NUM_CHUNKS = 10000;

private static final boolean KEEP_SEPARATOR = true;

private final EncodingRegistry registry = Encodings.newLazyEncodingRegistry();

private final Encoding encoding = this.registry.getEncoding(EncodingType.CL100K_BASE);

// The target size of each text chunk in tokens

private final int chunkSize;

// The minimum size of each text chunk in characters

private final int minChunkSizeChars;

// Discard chunks shorter than this

private final int minChunkLengthToEmbed;

// The maximum number of chunks to generate from a text

private final int maxNumChunks;

private final boolean keepSeparator;

public ChineseTokenTextSplitter() {

this(DEFAULT_CHUNK_SIZE, MIN_CHUNK_SIZE_CHARS, MIN_CHUNK_LENGTH_TO_EMBED, MAX_NUM_CHUNKS, KEEP_SEPARATOR);

}

public ChineseTokenTextSplitter(boolean keepSeparator) {

this(DEFAULT_CHUNK_SIZE, MIN_CHUNK_SIZE_CHARS, MIN_CHUNK_LENGTH_TO_EMBED, MAX_NUM_CHUNKS, keepSeparator);

}

public ChineseTokenTextSplitter(int chunkSize, int minChunkSizeChars, int minChunkLengthToEmbed, int maxNumChunks,

boolean keepSeparator) {

this.chunkSize = chunkSize;

this.minChunkSizeChars = minChunkSizeChars;

this.minChunkLengthToEmbed = minChunkLengthToEmbed;

this.maxNumChunks = maxNumChunks;

this.keepSeparator = keepSeparator;

}

public static Builder builder() {

return new Builder();

}

@Override

protected List<String> splitText(String text) {

return doSplit(text, this.chunkSize);

}

protected List<String> doSplit(String text, int chunkSize) {

if (text == null || text.trim().isEmpty()) {

return new ArrayList<>();

}

List<Integer> tokens = getEncodedTokens(text);

List<String> chunks = new ArrayList<>();

int num_chunks = 0;

// maxNumChunks多能分多少个块， 超过了就不管了

while (!tokens.isEmpty() && num_chunks < this.maxNumChunks) {

// 按照chunkSize进行分隔

List<Integer> chunk = tokens.subList(0, Math.min(chunkSize, tokens.size()));

String chunkText = decodeTokens(chunk);

// Skip the chunk if it is empty or whitespace

if (chunkText.trim().isEmpty()) {

tokens = tokens.subList(chunk.size(), tokens.size());

continue;

}

// Find the last period or punctuation mark in the chunk

int lastPunctuation =

Math.max(chunkText.lastIndexOf('.'),

Math.max(chunkText.lastIndexOf('?'),

Math.max(chunkText.lastIndexOf('!'),

Math.max(chunkText.lastIndexOf('\n'),

// 添加上我们中文的分割符号

Math.max(chunkText.lastIndexOf('。'),

Math.max(chunkText.lastIndexOf('？'),

chunkText.lastIndexOf('！')

))))));

// 按照句子截取之后长度 > minChunkSizeChars

if (lastPunctuation != -1 && lastPunctuation > this.minChunkSizeChars) {

// 保留按照句子截取之后的内容

chunkText = chunkText.substring(0, lastPunctuation + 1);

}

// 按照句子截取之后长度 < minChunkSizeChars 保留原块

// keepSeparator=true 替换/r/n =false不管

String chunkTextToAppend = (this.keepSeparator) ? chunkText.trim()

: chunkText.replace(System.lineSeparator(), " ").trim();

// 替换/r/n之后的内容是不是<this.minChunkLengthToEmbed 忽略

if (chunkTextToAppend.length() > this.minChunkLengthToEmbed) {

chunks.add(chunkTextToAppend);

}

// Remove the tokens corresponding to the chunk text from the remaining tokens

tokens = tokens.subList(getEncodedTokens(chunkText).size(), tokens.size());

num_chunks++;

}

// Handle the remaining tokens

if (!tokens.isEmpty()) {

String remaining_text = decodeTokens(tokens).replace(System.lineSeparator(), " ").trim();

if (remaining_text.length() > this.minChunkLengthToEmbed) {

chunks.add(remaining_text);

}

}

return chunks;

}

private List<Integer> getEncodedTokens(String text) {

Assert.notNull(text, "Text must not be null");

return this.encoding.encode(text).boxed();

}

private String decodeTokens(List<Integer> tokens) {

Assert.notNull(tokens, "Tokens must not be null");

var tokensIntArray = new IntArrayList(tokens.size());

tokens.forEach(tokensIntArray::add);

return this.encoding.decode(tokensIntArray);

}

public static final class Builder {

private int chunkSize = DEFAULT_CHUNK_SIZE;

private int minChunkSizeChars = MIN_CHUNK_SIZE_CHARS;

private int minChunkLengthToEmbed = MIN_CHUNK_LENGTH_TO_EMBED;

private int maxNumChunks = MAX_NUM_CHUNKS;

private boolean keepSeparator = KEEP_SEPARATOR;

private Builder() {

}

public Builder withChunkSize(int chunkSize) {

this.chunkSize = chunkSize;

return this;

}

public Builder withMinChunkSizeChars(int minChunkSizeChars) {

this.minChunkSizeChars = minChunkSizeChars;

return this;

}

public Builder withMinChunkLengthToEmbed(int minChunkLengthToEmbed) {

this.minChunkLengthToEmbed = minChunkLengthToEmbed;

return this;

}

public Builder withMaxNumChunks(int maxNumChunks) {

this.maxNumChunks = maxNumChunks;

return this;

}

public Builder withKeepSeparator(boolean keepSeparator) {

this.keepSeparator = keepSeparator;

return this;

}

public ChineseTokenTextSplitter build() {

return new ChineseTokenTextSplitter(this.chunkSize, this.minChunkSizeChars, this.minChunkLengthToEmbed,

this.maxNumChunks, this.keepSeparator);

}

}

}

分隔经验：

过细分块的潜在问题

‌语义割裂‌： 破坏上下文连贯性，影响模型理解‌。

‌计算成本增加‌：分块过细会导致向量嵌入和检索次数增多，增加时间和算力开销‌。

‌信息冗余与干扰‌：碎片化的文本块可能引入无关内容，干扰检索结果的质量，降低生成答案的准确性‌。

分块过大的弊端

‌信息丢失风险‌：过大的文本块可能超出嵌入模型的输入限制，导致关键信息未被有效编码‌。

‌检索精度下降‌：大块内容可能包含多主题混合，与用户查询的相关性降低，影响模型反馈效果‌。

‌场景‌ ‌分块策略‌ ‌参数参考‌

微博/短文本 句子级分块，保留完整语义 每块100-200字符‌

学术论文 段落级分块，叠加10%重叠 每块300-500字符‌

法律合同 条款级分块，严格按条款分隔 每块200-400字符‌

长篇小说 章节级分块，过长段落递归拆分为段落 每块500-1000字符‌

不要过分指望按照文本主题进行分隔， 因为实战中的资料太多而且没有规律， 根本没办法保证每个chunk是一个完整的主题内容， 哪怕人为干预也很难。 所以实战中往往需要结合资料来决定分割器，大多数情况就是按token数分， 因为没有完美的， 还可以加入人工干预,或者大模型分隔。

分块五种策略

以下是 RAG 的五种分块策略：

1）固定大小分块

生成块的最直观和直接的方法是根据预定义的字符、单词或标记数量将文本分成统一的段。

由于直接分割会破坏语义流，因此建议在两个连续的块之间保持一些重叠（上图蓝色部分）。

这很容易实现。而且，由于所有块的大小相同，它简化了批处理。

但有一个大问题。这通常会打断句子（或想法）。因此，重要的信息很可能会分散到不同的块之间。

2）语义分块

这个想法很简单。

根据句子、段落或主题部分等有意义的单位对文档进行细分。

接下来，为每个片段创建嵌入。