AI Engineering Academy · บทเรียน

การจัดกลุ่มและแสดงภาพเวกเตอร์ฝังตัว

ใช้การจัดกลุ่มแบบ k-means กับชุดเวกเตอร์ฝังตัว และแสดงภาพในรูปแบบสองมิติด้วย UMAP เพื่อค้นหาการรวมกลุ่มหัวข้อตามธรรมชาติในข้อมูล

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

เหตุใดจึงควรจัดกลุ่มเวกเตอร์ฝังตัว

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

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

ภาพรวมการจัดกลุ่มแบบเคมีนส์

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

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

from sklearn.cluster import KMeans
import numpy as np

# corpus_embeddings: (n_docs, 1536) — pre-computed
corpus_embeddings = np.random.randn(200, 1536)  # placeholder

kmeans = KMeans(n_clusters=5, random_state=42, n_init='auto')
kmeans.fit(corpus_embeddings)

labels = kmeans.labels_
print(f'Cluster assignments: {labels[:10]}')
print(f'Unique clusters: {set(labels)}')

การเลือกจำนวนกลุ่มที่เหมาะสม

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

ค่าคะแนนซิลูเอตวัดว่าจุดหนึ่งเข้ากับกลุ่มของตนเองได้ดีกว่ากลุ่มอื่นที่ใกล้ที่สุดเพียงใด ค่าที่ใกล้ 1 มากกว่าจะดีกว่า ลองใช้ค่า k ตั้งแต่ 3 ถึง 20 แล้วเลือกค่าที่ได้คะแนนดีที่สุด

from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
import numpy as np

corpus_embeddings = np.random.randn(200, 50)  # placeholder (50D for speed)

best_k, best_score = 2, -1
for k in range(2, 11):
    km = KMeans(n_clusters=k, random_state=42, n_init='auto')
    labels = km.fit_predict(corpus_embeddings)
    score = silhouette_score(corpus_embeddings, labels, sample_size=100)
    print(f'k={k}: silhouette={score:.3f}')
    if score > best_score:
        best_score, best_k = score, k

print(f'Best k: {best_k}')

การติดป้ายกำกับกลุ่มด้วย LLM

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

from openai import OpenAI

client = OpenAI()

def label_cluster(cluster_docs, n_examples=3):
    examples = '\n'.join(f'- {d}' for d in cluster_docs[:n_examples])
    prompt = f'Given these documents, provide a 3-word category label:\n{examples}\nLabel:'
    response = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}],
        max_tokens=20
    )
    return response.choices[0].message.content.strip()

# Example usage:
# cluster_0_docs = [documents[i] for i in range(len(documents)) if labels[i] == 0]
# print(label_cluster(cluster_0_docs))

การลดมิติด้วย UMAP

ไม่สามารถนำเวกเตอร์ขนาด 1536 มิติไปวาดกราฟได้โดยตรง UMAP (การประมาณและฉายแมนิโฟลด์แบบสม่ำเสมอ) จะลดข้อมูลหลายมิติให้เหลือ 2 หรือ 3 มิติ โดยยังรักษาโครงสร้างของบริเวณใกล้เคียงเอาไว้ ต่างจาก PCA ตรงที่ UMAP เป็นแบบไม่เชิงเส้นและรักษากลุ่มต่าง ๆ ได้ดีกว่ามาก

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

import umap
import numpy as np

corpus_embeddings = np.random.randn(200, 1536)  # placeholder

reducer = umap.UMAP(
    n_components=2,
    metric='cosine',   # important for text embeddings
    random_state=42
)

embeddings_2d = reducer.fit_transform(corpus_embeddings)
print(f'Reduced shape: {embeddings_2d.shape}')  # (200, 2)

การแสดงภาพกลุ่มด้วย Matplotlib

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

import matplotlib.pyplot as plt
import numpy as np

# Assume: embeddings_2d (n, 2), labels (n,), documents list
# Placeholder data:
np.random.seed(42)
embeddings_2d = np.random.randn(50, 2)
labels = np.random.randint(0, 5, 50)

fig, ax = plt.subplots(figsize=(10, 7))
scatter = ax.scatter(
    embeddings_2d[:, 0],
    embeddings_2d[:, 1],
    c=labels,
    cmap='tab10',
    s=60,
    alpha=0.8
)
plt.colorbar(scatter, label='Cluster')
ax.set_title('Document Embedding Clusters (UMAP)')
plt.tight_layout()
plt.savefig('/tmp/clusters.png', dpi=150)
print('Saved cluster plot')

พารามิเตอร์ UMAP ที่มีผลสำคัญ

ไฮเปอร์พารามิเตอร์หลักของ UMAP ที่มีผลต่อคุณภาพการแสดงภาพ:

n_neighbors (ค่าเริ่มต้น 15): ค่าที่มากขึ้นจะจับโครงสร้างโดยรวมได้มากขึ้น ค่าที่น้อยลงจะเผยให้เห็นกลุ่มเฉพาะที่
min_dist (ค่าเริ่มต้น 0.1): ระบุว่าจุดจะรวมตัวกันแน่นเพียงใด ค่าที่น้อยลงหมายถึงกลุ่มที่แน่นขึ้น แต่อาจทับซ้อนกันมากขึ้น
metric: ใช้ 'cosine' กับเวกเตอร์ฝังตัวของข้อความเสมอ เพราะระยะทางแบบยูคลิดไม่เหมาะสม

ทดลองใช้ค่า n_neighbors ระหว่าง 5 ถึง 50 เพื่อค้นหาการแสดงภาพที่เผยให้เห็นโครงสร้างข้อมูลของคุณได้ดีที่สุด

ทางเลือกแบบการจัดกลุ่มลำดับชั้น

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

from sklearn.cluster import AgglomerativeClustering
import numpy as np

corpus_embeddings = np.random.randn(100, 50)  # placeholder

cluster = AgglomerativeClustering(
    n_clusters=None,
    distance_threshold=1.5,
    metric='cosine',
    linkage='average'
)
labels = cluster.fit_predict(corpus_embeddings)

n_clusters = len(set(labels))
print(f'Found {n_clusters} natural clusters')

การค้นหาค่าผิดปกติและเอกสารเกือบซ้ำ

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

import numpy as np

def find_near_duplicates(corpus_vecs, threshold=0.95):
    # corpus_vecs assumed L2-normalized
    sim_matrix = corpus_vecs @ corpus_vecs.T  # (n, n)
    duplicates = []
    n = len(corpus_vecs)
    for i in range(n):
        for j in range(i + 1, n):
            if sim_matrix[i, j] >= threshold:
                duplicates.append((i, j, float(sim_matrix[i, j])))
    return duplicates

# pairs = find_near_duplicates(corpus_embeddings)
# print(f'Found {len(pairs)} near-duplicate pairs')

กระบวนการจัดกลุ่มในทางปฏิบัติ

กระบวนการจัดกลุ่มจริงควรทำตามขั้นตอนต่อไปนี้ตามลำดับ:

สร้างเวกเตอร์ฝังตัวให้เอกสารทั้งหมดด้วย text-embedding-3-small
หากต้องการ ให้ลดมิติเป็น 50 มิติด้วย UMAP ก่อนจัดกลุ่ม (ช่วยให้การจัดกลุ่มแบบเคมีนส์เร็วขึ้น)
จัดกลุ่มด้วยการจัดกลุ่มแบบเคมีนส์ ทดลองค่า k หลายค่าเพื่อหาค่าคะแนนซิลูเอตที่ดีที่สุด
ติดป้ายกำกับแต่ละกลุ่มด้วย LLM โดยใช้เอกสารตัวแทน 5 รายการ
แสดงกราฟกระจาย UMAP สองมิติ โดยระบายสีตามกลุ่ม
ตรวจสอบค่าผิดปกติ (จุดที่อยู่ห่างจากจุดศูนย์กลางทั้งหมด)

ข้อจำกัดของการจัดกลุ่ม

ควรคำนึงถึงข้อจำกัดสำคัญของการจัดกลุ่มเวกเตอร์ฝังตัวดังต่อไปนี้:

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

ใช้การจัดกลุ่มเป็นเครื่องมือสำรวจ ไม่ใช่ระบบจัดหมวดหมู่ที่ถือเป็นความจริงอ้างอิง

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

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

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า k-means จัดกลุ่มเอกสารตามความใกล้เคียงเชิงความหมายในพื้นที่เอ็มเบดดิง UMAP ลดเอ็มเบดดิงมิติสูงให้เหลือ 2 มิติสำหรับการแสดงภาพโดยใช้ระยะทางโคไซน์ และ คะแนน silhouette ช่วยให้คุณเลือกจำนวนคลัสเตอร์ที่เหมาะสมได้โดยไม่ต้องมีข้อมูลที่ติดป้ายกำกับ ต่อไป เราจะก้าวข้ามการค้นหาในหน่วยความจำและสำรวจฐานข้อมูลเวกเตอร์สำหรับระบบใช้งานจริง

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

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

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

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

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

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

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