Large Language Model (LLM)

Sebelum mulai, pastikan hal-hal ini sudah akrab bagimu:

• Python 3.10 atau lebih baru, dan sedikit NumPy: membuat larik, perkalian matriks dengan @, dan fungsi seperti np.exp.
• Peluang dasar: peluang bernilai 0 sampai 1, dan peluang semua kemungkinan berjumlah 1. Logaritma natural (ln) dipakai di langkah 1.
• Vektor dan matriks: vektor adalah deretan angka, dan perkalian dua vektor (dot product) mengukur seberapa searah keduanya.

Tak perlu latar belakang machine learning. Setiap istilah dijelaskan saat pertama muncul, dan tak perlu kunci API untuk menjalankan contohnya.

Cara terbaik memahami LLM adalah membuat versi paling kecilnya. Model bigram menebak kata berikutnya hanya dari satu kata sebelumnya, dengan menghitung seberapa sering pasangan kata muncul di korpus:

def peluang(model: dict[str, Counter[str]], sebelum: str, sesudah: str, kosakata: int) -> float:
    c = model.get(sebelum, Counter())
    return (c[sesudah] + 1) / (sum(c.values()) + kosakata)  # +1 supaya kata baru tak berpeluang 0


def loss(model: dict[str, Counter[str]], kalimat: str, kosakata: int) -> float:
    """Rata-rata -ln p(kata berikutnya). Inilah yang diturunkan selama pretraining."""
    kata = ["<awal>"] + kalimat.lower().split() + ["<akhir>"]
    nilai = [-math.log(peluang(model, a, b, kosakata)) for a, b in zip(kata, kata[1:])]
    return sum(nilai) / len(nilai)

Fungsi loss menghitung rata-rata −ln dari peluang kata yang benar. Makin yakin model pada kata yang benar, makin kecil angkanya. Inilah besaran yang diturunkan selama pretraining LLM sungguhan, hanya dengan model jauh lebih besar dan teks jauh lebih banyak.

Kami melatihnya pada enam kalimat sederhana tentang perpustakaan. Kalimat wajar "saya ingin meminjam novel" mendapat loss 1,929, sedangkan versi acaknya, "novel meminjam ingin saya", mendapat 2,841. Model sudah "merasa" mana yang lebih masuk akal.

Ketika diminta menulis sendiri dengan selalu memilih kata paling mungkin, ia menghasilkan "saya ingin meminjam buku di perpustakaan". Kalimat itu tak ada di korpusnya; model menyambung potongan dari kalimat-kalimat lain. Benih kemampuan menulis sudah terlihat, tetapi bigram tak punya ingatan lebih dari satu kata. Langkah-langkah berikutnya mengatasi keterbatasan itu.

Model tak membaca huruf atau kata secara langsung, melainkan token. Glosarium Claude menjelaskan bahwa token bisa berupa kata, potongan kata, huruf, bahkan byte. Cara memecahnya yang populer adalah Byte Pair Encoding (BPE), yang diperkenalkan untuk model bahasa oleh Sennrich dkk. (2016): mulai dari huruf, lalu berulang kali gabungkan pasangan simbol yang paling sering muncul.

def latih_bpe(korpus: dict[str, int], n_gabung: int) -> list[tuple[str, str]]:
    """korpus: kata -> frekuensi. Setiap kata dipecah per huruf, ditambah penanda akhir kata '</w>'."""
    kata = {tuple(k) + ("</w>",): f for k, f in korpus.items()}
    aturan: list[tuple[str, str]] = []
    for _ in range(n_gabung):
        pasangan: Counter[tuple[str, str]] = Counter()
        for simbol, f in kata.items():
            for a, b in zip(simbol, simbol[1:]):
                pasangan[(a, b)] += f
        if not pasangan:
            break
        terbaik = max(pasangan, key=lambda p: pasangan[p])  # seri: yang pertama ditemukan
        aturan.append(terbaik)
        kata = {_gabung(s, terbaik): f for s, f in kata.items()}
    return aturan

Aturan yang dihasilkannya sama persis dengan algoritma rujukan di makalah itu.

Kata yang sering muncul akhirnya menjadi satu token utuh, sedangkan kata langka dipecah menjadi potongan. Karena itu tak ada kata yang benar-benar "tak dikenal".

Bagi pengguna Claude, ada dua hal praktis:

• Perkiraan kasar bisa usang. Glosarium menyebut satu token kira-kira 3,5 karakter bahasa Inggris. Tetapi dokumentasi token counting mencatat bahwa tokenizer yang diperkenalkan bersama Claude Opus 4.7 menghitung prompt yang sama kira-kira 30% lebih banyak daripada model sebelumnya.
• Hitung dengan API, jangan menebak. Endpoint penghitung token gratis (tetap dibatasi jumlah permintaan per menit), dan hasilnya mengikuti tokenizer model yang kamu sebut. Angkanya perkiraan, tetapi jauh lebih tepat daripada rumus kasar.

Model hanya bisa menghitung dengan angka. Karena itu setiap token diubah menjadi embedding, yaitu vektor berisi ratusan sampai ribuan angka. Makalah Attention Is All You Need (Vaswani dkk., 2017), yang memperkenalkan arsitektur Transformer, menyebutnya learned embeddings. Angka-angka itu tak ditentukan manusia, melainkan disetel selama pelatihan.

Hasilnya, token yang maknanya mirip cenderung punya vektor yang berdekatan.

Ada satu masalah. Atensi, yang dibahas di langkah berikutnya, tak punya rasa urutan bawaan: "anjing menggigit orang" dan "orang menggigit anjing" berisi token yang sama. Makalah itu menjelaskan bahwa, karena modelnya tak memakai rekurensi maupun konvolusi, informasi posisi harus disuntikkan ke embedding. Caranya dengan menambahkan positional encoding, vektor posisi berdimensi sama dengan embedding.

Jadi setiap token masuk ke model sebagai satu vektor yang membawa dua hal: apa token itu, dan di mana letaknya.

Kata "bisa" berarti lain dalam "ular itu bisa" dan "saya bisa datang". Untuk memahami sebuah token, model perlu melihat token-token di sekitarnya. Itulah atensi. Setiap token membuat tiga vektor: query (Q, apa yang sedang kucari), key (K, apa yang kutawarkan), dan value (V, isi yang kuberikan). Rumusnya softmax(QKᵀ / √d_k) · V:

def atensi(Q: Matriks, K: Matriks, V: Matriks, kausal: bool = True) -> tuple[Matriks, Matriks]:
    d_k = Q.shape[-1]
    skor = Q @ K.T / np.sqrt(d_k)              # seberapa relevan token j bagi token i
    if kausal:                                 # token i tak boleh melihat token sesudahnya
        skor = np.where(np.triu(np.ones_like(skor), k=1) == 1, -np.inf, skor)
    bobot = softmax(skor)                      # setiap baris berjumlah 1
    return bobot @ V, bobot

Dua detail di kode itu berasal langsung dari makalah Transformer:

• Dibagi √d_k. Untuk dimensi besar, hasil perkalian titik bisa sangat besar sehingga softmax masuk ke wilayah dengan gradien sangat kecil. Bila komponen q dan k acak dengan rata-rata 0 dan ragam 1, ragam hasil kalinya sama dengan d_k. Kami memeriksanya: untuk d_k = 64, ragamnya 64,6, dan sesudah dibagi √64 menjadi 1,01.
• Masker kausal. Model penulis tak boleh mengintip token sesudahnya. Makalah itu menutup hubungan yang dilarang dengan mengisinya −∞ sebelum softmax, sehingga bobotnya tepat nol.

Setiap baris bobot berjumlah 1. Keluaran setiap token adalah rata-rata berbobot dari value token-token yang boleh dilihatnya.

Satu lapisan atensi belum cukup. Transformer menumpuk lapisan yang sama berkali-kali. Di makalah aslinya, setiap tumpukan terdiri dari 6 lapisan identik, dan setiap lapisan punya dua bagian:

• Multi-head attention: beberapa atensi berjalan berdampingan. Makalahnya menjelaskan bahwa ini memungkinkan model memperhatikan informasi dari berbagai sudut pandang sekaligus, sesuatu yang tak bisa dilakukan satu kepala atensi karena hasilnya dirata-ratakan.
• Jaringan feed-forward yang diterapkan pada setiap posisi.

Di sekitar setiap bagian ada sambungan residual: masukan ditambahkan kembali ke keluaran sebelum dinormalisasi. Dengan begitu informasi bisa mengalir melewati banyak lapisan tanpa hilang.

Di ujung tumpukan, vektor terakhir diubah menjadi peluang untuk setiap token di kosakata, lewat transformasi linear dan softmax. Dari situlah langkah 8 memilih token berikutnya.

Kenapa Transformer mengalahkan pendahulunya? Abstrak makalah itu menyebut dua keunggulan: kualitasnya lebih baik, dan pelatihannya jauh lebih mudah diparalelkan sehingga butuh waktu jauh lebih singkat. Model-model berbasis rekurensi memproses token satu per satu. Transformer memproses semua token dalam sebuah teks latihan sekaligus, dan kemampuan itulah yang memungkinkan pelatihan pada teks berskala sangat besar.

Seberapa besar model harus dibuat, dan berapa banyak teks yang perlu dibaca? Kaplan dkk. (2020) menemukan pola yang mengejutkan rapi: loss model bahasa turun mengikuti hukum pangkat (power law) terhadap ukuran model, jumlah data, dan jumlah komputasi pelatihan. Beberapa tren itu bertahan lebih dari tujuh orde besaran. Detail arsitektur, seperti lebar atau kedalaman jaringan, ternyata berpengaruh kecil dalam rentang yang luas.

Temuan itu membuat banyak tim memperbesar model sambil mempertahankan jumlah data. Hoffmann dkk. (2022) kemudian menunjukkan bahwa banyak model besar saat itu sebenarnya kurang dilatih. Setelah melatih lebih dari 400 model, mereka menyimpulkan bahwa untuk anggaran komputasi tertentu, ukuran model dan jumlah token latihan sebaiknya dinaikkan seimbang: setiap kali ukuran model digandakan, jumlah token latihan juga digandakan.

Untuk membuktikannya, mereka melatih Chinchilla, model 70 miliar parameter dengan anggaran komputasi yang sama dengan Gopher (280 miliar parameter) tetapi dengan data empat kali lebih banyak. Chinchilla mengungguli Gopher dan model lain yang jauh lebih besar di banyak tugas. Model yang lebih kecil juga lebih murah dipakai sesudahnya.

Pelajaran untukmu sebagai pengguna: ukuran model bukan satu-satunya ukuran mutu. Data, cara melatih, dan tahap-tahap sesudah pretraining sama pentingnya.

Model hasil pretraining pandai melanjutkan teks, tetapi belum tentu menuruti maksudmu. Ouyang dkk. (2022) menulis bahwa membuat model lebih besar tak otomatis membuatnya lebih baik dalam mengikuti maksud pengguna. Model besar bisa menghasilkan jawaban yang tak benar, kasar, atau sekadar tak membantu.

Jalan keluarnya adalah dua tahap tambahan:

• Fine-tuning dengan contoh: manusia menulis contoh jawaban yang baik, lalu model dilatih menirunya.
• Belajar dari preferensi: model menghasilkan beberapa jawaban, lalu manusia mengurutkannya. Glosarium Claude menjelaskan bahwa reinforcement learning from human feedback (RLHF) mendorong model memilih keluaran yang mirip dengan jawaban berperingkat tinggi.

Hasilnya mencolok. Dalam penilaian manusia, jawaban InstructGPT berukuran 1,3 miliar parameter lebih disukai daripada jawaban GPT-3 berukuran 175 miliar parameter, padahal parameternya 100 kali lebih sedikit.

Anthropic mengembangkan dua cara dalam keluarga ini. Bai dkk. (2022) melatih asisten yang membantu sekaligus tak membahayakan dengan RLHF. Constitutional AI (Bai dkk., 2022) mengganti sebagian penilaian manusia dengan model yang berpegang pada sekumpulan prinsip tertulis, sebuah "konstitusi". Cara ini disebut RLAIF, reinforcement learning from AI feedback. Tujuan bersamanya dirangkum glosarium Claude sebagai HHH: helpful, honest, harmless (membantu, jujur, tak membahayakan).

Di ujung Transformer, model memberi skor (logit) untuk setiap token. Skor diubah menjadi peluang dengan softmax, lalu satu token dipilih. Cara memilihnya ternyata sangat menentukan mutu teks:

def peluang(logit: Vektor, suhu: float = 1.0) -> Vektor:
    z = logit / suhu                  # suhu < 1 menajamkan, suhu > 1 meratakan
    e = np.exp(z - z.max())
    hasil: Vektor = e / e.sum()
    return hasil


def nukleus(p: Vektor, top_p: float) -> Vektor:
    """Simpan himpunan terkecil kata teratas yang peluang totalnya >= top_p, lalu normalkan lagi."""
    urut = np.argsort(-p)
    kumulatif = np.cumsum(p[urut])
    batas = int(np.searchsorted(kumulatif, top_p)) + 1
    q = np.zeros_like(p)
    q[urut[:batas]] = p[urut[:batas]]
    return q / q.sum()

Untuk skor contoh sesudah "Saya ingin meminjam", peluang "buku" adalah 0,79 pada suhu 0,5, 0,56 pada suhu 1,0, dan 0,44 pada suhu 1,5. Suhu (temperature) rendah menajamkan pilihan; suhu tinggi meratakannya. Glosarium Claude menjelaskan bahwa suhu tinggi memberi keluaran yang lebih beragam dan kreatif, sedangkan suhu rendah lebih konservatif.

Kenapa tidak selalu memilih token paling mungkin? Holtzman dkk. (2019) menemukan bahwa memaksimalkan peluang justru menghasilkan teks yang hambar dan anehnya berulang-ulang. Mereka mengusulkan nucleus sampling (top-p): ambil himpunan terkecil token teratas yang peluang totalnya mencapai p, lalu pilih secara acak dari situ. Pada contoh kita, top-p 0,9 hanya menyisakan "buku", "novel", dan "komik". Ekor distribusi yang tak bisa diandalkan, seperti "sepeda", dibuang.

Langkah berikutnya menjelaskan bagaimana semua ini terlihat ketika kamu memakai Claude hari ini.

Banyak tutorial menyarankan mengatur temperature. Untuk model Claude terbaru, saran itu sudah tak berlaku. Dokumentasi thinking menyebutkan bahwa pada Claude Fable 5.1, Claude Opus 5.5, Claude Sonnet 5.5, Claude Haiku 5.5, dan beberapa model lain, nilai temperature, top_p, atau top_k selain bawaannya menghasilkan galat 400 di setiap permintaan. Referensi API menandai ketiganya deprecated untuk model yang dirilis sesudah Claude Opus 4.6.

Sebagai gantinya, kendali utamanya adalah effort:

def tanya(client: anthropic.Anthropic, pertanyaan: str, effort: Effort = "low") -> tuple[str, Usage]:
    respons = client.messages.create(
        model="claude-opus-5-5",
        max_tokens=2048,
        output_config={"effort": effort},  # bukan temperature: model terbaru menolaknya
        messages=[{"role": "user", "content": pertanyaan}],
    )
    teks = "".join(b.text for b in respons.content if b.type == "text")  # lewati blok thinking
    return teks, respons.usage

Effort memengaruhi semua token keluaran: teks, panggilan tool, dan thinking. Ada lima tingkatnya, low, medium, high, xhigh, dan max. Bawaannya medium pada Claude Opus 5.5 dan Claude Haiku 5.5, dan high pada model lain. Pada Claude Opus 5.5, adaptive thinking selalu aktif, yaitu model memutuskan sendiri seberapa banyak berpikir sebelum menjawab, sehingga effort menjadi kendali utama atas kedalaman penalaran dan biaya. Dokumentasinya menyarankan menguji beberapa tingkat effort pada eval-mu sendiri, bukan menyalin pengaturan dari model lama.

Satu hal lagi dari glosarium: bahkan dengan temperature 0 pada model lama, keluaran API tak sepenuhnya deterministik. Jangan membangun aplikasi yang bergantung pada jawaban yang persis sama setiap kali.

Model tak mengingat percakapan di antara panggilan. Yang ia "lihat" hanyalah isi jendela konteks saat itu. Dokumentasi Claude menyebutnya memori kerja model, berbeda dari korpus besar yang dipakai untuk melatihnya.

Semua yang ada di permintaan dihitung masuk jendela itu: prompt sistem, setiap pesan (termasuk hasil tool, gambar, dan dokumen), definisi tool, dan juga keluaran yang sedang ditulis model, termasuk thinking. Untuk model Claude terbaru, jendelanya 1 juta token, dan satu permintaan bisa menghasilkan sampai 128 ribu token keluaran.

Besar bukan berarti boleh diisi sembarangan. Dokumentasi yang sama memperingatkan context rot: makin banyak token di konteks, makin turun ketelitian dan kemampuan model mengingat isinya. Karena itu memilih apa yang dimasukkan ke konteks sama pentingnya dengan seberapa besar ruangnya. Topik Memori agen membahas cara-cara mengelolanya, seperti compaction dan context editing.

Satu hal praktis lagi: setiap respons API melaporkan pemakaian token di medan usage. Biasakan membacanya. Angka itulah dasar biaya dan batas yang dibahas di langkah berikutnya.

Harga LLM dihitung per token, dengan harga berbeda untuk token masukan dan keluaran. Tabel Models overview di dokumentasi Claude mencantumkan, misalnya:

Menghitung biayanya tinggal mengalikan usage dengan harga:

HARGA_PER_JUTA = {  # USD per juta token, dari tabel Models overview dokumentasi Claude
    "claude-opus-5-5": {"masuk": 4.00, "keluar": 20.00},
    "claude-sonnet-5-5": {"masuk": 2.00, "keluar": 10.00},
}


def biaya(model: str, input_tokens: int, output_tokens: int) -> float:
    h = HARGA_PER_JUTA[model]
    return input_tokens / 1_000_000 * h["masuk"] + output_tokens / 1_000_000 * h["keluar"]

Permintaan dengan 2.000 token masukan dan 500 token keluaran berbiaya $0,018 di Claude Opus 5.5 dan $0,009 di Claude Sonnet 5.5.

Dokumentasi yang sama menyarankan mulai dari Claude Opus 5.5 untuk kebanyakan pekerjaan. Claude Fable 5.1 untuk penalaran yang sangat menuntut dan pekerjaan agen jangka panjang. Claude Haiku 5.5 untuk tugas bervolume tinggi yang butuh respons cepat, seperti klasifikasi, ekstraksi, dan perutean. Ada juga cara menghemat: Batch API memberi potongan 50%, dan token yang dibaca dari cache prompt jauh lebih murah daripada token masukan biasa.

Memahami cara kerja LLM juga berarti memahami di mana ia bisa salah. Ada empat batas penting:

• Pengetahuan berhenti di satu titik. Model hanya tahu apa yang ada di data latihnya. Dokumentasi Claude mencantumkan reliable knowledge cutoff, tanggal sampai mana pengetahuan model paling luas dan bisa diandalkan; untuk model Claude terbaru, Juni 2026. Untuk informasi sesudahnya atau data pribadimu, berikan lewat konteks.
• Halusinasi. Model dilatih menghasilkan teks yang masuk akal, dan teks yang masuk akal belum tentu benar. Karena itu "jujur", yaitu memberi informasi akurat tanpa mengarang dan mengakui ketidakpastian, menjadi salah satu tujuan HHH. Untuk fakta penting, beri model sumber dan minta ia merujuknya.
• Tak sepenuhnya deterministik. Pertanyaan yang sama bisa menghasilkan jawaban berbeda. Uji aplikasimu dengan banyak percobaan, seperti dibahas topik Evals & Observability.
• Konteks bukan gudang. Makin penuh, makin besar risiko context rot.

Kabar baiknya, sebagian besar batas ini bisa diatasi dengan desain aplikasi, bukan dengan model yang lebih besar. Retrieval augmented generation (RAG) memasukkan dokumen yang relevan ke konteks saat dibutuhkan. Tool use membiarkan model mengambil data terbaru atau menghitung dengan tepat. Dari sinilah bidang AI Agents dimulai.