AI Engineering Academy · บทเรียน

เวกเตอร์ฝังตัวคืออะไร

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

ความหมายเบื้องหลังตัวเลข

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

ปริภูมิเวกเตอร์หลายมิติ

เวกเตอร์ฝังความหมายสมัยใหม่โดยทั่วไปมี 768 ถึง 3072 มิติ แต่ละมิติจับคุณลักษณะแฝงบางอย่างของความหมาย เช่น หัวข้อ อารมณ์ รูปแบบ และความสัมพันธ์ โดยไม่ได้เขียนโปรแกรมกำหนดไว้อย่างชัดเจน ผลลัพธ์คือปริภูมิเรขาคณิตที่มีรายละเอียดมาก ซึ่งทำให้สามารถวัดความสัมพันธ์เชิงอรรถศาสตร์เป็นระยะทางได้

ตัวอย่างเช่น text-embedding-3-small สร้างเวกเตอร์ 1536 มิติ ขณะที่ text-embedding-3-large สร้างเวกเตอร์ 3072 มิติ

โครงข่ายประสาทเทียมเรียนรู้เวกเตอร์ฝังความหมายได้อย่างไร

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

นี่คือเหตุผลที่เรียกเวกเตอร์ฝังความหมายว่า ตัวแทนแบบหนาแน่น เพราะทุกมิติมีข้อมูลอยู่ ต่างจากการเข้ารหัสแบบ one-hot ที่มีค่าเป็นศูนย์เกือบทั้งหมด

ความคล้ายคลึงโคไซน์: การวัดความใกล้เคียง

ความคล้ายคลึงโคไซน์ วัดมุมระหว่างเวกเตอร์สองตัว และคืนค่าในช่วง -1 ถึง 1 คะแนน 1 หมายความว่าเวกเตอร์ชี้ไปในทิศทางเดียวกันทุกประการ (ความหมายเหมือนกัน) ค่า 0 หมายถึงตั้งฉากกัน (ไม่เกี่ยวข้องกัน) และค่า -1 หมายถึงชี้ไปในทิศทางตรงข้ามกัน

วิธีนี้เป็นที่นิยมกว่าระยะทางแบบยุคลิดสำหรับข้อความ เพราะไม่สนใจขนาดของเวกเตอร์และมุ่งพิจารณาเฉพาะทิศทาง จึงรับมือกับความแตกต่างของความยาวข้อความได้ดี

import numpy as np

def cosine_similarity(vec_a, vec_b):
    dot_product = np.dot(vec_a, vec_b)
    norm_a = np.linalg.norm(vec_a)
    norm_b = np.linalg.norm(vec_b)
    return dot_product / (norm_a * norm_b)

# Example with tiny 3D vectors
v1 = np.array([0.8, 0.2, 0.5])
v2 = np.array([0.9, 0.1, 0.4])
print(cosine_similarity(v1, v2))  # Close to 1.0

เหตุใดความคล้ายคลึงเชิงความหมายจึงสำคัญ

การค้นหาด้วยคำสำคัญแบบดั้งเดิมใช้ไม่ได้เมื่อผู้ใช้ถอดความใหม่ เช่น การค้นหา automobile อาจไม่พบเอกสารเกี่ยวกับ cars เวกเตอร์ฝังความหมายแก้ปัญหานี้ได้ เพราะข้อความที่มีความหมายเทียบเท่ากันจะถูกแปลงไปเป็นเวกเตอร์ที่อยู่ใกล้กัน ไม่ว่าคำที่ใช้จะตรงกันหรือไม่

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

ภาพแสดงเวกเตอร์ฝังความหมาย

ลองจินตนาการว่าเราพล็อตประโยคลงบนแผนที่ 2 มิติ (เป็นการเปรียบเทียบแบบง่าย) ประโยคเกี่ยวกับ การเรียนรู้ของเครื่อง จะรวมกลุ่มอยู่ในบริเวณหนึ่ง ประโยคเกี่ยวกับ การทำอาหาร จะรวมกลุ่มอยู่อีกบริเวณหนึ่ง และประโยคเกี่ยวกับ กีฬา จะก่อตัวเป็นกลุ่มที่สาม เวกเตอร์ฝังความหมายสร้างแผนที่ลักษณะนี้ขึ้นในปริภูมิที่มีหลายพันมิติ

ความสัมพันธ์ที่มีชื่อเสียง เช่น ราชา - ผู้ชาย + ผู้หญิง ≈ ราชินี เป็นการคำนวณทางคณิตศาสตร์จริงในปริภูมินี้ การดำเนินการกับเวกเตอร์สามารถเข้ารหัสการเปรียบเทียบเชิงความหมายได้

การสร้างเวกเตอร์ฝังความหมายอย่างง่าย

API เวกเตอร์ฝังความหมายของ OpenAI รับข้อความและส่งคืนรายการค่าทศนิยม การเรียก API เพียงครั้งเดียวสามารถแปลงประโยคเดียวหรือทั้งย่อหน้าเป็นเวกเตอร์ได้ เวกเตอร์ที่ส่งคืนมีจำนวนมิติคงที่ไม่ว่าความยาวของข้อมูลนำเข้าจะเป็นเท่าใด

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

from openai import OpenAI

client = OpenAI()  # uses OPENAI_API_KEY from environment

response = client.embeddings.create(
    model='text-embedding-3-small',
    input='Vector embeddings capture semantic meaning.'
)

embedding = response.data[0].embedding
print(f'Dimensions: {len(embedding)}')  # 1536
print(f'First 5 values: {embedding[:5]}')

การสร้างเวกเตอร์ฝังความหมายจากข้อความหลายรายการพร้อมกัน

คุณสามารถสร้างเวกเตอร์ฝังความหมายจากสตริงหลายรายการในการเรียก API ครั้งเดียวได้ โดยส่งรายการไปยังพารามิเตอร์ input วิธีนี้มีประสิทธิภาพมากกว่าการส่งคำขอแยกกันสำหรับแต่ละข้อความ เพราะลดการเดินทางไปกลับผ่านเครือข่ายและเปิดให้ API ประมวลผลเป็นชุด

การตอบกลับจะมีออบเจ็กต์เวกเตอร์ฝังความหมายหนึ่งรายการต่อข้อมูลนำเข้าแต่ละรายการ โดยเรียงตามลำดับเดิม คุณจึงจับคู่กับข้อความต้นฉบับได้ด้วยการรวมรายการตามตำแหน่ง

from openai import OpenAI

client = OpenAI()

texts = [
    'Python is a programming language.',
    'Snakes are reptiles.',
    'Machine learning requires data.'
]

response = client.embeddings.create(
    model='text-embedding-3-small',
    input=texts
)

for text, result in zip(texts, response.data):
    print(f'{text[:30]}... -> {len(result.embedding)}D vector')

ผลคูณจุดเทียบกับความคล้ายคลึงโคไซน์

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

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

import numpy as np

def normalize(vec):
    return vec / np.linalg.norm(vec)

v1 = normalize(np.array([3.0, 4.0, 0.0]))
v2 = normalize(np.array([4.0, 3.0, 0.0]))

# For unit vectors: dot product == cosine similarity
dot = np.dot(v1, v2)
print(f'Dot product: {dot:.4f}')  # same as cosine sim

เวกเตอร์ฝังความหมายเทียบกับการเข้ารหัสแบบ One-Hot

การเข้ารหัสแบบ One-Hot แทนคำแต่ละคำด้วยเวกเตอร์ที่มีค่า 1 อยู่เพียงหนึ่งค่า และค่าอื่นทั้งหมดเป็น 0 คำศัพท์จำนวน 50,000 คำจะสร้างเวกเตอร์ 50,000 มิติที่เกือบทั้งหมดเป็นศูนย์ ซึ่งไม่มีประสิทธิภาพอย่างมาก

เวกเตอร์ฝังความหมายแบบหนาแน่นใช้ 768-3072 มิติ แต่ทุกมิติมีข้อมูลจริงอยู่ ปริภูมิมีขนาดเล็กลง 10-20 เท่า แต่เก็บรายละเอียดได้มากกว่ามาก รวมถึงคำพ้องความหมาย การเปรียบเทียบ และความหมายจากการประกอบกัน ซึ่งการเข้ารหัสแบบ One-Hot ไม่สามารถเก็บได้เลย

กรณีการใช้งานเวกเตอร์ฝังความหมายที่พบบ่อย

นอกเหนือจากการค้นหาเชิงความหมายแล้ว เวกเตอร์ฝังความหมายยังเป็นพลังขับเคลื่อนการใช้งานจริงอีกมากมาย:

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

ระบบ RAG ทุกระบบต้องอาศัยเวกเตอร์ฝังความหมายเพื่อจับคู่คำค้นหาของผู้ใช้กับส่วนเอกสารที่เกี่ยวข้อง

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

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

สรุปบทเรียน

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

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

บทเรียน “เวกเตอร์ฝังตัวคืออะไร” ฟรีหรือไม่

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

คุณจะเรียนรู้อะไรในบทเรียน “เวกเตอร์ฝังตัวคืออะไร”

ทำความเข้าใจว่าโครงข่ายประสาทเทียมแมปข้อความเป็นเวกเตอร์หนาแน่นในปริภูมิหลายมิติอย่างไร เหตุใดข้อความที่มีความหมายคล้ายกันจึงได้เวกเตอร์ที่อยู่ใกล้กัน และความคล้ายคลึงแบบโคไซน์ใช้วัดอะไร คุณปฏิบัติ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

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