Model Penalaran Dilatih, Bukan Sekadar Di-prompt

Ini opini yang dulu saya pertahankan dengan kurang meyakinkan saat makan siang tim tahun lalu, dan sejak itu saya makin yakin: kalau model mental kamu tentang reasoning model adalah “LLM biasa yang disuruh berpikir langkah demi langkah”, kamu sebenarnya belum paham reasoning model, dan kesalahpahaman itu diam-diam merugikan uang dan akurasi kamu di production. Reasoning model bukan teknik prompting. Itu adalah artefak training. Perilaku chain-of-thought yang membuat mereka jago matematika dan coding muncul dari reinforcement learning dengan verifiable rewards, bukan dari apa pun yang kamu tulis di system prompt. Saya akhirnya benar-benar memahami ini saat mengerjakan materi yang sama dengan yang dibahas Sebastian Raschka dalam kursus baru 11 jam-nya tentang membangun reasoning model: memuat model dasar Qwen3 yang kecil, membangun verifier, menjalankan GRPO, lalu melihat jejak penalaran makin panjang dan akurasinya naik. Begitu kamu melihatnya terjadi di training loop sendiri, kamu tidak bisa lagi pura-pura tidak melihatnya.

Biar saya pertahankan klaim ini dengan benar, lalu saya tarik kembali di bagian yang memang perlu ditarik, karena ada satu tempat di mana prompting benar-benar penting, dan pura-pura sebaliknya juga akan jadi hype dengan rasa yang berbeda.

Mengapa model mental “tinggal di-prompt” itu runtuh

Cerita populernya begini: di 2022, peneliti menemukan bahwa menambahkan “Let's think step by step” ke prompt secara dramatis meningkatkan akurasi aritmetika, dan chain-of-thought prompting pun lahir. Benar sejauh itu. Yang dilewatkan cerita ini adalah apa yang terjadi berikutnya: lab-lab mengambil perilaku itu dan menanamkannya ke dalam bobot model dengan reinforcement learning. Model reasoning modern tidak butuh mantra step-by-step darimu. Ia menghasilkan jejak penalaran yang panjang secara default karena ia dilatih untuk itu, diberi reward untuk menghasilkan jejak yang berakhir dengan jawaban benar.

Kamu bisa memverifikasinya sendiri dengan eksperimen yang butuh satu sore. Ambil model dasar, misalnya Qwen3 0.6B yang cukup oke dan bisa jalan di satu GPU konsumen, lalu evaluasi di MATH-500 dengan dan tanpa prompting chain-of-thought. Kamu akan dapat kenaikan yang sedang. Sekarang ambil varian RLVR dari keluarga model yang sama. Selisih antara dua kondisi itu bukan kenaikan; itu jurang. Tidak ada system prompt yang pernah ditulis yang bisa menutupnya. Itulah inti empiris klaim saya: kemampuannya ada di bobot, dan bobot itu terbentuk lewat training, bukan lewat susunan token yang pintar saat inference.

Kebingungannya terus ada karena dari luar, keduanya terlihat sama: model mengeluarkan aliran panjang penalaran perantara sebelum menjawab. Tapi kemiripan permukaan menyembunyikan perbedaan kausal. Meminta model dasar berpikir langkah demi langkah itu seperti menyuruh seseorang menceritakan proses berpikirnya saat berhitung di kepala: narasinya mengikuti kemampuan. Training RL justru mengubah kemampuannya sendiri, karena model dioptimasi secara end-to-end untuk ketepatan jawaban, dan penalaran panjang kebetulan menjadi strategi yang berguna secara instrumental untuk mendapatkan jawaban benar pada soal sulit.

Verifier adalah triknya

Waktu saya masih jadi ML engineer, bagian RLHF yang selalu terasa agak “terkutuk” adalah reward model. Kamu melatih jaringan saraf terpisah untuk meniru preferensi manusia, lalu mengoptimasi policy terhadapnya, lalu menghabiskan sisa proyek untuk melawan reward hacking: policy menemukan output degenerate yang skornya tinggi di mata reward model tapi tidak berguna bagi manusia sungguhan. Ini relasi adversarial yang sudah tertanam di arsitekturnya.

Reinforcement learning dengan verifiable rewards, atau RLVR, menghindari masalah ini sepenuhnya, dan membangun verifier dari nol membuat kamu menghargai betapa elegannya langkah ini. Untuk matematika, verifier-nya adalah program deterministik yang membosankan: ekstrak jawaban akhir dari output model, normalisasi (tangani pecahan, desimal, dan bentuk setara seperti 1/2 vs 0.5), lalu cek kesetaraan matematisnya. Jawaban benar, reward satu. Jawaban salah, nol. Tidak ada reward model yang bisa di-hack. Sinyal rewardnya adalah ground truth.

Inilah alasan reasoning model lebih dulu jago matematika dan coding. Kedua domain ini punya verifier yang murah dan andal: pengecek kesetaraan simbolik untuk matematika, unit test untuk coding. Kamu tidak butuh anotator manusia yang meranking output; kamu butuh fungsi Python yang mengembalikan boolean. Konsekuensi praktisnya untuk siapa pun yang membangun penalaran khusus domain cukup jelas: kalau kamu bisa menulis verifier untuk domainmu, kemungkinan besar kamu bisa melatih reasoner untuknya. Kalau tidak bisa, misalnya karena ketepatan di domainmu soal selera seperti copywriting, kamu terjebak dengan RLHF dan segala sakit kepala reward hacking-nya.

Hambatan penalaran di domain baru bukan compute atau data. Hambatannya adalah apakah kamu bisa menuliskan apa arti “benar” sebagai sebuah program.

Satu detail yang saya suka dari membangun verifier dulu, sebelum training apa pun: ia bekerja ganda. Grader yang sama yang menilai model dasarmu di MATH-500 untuk evaluasi menjadi fungsi reward saat RL. Saat kamu mengimplementasikannya sendiri, kamu sadar betapa banyak pekerjaan halus yang dilakukannya. Ekstraksi jawaban itu benar-benar rumit, karena model menyatakan jawaban akhir dalam puluhan format, dan extractor yang rapuh diam-diam merusak sinyal reward-mu. Model yang menulis “maka x = 7” bisa salah dinilai kalau regex-mu hanya mencari jawaban yang di-box. Verifier yang sembrono mengajarkan policy yang sembrono. Ini jenis pelajaran yang tidak akan kamu dapat hanya dari membaca paper.

Apa yang sebenarnya dilakukan GRPO pada bobot

Training loop-nya sendiri, dalam bentuk from-scratch yang disederhanakan, ternyata cukup ringkas. Group Relative Policy Optimization, algoritma yang dipopulerkan DeepSeek, membuang critic network yang membuat PPO boros memori. Alih-alih mempelajari value function, kamu menghasilkan grup respons untuk prompt yang sama, memberi skor semuanya dengan verifier, lalu menghitung advantage tiap respons relatif terhadap rata-rata grup. Respons yang lebih baik dari rata-rata grup probabilitas tokennya didorong naik; yang lebih buruk didorong turun.

def grpo_advantages(rewards: torch.Tensor) -> torch.Tensor:
# rewards: [group_size], one per sampled response to the same prompt
mean = rewards.mean()
std = rewards.std().clamp_min(1e-4)
return (rewards - mean) / std  # relative advantage per response
# Training step: maximize advantage-weighted log-probability
def grpo_loss(logprobs: torch.Tensor, advantages: torch.Tensor) -> torch.Tensor:
# logprobs: summed sequence log-prob under the current policy
return -(advantages.detach() * logprobs).mean()

Implementasi nyata menambahkan penalti KL agar policy tidak melenceng terlalu jauh dari reference model, plus clipping yang dipinjam dari PPO, tapi kerangka di atas jujur saja adalah ide intinya. Dan inilah yang membuatnya terasa magis untuk ditonton: kamu tidak memberi tahu model apa pun tentang gaya penalaran. Kamu hanya memberi reward pada jawaban akhir yang benar. Namun seiring training, panjang respons bertambah. Model mulai membuat koreksi diri di tengah jejak, seperti “tunggu, saya cek lagi”, karena jejak dengan perilaku verifikasi lebih mungkin berakhir dengan jawaban benar, dan jawaban benar adalah satu-satunya yang mendapat reward. Gaya chain-of-thought adalah solusi yang muncul dengan sendirinya untuk masalah optimasi, bukan perilaku yang sengaja direkayasa siapa pun. Makanya saya bilang ini dilatih, bukan di-prompt: versi era prompting dari perilaku ini adalah manusia yang meniru apa yang kemudian ditemukan RL sendiri.

Ada catatan engineering pragmatis yang terkubur di sini dan dilewatkan siklus hype: model 0.6B dengan GPU yang lumayan sudah cukup untuk melihat dinamika ini secara nyata. Kamu akan mendapat peningkatan MATH-500 yang terukur dari GRPO di hardware yang bisa disewa beberapa dolar per jam. Kamu tidak akan mendapat model frontier. Tidak apa-apa, karena memang bukan itu tujuan latihannya.

Inference-time scaling: ketika compute menggantikan training (sebagian)

Sebelum RL apa pun terjadi, ada sekumpulan teknik yang memperbaiki jawaban dengan bobot yang dibekukan: ambil sampel beberapa kandidat dengan temperature dan top-p, lalu gabungkan. Self-consistency adalah kuda pekerjanya: hasilkan k jawaban, ambil voting mayoritas dari jawaban akhir. Caranya berhasil luar biasa, dan ia juga bekerja pada model dasar, yang merupakan retakan pertama pada klaim pembuka saya yang akan saya akui: compute saat inference adalah sumbu peningkatan yang nyata dan ortogonal.

Tapi lihat apa yang sebenarnya dibutuhkan teknik-teknik ini. Majority voting hanya membantu kalau model sudah punya probabilitas non-trivial untuk menghasilkan jawaban benar. Voting memperkuat sinyal yang sudah ada, bukan menciptakan sinyal dari nol. Seleksi berbasis skor, yaitu meranking kandidat berdasarkan log-probability sekuens, punya sifat yang sama. Dan loop self-refinement, di mana model mengkritik lalu merevisi jawabannya sendiri, ternyata lemah mengecewakan pada model dasar, karena self-critique yang jujur adalah kemampuan yang juga dipasang oleh RL. Setiap trik inference-time bisa dikombinasikan dengan training; tidak ada yang menggantikannya. Alasan sistem frontier menggabungkan model yang dilatih RL dengan inference scaling adalah karena keduanya saling mengalikan, bukan menjumlahkan.

Sisi biaya penting bagi praktisi. Self-consistency dengan k=16 memakan biaya inference enam belas kali lipat. Apakah itu trade-off yang bagus sepenuhnya bergantung pada kurva akurasi-per-dolar kamu, dan satu-satunya cara jujur untuk menjawabnya adalah memplot akurasi MATH-500 terhadap jumlah kandidat sendiri. Kami pernah membahas pertanyaan penempatan compute yang mirip dalam ulasan kami tentang model kelas flash dan efisiensi inference. Tema yang berulang adalah bahwa “menghabiskan lebih banyak compute” punya setidaknya tiga arti berbeda, dan ketiganya tidak bisa saling dipertukarkan.

Distilasi, dan satu-satunya tempat prompting bertahan

Tahap terakhir dalam pipeline from-scratch adalah distilasi: ambil jejak penalaran panjang dari reasoner kuat, yang biasanya berukuran besar, dan fine-tune model yang lebih kecil langsung di atasnya dengan supervised learning biasa. Tanpa RL, tanpa verifier dalam loop. Begitulah banyak model reasoning kecil dan murah yang akan kamu deploy dibuat. Ini justru memperkuat tesisnya, bukan melemahkannya: perilaku penalaran tetap berasal dari data training yang dihasilkan model yang dilatih RL, hanya saja ditransfer lewat gradient descent alih-alih reward. Kemampuannya tidak pernah disuntikkan saat prompt; selalu ditanamkan oleh optimasi.

Jadi di mana klaim kontrarian saya runtuh? Jujur saja: prompting masih penting di pinggirannya, dan pinggiran itu tidak nol. Kontrol effort penalaran, yaitu pengaturan thinking budget rendah, sedang, atau tinggi yang diekspos model generasi sekarang, adalah tuas inference-time yang secara bermakna menukar akurasi dengan latensi dan biaya. Constraint output terstruktur, pipeline dengan verifier dalam loop, dan constrained decoding semuanya adalah teknik level prompt dan harness dengan nilai nyata, seperti yang kami bahas dalam tulisan kami tentang constrained decoding. Dan kalau kamu terpaksa memakai model dasar dan tidak bisa melatih apa pun, chain-of-thought prompting tetap layak menambah poin di eval. “Dilatih, bukan di-prompt” adalah klaim tentang di mana kemampuan itu berasal, bukan klaim bahwa pilihan saat inference tidak penting.

Mengapa membangunnya lebih baik daripada hanya membacanya

Keberatan yang wajar muncul di tempat-tempat biasa: bukankah tutorial membangun reasoning model sendiri itu seperti panduan membangun CPU sendiri, menyenangkan tapi tidak berguna, mengingat training sungguhan butuh cluster dan data proprietary? Menurut saya ini melewatkan tujuan latihannya, dan saya akan bilang hal yang sama tentang tutorial klasik membangun shell, yang kami puji dalam What Building a Shell Teaches You About Unix justru karena alasan ini. Tidak ada yang menulis shell untuk menggantikan bash. Kamu menulisnya karena fork, exec, pipe, dan signal handling berhenti menjadi abstraksi yang sekadar dihafal dan berubah menjadi mesin yang benar-benar pernah kamu pegang.

Hal yang sama berlaku di sini. Hal-hal yang secara permanen mengubah cara saya bekerja dengan reasoning model datang dari detail implementasi, bukan dari paper:

• Menulis verifier mengajarkan saya bahwa kualitas reward adalah masalah rekayasa perangkat lunak. Kasus tepi normalisasi diam-diam mendistorsi training, dan “reward adalah ground truth” hanya benar selama extractor jawabanmu benar.
• Mengimplementasikan scoring log-probability sekuens, dengan akrobat stabilitas numerik yang menyertainya, membuat setengah fungsi loss di literatur post-training jadi jelas. Semuanya pada dasarnya membandingkan seberapa mungkin respons di bawah policy yang berbeda.
• Melihat panjang respons bertambah selama GRPO, tanpa di-prompt, menghancurkan sisa keyakinan terakhir saya bahwa gaya penalaran hanyalah perilaku permukaan. Itu adalah yang ditemukan optimasi ketika ketepatan adalah satu-satunya tujuan.
• Memplot akurasi terhadap jumlah kandidat untuk self-consistency memberi saya intuisi nyata tentang trade-off akurasi-per-dolar yang tidak pernah bisa diberikan oleh tabel benchmark mana pun.

Kekhawatiran soal compute juga terlalu dibesar-besarkan untuk tujuan belajar. Bagian awalnya, yaitu memuat model dasar, streaming generasi dengan KV caching, membangun verifier, dan menjalankan MATH-500, adalah wilayah laptop dan CPU atau mendekatinya. Training GRPO butuh GPU, tapi cukup satu, dan jika disewa per jam, biayanya lebih murah daripada kebanyakan buku teks. Yang tidak bisa direplikasi di rumah adalah skala, dan skala memang disiplin yang berbeda. Itu salah satu mitos tentang inference engine DeepSeek yang kami uji: serving stack sebuah lab frontier memecahkan masalah yang sama sekali tidak ada di skala tutorial, dan sebaliknya.

Kesimpulan praktisnya

Kalau kamu hanya ambil satu hal dari semua ini, ambil cara pandang yang berpusat pada verifier. Stack reasoning modern adalah: model dasar, program yang memutuskan apa arti “benar”, algoritma RL yang mengoptimasi terhadapnya, dan teknik inference-time yang melipatgandakan hasilnya. Prompting berada di tepi paling luar sistem itu, mengarahkan kemampuan yang diciptakan training. Tim yang memahami ini menaruh usahanya di tempat yang berlipat ganda: verifier yang lebih baik, desain reward yang lebih baik, dan loop evaluasi yang lebih baik seperti yang sudah kami argumentasikan kurang di sebagian besar benchmark AI yang melewatkan pekerjaan nyata. Tim yang tidak memahami ini terus mengutak-atik system prompt dan heran kenapa akurasinya mandek.

Klaim saya di meja makan siang tetap bertahan dengan satu catatan kaki: reasoning model dilatih, bukan di-prompt, tetapi harness yang kamu bangun di sekelilingnya, termasuk prompt-nya, menentukan seberapa banyak kemampuan terlatih itu benar-benar bisa kamu panen. Bangun versi kecilnya sendiri suatu saat nanti. Sebelas jam mengikuti kode adalah harga yang murah untuk tidak pernah bingung soal ini lagi.