การโหลด แบ่ง และสร้างเวกเตอร์ฝังสำหรับเอกสาร
PyPDFLoader, RecursiveCharacterTextSplitter, OpenAIEmbeddings และกลยุทธ์การสร้างเวกเตอร์ฝัง
การโหลด แบ่ง และสร้างเวกเตอร์ฝังสำหรับเอกสาร เป็นบทเรียน Learn AI with Python ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Learn AI with Python และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน
กระบวนการนำเข้าข้อมูลของ RAG
ก่อนที่ LLM จะตอบคำถามจากเอกสารของคุณได้ คุณต้อง load แบ่ง และ ฝังเวกเตอร์ เอกสารเหล่านั้น บทเรียนนี้ครอบคลุมกระบวนการนำเข้าข้อมูล ซึ่งเป็นรากฐานของระบบ Retrieval-Augmented Generation ทุกระบบ
pip install langchain-community pypdf langchain-openaiการโหลด PDF
PyPDFLoader จะอ่าน PDF และส่งคืนรายการออบเจ็กต์ เอกสาร โดยมีหนึ่งรายการต่อหนึ่งหน้า เอกสารแต่ละรายการมี page_content (ข้อความ) และ metadata (แหล่งที่มาและหมายเลขหน้า)
from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader("handbook.pdf")
docs = loader.load()
print(len(docs), "pages")เหตุใดจึงต้องแบ่งเอกสาร
หน้าเอกสารทั้งหน้ามักมีขนาดใหญ่เกินกว่าจะฝังเวกเตอร์หรือใส่ลงในพรอมป์ได้ การ แบ่ง จะแยกข้อความออกเป็นส่วนย่อยที่ฝังเวกเตอร์ได้อย่างเหมาะสม และทำให้การดึงข้อมูลส่งคืนเฉพาะข้อความที่เกี่ยวข้อง แทนที่จะส่งคืนทั้งหน้า
RecursiveCharacterTextSplitter
ตัวแบ่งที่แนะนำคือ RecursiveCharacterTextSplitter โดยจะพยายามแบ่งที่ย่อหน้าก่อน จากนั้นจึงแบ่งที่ประโยค แล้วจึงแบ่งที่คำ เพื่อรักษาความสอดคล้องทางความหมายของส่วนย่อยแทนการตัดกลางคำ
from langchain_text_splitters import RecursiveCharacterTextSplitter
splitter = RecursiveCharacterTextSplitter(
chunk_size=1000,
chunk_overlap=200
)ขนาดส่วนย่อยและส่วนที่ซ้อนทับ
chunk_size กำหนดจำนวนอักขระสูงสุดต่อส่วนย่อย ส่วน chunk_overlap จะทำซ้ำข้อความบางส่วนระหว่างส่วนย่อยที่อยู่ติดกัน เพื่อไม่ให้บริบทสูญหายตรงรอยต่อ การแบ่งแบบ 1000/200 เป็นจุดเริ่มต้นที่ใช้กันทั่วไป
chunks = splitter.split_documents(docs)
print(len(chunks), "chunks")
print(chunks[0].page_content[:120])การปรับขนาดส่วนย่อย
ส่วนย่อยขนาดเล็กช่วยให้ดึงข้อมูลได้แม่นยำ แต่บริบทโดยรอบอาจไม่เพียงพอ ส่วนย่อยขนาดใหญ่เก็บบริบทได้มากกว่า แต่ลดทอนความเกี่ยวข้องและใช้โทเค็นมากขึ้น โดยทั่วไปควรให้ส่วนที่ซ้อนทับมีขนาด 10–20% ของขนาดส่วนย่อย เพื่อเชื่อมบริเวณรอยต่อ
เวกเตอร์ฝังตัวคืออะไร
การฝังเวกเตอร์จะแปลงข้อความเป็นเวกเตอร์ตัวเลขที่มีความยาวคงที่และเก็บความหมายของข้อความไว้ ข้อความที่มีความหมายคล้ายกันจะได้เวกเตอร์ที่อยู่ใกล้กัน วิธีนี้ทำให้เราค้นหาด้วยความคล้ายคลึงเชิงความหมายแทนการค้นหาด้วยคำสำคัญได้
OpenAIEmbeddings
สร้างเวกเตอร์ฝังตัวด้วย OpenAIEmbeddings โมเดล text-embedding-3-small มีราคาถูกและใช้งานได้มีประสิทธิภาพ embed_query ใช้ฝังเวกเตอร์สตริงหนึ่งรายการ ส่วน embed_documents ใช้ฝังเวกเตอร์รายการ
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vector = embeddings.embed_query("How do I reset my password?")
print(len(vector)) # 1536การฝังเวกเตอร์เป็นชุด
ฝังเวกเตอร์ให้กับส่วนย่อยทั้งหมดในครั้งเดียว แต่ละส่วนย่อยจะกลายเป็นเวกเตอร์ที่คุณจะจัดเก็บในฐานข้อมูลเวกเตอร์ภายหลัง เพื่อใช้ค้นหาความคล้ายคลึงได้อย่างรวดเร็ว
texts = [c.page_content for c in chunks]
vectors = embeddings.embed_documents(texts)
print(len(vectors), "vectors of dim", len(vectors[0]))การประมาณค่าใช้จ่ายในการฝังเวกเตอร์
การฝังเวกเตอร์คิดค่าบริการตามจำนวนโทเค็น ให้ประมาณจำนวนโทเค็นทั้งหมดของส่วนย่อยทุกส่วน แล้วคูณด้วยราคาต่อ 1,000 โทเค็น การนับจำนวนก่อนฝังเวกเตอร์ช่วยป้องกันค่าใช้จ่ายที่สูงเกินคาดเมื่อประมวลผลคลังข้อมูลขนาดใหญ่
import tiktoken
enc = tiktoken.get_encoding("cl100k_base")
total = sum(len(enc.encode(c.page_content)) for c in chunks)
price_per_1k = 0.00002
print("tokens:", total, "cost $:", total / 1000 * price_per_1k)สรุปกระบวนการ
กระบวนการนำเข้าข้อมูลมีดังนี้: load เอกสาร แบ่ง เป็นส่วนย่อยที่ซ้อนทับกัน ฝังเวกเตอร์ ให้แต่ละส่วนย่อย และ (ในบทเรียนถัดไป) จัดเก็บส่วนย่อยเหล่านั้น การแบ่งส่วนย่อยที่ดีและการตระหนักถึงค่าใช้จ่ายในขั้นตอนนี้เป็นตัวกำหนดคุณภาพและราคาของระบบ RAG ทั้งหมด
ตรวจสอบความเข้าใจ
ทดสอบความรู้เกี่ยวกับการนำเข้าข้อมูลของคุณ
ทบทวน: การโหลด การแบ่ง และการฝังเวกเตอร์
คุณใช้ PyPDFLoader เพื่อโหลดเอกสาร ใช้ RecursiveCharacterTextSplitter ร่วมกับ chunk_size และ chunk_overlap เพื่อแบ่งเอกสารเป็นส่วนย่อย และใช้ OpenAIEmbeddings เพื่อแปลงส่วนย่อยให้เป็นเวกเตอร์ นอกจากนี้คุณยังได้เรียนรู้การประมาณค่าใช้จ่ายในการฝังเวกเตอร์ต่อโทเค็นก่อนประมวลผลคลังข้อมูลขนาดใหญ่
คำถามที่พบบ่อย
บทเรียน “การโหลด แบ่ง และสร้างเวกเตอร์ฝังสำหรับเอกสาร” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “การโหลด แบ่ง และสร้างเวกเตอร์ฝังสำหรับเอกสาร” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Learn AI with Python ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Learn AI with Python มีบทเรียนทั้งหมด 4 บทเรียน
คุณจะเรียนรู้อะไรในบทเรียน “การโหลด แบ่ง และสร้างเวกเตอร์ฝังสำหรับเอกสาร”
PyPDFLoader, RecursiveCharacterTextSplitter, OpenAIEmbeddings และกลยุทธ์การสร้างเวกเตอร์ฝัง คุณปฏิบัติ Learn AI with Python ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน
คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Learn AI with Python หรือไม่
ไม่จำเป็นต้องมีประสบการณ์มาก่อน Learn AI with Python บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน
บทเรียน “การโหลด แบ่ง และสร้างเวกเตอร์ฝังสำหรับเอกสาร” ใช้เวลานานแค่ไหน
บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย
ฉันเขียนและรันโค้ดในบทเรียน Learn AI with Python นี้ได้ไหม
ได้ บทเรียน Learn AI with Python ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- สถาปัตยกรรม LangChain และ LCEL
- การโหลด แบ่ง และสร้างเวกเตอร์ฝังสำหรับเอกสาร
- คลังเวกเตอร์: Chroma และ FAISS
- การสร้างระบบถาม–ตอบ RAG ตั้งแต่ต้นจนจบ