Pemotongan Semantik dengan Kemiripan Embedding
Implementasikan pemotongan semantik yang membagi teks pada titik dengan jarak semantik maksimum di antara kalimat-kalimat berurutan, sehingga konten yang masih satu tema tetap bersama.
Pemotongan Semantik dengan Kemiripan Embedding adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.
Apa Itu Pemotongan Semantik?
Pemotongan semantik adalah teknik yang membagi teks pada titik-titik ketika topik berubah secara signifikan, bukan berdasarkan jumlah karakter tetap. Alih-alih bertanya 'apakah kita sudah mencapai 500 token?', teknik ini bertanya 'apakah kalimat berikutnya membahas topik yang sama dengan potongan saat ini?' — lalu menggunakan kemiripan penyematan untuk menjawabnya.
Gagasan Inti: Jarak Penyematan
Algoritma ini bekerja dengan menyematkan setiap kalimat (atau kelompok kecil kalimat) dan menghitung kemiripan kosinus antara penyematan kalimat yang berurutan. Ketika kemiripan turun tajam — yang berarti topik telah bergeser — algoritma menyisipkan batas potongan. Kalimat yang membahas konsep yang sama tetap berada dalam potongan yang sama.
Langkah 1: Penyematan Tingkat Kalimat
Langkah pertama adalah membagi dokumen menjadi kalimat-kalimat individual menggunakan tokenisasi kalimat, lalu menyematkan setiap kalimat dengan model penyematan yang cepat. Anda memerlukan penyematan tingkat kalimat — bukan tingkat dokumen — agar dapat mendeteksi perubahan topik lokal saat menelusuri teks.
from openai import OpenAI
from nltk.tokenize import sent_tokenize
import numpy as np
client = OpenAI()
def embed_sentences(text):
sentences = sent_tokenize(text)
response = client.embeddings.create(
model='text-embedding-3-small',
input=sentences
)
vectors = [item.embedding for item in response.data]
return sentences, np.array(vectors)Langkah 2: Menghitung Kemiripan yang Berdekatan
Setelah memiliki penyematan kalimat, hitung kemiripan kosinus untuk setiap pasangan berurutan: kalimat i dan kalimat i+1. Hasilnya adalah daftar skor kemiripan, satu skor untuk setiap batas kalimat. Skor rendah menunjukkan bahwa kalimat yang berdekatan membahas topik berbeda — inilah kandidat titik pemisahan Anda.
def cosine_similarity_adjacent(vectors):
similarities = []
for i in range(len(vectors) - 1):
a = vectors[i]
b = vectors[i + 1]
sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
similarities.append(sim)
return similaritiesLangkah 3: Mendeteksi Titik Pemisah
Titik pemisah adalah batas kalimat ketika kemiripan turun di bawah ambang batas. Anda dapat menggunakan ambang tetap (misalnya 0,6) atau ambang berbasis persentil yang menyesuaikan dengan dokumen — misalnya, lakukan pemisahan setiap kali kemiripan turun di bawah persentil ke-25 dari seluruh skor kemiripan dalam dokumen tersebut.
def find_breakpoints(similarities, percentile=25):
threshold = np.percentile(similarities, percentile)
breakpoints = []
for i, sim in enumerate(similarities):
if sim < threshold:
breakpoints.append(i + 1) # split AFTER sentence i
return breakpointsLangkah 4: Menyusun Potongan
Setelah titik pemisah dikenali, Anda dapat menyusun potongan dengan menggabungkan kalimat-kalimat berurutan di antara setiap titik pemisah. Setiap potongan yang dihasilkan berisi rangkaian kalimat yang koheren tentang topik yang sama. Batas potongan sejajar dengan peralihan topik alami dalam dokumen asli.
def assemble_chunks(sentences, breakpoints):
chunks = []
start = 0
for bp in breakpoints:
chunk = ' '.join(sentences[start:bp])
chunks.append(chunk)
start = bp
chunks.append(' '.join(sentences[start:])) # last chunk
return chunksContoh Lengkap Pemotong Semantik
Menggabungkan semuanya ke dalam satu fungsi: menyematkan kalimat, menghitung kemiripan yang berdekatan, menemukan titik pemisah, dan menyusun potongan. Hasilnya adalah daftar segmen teks yang koheren secara semantik, siap disematkan sebagai potongan utuh dan disimpan dalam basis data vektor Anda.
def semantic_chunk(text, percentile=25):
sentences, vectors = embed_sentences(text)
similarities = cosine_similarity_adjacent(vectors)
breakpoints = find_breakpoints(similarities, percentile)
chunks = assemble_chunks(sentences, breakpoints)
return chunks
chunks = semantic_chunk(my_document)
print(f'Produced {len(chunks)} semantic chunks')
for i, c in enumerate(chunks):
print(f'Chunk {i+1}: {len(c)} chars')Memilih Ambang Persentil
Ambang persentil mengontrol tingkat perincian potongan. Persentil rendah (misalnya persentil ke-10) berarti Anda hanya memisahkan teks saat terjadi perubahan topik besar — sehingga menghasilkan lebih sedikit potongan yang lebih panjang. Persentil tinggi (misalnya persentil ke-40) memisahkan teks dengan lebih agresif — sehingga menghasilkan banyak potongan kecil yang sangat terfokus. Sesuaikan nilai ini berdasarkan set evaluasi hit rate pengambilan Anda.
SemanticChunker LangChain
LangChain menyediakan SemanticChunker bawaan yang menerapkan algoritma ini. Komponen ini menerima model penyematan dan jenis ambang titik pemisah. Dengan demikian, Anda tidak perlu menerapkan algoritma dari awal, dan komponen ini dapat langsung diintegrasikan dengan pemuat dokumen serta penyimpanan vektor LangChain.
from langchain_experimental.text_splitter import SemanticChunker
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model='text-embedding-3-small')
chunker = SemanticChunker(
embeddings,
breakpoint_threshold_type='percentile',
breakpoint_threshold_amount=25
)
chunks = chunker.create_documents([long_document_text])
print(f'{len(chunks)} semantic chunks created')Pertukaran Dibandingkan Pemotongan Berukuran Tetap
Pemotongan semantik menghasilkan potongan berkualitas lebih tinggi dengan koherensi topik yang lebih baik, tetapi lebih mahal: setiap kalimat harus disematkan hanya untuk menentukan batas potongan — bahkan sebelum potongan tersebut diindeks. Untuk dokumen sepanjang 100 halaman, ini berarti ribuan pemanggilan penyematan hanya untuk pemotongan. Gunakan pemotongan semantik ketika kualitas pengambilan lebih penting daripada kecepatan pengindeksan.
Kapan Menggunakan Pemotongan Semantik
Pemotongan semantik sangat baik untuk konten naratif panjang — artikel blog, makalah penelitian, dokumen hukum, dan buku — yang topiknya bergeser secara alami. Teknik ini kurang diperlukan untuk dokumen yang sangat terstruktur seperti katalog produk, daftar FAQ, atau file kode, yang lebih baik ditangani dengan pemisah yang memahami dokumen dan menghormati strukturnya secara langsung.
Pemeriksaan Singkat
Uji pemahaman Anda tentang pemotongan semantik dari pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini, Anda mempelajari bahwa: pemotongan semantik menggunakan kemiripan penyematan untuk mendeteksi pergeseran topik, ambang persentil mengontrol tingkat perincian, dan SemanticChunker milik LangChain menerapkan semua ini secara bawaan. Selanjutnya kita akan mempelajari pemotongan induk-anak, yang menggabungkan potongan kecil yang presisi dengan bagian induk yang besar dan kaya konteks.
Belajar Python dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Pemotongan Semantik dengan Kemiripan Embedding” gratis?
Ya — teks lengkap “Pemotongan Semantik dengan Kemiripan Embedding” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Pemotongan Semantik dengan Kemiripan Embedding”?
Implementasikan pemotongan semantik yang membagi teks pada titik dengan jarak semantik maksimum di antara kalimat-kalimat berurutan, sehingga konten yang masih satu tema tetap bersama. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?
Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.
Berapa lama pelajaran “Pemotongan Semantik dengan Kemiripan Embedding” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?
Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Mengapa Pemotongan Naif Menghambat Pengambilan
- Pemotongan Semantik dengan Kemiripan Embedding
- Pengambilan Induk-Anak dan Kecil-ke-Besar
- Strategi Khusus Dokumen untuk Kode dan HTML