Kejuruteraan Arahan AI · Pelajaran

Strategi Membahagi Teks Panjang

Pendekatan pembahagian mengikut saiz tetap, sempadan ayat dan makna.

Pelajaran 1 daripada 413 langkah

Strategi Membahagi Teks Panjang ialah pelajaran Kejuruteraan Arahan AI percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kejuruteraan Arahan AI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kejuruteraan Arahan AI merangkumi sejumlah 4 pelajaran.

Mengapa Dokumen Panjang Menjadi Cabaran

LLM mempunyai tetingkap konteks — bilangan maksimum token yang boleh diproses pada satu-satu masa. GPT-4 menyokong 128k token, manakala Claude menyokong 200k, tetapi banyak dokumen melebihi had ini. Lebih penting lagi, penyelidikan menunjukkan bahawa ketepatan model sering merosot apabila konteks terlalu panjang. Pembahagian kepada cebisan ialah amalan memecahkan dokumen kepada bahagian yang lebih kecil sebelum diproses.

Pembahagian Cebisan Saiz Tetap

Pembahagian cebisan saiz tetap memecahkan teks setiap N token (atau aksara) tanpa mengira sempadan kandungan. Ini ialah strategi paling mudah dan tidak memerlukan pemahaman semantik.

Saiz cebisan lazim: 500–1000 token. Cebisan mudah diindeks dan diambil semula, tetapi ayat mungkin terputus di tengah, lalu kehilangan makna pada sempadan.

import tiktoken

def fixed_chunk(text, max_tokens=1000):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    for i in range(0, len(tokens), max_tokens):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
    return chunks

chunks = fixed_chunk(long_document)
print(f'Total chunks: {len(chunks)}')

Pertukaran dalam Pembahagian Cebisan Saiz Tetap

Kelebihan:

Mudah dilaksanakan — tiada pemprosesan bahasa semula jadi diperlukan
Saiz cebisan boleh dijangka — kos API lebih mudah diurus
Pemprosesan pantas

Kekurangan:

Memotong merentasi sempadan ayat dan perenggan
Ayat yang terbelah antara cebisan kehilangan konteks untuk dapatan semula
Tidak sesuai untuk peringkasan — cebisan mungkin berakhir di tengah hujah

Pembahagian pada Sempadan Ayat

Pembahagian pada sempadan ayat memecahkan teks pada pemisah ayat atau perenggan yang semula jadi. Setiap cebisan berakhir pada noktah penuh, memastikan tiada ayat terpotong dua. Kaedah ini menghasilkan cebisan yang lebih mudah dibaca dan koheren.

Gunakan alat tokenisasi ayat (spaCy atau NLTK) untuk mengesan sempadan, kemudian kumpulkan ayat sehingga cebisan mencapai saiz sasaran.

import spacy

nlp = spacy.load('en_core_web_sm')

def sentence_chunk(text, max_tokens=1000):
    doc = nlp(text)
    sentences = [sent.text.strip() for sent in doc.sents]
    chunks, current, count = [], [], 0
    for sent in sentences:
        word_count = len(sent.split())
        if count + word_count > max_tokens and current:
            chunks.append(' '.join(current))
            current, count = [], 0
        current.append(sent)
        count += word_count
    if current:
        chunks.append(' '.join(current))
    return chunks

Pembahagian Semantik

Pembahagian semantik melangkah lebih jauh — teks dipecahkan apabila topik berubah. Dengan membenamkan ayat yang bersebelahan dan mengukur keserupaan kosinus, kita boleh mengesan apabila perbincangan beralih kepada subjek baharu.

Apabila keserupaan menurun di bawah ambang, masukkan sempadan cebisan. Kaedah ini menghasilkan cebisan yang padu dari segi topik dan sesuai untuk penjanaan diperkaya dengan dapatan semula (RAG).

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

model = SentenceTransformer('all-MiniLM-L6-v2')

def semantic_chunk(sentences, threshold=0.75):
    embeddings = model.encode(sentences)
    chunks, current = [], [sentences[0]]
    for i in range(1, len(sentences)):
        sim = cosine_similarity(
            [embeddings[i-1]], [embeddings[i]]
        )[0][0]
        if sim < threshold:
            chunks.append(' '.join(current))
            current = []
        current.append(sentences[i])
    if current:
        chunks.append(' '.join(current))
    return chunks

Membandingkan Tiga Strategi

Berikut ialah perbandingan sebelah-menyebelah untuk membantu anda membuat pilihan:

Saiz tetap: sempadan paling pantas tetapi paling kurang tepat — gunakan untuk alur pemprosesan ringkas
Sempadan ayat: mengekalkan keutuhan ayat — gunakan apabila koheren penting
Semantik: kepaduan topik terbaik — gunakan untuk RAG apabila ketepatan dapatan semula amat penting

Dalam amalan, pembahagian semantik menambah kependaman kerana pengiraan pembenaman. Buat pilihan berdasarkan keperluan ketepatan dapatan semula.

Pembahagian Cebisan untuk Tugas Dapatan Semula

Untuk penjanaan diperkaya dengan dapatan semula (RAG), cebisan menjadi unit carian. Pertanyaan pengguna dibenamkan, kemudian cebisan yang paling serupa diambil semula dan disuntik ke dalam gesaan.

Cebisan yang lebih kecil (200–400 token) meningkatkan ketepatan dapatan semula — setiap cebisan mengandungi satu idea yang fokus. Cebisan yang lebih besar (800–1000 token) memberikan lebih banyak konteks tetapi mungkin mengandungi kandungan yang tidak berkaitan bersama petikan yang relevan.

import openai
import numpy as np

client = openai.OpenAI(api_key='sk-...')

def embed(text):
    resp = client.embeddings.create(
        model='text-embedding-3-small',
        input=text
    )
    return np.array(resp.data[0].embedding)

def retrieve(query, chunks, top_k=3):
    q_emb = embed(query)
    scores = [(i, np.dot(q_emb, embed(c))) for i, c in enumerate(chunks)]
    scores.sort(key=lambda x: x[1], reverse=True)
    return [chunks[i] for i, _ in scores[:top_k]]

Peringkasan untuk Tugas Peringkasan

Untuk peringkasan, cebisan hendaklah cukup besar untuk mengandungi hujah atau bahagian yang lengkap. Cebisan pada sempadan ayat sebanyak 600–800 token berfungsi dengan baik.

Setiap cebisan diringkaskan secara berasingan (langkah pemetaan), kemudian ringkasan digabungkan menjadi ringkasan akhir (langkah pengurangan). Ini ialah corak pemetaan-pengurangan klasik, yang dibincangkan dalam pelajaran seterusnya.

Pertindihan: Merapatkan Sempadan Cebisan

Satu teknik praktikal untuk mengurangkan ralat sempadan ialah menambahkan pertindihan antara cebisan. 100–200 token terakhir cebisan N diulang pada permulaan cebisan N+1.

Pertindihan memastikan ayat yang merentasi sempadan muncul sepenuhnya dalam sekurang-kurangnya satu cebisan. Hal ini amat penting untuk dapatan semula — pertanyaan tentang topik yang merentasi sempadan akan sepadan dengan cebisan yang bertindih.

def fixed_chunk_with_overlap(text, max_tokens=1000, overlap=200):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    step = max_tokens - overlap
    for i in range(0, len(tokens), step):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
        if i + max_tokens >= len(tokens):
            break
    return chunks

Pengayaan Metadata bagi Setiap Cebisan

Setiap cebisan hendaklah membawa metadata supaya langkah seterusnya boleh merujuk asalnya:

source: nama fail atau URL
page: nombor halaman
chunk_index: kedudukan dalam dokumen
section: bab atau tajuk

Metadata ini disimpan bersama pembenaman dalam pangkalan data vektor (Pinecone, Chroma, Weaviate) dan dikembalikan bersama cebisan yang diambil semula supaya LLM boleh memetik sumber.

def chunk_with_metadata(text, source='doc.pdf', page=1):
    chunks = fixed_chunk_with_overlap(text)
    return [
        {
            'text': chunk,
            'metadata': {
                'source': source,
                'page': page,
                'chunk_index': i
            }
        }
        for i, chunk in enumerate(chunks)
    ]

Memilih Strategi yang Tepat

Panduan keputusan ringkas:

Keutamaan ialah kelajuan, kandungan berbentuk prosa: pembahagian pada sempadan ayat
Ketepatan dapatan semula amat penting: pembahagian semantik dengan cebisan kecil (300 token)
Merumuskan buku atau laporan: sempadan ayat, cebisan lebih besar (800 token), pemetaan-pengurangan
Dokumen undang-undang/teknikal: pembahagian semantik untuk mengekalkan klausa bersama-sama

Sentiasa ukur kadar dapatan semula pada set pertanyaan yang mewakili sebelum memilih sesuatu strategi.

Semakan Pengetahuan

Strategi pembahagian segmen manakah yang membahagikan teks apabila keserupaan kosinus antara pembenaman ayat bersebelahan jatuh di bawah ambang?

Jawab dalam pelajaran interaktif

Ulang Kaji: Strategi Pembahagian Segmen

Anda telah mempelajari tiga strategi utama pembahagian segmen:

Saiz tetap: membahagikan setiap N token — pantas, mudah, tidak mengambil kira sempadan
Sempadan ayat: membahagikan pada pemisah ayat semula jadi — koheren, kerumitan sederhana
Semantik: membahagikan berdasarkan peralihan topik melalui keserupaan pembenaman — paling tepat, kos tertinggi

Tambahkan pertindihan antara segmen untuk mengurangkan ralat sempadan, dan sentiasa sertakan metadata (sumber, halaman, indeks) untuk membolehkan sitasi dan kebolehkesanan. Pelajaran seterusnya membincangkan corak ringkasan pemetaan-pengurangan.

Percuma untuk bermula

Pelajari Kejuruteraan Arahan AI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 53
Pelajaran: 199

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Strategi Membahagi Teks Panjang” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kejuruteraan Arahan AI, termasuk “Strategi Membahagi Teks Panjang”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kejuruteraan Arahan AI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Strategi Membahagi Teks Panjang”?

Pendekatan pembahagian mengikut saiz tetap, sempadan ayat dan makna. Anda berlatih Kejuruteraan Arahan AI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kejuruteraan Arahan AI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kejuruteraan Arahan AI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Strategi Membahagi Teks Panjang” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kejuruteraan Arahan AI ini?

Ya. Setiap pelajaran Kejuruteraan Arahan AI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Kejuruteraan Arahan AI