กลยุทธ์การแบ่งเป็นส่วน (คงที่ ประโยค เชิงความหมาย)
เปรียบเทียบข้อแลกเปลี่ยนระหว่างการแบ่งขนาดคงที่ การแบ่งโดยคำนึงถึงประโยค และการแบ่งเชิงความหมาย เพื่อคุณภาพการค้นคืน
กลยุทธ์การแบ่งเป็นส่วน (คงที่ ประโยค เชิงความหมาย) เป็นบทเรียน AI Agents ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Agents และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Agents มีบทเรียนทั้งหมด 4 บทเรียน
เหตุใดจึงต้องแบ่งเป็นส่วนย่อย
คุณไม่สามารถสร้างเวกเตอร์ฝังตัวจากไฟล์ PDF 200 หน้าเป็นเวกเตอร์เดียวได้ เพราะเวกเตอร์จะเป็นนามธรรมเกินไปจนไม่ตรงกับคำค้นหาเฉพาะเจาะจง คุณจึงแบ่งเอกสารออกเป็นชิ้นเล็ก ๆ (ชิ้นละประมาณ 200-800 โทเค็น) สร้างเวกเตอร์ฝังตัวของแต่ละชิ้น แล้วค้นหาในระดับส่วนย่อย
การแบ่งขนาดคงที่
วิธีที่ง่ายที่สุด คือแบ่งทุก ๆ N อักขระหรือโทเค็น:
def fixed_chunks(text, chunk_size=1000, overlap=200):
chunks = []
i = 0
while i < len(text):
chunks.append(text[i:i + chunk_size])
i += chunk_size - overlap
return chunks
sample_text = "A" * 2500
chunks = fixed_chunks(sample_text, chunk_size=1000, overlap=200)
print(f"Split {len(sample_text)} characters into {len(chunks)} chunks")
for i, c in enumerate(chunks):
print(f"Chunk {i+1}: {len(c)} chars")
เหตุใดจึงต้องมีส่วนทับซ้อน
ส่วนทับซ้อน (โดยทั่วไปคิดเป็น 10-20% ของขนาดส่วนย่อย) ช่วยให้ประโยคที่พาดผ่านขอบเขตยังปรากฏครบถ้วนในส่วนย่อยอย่างน้อยหนึ่งส่วน หากไม่มีส่วนทับซ้อน ข้อเท็จจริงสำคัญที่ถูกแบ่งข้ามส่วนย่อยอาจไม่สามารถดึงข้อมูลได้
การแบ่งตามประโยค
แบ่งตามขอบเขตประโยค โดยไม่ตัดกลางประโยค:
import re
def sentence_chunks(text, max_chars=1000):
sentences = re.split(r'(?<=[.!?])\s+', text)
chunks = []
current = ''
for s in sentences:
if len(current) + len(s) > max_chars and current:
chunks.append(current.strip())
current = s
else:
current += ' ' + s
if current:
chunks.append(current.strip())
return chunks
sample_text = "This is sentence one. This is sentence two! Is this sentence three? Yes it is."
chunks = sentence_chunks(sample_text, max_chars=40)
for i, c in enumerate(chunks):
print(f"Chunk {i+1}: {c!r}")
การแบ่งแบบวนซ้ำ (LangChain)
ตัวแบ่ง RecursiveCharacterTextSplitter ของ LangChain จะพยายามแบ่งตามขอบเขตย่อหน้าก่อน จากนั้นจึงแบ่งตามประโยคและคำ เพื่อรักษาโครงสร้างไว้ให้มากที่สุด
from langchain.text_splitter import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(
chunk_size=800,
chunk_overlap=100,
separators=['\n\n', '\n', '. ', ' ']
)
chunks = splitter.split_text(document)การแบ่งตามความหมาย
แบ่งตรงจุดที่หัวข้อเปลี่ยนแปลง วิธีการทำงานคือสร้างเวกเตอร์ฝังตัวของแต่ละประโยค แล้วแบ่งตรงจุดที่เวกเตอร์ฝังตัวของประโยคที่อยู่ติดกันมีความห่างกันมาก
คำนวณได้ช้ากว่า แต่สร้างส่วนย่อยที่สอดคล้องกับหัวข้อ
การแบ่งที่เข้าใจ Markdown
สำหรับเอกสาร Markdown ให้แบ่งตามขอบเขตหัวข้อเพื่อให้แต่ละส่วนอยู่รวมกัน ส่วนย่อยแต่ละส่วนจะสืบทอดหัวข้อหลักของตนมาเป็นบริบท
การแบ่งที่เข้าใจโค้ด
สำหรับซอร์สโค้ด ให้แบ่งตามขอบเขตฟังก์ชันหรือคลาส ไม่ใช่ตามจำนวนอักขระ เครื่องมืออย่าง tree-sitter ช่วยให้แบ่งส่วนย่อยโดยคำนึงถึง AST ได้
การเลือกขนาดส่วนย่อย
ข้อแลกเปลี่ยน:
- ส่วนย่อยขนาดเล็ก (ประมาณ 200 โทเค็น) — ตรงกับข้อมูลได้แม่นยำ มีส่วนย่อยให้จัดการมากขึ้น
- ส่วนย่อยขนาดใหญ่ (ประมาณ 1000 โทเค็น) — มีบริบทต่อการตรงกันมากขึ้น แต่แม่นยำน้อยลง
ค่าเริ่มต้น: 500-800 โทเค็น โดยมีส่วนทับซ้อน 10-20%
การรักษาข้อมูลเมตา
แนบข้อมูลเมตาให้กับส่วนย่อยทุกส่วน:
- URL แหล่งที่มา / เส้นทางไฟล์
- หมายเลขหน้า
- ชื่อเอกสาร
- ส่วน / หัวข้อ
- เวลาที่สร้าง / อัปเดต
มีประโยชน์สำหรับการกรอง การอ้างอิง และการจัดอันดับใหม่
ส่วนย่อยที่มีบริบท
เทคนิคล่าสุดคือเติมบริบทหนึ่งบรรทัดที่สร้างโดย LLM ไว้หน้าส่วนย่อยแต่ละส่วน (เช่น "ส่วนย่อยนี้มาจากรายงานการเงินไตรมาส 2 ปี 2024 ของบริษัท และกล่าวถึงรายได้") ช่วยปรับปรุงการดึงข้อมูลได้ 30-50%
ส่วนย่อยแม่และลูก
จัดทำดัชนีส่วนย่อยขนาดเล็กเพื่อให้จับคู่ได้แม่นยำ แต่ดึงย่อหน้าแม่ที่มีขนาด LARGER มาเป็นบริบท:
- สร้างเวกเตอร์ฝังตัวของส่วนย่อยระดับประโยค
- เมื่อจับคู่ได้ ให้ส่งคืนส่วนย่อยแม่ขนาด 800 โทเค็น
เหตุใดจึงต้องมีส่วนทับซ้อน
เหตุใดส่วนย่อยจึงมักทับซ้อนกัน 10-20%
สรุปทบทวน
เริ่มด้วยการแบ่งอักขระแบบวนซ้ำที่ประมาณ 800 โทเค็น โดยมีส่วนทับซ้อน 10% เมื่อความต้องการเพิ่มขึ้น จึงค่อยเพิ่มความเข้าใจเชิงความหมายหรือโครงสร้าง
เรียนรู้ AI Agents ด้วย AI tutor — ฟรี
เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป
- คอร์ส
- 60
- บทเรียน
- 239
คำถามที่พบบ่อย
บทเรียน “กลยุทธ์การแบ่งเป็นส่วน (คงที่ ประโยค เชิงความหมาย)” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “กลยุทธ์การแบ่งเป็นส่วน (คงที่ ประโยค เชิงความหมาย)” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Agents ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Agents มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “กลยุทธ์การแบ่งเป็นส่วน (คงที่ ประโยค เชิงความหมาย)”
เปรียบเทียบข้อแลกเปลี่ยนระหว่างการแบ่งขนาดคงที่ การแบ่งโดยคำนึงถึงประโยค และการแบ่งเชิงความหมาย เพื่อคุณภาพการค้นคืน คุณปฏิบัติ AI Agents ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Agents หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Agents บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน
บทเรียน “กลยุทธ์การแบ่งเป็นส่วน (คงที่ ประโยค เชิงความหมาย)” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน AI Agents นี้ได้ไหม
ได้ บทเรียน AI Agents ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- RAG แก้ปัญหาอะไร (จุดตัดความรู้ ภาพหลอน)
- กลยุทธ์การแบ่งเป็นส่วน (คงที่ ประโยค เชิงความหมาย)
- การสร้างดัชนีชุดเอกสาร
- การสร้าง RAG แบบง่ายด้วย FAISS หรือ Chroma