Pengambilan Induk-Anak dan Kecil-ke-Besar
Simpan potongan anak berukuran kecil untuk pengambilan yang presisi, tetapi kembalikan potongan induknya yang lebih besar kepada LLM untuk konteks yang lebih kaya, dengan menyeimbangkan presisi pengambilan dan kualitas generasi.
Pengambilan Induk-Anak dan Kecil-ke-Besar adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.
Dilema Presisi dan Konteks
Sistem RAG menghadapi ketegangan: potongan kecil diambil dengan presisi tinggi karena setiap potongan berfokus pada satu gagasan, tetapi tidak memiliki konteks sekitar yang diperlukan LLM untuk menghasilkan jawaban lengkap. Potongan besar menyediakan konteks yang kaya, tetapi mengurangi presisi pengambilan karena cocok secara lemah dengan banyak kueri, alih-alih cocok secara kuat dengan satu kueri. Pemotongan induk-anak menyelesaikan dilema ini.
Arsitektur Induk-Anak
Dalam pemotongan induk-anak, Anda membuat dua lapisan potongan dari dokumen yang sama. Potongan anak berukuran kecil (misalnya 1–3 kalimat) dan disematkan serta diindeks untuk pengambilan. Potongan induk adalah bagian yang lebih besar (misalnya paragraf atau halaman lengkap) yang disimpan secara terpisah. Ketika potongan anak diambil, Anda justru mengembalikan induknya kepada LLM.
Membangun Hierarki Potongan
Langkah pertama adalah membagi dokumen menjadi potongan induk yang besar, lalu membagi setiap induk menjadi potongan anak yang lebih kecil. Setiap potongan anak menyimpan referensi — biasanya berupa bidang metadata parent_id — yang menunjuk kembali ke induknya. Pemetaan ini memungkinkan Anda mencari bagian induk lengkap berdasarkan potongan anak mana pun yang diambil.
from langchain.text_splitter import RecursiveCharacterTextSplitter
parent_splitter = RecursiveCharacterTextSplitter(chunk_size=1500, chunk_overlap=0)
child_splitter = RecursiveCharacterTextSplitter(chunk_size=300, chunk_overlap=30)
parent_chunks = parent_splitter.split_documents(docs)
child_chunks = []
for i, parent in enumerate(parent_chunks):
children = child_splitter.split_documents([parent])
for child in children:
child.metadata['parent_id'] = i
child_chunks.extend(children)Hanya Mengindeks Potongan Anak
Hanya potongan anak yang disematkan dan disimpan dalam basis data vektor. Potongan induk disimpan dalam penyimpanan nilai-kunci terpisah (kamus dalam memori, Redis, atau basis data dokumen). Dengan demikian, indeks vektor tetap padat dan presisi, sementara konteks yang kaya berada di luarnya.
# Store parents in a docstore
parent_store = {i: chunk.page_content for i, chunk in enumerate(parent_chunks)}
# Embed and index only children
vectorstore = Chroma.from_documents(
child_chunks,
embedding=OpenAIEmbeddings()
)Pengambilan: Anak Masuk, Induk Keluar
Saat pengambilan berlangsung, kueri pengguna disematkan dan dicocokkan dengan potongan anak. Potongan anak k teratas ditemukan, lalu referensi parent_id-nya diselesaikan dengan mencari di penyimpanan induk. Bagian induk — bukan bagian anak — kemudian disisipkan ke dalam perintah LLM. LLM menerima konteks yang luas; pengambilannya tetap presisi.
def retrieve_with_parents(query, vectorstore, parent_store, k=5):
child_results = vectorstore.similarity_search(query, k=k)
seen_parent_ids = set()
parent_contexts = []
for child in child_results:
pid = child.metadata['parent_id']
if pid not in seen_parent_ids:
parent_contexts.append(parent_store[pid])
seen_parent_ids.add(pid)
return parent_contextsParentDocumentRetriever LangChain
LangChain menyediakan kelas ParentDocumentRetriever yang langsung menerapkan pola ini. Anda menyediakan pemisah induk, pemisah turunan, penyimpanan vektor untuk penyematan turunan, dan penyimpanan dokumen untuk dokumen induk. Kelas ini mengatur hierarki dan menangani pengambilan secara transparan.
from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore
store = InMemoryStore()
retriever = ParentDocumentRetriever(
vectorstore=vectorstore,
docstore=store,
child_splitter=child_splitter,
parent_splitter=parent_splitter
)
retriever.add_documents(docs)
results = retriever.invoke('What is the refund policy?')Penjelasan Pengambilan dari Kecil ke Besar
Pengambilan dari kecil ke besar adalah nama lain untuk konsep yang sama: Anda mengambil potongan kecil yang tepat, lalu memperluasnya dengan konteks di sekitarnya sebelum mengirimkannya ke LLM. Beberapa implementasi memperluasnya bukan ke induk yang tetap, melainkan ke jendela kalimat yang berdekatan—memberikan model kalimat sebelum dan sesudah potongan yang cocok agar kesinambungan konteks tetap terjaga.
def retrieve_with_window(query, vectorstore, sentences, window=2, k=5):
results = vectorstore.similarity_search(query, k=k)
expanded = []
for r in results:
idx = r.metadata['sentence_index']
start = max(0, idx - window)
end = min(len(sentences), idx + window + 1)
expanded.append(' '.join(sentences[start:end]))
return expandedMenghapus Duplikasi Potongan Induk
Beberapa potongan turunan dari induk yang sama mungkin semuanya diambil untuk satu kueri. Tanpa penghapusan duplikasi, bagian induk yang sama akan muncul berkali-kali dalam prompt sehingga memboroskan token. Selalu hapus duplikasi berdasarkan ID induk sebelum menyusun konteks. Contoh kode dalam fungsi pengambilan di atas menangani hal ini dengan set seen_parent_ids.
Kapan Menggunakan Pemotongan Induk-Turunan
Pengambilan induk-turunan bekerja paling baik ketika dokumen Anda memiliki struktur hierarkis yang jelas: bab dengan bagian, artikel dengan paragraf, atau wiki dengan subbagian. Teknik ini sangat efektif untuk dokumentasi teknis yang panjang, ketika pertanyaan yang tepat memerlukan jawaban yang terlokalisasi, tetapi jawaban tersebut hanya masuk akal dalam konteks bagian yang lebih luas.
Memilih Ukuran Turunan dan Induk
Konfigurasi yang umum adalah: potongan turunan berukuran 200–400 token (gagasan tunggal yang terfokus) dan potongan induk berukuran 1.000–2.000 token (bagian yang lengkap). Jika potongan turunan terlalu kecil, potongan tersebut menjadi kalimat-kalimat tersendiri yang tidak memiliki makna yang cukup jika berdiri sendiri. Jika potongan induk terlalu besar, Anda mulai menghadirkan kembali masalah pengenceran konteks yang sebelumnya ingin Anda hindari.
Perbandingan Pendekatan: Ringkasan
Sebagai rangkuman strategi pemotongan sejauh ini: ukuran tetap cepat, tetapi memutus konteks; pemotongan semantik mempertahankan keterpaduan topik; induk-turunan mengoptimalkan ketepatan pengambilan sekaligus kekayaan konteks LLM. Untuk sebagian besar sistem RAG produksi yang menangani dokumen panjang, pemotongan induk-turunan memberikan kualitas pengambilan terbaik dengan kompleksitas yang masih terkelola.
Pemeriksaan Singkat
Uji pemahaman Anda tentang pemotongan induk-turunan dari pelajaran ini.
Rangkuman Pelajaran
Dalam pelajaran ini Anda mempelajari bahwa: potongan turunan menyediakan pengambilan yang tepat, sedangkan potongan induk menyediakan konteks yang kaya, ParentDocumentRetriever milik LangChain mengimplementasikan proses ini secara otomatis, dan penghapusan duplikasi berdasarkan ID induk mencegah pengulangan konteks. Selanjutnya, kita akan membahas strategi pemotongan khusus dokumen untuk file kode dan dokumen HTML.
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 “Pengambilan Induk-Anak dan Kecil-ke-Besar” gratis?
Ya — teks lengkap “Pengambilan Induk-Anak dan Kecil-ke-Besar” 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 “Pengambilan Induk-Anak dan Kecil-ke-Besar”?
Simpan potongan anak berukuran kecil untuk pengambilan yang presisi, tetapi kembalikan potongan induknya yang lebih besar kepada LLM untuk konteks yang lebih kaya, dengan menyeimbangkan presisi penga… 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 3 dari 4.
Berapa lama pelajaran “Pengambilan Induk-Anak dan Kecil-ke-Besar” 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