[๊ฐ์๋ ธํธ] Text Splitting For Retrieval
์๋ณธ ๊ฒ์๊ธ: https://velog.io/@euisuk-chung/The-5-Levels-Of-Text-Splitting-For-Retrieval-๊ฐ์์์ฝ
Introduction
๋๊ท๋ชจ ์ธ์ด ๋ชจ๋ธ(LLM, Large Language Model)์ ์ด์ฉํ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฑ๋ฅ์ ํฅ์์ํค๋ ๊ฐ์ฅ ํจ๊ณผ์ ์ธ ์ ๋ต ์ค ํ๋๋ ํฐ ํ ์คํธ ๋ฐ์ดํฐ๋ฅผ ๋ ์์ ์กฐ๊ฐ์ผ๋ก ๋ถํ ํ๋ ๊ฒ์ ๋๋ค. LLM์๊ฒ ํ์ํ ์ ๋ณด๋ง์ ์ ๊ณตํจ์ผ๋ก์จ ๋ชจ๋ธ์ ์์ ํจ์จ์ฑ์ ๊ทน๋ํํ ์ ์์ต๋๋ค. ์ด๋ฌํ ํ ์คํธ ๋ถํ ๊ธฐ์ ์ ๋จ์ํ ๋ฐฉ๋ฒ ๊ฐ์ง๋ง, ๊ทธ ์์๋ ๋ณต์กํ ๊ณผํ๊ณผ ์์ ์ด ์จ์ด ์์ต๋๋ค.
์์ ์ ๋ชฉ
: The 5 Levels Of Text Splitting For Retrieval์์ ๋งํฌ
: https://youtu.be/8OJC21T2SL4
์ด๋ฒ ํฌ์คํธ์์๋ 5๊ฐ์ง์ ํ ์คํธ ๋ถํ (Levels of Text Splitting) ๋ฐฉ๋ฒ์ ์๊ฐํฉ๋๋ค.
(*ํด๋น ๊ธ์ ์ Youtube ์์ ์๋ฃ๋ฅผ ๊ณต๋ถ ํ์ ์ ๋ฆฌํ์์ต๋๋ค.)
Background
์ธ์ด ๋ชจ๋ธ์ ์ผ๋ฐ์ ์ผ๋ก ๋ฌธ๋งฅ ๊ธธ์ด(Context Length)๋ผ๋ ์ ํ์ด ์์ต๋๋ค. ์ฆ, ํ ๋ฒ์ ์ฒ๋ฆฌํ ์ ์๋ ๋ฐ์ดํฐ์ ์์ด ์ ํ๋์ด ์์ต๋๋ค. ๋ฐ๋ผ์ ๋๋์ ๋ฐ์ดํฐ๋ฅผ ํ๊บผ๋ฒ์ ๋ชจ๋ธ์ ๋๊ธฐ๊ธฐ๋ณด๋ค๋, ๋ฐ์ดํฐ๋ฅผ ์์ ์กฐ๊ฐ์ผ๋ก ๋๋ ์ ํ์ํ ๋ถ๋ถ๋ง ์ ๊ณตํ๋ ๊ฒ์ด ๋ ํจ์จ์ ์ ๋๋ค. ์ด๋ ์ค์ํ ๊ฒ์ด ๋ฐ๋ก ํ ์คํธ ๋ถํ ์ ๋๋ค.
ํ ์คํธ ๋ถํ ์ ๋จ์ํ ๋ฐ์ดํฐ๋ฅผ ์๋ฅด๋ ๊ฒ์ด ์๋๋ผ, ์ต์ ์ ์ ๋ณด ๊ตฌ์กฐ๋ฅผ ๋ง๋ค๊ธฐ ์ํ ์ ๋ต์ ๋๋ค. ์ด๋ฅผ ํตํด ์ ํธ ๋ ์ก์๋น(Signal-to-Noise Ratio)๋ฅผ ๋์ฌ ๋ชจ๋ธ์ด ๋ณด๋ค ์ค์ํ ์ ๋ณด์ ์ง์คํ๊ฒ ๋ง๋ค ์ ์์ต๋๋ค.
The 5 Levels of Text Splitting
ํ ์คํธ ๋ถํ ์ ํฌ๊ฒ ๋ค์ฏ ๋จ๊ณ๋ก ๋๋ ์ ์์ต๋๋ค. ๊ฐ ๋จ๊ณ๋ ์ ์ ๋ ๋ณต์กํ ๋ฐฉ์์ผ๋ก ๋ฐ์ ํ๋ฉฐ, ํ ์คํธ์ ๋ฌผ๋ฆฌ์ ๊ตฌ์กฐ์์๋ถํฐ ์๋ฏธ์ ๊ตฌ์กฐ๊น์ง ๋ค์ํ ๊ด์ ์ ๊ณ ๋ คํฉ๋๋ค.
โ Level 1
: Character Splitting - Simple static character chunks of data
โก Level 2
: Recursive Character Text Splitting - Recursive chunking based on a list of separators
โข Level 3
: Document Specific Splitting - Various chunking methods for different document types (PDF, Python, Markdown)
โฃ Level 4
: Semantic Splitting - Embedding walk based chunking
โค Level 5
: Agentic Splitting - Experimental method of splitting text with an agent-like system.
Level 1: Character Splitting (์บ๋ฆญํฐ ๋ถํ )
์ฒซ ๋ฒ์งธ ๋จ๊ณ๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ์์ธ ํ ์คํธ๋ฅผ ๊ณ ์ ๋ ๋ฌธ์ ์๋ก ๋ถํ ํ๋ ๋ฐฉ์์ ๊ธฐ๋ณธ์ ์ธ ํ ์คํธ ๋ถํ ๋ฐฉ๋ฒ์ ๋๋ค. ์ด ๋ฐฉ๋ฒ์ ๊ตฌํ์ด ๊ฐ๋จํ์ง๋ง, ํ ์คํธ์ ๋ฌธ๋งฅ์ด๋ ์๋ฏธ๋ฅผ ๊ณ ๋ คํ์ง ์๊ธฐ ๋๋ฌธ์ ์ค๋ฌด์์ ์์ฃผ ์ฌ์ฉ๋์ง๋ ์์ต๋๋ค.
๊ณ ์ ๋ ๋ฌธ์ ์๋ก ๋ถํ ํ ๊ฒฝ์ฐ, ๋จ์ด ์ค๊ฐ์์ ๋ถํ ์ด ๋ฐ์ํ ์ ์์ผ๋ฉฐ, ์ด๋ ๊ฐ๋ ์ฑ์ ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ์ ์์ต๋๋ค. ์ด๋ฐ ์ด์ ๋ก ์ด ๋ฐฉ์์ ์ค์ ์์ฉ์์ ๊ฑฐ์ ์ฌ์ฉ๋์ง ์์ผ๋ฉฐ, ๋์ ๋ ์ ๊ตํ ๋ถํ ๊ธฐ๋ฒ์ด ์ ํธ๋ฉ๋๋ค.
1
2
3
4
5
6
7
8
text = "This is the text I would like to chunk up. It is the example text for this exercise"
chunks = []
chunk_size = 35
for i in range(0, len(text), chunk_size):
chunk = text[i:i + chunk_size]
chunks.append(chunk)
์ฅ์ :
- ๋งค์ฐ ๊ฐ๋จํ๊ณ ๋น ๋ฆ ๋๋ค.
- ๊ตฌํ์ด ์ฝ์ต๋๋ค.
๋จ์ :
- ํ ์คํธ์ ์๋ฏธ๋ ๊ตฌ์กฐ๋ฅผ ๊ณ ๋ คํ์ง ์๊ธฐ ๋๋ฌธ์, ์ค์ ์์ ๊ฑฐ์ ์ฌ์ฉ๋์ง ์์ต๋๋ค.
- ๋จ์ด ์ค๊ฐ์์ ๋ถํ ์ด ๋ฐ์ํ์ฌ ๊ฐ๋ ์ฑ์ ๋ฌธ์ ๊ฐ ์๊ธธ ์ ์์ต๋๋ค.
Level 2: Recursive Character Splitting (์ฌ๊ท์ ์บ๋ฆญํฐ ๋ถํ )
๋ ๋ฒ์งธ ๋จ๊ณ๋ ์ฌ๊ท์ ์บ๋ฆญํฐ ๋ถํ ์
๋๋ค. RecursiveCharacterTextSplitter
์ ๊ฐ์ ๋๊ตฌ๋ฅผ ์ฌ์ฉํด ํ
์คํธ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ถํ ํฉ๋๋ค. ์ฃผ์ด์ง ๊ตฌ๋ถ์(์: ๋ฌธ์ฅ, ๋จ๋ฝ, ๊ณต๋ฐฑ ๋ฑ)์ ๋ฐ๋ผ ํ
์คํธ๋ฅผ ๋๋๋ฉฐ, ๊ฐ ๊ตฌ๋ถ์๊ฐ ์๋ํ์ง ์๋ ๊ฒฝ์ฐ ๋ค์ ๊ตฌ๋ถ์๋ฅผ ์ฌ์ฉํ์ฌ ํ
์คํธ๋ฅผ ๋ ์ธ๋ถํํ ์ ์์ต๋๋ค.
์ด ๋ฐฉ๋ฒ์ ํ ์คํธ์ ์์ฐ์ค๋ฌ์ด ํ๋ฆ์ ๊ณ ๋ คํด ์ ์ ํ ๊ตฌ๋ถ์๋ฅผ ์ด์ฉํ๋ ๊ฒ์ด ํน์ง์ ๋๋ค. ๋จผ์ ํฐ ๋จ์๋ก ๋๋ ํ, ํ์์ ๋ฐ๋ผ ์์ ๋จ์๋ก ์ฌ๊ท์ ์ผ๋ก ๋ถํ ํฉ๋๋ค. ์ด๋ ๋ณด๋ค ์๋ฏธ ์๋ ์ฒญํฌ๋ฅผ ์์ฑํ๋ ๋ฐ ์ ๋ฆฌํฉ๋๋ค.
1
2
3
4
5
from langchain.text_splitter import RecursiveCharacterTextSplitter
text_splitter = RecursiveCharacterTextSplitter(chunk_size=100, chunk_overlap=20)
texts = text_splitter.split_text(text)
์ฅ์ :
- ํ ์คํธ์ ๊ตฌ์กฐ๋ฅผ ๊ณ ๋ คํ์ฌ ์๋ฏธ ์๋ ๋จ์๋ก ๋ถํ ํ ์ ์์ต๋๋ค.
- ๋ค์ํ ๊ตฌ๋ถ์๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ฐํ๊ฒ ํ ์คํธ๋ฅผ ๋ถํ ํ ์ ์์ต๋๋ค.
๋จ์ :
- ์ฌ์ ํ ๊ณ ์ ๋ ๋ฌธ์ ์์ ์์กดํ์ฌ ๋ถํ ๋ฉ๋๋ค.
- ๋ณต์กํ ๋ฌธ์์์๋ ์ถ๊ฐ์ ์ธ ์กฐ์ ์ด ํ์ํ ์ ์์ต๋๋ค.
Level 3: Document-Specific Splitting (๋ฌธ์ ํนํ ๋ถํ )
์ธ ๋ฒ์งธ ๋จ๊ณ๋ ๋ฌธ์์ ์ข ๋ฅ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ๋ถํ ํ๋ ๋ฌธ์ ํนํ ๋ถํ ์ ๋๋ค. ์๋ฅผ ๋ค์ด, Markdown, Python ์ฝ๋, PDF ๋ฌธ์ ๋ฑ ๊ฐ๊ฐ์ ๋ฌธ์ ํ์์๋ ๊ณ ์ ์ ๊ตฌ์กฐ์ ํน์ง์ด ์์ต๋๋ค. Markdown ๋ฌธ์์ ๊ฒฝ์ฐ, ์ ๋ชฉ(Heading)์ ๊ธฐ์ค์ผ๋ก, ์ฝ๋ ๋ฌธ์์ ๊ฒฝ์ฐ ํจ์๋ ํด๋์ค ๋จ์๋ก ๋ถํ ํ ์ ์์ต๋๋ค.
PDF์ ๊ฐ์ ๋ณต์กํ ๋ฌธ์๋ ์ด๋ฏธ์ง, ํ ๋ฑ ์ฌ๋ฌ ์์๋ฅผ ํฌํจํ ์ ์์ผ๋ฉฐ, ์ด๋ฌํ ์์๋ค์ ๋ง๋ ๋ถํ ๋ฐฉ์์ด ํ์ํฉ๋๋ค.
python ๋ถํ ์์:
1
2
3
4
5
6
7
8
9
10
# Python ์ฝ๋ ๋ฌธ์ ๋ถํ ์์
from langchain.text_splitter import PythonCodeSplitter
code = """
class Example:
def function(self):
pass
"""
splitter = PythonCodeSplitter(chunk_size=200)
chunks = splitter.split_text(code)
JS ๋ถํ ์์:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from langchain.text_splitter import RecursiveCharacterTextSplitter, Language
javascript_text = """
// Function is called, the return value will end up in x
let x = myFunction(4, 3);
function myFunction(a, b) {
// Function returns the product of a and b
return a * b;
}
"""
js_splitter = RecursiveCharacterTextSplitter.from_language(
language=Language.JS, chunk_size=65, chunk_overlap=0
)
js_splitter.create_documents([javascript_text])
PDF ๋ถํ ์์:
1
2
3
4
from PyPDF2 import PdfReader
reader = PdfReader('sample.pdf')
chunks = [page.extract_text() for page in reader.pages]
Markdown ๋ถํ ์์:
1
2
3
4
from langchain.text_splitter import MarkdownTextSplitter
text_splitter = MarkdownTextSplitter(chunk_size=200)
chunks = text_splitter.split_text(markdown_text)
์ฅ์ :
- ๋ฌธ์์ ํ์(์: Markdown, Python ์ฝ๋, PDF)์ ๊ณ ๋ คํ ๋ง์ถคํ ๋ถํ ์ด ๊ฐ๋ฅํฉ๋๋ค.
- ๋ฌธ์ ๊ตฌ์กฐ์ ๋ฐ๋ผ ์ ์ ํ ๋ฐฉ์์ผ๋ก ๋ถํ ํ์ฌ ์๋ฏธ๋ฅผ ๋ ์ ๋ณด์กดํฉ๋๋ค.
๋จ์ :
- ๊ฐ ๋ฌธ์ ํ์์ ๋ง์ถ ๋ง์ถคํ ์ฝ๋๊ฐ ํ์ํฉ๋๋ค.
- ์ฌ๋ฌ ๋ฌธ์ ํ์์ ๋์์ ์ฒ๋ฆฌํ๋ ค๋ฉด ์ถ๊ฐ์ ์ธ ๋๊ตฌ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ํ์ํ ์ ์์ต๋๋ค.
Level 4: Semantic Splitting (์๋ฏธ ๊ธฐ๋ฐ ๋ถํ )
๋ค ๋ฒ์งธ ๋จ๊ณ๋ ์๋ฏธ์ ๋ถํ ์ ๋๋ค. ์์ ์ธ๊ธํ ๋จ๊ณ๋ค์ ํ ์คํธ์ ๋ฌผ๋ฆฌ์ ๊ตฌ์กฐ(๋ฌธ๋จ, ๋ฌธ์ฅ, ๋จ์ด)๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ถํ ํ์ง๋ง, ์ด ๋จ๊ณ์์๋ ํ ์คํธ์ ์๋ฏธ์ ๋ด์ฉ์ ๊ธฐ์ค์ผ๋ก ๋ถํ ํฉ๋๋ค. ์ฆ, ๊ฐ ๋ฌธ์ฅ์ด ๋ค๋ฃจ๋ ์ฃผ์ ๋ ๋ด์ฉ์ ์ ์ฌ์ฑ์ ๋ฐํ์ผ๋ก ํ ์คํธ๋ฅผ ๋ถํ ํ๋ ๊ฒ์ ๋๋ค.
์ด ๋ฐฉ๋ฒ์ ํ ์คํธ์ ์๋ฏธ๋ฅผ ๋ ์ ๋ฐ์ํ ์ ์์ผ๋, ๊ตฌํ์ด ๋ณต์กํ๊ณ ๋น์ฉ์ด ๋ง์ด ๋ญ๋๋ค. ์ด๋ฅผ ์ํด ํ ์คํธ์ ์๋ฒ ๋ฉ(embedding)์ ์ฌ์ฉํด ๋ฌธ์ฅ์ ์ ์ฌ๋๋ฅผ ๊ณ์ฐํ์ฌ ์๋ฏธ์ ์ผ๋ก ๊ด๋ จ๋ ๋ฌธ์ฅ๋ค์ ํ๋์ ์ฒญํฌ๋ก ๋ฌถ์ต๋๋ค.
1
2
3
4
5
6
7
8
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_distances
model = SentenceTransformer('paraphrase-MiniLM-L6-v2')
sentences = ["This is a test.", "How does it work?", "Let's see!"]
embeddings = model.encode(sentences)
distances = cosine_distances(embeddings)
์ฅ์ :
- ํ ์คํธ์ ์๋ฏธ์ ์ ์ฌ์ฑ์ ๊ณ ๋ คํ์ฌ ์์ฐ์ค๋ฝ๊ณ ์๋ฏธ ์๋ ๋ถํ ์ด ๊ฐ๋ฅํฉ๋๋ค.
- ์๋ฏธ์ ์ผ๋ก ๊ด๋ จ๋ ๋ฌธ์ฅ๋ค์ ํ๋์ ์ฒญํฌ๋ก ๋ฌถ์ด ์ ๋ณด ๊ฒ์ ๋ฐ ๋ถ์์ ์ ๋ฆฌํฉ๋๋ค.
๋จ์ :
- ์๋ฒ ๋ฉ ๋ฐ ์ ์ฌ๋ ๊ณ์ฐ์ ์ฌ์ฉํ๋ฏ๋ก ๊ณ์ฐ ๋น์ฉ์ด ํฝ๋๋ค.
- ๋๋์ ๋ฐ์ดํฐ๋ ๋ณต์กํ ๋ฌธ์์ ๊ฒฝ์ฐ ์ฒ๋ฆฌ ์๊ฐ์ด ๊ธธ์ด์ง ์ ์์ต๋๋ค.
Level 5: Agentic Splitting (์์ด์ ํธ ๊ธฐ๋ฐ ๋ถํ )
๋ง์ง๋ง ๋จ๊ณ๋ ์์ด์ ํธ ๊ธฐ๋ฐ ๋ถํ ์ ๋๋ค. Agentic Splitting์ ํ ์คํธ๋ฅผ ๋ฅ๋์ ์ผ๋ก ํ๊ฐํ์ฌ ๋ถํ ํ๋ ์คํ์ ์ธ ๋ฐฉ๋ฒ์ ๋๋ค. ๊ฐ ๋ฌธ์ฅ์ ํ๋์ โPropositionโ์ผ๋ก ๋ณด๊ณ , ๊ฐ Proposition์ ํ๊ฐํ์ฌ ๊ธฐ์กด ์ฒญํฌ์ ํฌํจํ ์ง ์๋ก์ด ์ฒญํฌ๋ก ๋๋์ง ๊ฒฐ์ ํฉ๋๋ค. ๋ฌธ์ฅ์ด ์ถ๊ฐ๋ ๋๋ง๋ค ์ฒญํฌ์ ์์ฝ๊ณผ ์ ๋ชฉ์ด ์๋์ผ๋ก ์ ๋ฐ์ดํธ๋ฉ๋๋ค.
์ด ๋ฐฉ์์ ๋งค์ฐ ๋๋ฆฌ๊ณ ๋น์ฉ์ด ๋ง์ด ๋ค์ง๋ง, ๋ณต์กํ๊ณ ๋ค์ํ ๋ฌธ์์ ๋ํด ๋์ ์์ค์ ๋ถํ ์ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
1
2
3
4
5
6
7
8
9
10
11
class AgenticChunker:
def __init__(self):
self.chunks = []
def add_proposition(self, proposition):
# Proposition์ ์ถ๊ฐํ ์ฒญํฌ๋ฅผ ํ๊ฐ
pass
def create_new_chunk(self, proposition):
# ์ ์ฒญํฌ ์์ฑ
pass
์๋ ๋ฐฉ์:
- Proposition(๋ฌธ์ฅ)์ด ์ฃผ์ด์ง๋ฉด, ๊ธฐ์กด ์ฒญํฌ ์ค ์ด๋ ๊ฒ์ ํฌํจ๋ ์ง ํ๋จํ๊ฑฐ๋, ์๋ก์ด ์ฒญํฌ๋ฅผ ์์ฑํฉ๋๋ค.
- ์ฒญํฌ๊ฐ ์์ฑ๋ ๋๋ง๋ค GPT-4์ ๊ฐ์ LLM์ ์ฌ์ฉํ์ฌ ์์ฝ๊ณผ ์ ๋ชฉ์ ์๋ ์์ฑํ๋ฉฐ, Proposition์ด ์ถ๊ฐ๋ ๋๋ง๋ค ์ฒญํฌ์ ์์ฝ๊ณผ ์ ๋ชฉ์ด ์ ๋ฐ์ดํธ๋ฉ๋๋ค.
์ฅ์ :
- ๋ฌธ์ฅ์ ๋ฅ๋์ ์ผ๋ก ํ๊ฐํ์ฌ ๋ถํ ํ๋ฉฐ, ์ฒญํฌ์ ์์ฝ ๋ฐ ์ ๋ชฉ์ด ์ง์์ ์ผ๋ก ์ ๋ฐ์ดํธ๋ฉ๋๋ค.
- ๋ฌธ์์ ์๋ฏธ ๋ณํ์ ์ ์ฐํ๊ฒ ๋์ํ ์ ์์ต๋๋ค.
๋จ์ :
- LLM์ ๊ธฐ๋ฐ์ผ๋ก ํ๊ธฐ ๋๋ฌธ์ ๊ณ์ฐ ๋น์ฉ์ด ํฌ๊ณ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฝ๋๋ค.
- ์คํ์ ์ธ ๊ธฐ๋ฒ์ผ๋ก, ์์ง ์ผ๋ฐ์ ์ธ ํ๋ก๋์ ํ๊ฒฝ์์๋ ์ฌ์ฉ๋์ง ์์ต๋๋ค.
AgenticChunker์ ๋ํ ๋ณด์ถฉ ์ค๋ช :
AgenticChunker
ํด๋์ค๋ ๋ฌธ์ฅ์ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋ถ๋ฅํ์ฌ ์ฒญํฌ๋ฅผ ์์ฑํ๊ณ , ๊ฐ ์ฒญํฌ์ ๋ด์ฉ์ ์์ฝํ๊ณ ์ ๋ชฉ์ ์์ฑํ๋ ์์ ์ ์ํํ๋ ์์คํ ์ ๋๋ค. ์ด ์์คํ ์ ์ฌ์ฉ์๊ฐ ๋ฌธ์๋ฅผ ์ธ๋ถ์ ์ผ๋ก ๋ถํ ํ๊ณ ๊ด๋ฆฌํ๋ ๋ฐ ์ ํฉํ๋ฉฐ, ํนํ ํฐ ๋ฌธ์๋ ์ฌ๋ฌ ๋ฌธ์ฅ์ด ์๋ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ ๋ ์ ์ฉํฉ๋๋ค.
AgenticChunker
๋ ๋ค์๊ณผ ๊ฐ์ ์ค์ํ ๊ธฐ๋ฅ์ ํฌํจํ๊ณ ์์ต๋๋ค:
- ๋ฌธ์ฅ์ ์ฒญํฌ์ ์ถ๊ฐํ ์ง ์๋ก์ด ์ฒญํฌ๋ฅผ ์์ฑํ ์ง ํ๋จ.
- GPT-4๋ฅผ ํตํด ๊ฐ ์ฒญํฌ์ ์์ฝ๊ณผ ์ ๋ชฉ์ ์๋์ผ๋ก ์์ฑ ๋ฐ ๊ฐฑ์ .
- Proposition์ด ์ถ๊ฐ๋ ๋๋ง๋ค ์๋ฏธ๋ฅผ ํ๊ฐํ๊ณ ์ฒญํฌ๋ฅผ ๋์ ์ผ๋ก ๊ด๋ฆฌ.
Conclusion
ํ ์คํธ ๋ถํ ์ ์ธ์ด ๋ชจ๋ธ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฑ๋ฅ์ ๊ทน๋ํํ๊ธฐ ์ํ ํ์์ ์ธ ๊ณผ์ ์ ๋๋ค.
์ด๋ฒ ํฌ์คํธ์์๋ โThe 5 Levels Of Text Splitting For Retrievalโ ๊ฐ์์์ ์๊ฐํ๋ 5๋จ๊ณ์ ํ ์คํธ ๋ถํ ๋ฐฉ๋ฒ๋ค์ ๋ํด์ ๊ฐ๋จํ๊ฒ ์๊ฐํฉ๋๋ค. ์ด๋ฌํ ๋ฐฉ๋ฒ๋ค์ ๊ฐ๊ธฐ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ํ ์คํธ๋ฅผ ๋๋๋ฉฐ, ๋ฌธ์์ ํน์ฑ, ์๋ฏธ, ๊ทธ๋ฆฌ๊ณ ์์ ์ ๋ชฉ์ ์ ๋ง๋ ๋ถํ ์ ๋ต์ ์ ํํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๊ธฐ๋ณธ์ ์ธ ์บ๋ฆญํฐ ๋ถํ ์์๋ถํฐ ์๋ฏธ์ ๋ถํ , ๊ทธ๋ฆฌ๊ณ ์์ด์ ํธ ๊ธฐ๋ฐ์ ๋ถํ ๊น์ง ๋ค์ํ ์ต์ ์ ์คํํด๋ณด๋ฉด์, ์ฌ๋ฌ๋ถ์ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋ ์ต์ ์ ๋ฐฉ๋ฒ์ ์ฐพ์ ์ ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค. ๋ ๋์๊ฐ, ํ ์คํธ ๋ถํ ์ธ์๋ ๋ฉํฐ๋ฒกํฐ ์ธ๋ฑ์ฑ(Multi-Vector Indexing)์ด๋ ๊ทธ๋ํ ๊ตฌ์กฐ ์ถ์ถ๊ณผ ๊ฐ์ ๊ณ ๊ธ ๊ธฐ๋ฒ๋ค์ ํ์ฉํ์ฌ ๋์ฑ ์ ๊ตํ ์ ๋ณด ๊ฒ์ ์์คํ ์ ๊ตฌ์ถํ ์ ์์ต๋๋ค.