วิธีทำ Semantic Search ใน MongoDB

นี่คือช่วงเวลาที่ การค้นหาข้อความแบบปกติทำได้ไม่ดีพอ ตัวอย่างต่อไปนี้คือสิ่งที่เกิดขึ้นจริง:

• พอร์ทัลซัพพอร์ตลูกค้าไม่แสดงผลลัพธ์เมื่อผู้ใช้พิมพ์ว่า "เปิดไม่ติด" แทนวลีที่ตรงกับบทความวิธีใช้แบบคำต่อคำ
• แพลตฟอร์มอีคอมเมิร์ซไม่พบสินค้าเมื่อผู้ซื้อค้นหา "ของกันหนาว" เพราะไม่มีคำอธิบายสินค้าชิ้นใดที่มีคำเหล่านั้นตรงตัว
• ฐานความรู้พลาดเอกสารถูกต้องเพราะผู้ใช้ตั้งคำถามต่างจากวิธีเขียนในเอกสาร

Semantic search แก้ปัญหานี้ได้ เพราะเข้าใจความหมายและเจตนาของคำค้นหา แทนการจับคู่คำที่เหมือนกันแบบเป๊ะๆ

บทเรียนนี้จะแสดงวิธีทำ semantic search ใน MongoDB ด้วย Python และโมเดลอิมเบดดิ้งฟรี nomic-embed-text-v1.

หมายเหตุ: nomic-embed-text-v1 มีขนาดประมาณ 0.27 GB เมื่อถูกโหลดเข้าเมมโมรี ดังนั้นควรมี RAM ว่างอย่างน้อย 1 GB ก่อนรันสคริปต์ใดๆ ในบทเรียนนี้ ครั้งแรกจะดาวน์โหลดโมเดลจาก Hugging Face จึงอาจใช้เวลามากขึ้นตามความเร็วอินเทอร์เน็ต ครั้งถัดไปจะโหลดจากแคชในเครื่อง การประมวลผลด้วย CPU จะช้ากว่า GPU มาก บนเครื่องที่ไม่มี GPU เฉพาะ โมเดลจะรันบน CPU และใช้ RAM แทน VRAM ดังนั้นการสร้างอิมเบดดิ้งอาจใช้เวลานานกว่า

ในบทเรียนนี้จะได้เรียนรู้:

• เวกเตอร์อิมเบดดิ้งคืออะไร และแทนความหมายได้อย่างไร
• วิธีสร้างและจัดเก็บอิมเบดดิ้งใน MongoDB
• วิธีสร้างดัชนี MongoDB Vector Search
• วิธีแปลงคำค้นหาของผู้ใช้เป็นเวกเตอร์
• วิธีรันไปป์ไลน์การรวมข้อมูล $vectorSearch และตีความผลลัพธ์

สามารถดูโค้ดตัวอย่างทั้งหมดของบทเรียนนี้ได้ที่ ที่เก็บ GitHub.

Text Search เทียบกับ Semantic Search

Text search จะจับคูเอกสารที่มีคำเหมือนกับคำค้นหาของคุณแบบตรงตัว ส่วน Semantic search จะจับคูเอกสารที่มีความหมายเดียวกับคำค้นหาของคุณ แม้จะใช้คำที่ต่างกันโดยสิ้นเชิงก็ตาม

ตารางต่อไปนี้แสดงสิ่งที่แต่ละแนวทางส่งคืนสำหรับคำค้นหา "heart problems":

แนวคิดของ Semantic Search

มีสามแนวคิดหลักสำหรับ semantic search ใน MongoDB ซึ่งจะช่วยให้เข้าใจว่าทำไมแต่ละขั้นตอนในบทเรียนนี้จึงทำงานแบบนั้น

เวกเตอร์อิมเบดดิ้ง

โมเดลอิมเบดดิ้งจะแปลงข้อความเป็นรายการตัวเลขความยาวคงที่ที่เรียกว่าเวกเตอร์ โดยแต่ละค่าจะแทนมิติของความหมาย

ข้อความสองชิ้นที่มีความหมายคล้ายกันจะได้เวกเตอร์ที่มีค่าใกล้กันในเชิงตัวเลข "cardiac conditions" และ "heart problems" จะอยู่ใกล้กันในเวกเตอร์สเปซ แม้จะไม่มีคำร่วมกันเลย ความใกล้เคียงนั้นเองที่ทำให้ semantic search เป็นไปได้

บทเรียนนี้ใช้โมเดลอิมเบดดิ้ง nomic-embed-text-v1 ซึ่งเป็นโอเพ่นซอร์ส ฟรี และรันบนเครื่องของคุณทั้งหมด โมเดลจะถูกดาวน์โหลดอัตโนมัติจาก Hugging Face เมื่อรันสคริปต์ครั้งแรก และบันทึกไว้ในเครื่องสำหรับครั้งถัดไป โมเดลนี้ให้ค่า 768 ตัวต่ออินพุตหนึ่งรายการ

ดัชนีการค้นหาเวกเตอร์

ดัชนีการค้นหาเวกเตอร์บอก MongoDB ว่าเขตข้อมูลใดเก็บอิมเบดดิ้งไว้ จำนวนมิติควรเป็นเท่าไร และจะใช้ฟังก์ชันวัดความคล้ายแบบใดในการเปรียบเทียบ ต้องสร้างดัชนีนี้ก่อนจึงจะรันคำสั่ง $vectorSearch ได้

สเตจการรวมข้อมูล $vectorSearch

$vectorSearch คือสเตจของการรวมข้อมูลที่ใช้รันการค้นหา รับเวกเตอร์คำค้น ค้นหาในฟิลด์ที่ทำดัชนีไว้ และส่งคืนเอกสารโดยจัดอันดับตามความคล้ายเชิงความหมาย สามารถเชนร่วมกับ $project และสเตจอื่นๆ ได้เหมือนกับไปป์ไลน์การรวมข้อมูลทั่วไป

มาเริ่มกันเลย

สิ่งที่ต้องเตรียม

ก่อนเริ่ม โปรดตรวจสอบให้พร้อมตามนี้:

• ติดตั้ง Python 3.8 ขึ้นไปแล้ว
• มี บัญชี MongoDB Atlas พร้อมคลัสเตอร์ M0 (ชั้นฟรี) ตั้งค่าเรียบร้อย
• pymongo เวอร์ชัน 4.7 ขึ้นไป, แพ็กเกจ Python sentence-transformers และ einops ติดตั้งแล้ว
• คุ้นเคยพื้นฐานกับ Python และคอลเลกชันของ MongoDB
• สตริงการเชื่อมต่อ Atlas ซึ่งดูได้ใน Atlas UI ที่เมนู Database > Connect > Drivers
• อนุญาตที่อยู่ IP ของคุณใน Atlas ก่อนรันสคริปต์ ไปที่ Security > Network Access ใน Atlas UI แล้วเพิ่ม IP ปัจจุบันของคุณ

ตั้งค่าโปรเจ็กต์

สร้างโฟลเดอร์สำหรับโปรเจ็กต์และเข้าไปยังโฟลเดอร์นั้นในเทอร์มินัล:

mkdir mongodb-semantic-search
cd mongodb-semantic-search

สร้างและเปิดใช้งาน virtual environment เพื่อแยกการพึ่งพาแพ็กเกจของโปรเจ็กต์นี้:

python -m venv venv
source venv/bin/activate

บน Windows ให้เปิดใช้งาน virtual environment ด้วย:

venv\Scripts\activate

จากนั้นติดตั้งแพ็กเกจที่ต้องใช้:

pip install pymongo sentence-transformers einops

คุณจะสร้างไฟล์ Python หนึ่งไฟล์สำหรับแต่ละขั้นตอนของบทเรียนนี้ โดยเก็บทั้งหมดไว้ในโฟลเดอร์ mongodb-semantic-search

สร้างไฟล์ยูทิลิตีสำหรับอิมเบดดิ้ง

สร้างไฟล์ชื่อ embedding_utils.py ไฟล์นี้จะเก็บฟังก์ชันอิมเบดดิ้งทั้งสองที่ใช้ในบทเรียนนี้:

from sentence_transformers import SentenceTransformer

# Load the free, open-source embedding model.
# The model downloads from Hugging Face on first run and saves locally.
# trust_remote_code=True is required by this model:
model = SentenceTransformer("nomic-ai/nomic-embed-text-v1", trust_remote_code=True)


def get_embedding(text, precision="float32"):
    # Use this function when embedding text you plan to store in MongoDB:
    return model.encode(text, precision=precision).tolist()


def get_query_embedding(text, precision="float32"):
    # Use this function when embedding a user's search query:
    return model.encode(text, precision=precision).tolist()

คำเตือน: trust_remote_code=True อนุญาตให้โมเดลรันโค้ด Python เฉพาะของโมเดลที่ดาวน์โหลดจาก Hugging Face บนเครื่องของคุณ หากซอร์สโค้ดของโมเดลบน Hugging Face ถูกเจาะหรือถูกอัปเดตด้วยโค้ดอันตราย โค้ดนั้นจะถูกรันอัตโนมัติในสภาพแวดล้อมของคุณ ควรใช้ความระมัดระวังก่อนใช้พารามิเตอร์นี้ในการใช้งานจริงในระบบโปรดักชัน

สร้างและจัดเก็บเวกเตอร์อิมเบดดิ้ง

สร้างไฟล์ชื่อ generate_embeddings.py ไฟล์นี้จะอิมพอร์ตฟังก์ชันอิมเบดดิ้งจาก embedding_utils.py สร้างเวกเตอร์สำหรับฟิลด์ข้อความของเอกสารแต่ละรายการ และจัดเก็บเอกสารเต็ม รวมถึงอิมเบดดิ้ง ไว้ใน MongoDB:

from embedding_utils import get_embedding
from pymongo import MongoClient

# Replace the placeholder with your Atlas connection string:
mongodb_client = MongoClient(
    "mongodb+srv://<USERNAME>:<PASSWORD>@<HOST>/",
    appname="devrel-tutorial-python-semantic-search"
)

collection = mongodb_client["sample_db"]["documents"]

# Sample data:
sample_documents = [
    {
        "title": "MongoDB Atlas",
        "text": "MongoDB Atlas is a fully managed cloud database."
    },
    {
        "title": "Vector Search",
        "text": "Vector search finds results based on semantic meaning."
    },
    {
        "title": "Nomic AI",
        "text": "nomic-embed-text-v1 is a free, open-source embedding model."
    },
]

docs_to_insert = []

for doc in sample_documents:
    embedding = get_embedding(doc["text"])
    docs_to_insert.append({
        "title": doc["title"],
        "text": doc["text"],
        # The vector lives alongside your original data in the same document:
        "embedding": embedding
    })

# Drop the collection before each run to avoid inserting duplicate documents:
collection.drop()

result = collection.insert_many(docs_to_insert)
print(f"Inserted {len(result.inserted_ids)} documents with embeddings.")

mongodb_client.close()

ในโค้ดข้างต้น collection.drop() จะลบเอกสารและดัชนีทั้งหมดในคอลเลกชันก่อนแต่ละการรัน หากรัน generate_embeddings.py ซ้ำโดยไม่มีบรรทัดนี้ จะทำให้เพิ่มเอกสารซ้ำ ซึ่งทำให้ $vectorSearch ส่งคืนเอกสารเดียวกันหลายครั้ง การดร็อปคอลเลกชันจะลบดัชนีเวกเตอร์เสิร์ชไปด้วย ดังนั้นต้องรัน create_vector_index.py ใหม่ทุกครั้งที่รัน generate_embeddings.py อีกครั้ง

รันสคริปต์:

python generate_embeddings.py

จะได้เอาต์พุตดังนี้ในเทอร์มินัล:

<All keys matched successfully>
Inserted 3 documents with embeddings.

ขณะนี้แต่ละเอกสารใน MongoDB จะมีทั้งข้อความต้นฉบับและเวกเตอร์ 768 มิติอยู่ในฟิลด์ embedding เวกเตอร์ถูกเก็บรวมกับข้อมูลเดิมในเอกสารเดียว จึงไม่ต้องมีที่เก็บแยกหรือการค้นหาเพิ่มเติมขณะคิวรี

สร้างดัชนี MongoDB Vector Search

สร้างไฟล์ชื่อ create_vector_index.py ไฟล์นี้จะกำหนดและสร้างดัชนีการค้นหาเวกเตอร์บนฟิลด์ embedding เพื่อให้ MongoDB รันคำสั่ง $vectorSearch กับคอลเลกชันของคุณได้

การกำหนดดัชนีต้องใช้สามฟิลด์:

• path: ฟิลด์ที่เก็บอิมเบดดิ้ง (embedding ในบทเรียนนี้)
• numDimensions: ต้องตรงกับขนาดเอาต์พุตของโมเดล (768 สำหรับ nomic-embed-text-v1)
• similarity: ฟังก์ชันเปรียบเทียบ (cosine เหมาะกับโมเดลนี้)

ค่า numDimensions ต้องตรงกับโมเดลอิมเบดดิ้งของคุณอย่างแม่นยำ หากไม่ตรง การสร้างดัชนีจะล้มเหลว:

from pymongo.mongo_client import MongoClient
from pymongo.operations import SearchIndexModel
import time

# Replace the placeholder with your Atlas connection string:
mongodb_client = MongoClient(
    "mongodb+srv://<USERNAME>:<PASSWORD>@<HOST>/",
    appname="devrel-tutorial-python-semantic-search"
)

# Point to the same database and collection you used in the previous step:
database = mongodb_client["sample_db"]
collection = database["documents"]

# Define the vector search index.
# The three required fields tell MongoDB what to index and how to compare vectors:
search_index_model = SearchIndexModel(
    definition={
        "fields": [
            {
                "type": "vector",
                "path": "embedding",      # The field name from generate_embeddings.py
                "numDimensions": 768,     # nomic-embed-text-v1 always outputs 768 dimensions
                "similarity": "cosine"    # Recommended similarity function for this model
            }
        ]
    },
    name="vector_index",
    type="vectorSearch"
)

result = collection.create_search_index(model=search_index_model)
print("New search index named " + result + " is building.")

# Poll every five seconds until the index is ready to accept queries:
print("Polling to check if the index is ready. This may take up to a minute.")

predicate = lambda index: index.get("queryable") is True

while True:
    indices = list(collection.list_search_indexes(result))
    if len(indices) and predicate(indices[0]):
        break
    time.sleep(5)

print(result + " is ready for querying.")

mongodb_client.close()

รันสคริปต์:

python create_vector_index.py

จะได้เอาต์พุตดังนี้ในเทอร์มินัล:

New search index named vector_index is building.
Polling to check if the index is ready. This may take up to a minute.
vector_index is ready for querying.

ดัชนีอาจใช้เวลาสร้างถึงหนึ่งนาที ลูปการโพลจะตรวจทุก 5 วินาทีและออกจากลูปก็ต่อเมื่อ MongoDB ยืนยันว่าดัชนีพร้อมคิวรีแล้ว อย่าไปขั้นตอนถัดไปจนกว่าจะเห็นข้อความว่า "vector_index is ready for querying."

แปลงคำค้นหาให้เป็นเวกเตอร์

สร้างไฟล์ชื่อ generate_query_vector.py ไฟล์นี้จะอิมพอร์ตฟังก์ชัน get_query_embedding() จากไฟล์ embedding_utils.py รันไฟล์ generate_query_vector.py เพื่อยืนยันว่าโมเดลอิมเบดดิ้งโหลดได้ถูกต้องและให้เวกเตอร์ความยาว 768 มิติ:

• กำหนดฟังก์ชัน get_query_embedding() ที่ขั้นตอนถัดไปจะอิมพอร์ตไปใช้
• สามารถรันแยกได้เองเพื่อยืนยันว่าโมเดลทำงานปกติ

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

from embedding_utils import get_query_embedding

user_query = "I need an automated, scalable system for serious information storage"
query_vector = get_query_embedding(user_query)
print(f"Query: '{user_query}'")
print(f"Vector dimensions: {len(query_vector)}")
print(f"First 5 values: {query_vector[:5]}")

รันสคริปต์:

python generate_query_vector.py

คุณจะได้เอาต์พุตคล้ายกับนี้:

<All keys matched successfully>
Query: 'I need an automated, scalable system for serious information storage'
Vector dimensions: 768
First 5 values: [0.0025914530269801617, 0.09862980246543884, -0.023092379793524742, -0.0171672236174345, -0.05548065900802612]

ในเอาต์พุตข้างต้น บรรทัด Vector dimensions: 768 ยืนยันว่าผลลัพธ์ของโมเดลตรงกับอิมเบดดิ้งที่จัดเก็บไว้

รันคิวรี $vectorSearch

สร้างไฟล์ชื่อ run_vector_search.py ไฟล์นี้จะอิมพอร์ตฟังก์ชัน get_query_embedding() จากไฟล์ embedding_utils.py และแปลงคำค้นหาของผู้ใช้เป็นเวกเตอร์ run_vector_search.py จะรันไปป์ไลน์การรวมข้อมูล $vectorSearch และพิมพ์ผลลัพธ์ที่จัดอันดับตามความใกล้เคียงเชิงความหมาย:

from embedding_utils import get_query_embedding
from pymongo import MongoClient

# Replace the placeholder with your Atlas connection string:
mongodb_client = MongoClient(
    "mongodb+srv://<USERNAME>:<PASSWORD>@<HOST>/",
    appname="devrel-tutorial-python-semantic-search"
)

collection = mongodb_client["sample_db"]["documents"]

# Generate a query vector from the user's search input:
user_query = "I need an automated, scalable system for serious information storage"
query_vector = get_query_embedding(user_query)

# Define the $vectorSearch aggregation pipeline:
pipeline = [
    {
        "$vectorSearch": {
            "index": "vector_index",      # The index created in create_vector_index.py
            "path": "embedding",          # The field that holds your stored vectors
            "queryVector": query_vector,  # The vector generated from the user's query
            "numCandidates": 150,         # How many neighbors MongoDB considers
            "limit": 3                    # How many results to return
        }
    },
    {
        "$project": {
            "_id": 0,
            "title": 1,
            "text": 1,
            "score": {
                "$meta": "vectorSearchScore"  # Relevance score for each result
            }
        }
    }
]

results = collection.aggregate(pipeline)

print(f"\nTop results for query: '{user_query}'\n")

for doc in results:
    print(f"Title: {doc['title']}")
    print(f"Text:  {doc['text']}")
    print(f"Score: {doc['score']:.4f}")
    print()

mongodb_client.close()

ในโค้ดข้างต้น มีพารามิเตอร์สองตัวควบคุมพฤติกรรมการค้นหา:

• numCandidates กำหนดขนาดพูลเริ่มต้นที่ MongoDB จะพิจารณาก่อนคัดไปยังผลลัพธ์สุดท้าย ค่าที่มากขึ้นช่วยเพิ่มการครอบคลุมแต่ใช้เวลานานขึ้นเล็กน้อย
• limit กำหนดจำนวนผลลัพธ์ที่ต้องการ ในบทเรียนนี้ limit ตั้งไว้ที่ 3 และ numCandidates ตั้งไว้ที่ 150 แนวทางเริ่มต้นที่พบบ่อยคือกำหนด numCandidates ประมาณ 10–15 เท่าของค่า limit

ตอนนี้ให้รันสคริปต์:

python run_vector_search.py

จะได้เอาต์พุตคล้ายต่อไปนี้:

<All keys matched successfully>

Top results for query: 'I need an automated, scalable system for serious information storage.'

Title: MongoDB Atlas
Text:  MongoDB Atlas is a fully managed cloud database.
Score: 0.7211

Title: Nomic AI
Text:  nomic-embed-text-v1 is a free, open-source embedding model.
Score: 0.6818

Title: Vector Search
Text:  Vector search finds results based on semantic meaning.
Score: 0.6642

"MongoDB Atlas" ได้คะแนนสูงสุด แม้คำค้นหา "I need an automated, scalable system for serious information storage" จะไม่มีคำใดตรงกับประโยค "MongoDB Atlas is a fully managed cloud database." การค้นหาส่งคืนเพราะเวกเตอร์มีความหมายใกล้กัน: "...ระบบอัตโนมัติที่ปรับขยายได้สำหรับการเก็บข้อมูล" แผนที่เชิงความหมายไปยัง "...ฐานข้อมูลคลาวด์ที่มีการจัดการเต็มรูปแบบ" การค้นหาข้อความสำหรับคำค้นหาเดียวกันจะได้ศูนย์ผลลัพธ์ เพราะไม่มีคำในคำค้นหาปรากฏตรงตัวในเอกสารใดเลย นี่คือ semantic search ที่ทำงานตามวัตถุประสงค์

สรุปประเด็นสำคัญ

• MongoDB Vector Search ใช้งานได้บนคลัสเตอร์ M0 ชั้นฟรี ไม่ต้องใช้แผนเสียเงิน
• ต้องใช้โมเดลอิมเบดดิ้งตัวเดียวกันทั้งตอนสร้างอิมเบดดิ้งสำหรับจัดเก็บและตอนสร้างเวกเตอร์คำค้น หากผสมโมเดล ผลลัพธ์จะไม่มีความหมาย
• ค่า numDimensions ในการกำหนดดัชนีต้องตรงกับขนาดเอาต์พุตของโมเดลอิมเบดดิ้งอย่างแม่นยำ nomic-embed-text-v1 ให้ค่า 768 มิติเสมอ
• input_type="document" จะปรับอิมเบดดิ้งให้เหมาะกับการจัดเก็บ ส่วน input_type="query" จะปรับให้เหมาะกับการดึงคืน ใช้ประเภทให้ถูกต้องในแต่ละขั้นตอน
• numCandidates ควบคุมขนาดของตาข่ายการค้นหาที่ MongoDB ครอบไว้ก่อนจำกัดเหลือผลลัพธ์ตาม limit ค่าที่มากขึ้นช่วยเพิ่มการครอบคลุมแต่ใช้เวลาเพิ่ม
• vectorSearchScore จัดอันดับผลลัพธ์ตามความคล้ายเชิงความหมาย ผลลัพธ์ไม่จำเป็นต้องมีคำใดๆ จากคำค้นหาแบบตรงตัว ช่วงคะแนนอาจแตกต่างตามโมเดลและดาต้าเซ็ต แต่ขอบเขตด้านล่างเป็นจุดเริ่มต้นที่มีประโยชน์สำหรับ nomic-embed-text-v1 กับ cosine similarity:
  • 0.9 ขึ้นไป: ความหมายแทบเหมือนกัน เอกสารและคำค้นหาเกือบจะเหมือนกันในเชิงความหมาย
  • 0.7 ถึง 0.9: เกี่ยวข้องมาก เอกสารเชื่อมโยงชัดเจนกับเจตนาของคำค้นหา
  • 0.5 ถึง 0.7: เกี่ยวข้องปานกลาง เอกสารเกี่ยวข้องในหัวข้อเดียวกันแต่ใช้การเล่าเรื่องหรือบริบทต่างกัน
  • ต่ำกว่า 0.5: เกี่ยวข้องน้อย ความเชื่อมโยงหลวม และผลลัพธ์อาจไม่เป็นประโยชน์

สามารถดูโค้ดตัวอย่างทั้งหมดของบทเรียนนี้ได้ที่ ที่เก็บ GitHub.

อ่านเพิ่มเติม

• ภาพรวม MongoDB Vector Search ครอบคลุมความสามารถทั้งหมดของ MongoDB Vector Search รวมถึงการกรองและการควอนไทเซชัน
• วิธีทำ hybrid search แสดงวิธีผสาน vector search และ full-text search ในคิวรีเดียว
• วิธีสร้าง Vector Embeddingsอธิบายวิธีสร้างเวกเตอร์อิมเบดดิ้งสำหรับข้อมูลข้อความในคอลเลกชันของคุณโดยใช้โมเดลอิมเบดดิ้งจาก Voyage AI, OpenAI และผู้ให้บริการโมเดลโอเพ่นซอร์สอื่นๆ
• Retrieval-Augmented Generation (RAG) กับ MongoDB แสดงวิธีใช้ semantic search เป็นชั้นการดึงคืนข้อมูลในแอปพลิเคชัน retrieval-augmented generation