AI Engineering Academy · บทเรียน

เหตุใดคุณจึงต้องมีฐานข้อมูลเวกเตอร์

เหตุใดคุณจึงต้องมีฐานข้อมูลเวกเตอร์ เป็นบทเรียน AI Engineering Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Engineering Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

ข้อจำกัดของการค้นหาในหน่วยความจำ

การค้นหาเชิงความหมายด้วย NumPy ทำงานได้ดีสำหรับคลังข้อมูลขนาดเล็ก แต่มีปัญหาด้านการขยายขนาดโดยพื้นฐานคือ การค้นหาแต่ละครั้งต้องสแกนเวกเตอร์ทุกตัว เมื่อมีเอกสาร 1 ล้านรายการ การค้นหาแต่ละครั้งต้องคูณเลขทศนิยม 1.5 พันล้านครั้ง และใช้เวลาหลายร้อยมิลลิวินาที ที่แย่กว่านั้นคือเวกเตอร์ทั้งหมดต้องพอดีกับ RAM

ระบบ AI สำหรับใช้งานจริงต้องค้นหาเอกสารนับล้านรายการให้เสร็จภายใน 50 มิลลิวินาที ฐานข้อมูลเวกเตอร์ได้รับการออกแบบมาเพื่อให้ทำเช่นนี้ได้

การค้นหาเพื่อนบ้านใกล้เคียงโดยประมาณ

อัลกอริทึม Approximate Nearest Neighbor (ANN) ยอมแลกความแม่นยำเล็กน้อยกับการเพิ่มความเร็วอย่างมาก แทนที่จะตรวจสอบเวกเตอร์ทุกตัว อัลกอริทึม ANN จะใช้โครงสร้างดัชนีอัจฉริยะเพื่อข้ามส่วนขนาดใหญ่ของพื้นที่ค้นหา

ในทางปฏิบัติ ANN คืนค่าเพื่อนบ้านที่ใกล้เคียงที่สุดจริงมากกว่า 95% ของเวลา และเร็วกว่าการค้นหาแบบแม่นยำ 100–1000 เท่า สำหรับ RAG การแลกเปลี่ยนนี้แทบจะคุ้มค่าเสมอ

HNSW ทำงานอย่างไร

HNSW (Hierarchical Navigable Small World) เป็นอัลกอริทึม ANN หลักที่ใช้โดย Pinecone, Weaviate, Qdrant และ pgvector โดยจะสร้างกราฟหลายชั้นที่แต่ละโหนดเชื่อมต่อกับเพื่อนบ้านที่ใกล้ที่สุด การค้นหาเริ่มจากชั้นบนสุดที่มีโหนดเบาบาง นำทางไปยังบริเวณโดยประมาณ จากนั้นจึงลงมายังชั้นล่างสุดที่หนาแน่นเพื่อเพิ่มความแม่นยำ

HNSW มีความเร็วในการค้นหาที่ยอดเยี่ยม (เพิ่มขึ้นตามลอการิทึมของขนาดชุดข้อมูล) และมีอัตราการค้นพบผลลัพธ์สูง แต่จำเป็นต้องสร้างดัชนีไว้ล่วงหน้า

สิ่งที่ฐานข้อมูลเวกเตอร์เพิ่มเข้ามา

ฐานข้อมูลเวกเตอร์มีความสามารถมากกว่าดัชนี ANN โดยยังมี:

การกรองข้อมูลเมทาดาทา — ดึงเฉพาะเวกเตอร์ที่ category='finance' หรือ date > '2024-01-01'
การจัดเก็บแบบถาวร — ข้อมูลยังคงอยู่หลังการเริ่มระบบใหม่และขยายได้เกินขนาด RAM
การดำเนินการ CRUD — แทรก อัปเดต และลบเวกเตอร์แต่ละตัว
การแยกเนมสเปซ — แยกคอลเลกชันสำหรับลูกค้าหรือสภาพแวดล้อมที่แตกต่างกัน
การขยายตามแนวนอน — กระจายเวกเตอร์นับล้านรายการไปยังชาร์ดต่าง ๆ

การกรองข้อมูลเมทาดาทาในทางปฏิบัติ

การกรองข้อมูลเมทาดาทาช่วยจำกัดการดึงข้อมูลให้เหลือเฉพาะส่วนย่อยที่เกี่ยวข้องก่อนเรียกใช้การค้นหา ANN ตัวอย่างเช่น ในระบบ RAG แบบหลายผู้เช่า คุณจะกรองด้วย tenant_id เพื่อให้ผู้ใช้เห็นเฉพาะเอกสารของตนเอง หากไม่มีการกรองข้อมูลเมทาดาทา คุณจะต้องสร้างดัชนีแยกสำหรับผู้เช่าแต่ละราย

นี่เป็นหนึ่งในความสามารถสำคัญที่ทำให้ฐานข้อมูลเวกเตอร์แตกต่างจากไลบรารี ANN อย่างง่าย เช่น FAISS

# Conceptual example — Pinecone query with metadata filter
results = index.query(
    vector=query_embedding,
    top_k=5,
    filter={
        'tenant_id': {'$eq': 'acme_corp'},
        'document_type': {'$in': ['invoice', 'contract']},
        'date': {'$gte': '2024-01-01'}
    },
    include_metadata=True
)

FAISS: ไลบรารี ANN ประสิทธิภาพสูง

FAISS (Facebook AI Similarity Search) เป็นไลบรารี ANN แบบโอเพนซอร์สจาก Meta และเป็นตัวเลือกที่เร็วที่สุดสำหรับการค้นหาที่เร่งความเร็วด้วย GPU แต่ไม่ใช่ฐานข้อมูลแบบเต็มรูปแบบ เพราะไม่มีการจัดเก็บแบบถาวร ไม่มีเมทาดาทา และไม่มีระบบให้บริการในตัว

FAISS เหมาะอย่างยิ่งเมื่อคุณต้องการปริมาณงานสูงสุดบนเครื่องเดียวและจัดการการจัดเก็บแบบถาวรด้วยตนเอง Chroma, Weaviate และ pgvector ล้วนใช้ FAISS หรือ HNSW อยู่เบื้องหลัง

import faiss
import numpy as np

d = 1536  # dimension
n = 10000  # number of vectors

# Build a flat (exact) index as a baseline
index = faiss.IndexFlatIP(d)  # Inner Product = dot product

# Add random vectors (pretend these are embeddings)
vectors = np.random.randn(n, d).astype('float32')
faiss.normalize_L2(vectors)  # normalize for cosine sim
index.add(vectors)

query = np.random.randn(1, d).astype('float32')
faiss.normalize_L2(query)

scores, indices = index.search(query, k=5)
print('Top 5 indices:', indices[0])
print('Top 5 scores:', scores[0])

ฐานข้อมูลเวกเตอร์กับฐานข้อมูลแบบดั้งเดิม

ฐานข้อมูล SQL แบบดั้งเดิม เช่น PostgreSQL ได้รับการปรับให้เหมาะกับการค้นหาค่าที่ตรงกันทุกประการและการค้นหาแบบช่วงบนข้อมูลที่มีโครงสร้าง แต่ ไม่ได้ออกแบบมาสำหรับการค้นหาเพื่อนบ้านใกล้เคียงในมิติสูง แม้จะใช้ส่วนขยาย pgvector แต่ PostgreSQL ล้วน ๆ ก็ยังช้ากว่าฐานข้อมูลเวกเตอร์ที่สร้างขึ้นโดยเฉพาะเมื่อใช้กับคลังข้อมูลขนาดใหญ่

อย่างไรก็ตาม pgvector เป็นตัวเลือกที่ยอดเยี่ยมเมื่อแอปพลิเคชันของคุณทำงานบน PostgreSQL อยู่แล้วและคลังข้อมูลมีเอกสารไม่ถึงสองสามล้านรายการ เพราะไม่ต้องเพิ่มส่วนประกอบโครงสร้างพื้นฐานอีกตัว

ตัวเลือกแบบมีผู้ดูแลกับโฮสต์ด้วยตนเอง

ตัวเลือกฐานข้อมูลเวกเตอร์แบ่งออกเป็นสองประเภท:

มีผู้ดูแล (serverless): Pinecone, Weaviate Cloud — ไม่ต้องจัดการโครงสร้างพื้นฐาน จ่ายตามการค้นหา/พื้นที่จัดเก็บ และขยายขนาดได้ทันที
โฮสต์ด้วยตนเอง: Qdrant, Chroma, Weaviate แบบโอเพนซอร์ส, pgvector — ควบคุมได้เต็มที่ ต้นทุนต่ำกว่าเมื่อใช้งานในขนาดใหญ่ แต่คุณต้องจัดการการสำรองข้อมูล การอัปเกรด และการขยายขนาดเอง

สำหรับโครงการระยะเริ่มต้น ให้เริ่มด้วยบริการที่มีผู้ดูแลเพื่อพัฒนาได้อย่างรวดเร็ว และพิจารณาการโฮสต์ด้วยตนเองเมื่อค่าใช้จ่ายรายเดือนเกิน 200–300 ดอลลาร์สหรัฐ

ประเภทของดัชนี: Flat, IVF และ HNSW

ดัชนีแต่ละประเภทมีข้อแลกเปลี่ยนแตกต่างกัน:

Flat: การค้นหาแบบแม่นยำ ไม่มีการประมาณ ช้าเมื่อขยายขนาด แต่ไม่มีการสูญเสียความแม่นยำ เหมาะสำหรับการวัดประสิทธิภาพพื้นฐาน
IVF (Inverted File): แบ่งเวกเตอร์ออกเป็นคลัสเตอร์และค้นหาเฉพาะคลัสเตอร์ที่ใกล้ที่สุด รวดเร็วแต่ต้องปรับค่า nlist และ nprobe
HNSW: ใช้กราฟและให้สมดุลระหว่างอัตราการค้นพบผลลัพธ์กับความเร็วดีที่สุดสำหรับปริมาณงานส่วนใหญ่ เป็นค่าเริ่มต้นในฐานข้อมูลสำหรับใช้งานจริงส่วนใหญ่

การควอนไทซ์เพื่อลดการใช้หน่วยความจำ

การควอนไทซ์เวกเตอร์ บีบอัดเลขทศนิยม 32 บิตแต่ละตัวในเวกเตอร์ให้เหลือจำนวนบิตน้อยลง ช่วยลดการใช้หน่วยความจำได้อย่างมาก โดยแลกกับการสูญเสียความแม่นยำเล็กน้อย:

FP32: 1536 มิติ × 4 ไบต์ = 6KB ต่อเวกเตอร์
FP16: 3KB ต่อเวกเตอร์ — บีบอัด 2 เท่า ความแม่นยำสูญเสียเพียงเล็กน้อยจนแทบไม่มีผล
INT8: 1.5KB ต่อเวกเตอร์ — บีบอัด 4 เท่า อัตราการค้นพบผลลัพธ์ลดลงประมาณ 1%

เมื่อมีเวกเตอร์ 10 ล้านตัว การควอนไทซ์แบบ INT8 จะลดการใช้หน่วยความจำจาก 60GB เหลือ 15GB ซึ่งเป็นความแตกต่างระหว่างการจัดเก็บให้พอดีกับ RAM กับการจัดเก็บไม่พอดี

เมื่อใดควรเปลี่ยนจาก NumPy เป็นฐานข้อมูลเวกเตอร์

พิจารณาเปลี่ยนจากการค้นหา NumPy ในหน่วยความจำไปใช้ฐานข้อมูลเวกเตอร์เมื่อ:

คลังข้อมูลของคุณมีเอกสารเกิน 50,000 รายการ และเวลาแฝงของการค้นหาเพิ่มขึ้น
คุณต้องการ การกรองข้อมูลเมทาดาทา (ตามวันที่ ผู้ใช้ หมวดหมู่ และอื่น ๆ)
คุณต้องการ การจัดเก็บแบบถาวร ที่ยังคงอยู่หลังแอปพลิเคชันเริ่มระบบใหม่
บริการหรือผู้ใช้หลายรายต้อง ใช้ดัชนีเดียวกันร่วมกัน
คุณต้องการ อัปเดตหรือลบเอกสารแต่ละรายการ โดยไม่ต้องสร้างดัชนีทุกอย่างใหม่

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจแนวคิดวิศวกรรม AI จากบทเรียนนี้

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า การค้นหา NumPy แบบไล่ตรวจทุกตัวไม่สามารถขยายเกินเอกสารหลักหมื่นรายการได้ HNSW ช่วยให้ค้นหาเพื่อนบ้านใกล้เคียงโดยประมาณได้อย่างรวดเร็วด้วยการนำทางผ่านกราฟแบบลำดับชั้น และ ฐานข้อมูลเวกเตอร์เพิ่มการกรองข้อมูลเมทาดาทา การจัดเก็บแบบถาวร และการดำเนินการ CRUD ให้กับดัชนี ANN ต่อไป เราจะตั้งค่า Pinecone ซึ่งเป็นฐานข้อมูลเวกเตอร์แบบมีผู้ดูแลที่ได้รับความนิยมมากที่สุด และจัดทำดัชนีเอกสารชุดแรกของเรา

คำถามที่พบบ่อย

บทเรียน “เหตุใดคุณจึงต้องมีฐานข้อมูลเวกเตอร์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เหตุใดคุณจึงต้องมีฐานข้อมูลเวกเตอร์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Engineering Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เหตุใดคุณจึงต้องมีฐานข้อมูลเวกเตอร์”

ทำความเข้าใจข้อจำกัดของการค้นหาความคล้ายคลึงแบบไล่ตรวจทุกกรณี วิธีทำงานของอัลกอริทึมค้นหาเพื่อนบ้านใกล้เคียงโดยประมาณ เช่น HNSW และปัญหาที่ฐานข้อมูลเวกเตอร์ช่วยแก้ในการใช้งานจริง คุณปฏิบัติ AI Engineering Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Engineering Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Engineering Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “เหตุใดคุณจึงต้องมีฐานข้อมูลเวกเตอร์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Engineering Academy นี้ได้ไหม

ได้ บทเรียน AI Engineering Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

เหตุใดคุณจึงต้องมีฐานข้อมูลเวกเตอร์
เริ่มต้นใช้งาน Pinecone
pgvector: เวกเตอร์ฝังตัวใน PostgreSQL
การเลือกและทดสอบประสิทธิภาพแหล่งจัดเก็บเวกเตอร์

← กลับไปที่ AI Engineering Academy