构建无框架的多模态rag系统：从零开始实现文本与图像处理的最佳实践

Photo by on Unsplash

This article is co-authored by Areej Mehboob.

检索增强生成 (RAG) 系统

检索增强生成 (RAG) 系统和多模态大型语言模型 (LLMs) 正在快速发展，应用范围从增强搜索体验到生成复杂内容。这些方法不断被改进，以扩展人工智能的能力边界。但是，如果你能够结合它们的优势，构建一个不仅处理文本而且无缝处理图像的 RAG 系统，会怎样呢？

现在想象一下进一步的步骤，创建这个系统而不依赖于像 LangChain 或 LlamaIndex 这样的预构建框架？

无框架的方法使你拥有完全的控制权，允许你根据自己的确切需求定制应用，而不受外部依赖或版本限制的约束。

在本博客中，我们将带你深入了解这个过程。从比较文本和图像提取工具到从零构建一个强大的多模态 RAG 系统，我们将逐步引导你，帮助你创建自己的定制解决方案。

本教程的完整代码可在以下 Colab笔记本中找到（文章中的代码格式可能不太准确）：

Colab笔记本：多模态 RAG 实现

多模态 RAG 流程图（图像来源：作者）

在我们开始之前！

如果你喜欢这个主题并且想要支持我：

1. 为我的文章点赞50次；这对我真的很有帮助。
2. 在LinkedIn上与我联系并订阅以获取我的最新帖子。

第1部分：多模态RAG系统的数据摄取

任何RAG系统的基础是可靠的数据。为了使系统能够检索和生成准确的结果，它处理的内容需要干净、完整且结构良好。在处理PDF时，这意味着不仅要提取文本，还要提取图像和表格，确保没有有价值的信息丢失。

选择合适的PDF处理工具至关重要。由于可用的库众多，决定哪个最适合您的需求可能会让人感到不知所措。有些库优先考虑速度，有些则专注于准确性，还有一些在两者之间提供平衡。为了帮助您做出明智的决定，我们评估了三个流行的库：PyMuPDF、PDFium和PDFPlumber。

选择适合RAG系统的PDF处理工具

PDFPlumber:

pdfplumber可以从PDF中提取相当准确的文本和表格。然而，它有一个显著的缺点：对于复杂的PDF，它可能非常耗时。例如，从一个100页的PDF中提取内容可能需要长达1分钟和10-30秒。这是一个相当大的延迟，尤其是在处理多个PDF时。

代码示例：

import pdfplumber
import time

def read_text_pdfplumber(pdf_path):
    """ Extracts text and tables from pdf using pdfplumber """

    text_results = []
    tables = []
    with pdfplumber.open(pdf_path) as pdf:
        for page in pdf.pages:
            text = page.extract_text()
            text_results.append(text)

            table = page.extract_tables()
            tables.append(table)
    return (text_results, tables)

对于一个622页的PDF，该脚本花费了152.35秒来提取文本和表格。

PDFium

pdfium 是一个快速的库，可以在 5–15 秒内将 PDF 内容转换为文本。由于它将 PDF 页面转换为图像并从中提取文本的方法，文本提取相当准确。这使得它成为快速文本提取的优秀选择。然而，它有一个限制：它并不明确支持将图像或表格与文本分开。

代码示例

import pypdfium2 as pdfium

def read_text_pdfium(path):
   """ Extracts text from pdf using pdfium """
   pdf = pdfium.PdfDocument(path)
   version = pdf.get_version()  
   n_pages = len(pdf)
   pdfium_text = ""
   for i in range(len(pdf)):
       page = pdf[i]  
       width, height = page.get_size()
       textpage = page.get_textpage()
       text_part = textpage.get_text_bounded(left=50, bottom=100, right=width, top=height)
       pdfium_text += text_part

   return pdfium_text

对于一个 622 页的 PDF，该脚本花费了 5–10 秒 来提取文本。

PyMuPDF

如果您正在寻找从PDF中提取内容的最佳工具之一，PyMuPDF几乎无可匹敌。它速度极快，仅需4-7秒即可处理一个PDF。它不仅可以提取文本，还可以处理图像，使其成为一个全面的选择。如果您需要在多个PDF中快速且可靠的结果，PyMuPDF绝对值得考虑。

代码示例：

import fitz  
def read_text_pymupdf(path):
    """Extracts text from a PDF using PyMuPDF."""
    doc = fitz.open(path)
    text_results = []
    for page in doc:
        text = page.get_text()
        text_results.append(text)
    return text_results

在这里，我将使用PyMuPDF从PDF中提取图像。图像将保存在输出目录中。

代码示例：

import fitz  
import os
def extract_images_from_pdf(pdf_path, output_folder):
    """Extract images from pdf using PyMuPDF"""

    pdf_document = fitz.open(pdf_path)

    os.makedirs(output_folder, exist_ok=True)
    for page_number in range(len(pdf_document)):
        page = pdf_document[page_number]
        images = page.get_images(full=True)
        for image_index, img in enumerate(images):
            xref = img[0]
            base_image = pdf_document.extract_image(xref)
            image_bytes = base_image["image"]
            image_ext = base_image["ext"]
            image_filename = f"page_{page_number+1}_image_{image_index+1}.{image_ext}"
            image_path = os.path.join(output_folder, image_filename)
            with open(image_path, "wb") as image_file:
                image_file.write(image_bytes)
            print(f"Saved: {image_path}")
    pdf_document.close()

对于一个622页的PDF，PyMuPDF仅用5-6秒就提取了文本，提供了显著的性能优势，超过其他库。这种效率使其成为处理大型或多个PDF的优秀选择。然而，理想的库取决于您的具体用例和需求。

PDF库的处理时间比较

下表比较了使用三个库（PDFium、PyMuPDF和PDFPlumber）处理不同页数的PDF所需的时间。

不同页数下每个Python包的性能

根据性能分析，PyMuPDF的表现始终优于PDFium和PDFPlumber，对于处理超过1,000页的PDF，其速度比PDFium快2.3倍，比PDFPlumber快59倍。

关键要点

• PyMuPDF 是最快的，适合大规模或时间敏感的任务。
• PDFium 在速度和准确性之间提供了平衡，但缺乏图像提取功能。
• PDFPlumber 较慢，但在从复杂PDF中提取详细表格方面表现出色。

库性能比较

文本提取准确性与速度（图片由作者提供）

如果您想了解更多关于PDF基准测试的信息，请查看这个仓库：

https://github.com/py-pdf/benchmarks?tab=readme-ov-file

Part 2: 嵌入文本和图像

现在我们已经处理了PDF内容，下一步是构建一个多模态RAG系统。这涉及将提取的文本和图像集成到一个检索增强的管道中。

对于内容提取，我将使用PyMuPDF，因为它具有卓越的速度和处理文本与图像的能力。为了构建多模态检索器，我将利用QdrantDB作为向量存储。

处理和嵌入文本和图像

文本内容被拆分为更小、可管理的块，以优化嵌入性能和检索准确性。在这里，我们使用LangChain的RecursiveCharacterTextSplitter，因为它简单且可配置。然而，拆分文本可以通过多种方式完成，例如编写自定义分割器或利用像NLTK或spaCy这样的库。

在这个例子中，我们为每个块添加元数据，包括PDF路径和唯一的UUID。元数据有助于在检索过程中保持上下文。

安装依赖项：

%%capture
!pip install openai==1.55.3 httpx==0.27.2 --force-reinstall --quiet

!pip install transformers torch pillow
!pip install --upgrade nltk
!pip install sentence-transformers
!pip install --upgrade qdrant-client fastembed Pillow
!pip install -U langchain-community

将文本分割成块

我们将为每个块添加相关的元数据，元数据可以是任何内容，它可以帮助检索块。但在这里，我只是将pdf路径和一个唯一的uuid作为文本的元数据。

from langchain_text_splitters import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1024,
    chunk_overlap=20,
    length_function=len,
    is_separator_regex=False,
)

doc_texts = text_splitter.create_documents(text_results)

import uuid
for i in range(len(doc_texts)):
    unique_id = str(uuid.uuid4())
    doc_texts[i].metadata['document_info'] = pdf_path
    doc_texts[i].metadata['uuid'] = unique_id
    print(doc_texts[0].metadata)

嵌入文本块

一旦分割，文本块将使用 Nomic文本嵌入模型 进行嵌入。这将每个块转换为适合在检索器中存储的向量表示。

from transformers import AutoTokenizer, AutoModel

text_tokenizer = AutoTokenizer.from_pretrained("nomic-ai/nomic-embed-text-v1.5", trust_remote_code=True)
text_model = AutoModel.from_pretrained("nomic-ai/nomic-embed-text-v1.5", trust_remote_code=True)

def get_text_embeddings(text):
    inputs = text_tokenizer(text, return_tensors="pt", padding=True, truncation=True)
    outputs = text_model(**inputs)
    embeddings = outputs.last_hidden_state.mean(dim=1)
    return embeddings[0].detach().numpy()

text = "This is a test sentence."
embeddings = get_text_embeddings(text)
print(embeddings[:5])

texts_embeded = [get_text_embeddings(document.page_content) for document in doc_texts]
text_embeddings_size = len(texts_embeded[0])
text_embeddings_size

嵌入图像

图像从指定目录读取，并使用 Nomic Vision 嵌入模型 进行嵌入。last_hidden_state 输出的均值用于将每个图像表示为固定长度的向量。

这是加载模型和测试图像的示例代码：

from transformers import AutoModel, AutoProcessor
from PIL import Image
import torch

model = AutoModel.from_pretrained("nomic-ai/nomic-embed-vision-v1.5", trust_remote_code=True)
processor = AutoProcessor.from_pretrained("nomic-ai/nomic-embed-vision-v1.5")

image = Image.open("/content/drive/MyDrive/images/Screenshot 2024-09-08 025257.png")
inputs = processor(images=image, return_tensors="pt")

Please translate the following text to Chinese. Requirements: 1. Keep code blocks (```) unchanged 2. Keep inline code (`) unchanged 3. Keep Markdown formatting 4. Use these technical term translations: Retrieval-Augmented Generation -> 检索增强生成 RAG -> RAG multimodal large language models -> 多模态大型语言模型 AI -> 人工智能 LangChain -> LangChain LlamaIndex -> LlamaIndex Colab notebook -> Colab笔记本 PDF -> PDF PyMuPDF -> PyMuPDF PDFium -> PDFium PDFPlumber -> PDFPlumber RecursiveCharacterTextSplitter -> 递归字符文本分割器 NLTK -> NLTK spaCy -> spaCy openai -> openai transformers -> transformers torch -> torch Pillow -> Pillow sentence-transformers -> sentence-transformers qdrant-client -> qdrant-client fitz -> fitz Qdrant -> Qdrant UUID -> UUID MultiModalRetriever -> 多模态检索器 MultiModalRetrieverDisplay -> 多模态检索器显示 ChatCompletion -> 聊天完成 base64 -> base64 image_url -> 图像网址 image_path -> 图像路径 user_query -> 用户查询 context -> 上下文 images -> 图像 model -> 模型 temperature -> 温度 top_p -> top_p image_embeddings -> 图像嵌入 text_embeddings -> 文本嵌入 embedding model -> 嵌入模型 embedding -> 嵌入 retriever -> 检索器 metadata -> 元数据 payload -> 有效载荷 text_hits -> 文本命中 image_hits -> 图像命中 doc_texts -> 文档文本 texts_embeded -> 嵌入文本 image_embeddings_size -> 图像嵌入大小 text_embeddings_size -> 文本嵌入大小 outputs -> 输出 last_hidden_state -> 最后隐藏状态 vector -> 向量 distance -> 距离 size -> 大小 cosine -> 余弦 id -> ID points -> 点 collection_name -> 集合名称 collection_exists -> 集合是否存在 create_collection -> 创建集合 upload_points -> 上传点 query_points -> 查询点 upload_embeddings -> 上传嵌入 extract_images_from_pdf -> 从PDF提取图像 read_text_pdfplumber -> 使用pdfplumber读取文本 read_text_pdfium -> 使用pdfium读取文本 get_text_embeddings -> 获取文本嵌入 encode_image -> 编码图像

     Text: ## testing model

with torch.no_grad():
    outputs = model(**inputs)

embeddings = outputs.last_hidden_state
print(embeddings)

For our multimodal RAG, images will be read from the directory by using PIL, and then will be embedded by using the loaded vision model, using the code below.

import os
import numpy as np

image_embeddings = []
image_files = os.listdir(output_directory)
for img in image_files:
    try:
        image = Image.open(os.path.join(output_directory, img))
        inputs = processor(images=image, return_tensors="pt")
        model.eval()
        with torch.no_grad():
            outputs = model(**inputs)
        embeddings = outputs.last_hidden_state
        print(f"Image: {img}, Embedding shape: {embeddings.shape}")
        if embeddings.size(0) > 0:  
            image_embedding = embeddings.mean(dim=1).squeeze().cpu().numpy()
            image_embeddings.append(image_embedding)
        else:
            print(f"Skipping image {img} due to empty embeddings.")
    except Exception as e:
        print(f"Error processing {img}: {e}")

image_embeddings_size = len(image_embeddings[0])

关键注意事项：

• 工具的灵活性：虽然这里使用了Nomic模型，但可以替换为Sentence Transformers或自定义模型，以满足特定需求。
• 元数据的重要性：添加相关的元数据，如唯一标识符，确保可追溯性并提高检索准确性。

在文本和图像嵌入准备就绪后，下一步是将它们集成到统一的检索管道中。这将允许系统在不同模态之间无缝地检索和生成响应。

为多模态检索设置Qdrant

准备好文本和图像嵌入后，下一步是初始化一个Qdrant client并将其配置为多模态检索。Qdrant作为向量数据库，允许在文本和图像嵌入之间进行高效的相似性搜索。

初始化 Qdrant 客户端

在这里，我们使用 Qdrant 进行内存配置以进行测试。对于生产环境，请将 :memory: 替换为持久数据库路径以确保可扩展性。

from qdrant_client import QdrantClient, models
client = QdrantClient(":memory:")

为文本和图像创建单独的集合

我们创建了两个单独的集合：一个用于文本，另一个用于图像。每个集合根据所使用的嵌入模型配置了向量参数（size 和 distance）。

if not client.collection_exists("images"):  
    client.create_collection(
        collection_name="images",
        vectors_config=models.VectorParams(
            size=image_embeddings_size,  
            distance=models.Distance.COSINE,
        ),
    )

if not client.collection_exists("text"):
    client.create_collection(
        collection_name="text",
        vectors_config=models.VectorParams(
            size=text_embeddings_size,  
            distance=models.Distance.COSINE,
        ),
    )

上传嵌入到 Qdrant

在创建集合后，我们用嵌入和元数据填充它们。元数据确保在检索过程中上下文的保留和可追溯性。

上传文本嵌入

我们通过上传文本嵌入及其相关的元数据（例如内容和唯一标识符）来填充文本集合。

client.upload_points(
    collection_name="text",
    points=[
        models.PointStruct(
            id=doc.metadata['uuid'],
            vector=np.array(texts_embeded[idx]),
            payload={ 
                "metadata": doc.metadata,
                "content": doc.page_content
            }
        )
        for idx, doc in enumerate(doc_texts)
    ]
)

上传图像嵌入

对于图像，每个嵌入都与有效载荷元数据中的相应图像路径相关联。我们存储图像路径，以便在我们的多模态大型语言模型检索图像时能够重新加载图像。这种有组织的方法允许在集合中高效地搜索图像。

if len(image_embeddings) > 0:
    client.upload_points(
        collection_name="images",
        points=[
            models.PointStruct(
                id=str(uuid.uuid4()),  
                vector=np.array(image_embeddings[idx]),
                payload={"image_path": output_directory+'/'+str(image_files[idx])}  
            )
            for idx in range(len(image_files))  
        ]
    )
else:
    print("未找到有效的嵌入，无法上传。")

第三部分：创建检索器

最后，我们通过设置一个多模态检索器将所有内容整合在一起，使我们能够检索与用户查询匹配的文本块和图像。检索器配置为根据相似性分数从每个集合（文本和图像）中返回前3个结果。

为什么要分开集合？

文本和图像嵌入在不同的特征空间中操作，它们的相似性分数不可直接比较。通过分开集合并运行独立查询，我们确保文本和图像结果都能以适当的权重和相关性被检索。这种方法避免了由于较高的相似性分数而导致某一模态（例如，文本）主导结果的情况，从而可能掩盖来自另一模态的相关结果。

使用独立集合确保：

• 文本块根据其与查询的语义相似性被检索。
• 图像根据其视觉相似性被检索，与文本分数无关。

这种分离对于多模态系统至关重要，因为这两种模态对满足用户意图同样重要。

检索器函数

import matplotlib.pyplot as plt
import matplotlib.image as mpimg

def MultiModalRetriever(user_query):
    """
    检索多模态结果（文本和图像）。
    参数：
    - user_query: 用户的查询字符串。
    """
    query = get_text_embeddings(user_query)

    text_hits = client.query_points(
        collection_name="text",
        query=query,
        limit=3, 
    ).points

    image_hits = client.query_points(
        collection_name="images",
        query=query,
        limit=3, 
    ).points
    return text_hits, image_hits

现在构建一个查看器来显示检索结果：

import matplotlib.pyplot as plt
import matplotlib.image as mpimg

def MultiModalRetrieverDisplay(text_hits, image_hits, text_trunc_length=150):
    """
    显示来自多模态检索器的文本和图像结果。  
    参数：
    ----------
    text_hits : 包含 `id`、`payload` 和 `score` 的文本结果列表。
    image_hits : 包含 `id`、`payload` 和 `score` 的图像结果列表。
    text_trunc_length : int, 显示文本内容的最大长度（默认为150）。
    显示：
    --------
    - 以粗体显示的文本结果，包含ID、截断内容和分数。
    - 在matplotlib图中显示的图像结果，标题中包含分数。
    """
    
    print("\\\\033\[1m文本结果:\\\\033\[0m")
    for i, hit in enumerate(text_hits, 1):
        print("NODEID:", hit.id)
        content = hit.payload['content']
        truncated_content = content[:text_trunc_length] + "..." if len(content) > text_trunc_length else content
        bold_truncated_content = f"\\\\033\[1m{truncated_content}"
        print(f"{i}. {bold_truncated_content} | 分数: {hit.score}")

    print("\\\\n图像结果:")
    fig, axes = plt.subplots(1, len(image_hits), figsize=(15, 5))  
    for ax, hit in zip(axes, image_hits):
        image_path = hit.payload['image_path']
        print(f"显示图像: {image_path} | 分数: {hit.score}")
        img = mpimg.imread(image_path)
        ax.imshow(img)
        ax.axis('off')
        ax.set_title(f"分数: {hit.score}", fontsize=10)
    plt.suptitle("图像结果", fontsize=16)
    plt.tight_layout()
    plt.show()

测试多模态检索器和查看器功能

text_hits, Image_hits = MultiModalRetriever("how much of acre burned in 2022?")
MultiModalRetrieverDisplay(text_hits, Image_hits, text_trunc_length=150)

查询的文本结果（图片由作者提供）

查询的图像结果（图片由作者提供）

RAG Pipeline with Multimodal LLM Integration

要构建一个多模态 RAG系统管道，您可以集成任何多模态大型语言模型来处理文本和图像。以下是其工作原理：

1. 准备数据：将文本块（上下文列表）和图像分离成其文件路径的列表。
2. 处理图像：将图像文件路径转换为编码的图像数据。这些编码的图像将根据模型的要求作为网址或编码对象传递给模型。
3. 输入模型：将文本块和编码的图像组合成单一的输入格式。多模态大型语言模型将使用文本块作为上下文，并将图像作为视觉数据来生成答案。

这种方法允许模型无缝处理文本和视觉信息，提供全面而准确的响应。

构建RAG功能：

from openai import ChatCompletion
import openai
import base64
from base64 import b64decode
import os

def MultiModalRAG(
    context: list,
    images: list,
    user_query: str,
    client: client,
    model: str = "yourMLLM"):  
    generation_prompt = f"""
    根据给定的上下文，回答用户查询：{user_query}，
    上下文可以是表格、文本或图像。从上下文中提供答案。
    用户查询：{user_query}

上下文：{context}\\\\n
    输出：
    """

def encode_image(image_path):
    if image_path:
        with open(image_path, "rb") as image_file:
            return base64.b64encode(image_file.read()).decode()
    return None

image_paths = images
messages = [
    {
        "role": "system",
        "content": "您是一个有帮助的助手。"
    },
    {
        "role": "user",
        "content": generation_prompt,
    }
]

for image_path in image_paths:
    img_base64 = encode_image(image_path)
    if img_base64:
        messages.append({
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/jpeg;base64,{img_base64}"  
                    },
                },
            ],
        })

chat_completion = client.chat.completions.create(
    messages=messages,
    model=model,
    temperature=0.5,
    top_p=0.99,
)

return chat_completion.choices[0].message.content

def RAG(query):
    text_hits, Image_hits = MultiModalRetriever(query)
    retrieved_images = [i.payload['image_path'] for i in Image_hits]
    answer = MultiModalRAG(text_hits, retrieved_images, query, openaiclient)
    return(answer)

RAG("""2022年全国因野火烧毁的土地面积中，有多少百分比是在联邦土地上，这与10年平均水平相比如何？""")

![Image 7](https://wsrv.nl/?url=https://cdn-images-1.readmedium.com/v2/resize:fit:800/1*DjZ9CW9fwIJKvYyHo5aS0w.png)

RAG输出（作者提供的图像）

第4部分：结论：让多模态数据为您服务

构建一个多模态RAG系统是将复杂、多样化的数据转化为真正有用的东西。从使用工具如PyMuPDF提取内容，到使用像Nomic Vision和Text这样的模型嵌入文本和图像，再到将所有内容组织在Qdrant中，每一步都朝着一个无缝工作的系统迈进。最后添加一个多模态大型语言模型使一切结合在一起，使系统能够提供不仅准确而且上下文丰富和全面的答案。

概述的过程展示了如何：

• 提取多模态数据。
• 将其嵌入并存储在Qdrant中。
• 为多模态大型语言模型处理检索数据。

这个过程展示了人工智能如何弥合不同类型的数据、文本和视觉之间的差距，以解决现实世界的问题。通过正确的方法，RAG系统不仅仅是一个工具；它成为获取有意义的见解和做出更聪明决策的一种方式。

关于我

嗨！我是Hamza，很高兴能成为您进入人工智能世界的向导。我目前领导一家名为Traversaal.ai的初创公司。作为前谷歌高级研究科学家和斯坦福大学及加州大学洛杉矶分校的讲师，我一直处于人工智能开发和教育的前沿。我的热情在于揭开复杂人工智能概念的神秘面纱，并赋能下一代人工智能从业者。

如果您喜欢深入了解从零开始构建多模态RAG，您可能想进一步提升您的LLM知识。

在企业RAG和多智能体应用中，我们探索超越基础的前沿技术。从先进的RAG解决方案到最新的模型优化方法和负责任的人工智能实践，本课程为您提供应对现实世界人工智能挑战所需的技能。

无论您是在实施最先进的LLM应用，还是深入模型微调和伦理人工智能部署，本课程都能满足您的需求。

课程特点：

• 高级RAG与智能体系统：最新架构和优化
• 企业云集成：GCP和AWS Bedrock部署
• 人工智能安全与质量控制：行业标准实践

通过实用的、以商业为导向的培训提升您的人工智能专业知识。

关于Areeej:

Areej Mehboob 是 Traversaal.ai 的NLP研究员，专注于人工智能产品开发。她的工作主要集中在自然语言处理和机器学习，以应对现实世界的挑战。