GraphRAG with Document

GraphRAG 리마인드 그리고 메타 검색 방식과 대조해보기

지식 그래프 구축을 위해 정보체계 온톨로지를 만드는 방식

 

 

Graph Document Hierarchy

A submodular concept in the context of personalized recommendations refers to a mathematical property of certain types of functions that are often used in optimization problems. Specifically, a function is called submodular if it has a diminishing returns property, meaning that adding an item to a smaller set provides more benefit than adding the same item to a larger set.

In personalized recommendations, submodular functions are used to model how to select a diverse and relevant set of recommendations. Here's a simplified explanation:

• Diminishing Returns: If you recommend a movie or product to a user, the first few items in a set will add significant value because they meet the user's interest. However, as you keep adding more items that are similar, the additional value decreases. This property of diminishing returns helps ensure that a recommendation system suggests a diverse set of items, not just items similar to what the user has already interacted with.

For example, if you are building a recommendation list, you want to suggest items that cover different aspects of a user’s interest to maximize engagement. A submodular function could help optimize this by balancing diversity with relevance.

Intra, 문서 간의 관계

Inter, 문서 내부 요소들간의 관계

Content Hierarchy, 문서가 이루어진 요소들 중 표 이미지에서 관계를 표현해본다면?

import fitz  # PyMuPDF
import pandas as pd
from bs4 import BeautifulSoup
import re
import os

def convert_html_table_to_markdown(html_table_text: str) -> str:
    # BeautifulSoup을 사용하여 HTML 파싱
    soup = BeautifulSoup(html_table_text, 'html.parser')

    # 테이블 찾기
    table = soup.find('table')

    # Pandas DataFrame으로 변환
    df = pd.read_html(str(table))[0]

    # DataFrame을 Markdown으로 변환
    markdown_table = df.to_markdown(index=False)

    return markdown_table

def is_table(text: str) -> bool:
    # 간단한 규칙으로 표를 구분 (예: 여러 개의 연속된 공백이나 줄바꿈이 표 형식일 가능성이 큼)
    if re.search(r'\n\s*\n', text):
        return True
    return False

def get_nearest_paragraph(text: str, current_position: int, window_size: int = 1000) -> str:
    """
    주어진 위치에서 앞뒤 문단을 추출하는 함수
    :param text: 전체 텍스트
    :param current_position: 현재 텍스트 위치
    :param window_size: 앞뒤로 몇 글자 정도 추출할지 결정
    :return: 주석에 해당하는 텍스트 (앞, 뒤 텍스트)
    """
    start = max(0, current_position - window_size)
    end = min(len(text), current_position + window_size)
    
    # 앞뒤로 텍스트를 제한된 범위만큼 추출
    return text[start:current_position], text[current_position:end]

def extract_pdf_content(pdf_path: str, image_output_dir: str, window_size: int = 1000):
    # PDF 문서 열기
    doc = fitz.open(pdf_path)
    
    documents = []
    
    for page_num in range(len(doc)):
        page = doc.load_page(page_num)
        text = page.get_text("text")
        html = page.get_text("html")

        # 이미지가 포함되어 있는지 체크
        image_list = page.get_images(full=True)

        # 이미지가 있으면 이미지 처리
        if image_list:
            for img_index, img in enumerate(image_list):
                xref = img[0]
                base_image = doc.extract_image(xref)
                image_bytes = base_image["image"]
                image_ext = base_image["ext"]

                # 이미지 저장
                image_filename = os.path.join(image_output_dir, f"page{page_num + 1}_img{img_index + 1}.{image_ext}")
                with open(image_filename, "wb") as image_file:
                    image_file.write(image_bytes)

                # 이미지 주변의 텍스트(주석)를 추출
                img_position = page.search_for(base_image['image'])[0] if base_image else 0
                before_text, after_text = get_nearest_paragraph(text, img_position, window_size)

                # 이미지 메타데이터와 주석 정보 기록
                documents.append({
                    "page_content": image_filename,
                    "metadata": {
                        "source": pdf_path, 
                        "page_type": "image", 
                        "page_num": page_num + 1, 
                        "image_index": img_index + 1,
                        "before_text": before_text,  # 이미지 앞 주석
                        "after_text": after_text     # 이미지 뒤 주석
                    }
                })

        # 텍스트와 표 구분
        if is_table(text):
            # 표로 인식한 경우 HTML 형태로 저장
            table_position = text.find('<table>')
            before_text, after_text = get_nearest_paragraph(text, table_position, window_size)

            documents.append({
                "page_content": html,
                "metadata": {
                    "source": pdf_path, 
                    "page_type": "table", 
                    "page_num": page_num + 1,
                    "before_text": before_text,  # 표 앞 주석
                    "after_text": after_text     # 표 뒤 주석
                }
            })
        else:
            # 텍스트로 인식한 경우
            documents.append({
                "page_content": text,
                "metadata": {
                    "source": pdf_path, 
                    "page_type": "text", 
                    "page_num": page_num + 1
                }
            })
    
    return documents

def process_documents(documents):
    markdown_documents = []

    for doc in documents:
        if doc["metadata"].get("page_type") == 'table':
            try:
                # HTML로부터 표를 마크다운으로 변환
                doc["page_content"] = convert_html_table_to_markdown(doc["page_content"])
                markdown_documents.append(doc)
            except Exception as e:
                print(f"Error processing table on page {doc['metadata']['page_num']}: {e}")
                markdown_documents.append(doc)
        else:
            # 텍스트 및 이미지는 그대로 추가
            markdown_documents.append(doc)

    return markdown_documents


# 사용 예시
pdf_path = 'your_pdf_file.pdf'  # 처리할 PDF 파일 경로
image_output_dir = 'output_images'  # 이미지가 저장될 폴더
window_size = 1000  # 주석을 추출할 앞뒤 텍스트의 길이 설정

# 이미지 저장 폴더가 없으면 생성
if not os.path.exists(image_output_dir):
    os.makedirs(image_output_dir)

# PDF에서 텍스트, 표, 이미지 및 주석 추출
documents = extract_pdf_content(pdf_path, image_output_dir, window_size)
markdown_documents = process_documents(documents)

print(f"Total documents processed: {len(markdown_documents)}")

코드 설명

1. convert_html_table_to_markdown 함수: HTML 형식의 표를 마크다운 형식으로 변환하는 기존 함수입니다.

2. is_table 함수: 텍스트가 표로 인식되는지를 간단히 판단하는 함수입니다.

3. get_nearest_paragraph 함수: 주어진 위치에서 앞뒤로 일정 범위의 텍스트를 추출하여 이미지나 표 앞뒤의 주석(설명)을 찾아냅니다. window_size는 추출할 텍스트의 길이를 결정하며, 필요에 따라 조정할 수 있습니다.

4. extract_pdf_content 함수: 각 페이지에서 텍스트, 표, 이미지 등을 구분하여 추출하며, 이미지나 표의 앞뒤에 있는 설명 문단도 함께 추출합니다.
• 이미지: 이미지가 있을 경우 파일로 저장하며, 이미지 주변의 설명(앞뒤 텍스트)을 추출하여 함께 저장합니다.
• 표: 표가 있을 경우 HTML로 변환하고, 표 주변의 설명 문단을 함께 기록합니다.

5. process_documents 함수: 각 문서를 처리하여 표는 마크다운으로 변환하고, 이미지 및 텍스트는 그대로 저장합니다.

이미지 추출과 저장

주석(설명 문단) 연결

Lexical 그리고 Text, 기존 RAG 에서 활용하는 청킹 방식과 GraphRAG에서 Text를 활용한 방식은 무엇이 다를까요?

Structured or Semantic Search?

Structured Search typically requires certain schema to be defined; e.g., column, row, and fields in a relational database, or node, relationship, and property in a graph database. The biggest benefit of having a predefined schema, which means you need to know what fields or columns are available and their data types, is the precision and powerful features of manipulating data through a query language like SQL for RDBMS and Cypher for graph database.

Meanwhile, Semantic Search aims to understand the intent and contextual meaning of search phrases to produce highly relevant results. Instead of focusing solely on matching keywords, it seeks to understand the context in which keywords are used. For instance, the word “apple” could refer to the fruit or the tech company, and a semantic search system would attempt to discern which meaning was intended based on additional context.

Semantic Search often uses NLP techniques to understand context, synonyms, user intent, and more. Many semantic search systems use knowledge graphs to understand the relationships between different entities and concepts.

Because of the nature of the stored information and the capabilities offered, structured search excels in environments where data is well-organized, and the user knows precisely what they are querying for. Semantic search shines in more complex, natural language environments where user intent and context play a significant role in retrieving the right information.

끝으로,

본 글은 Open UP(오픈소스 소프트웨어 통합지원센터)로부터 지원받아 작성하였습니다.

레퍼런스