AI Engineering Academy · บทเรียน

การเลือกและทดสอบประสิทธิภาพแหล่งจัดเก็บเวกเตอร์

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

ภาพรวมระบบคลังเวกเตอร์

ระบบนิเวศของ ฐานข้อมูลเวกเตอร์ เติบโตอย่างรวดเร็วในช่วงไม่กี่ปีที่ผ่านมา ตัวเลือกมีตั้งแต่บริการคลาวด์ที่สร้างขึ้นมาโดยเฉพาะอย่าง Pinecone ส่วนขยายของ PostgreSQL อย่าง pgvector เซิร์ฟเวอร์โอเพนซอร์สอย่าง Chroma Qdrant และ Weaviate ไปจนถึงไลบรารีในหน่วยความจำอย่าง FAISS การเลือกเครื่องมือที่เหมาะสมมีความสำคัญ เพราะการเปลี่ยนเครื่องมือภายหลังมีค่าใช้จ่ายสูงเมื่อจัดทำดัชนีข้อมูลไปแล้ว

มิติสำคัญสำหรับการประเมิน

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

Pinecone: ความเรียบง่ายแบบมีการจัดการ

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

import pinecone

pc = pinecone.Pinecone(api_key='YOUR_API_KEY')
index = pc.Index('my-index')

# Query with metadata filter
results = index.query(
    vector=[0.1, 0.2, 0.3],
    top_k=10,
    filter={'category': {'$eq': 'finance'}},
    include_metadata=True
)

pgvector: เวกเตอร์ฝังตัวใน PostgreSQL

pgvector ขยายความสามารถของ PostgreSQL ด้วยชนิดข้อมูล vector และดัชนีเพื่อนบ้านที่ใกล้ที่สุดแบบประมาณค่า (ANN) โดยใช้อัลกอริทึม HNSW หรือ IVFFlat เหมาะอย่างยิ่งเมื่อคุณใช้งาน PostgreSQL อยู่แล้ว เพราะเวกเตอร์ฝังตัวจะอยู่ในฐานข้อมูลเดียวกับข้อมูลเชิงสัมพันธ์ ทำให้สามารถใช้ การรวม SQL ระหว่างการค้นหาเวกเตอร์กับตัวกรองแบบมีโครงสร้างได้อย่างมีประสิทธิภาพโดยไม่ต้องเพิ่มโครงสร้างพื้นฐาน

-- Create table with embedding column
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT,
    category TEXT,
    embedding vector(1536)
);

-- Create HNSW index for fast ANN search
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops);

-- Query nearest neighbors with SQL filter
SELECT content, 1 - (embedding <=> '[0.1,0.2,...]')
FROM documents
WHERE category = 'finance'
ORDER BY embedding <=> '[0.1,0.2,...]'
LIMIT 10;

Chroma: เป็นมิตรต่อนักพัฒนาและเริ่มต้นจากการใช้งานในเครื่อง

Chroma คือฐานข้อมูลเวกเตอร์ฝังตัวแบบโอเพนซอร์สที่ออกแบบมาสำหรับการสร้างต้นแบบอย่างรวดเร็ว ทำงานภายในกระบวนการสำหรับการพัฒนาในเครื่อง (ไม่ต้องใช้เซิร์ฟเวอร์) และรองรับโหมดเซิร์ฟเวอร์แบบคงอยู่สำหรับการใช้งานจริง Chroma ได้รับความนิยมในบทเรียน LangChain เนื่องจากมี API ที่เรียบง่ายอย่างยิ่ง แต่มีข้อจำกัดเมื่อข้อมูลมีขนาดใหญ่ ได้แก่ ไม่รองรับโหมดแบบกระจาย และการกรองมีประสิทธิภาพน้อยกว่า Pinecone หรือ Qdrant

import chromadb

client = chromadb.PersistentClient(path='./chroma_db')
collection = client.get_or_create_collection('my_docs')

# Add documents
collection.add(
    documents=['text one', 'text two'],
    metadatas=[{'source': 'doc1'}, {'source': 'doc2'}],
    ids=['id1', 'id2']
)

# Query
results = collection.query(
    query_texts=['search query'],
    n_results=5
)

Qdrant: การกรองและการค้นหาเพย์โหลด

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

from qdrant_client import QdrantClient
from qdrant_client.models import Filter, FieldCondition, MatchValue

client = QdrantClient(url='http://localhost:6333')

# Search with payload filter
results = client.search(
    collection_name='documents',
    query_vector=[0.1, 0.2, 0.3],
    query_filter=Filter(
        must=[
            FieldCondition(
                key='category',
                match=MatchValue(value='finance')
            )
        ]
    ),
    limit=10
)

Weaviate: GraphQL และข้อมูลหลายรูปแบบ

Weaviate คือฐานข้อมูลเวกเตอร์โอเพนซอร์สที่มี API ของ GraphQL อันเป็นเอกลักษณ์ และรองรับออบเจ็กต์หลายรูปแบบในตัว (ข้อความ รูปภาพ เสียง) สามารถผสานรวมกับผู้ให้บริการโมเดลเวกเตอร์ฝังตัวได้โดยตรงผ่านโมดูล คุณจึงนำเข้าข้อความดิบและให้ Weaviate เรียก API ของเวกเตอร์ฝังตัวโดยอัตโนมัติได้ ความสะดวกนี้แลกมาด้วยการตั้งค่าที่ซับซ้อนกว่า Chroma หรือ Qdrant

import weaviate

client = weaviate.Client('http://localhost:8080')

# Near-text search using built-in vectorizer
result = client.query.get(
    'Document', ['content', 'category']
).with_near_text(
    {'concepts': ['financial analysis']}
).with_where({
    'path': ['category'],
    'operator': 'Equal',
    'valueString': 'finance'
}).with_limit(10).do()

FAISS: การทำงานในหน่วยความจำเมื่อข้อมูลมีขนาดใหญ่

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

import faiss
import numpy as np

dimension = 1536
vectors = np.random.random((100000, dimension)).astype('float32')

# Normalize for cosine similarity
faiss.normalize_L2(vectors)

# Build HNSW index
index = faiss.IndexHNSWFlat(dimension, 32)  # M=32 neighbors
index.add(vectors)

# Search
query = np.random.random((1, dimension)).astype('float32')
faiss.normalize_L2(query)
D, I = index.search(query, k=10)  # top-10 results

การสร้างการทดสอบประสิทธิภาพ

วิธีเดียวที่จะเลือกได้อย่างมั่นใจคือ ทดสอบประสิทธิภาพด้วยข้อมูลของคุณเอง การทดสอบที่ดีควรวัด: (1) เวลาสร้างดัชนีสำหรับชุดข้อมูลทั้งหมด (2) เวลาแฝงของการสืบค้นที่เปอร์เซ็นไทล์ p50, p95 และ p99 ภายใต้ภาระงานพร้อมกัน (3) recall@K โดยเปรียบเทียบผลลัพธ์ ANN กับผลลัพธ์แบบตรงทั้งหมด และ (4) หน่วยความจำและค่าใช้จ่ายเมื่อใช้ข้อมูลตามขนาดเป้าหมาย ให้ใช้คำสืบค้นเดียวกันกับคลังตัวเลือกแต่ละรายการ

import time
import numpy as np

def benchmark_store(store, queries, k=10):
    latencies = []
    for q in queries:
        start = time.perf_counter()
        store.search(q, k)
        latencies.append(time.perf_counter() - start)
    latencies.sort()
    n = len(latencies)
    print(f'p50: {latencies[n//2]*1000:.1f}ms')
    print(f'p95: {latencies[int(n*0.95)]*1000:.1f}ms')
    print(f'p99: {latencies[int(n*0.99)]*1000:.1f}ms')

การวัดข้อแลกเปลี่ยนระหว่างการเรียกคืนกับเวลาแฝง

ดัชนี ANN แลก ความแม่นยำของการเรียกคืนกับความเร็ว พารามิเตอร์ ef_search ของ HNSW ที่สูงขึ้นจะค้นหาเพื่อนบ้านได้แม่นยำกว่า แต่ใช้เวลานานขึ้น ให้วัด recall@10 (สัดส่วนของเพื่อนบ้าน 10 อันดับแรกที่เป็นจริงซึ่งถูกส่งคืน) ด้วยการตั้งค่าพารามิเตอร์ต่าง ๆ แล้วพล็อตกราฟความสัมพันธ์ระหว่างการเรียกคืนกับเวลาแฝง ระบบที่ใช้งานจริงส่วนใหญ่มุ่งเป้าค่าการเรียกคืน 95-99% หากต่ำกว่า 90% หมายความว่าผู้ใช้จะได้รับส่วนข้อความที่ไม่เกี่ยวข้อง แม้การสืบค้นจะรวดเร็วก็ตาม

def compute_recall(approx_ids, exact_ids):
    '''Compute recall@K for one query'''
    return len(set(approx_ids) & set(exact_ids)) / len(exact_ids)

def benchmark_recall(index, brute_force, queries, k=10):
    recalls = []
    for q in queries:
        approx = index.search(q, k)
        exact = brute_force.search(q, k)
        recalls.append(compute_recall(approx, exact))
    print(f'Mean recall@{k}: {sum(recalls)/len(recalls):.3f}')

กรอบการตัดสินใจสำหรับการเลือก

ใช้แผนผังการตัดสินใจนี้: หากต้องการ ไม่ต้องจัดการโครงสร้างพื้นฐานเลย และงบประมาณไม่ใช่ข้อจำกัด ให้เลือก Pinecone หากใช้งาน PostgreSQL อยู่แล้วและชุดข้อมูลมีเวกเตอร์ไม่ถึง 10 ล้านรายการ ให้เพิ่ม pgvector หากต้องการโซลูชันโอเพนซอร์สที่ดูแลเองและมีการกรองเพย์โหลดที่ซับซ้อน ให้เลือก Qdrant สำหรับการสร้างต้นแบบอย่างรวดเร็วและการพัฒนาในเครื่อง ให้เริ่มด้วย Chroma แล้วค่อยย้ายภายหลัง สำหรับงานเป็นชุดแบบออฟไลน์ระดับพันล้านรายการ ให้ใช้ FAISS

ตรวจสอบความเข้าใจ

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

ทบทวนบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้เกี่ยวกับ ภาพรวมของคลังเวกเตอร์ ซึ่งประกอบด้วย Pinecone, pgvector, Chroma, Qdrant, Weaviate และ FAISS ห้ามิติสำหรับการประเมิน ได้แก่ เวลาแฝง อัตราการประมวลผล การกรอง ความซับซ้อน และค่าใช้จ่าย รวมถึง กรอบการตัดสินใจเชิงปฏิบัติ สำหรับเลือกคลังที่เหมาะสมตามโครงสร้างพื้นฐานและข้อกำหนดด้านขนาดของคุณ บทถัดไปเราจะสำรวจปัญหาที่ RAG ถูกสร้างขึ้นมาเพื่อแก้ไข

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

บทเรียน “การเลือกและทดสอบประสิทธิภาพแหล่งจัดเก็บเวกเตอร์” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “การเลือกและทดสอบประสิทธิภาพแหล่งจัดเก็บเวกเตอร์”

เปรียบเทียบ Pinecone, pgvector, Chroma, Weaviate และ Qdrant ในด้านค่าใช้จ่าย เวลาแฝง ความสามารถในการกรอง และความซับซ้อนด้านการปฏิบัติงาน เพื่อเลือกเครื่องมือที่เหมาะกับกรณีใช้งาน คุณปฏิบัติ AI Engineering Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

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

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

บทเรียน “การเลือกและทดสอบประสิทธิภาพแหล่งจัดเก็บเวกเตอร์” ใช้เวลานานแค่ไหน

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

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

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

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

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

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