AI Prompt Engineering · Pelajaran

Apa Itu Temperature pada LLM?

Temperature sebagai pengendali kreativitas: 0=deterministik, 2=kacau, dan semua nilai di antaranya.

Apa Itu Temperature pada LLM? adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 1 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 Prompt Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Cara LLM Memilih Token Berikutnya

Pada setiap langkah, LLM menghasilkan distribusi probabilitas atas semua token dalam kosakatanya (~50.000 token untuk GPT). Model memberikan setiap token skor yang disebut logit — angka mentah yang belum dinormalisasi. Logit yang lebih tinggi = token yang lebih mungkin dipilih.

Suhu adalah parameter yang mengontrol cara logit mentah ini diubah menjadi probabilitas sebelum pengambilan sampel.

Fungsi Softmax

Logit diubah menjadi probabilitas menggunakan fungsi softmax. Softmax menerima vektor logit dan menghasilkan distribusi probabilitas yang jumlahnya sama dengan 1.

Untuk contoh kosakata kecil dengan 4 token:

import numpy as np

# Raw logits from the model
logits = np.array([2.0, 1.0, 0.5, -1.0])  # scores for 4 tokens

# Standard softmax (temperature = 1)
def softmax(logits, temperature=1.0):
    scaled = logits / temperature
    exp_scaled = np.exp(scaled - np.max(scaled))  # subtract max for numerical stability
    return exp_scaled / exp_scaled.sum()

probs = softmax(logits, temperature=1.0)
print('Probabilities:', np.round(probs, 3))
# [0.567, 0.208, 0.129, 0.095]
# Token 0 is most likely at 56.7%

Suhu = 0: Dekode Greedy

Saat suhu mendekati 0, distribusi softmax menyusut: token dengan logit tertinggi mendapat probabilitas ~1,0, sedangkan semua token lainnya mendekati 0. Model selalu memilih satu token dengan probabilitas tertinggi.

Ini disebut dekode greedy. Prosesnya deterministik — prompt yang sama selalu menghasilkan output yang sama. Tanpa keacakan, tanpa kreativitas.

# Temperature = 0 (greedy)
probs_temp0 = softmax(logits, temperature=0.01)  # near-zero
print('Probs at T=0.01:', np.round(probs_temp0, 4))
# [~1.0, ~0.0, ~0.0, ~0.0]

# In practice, temperature=0 is implemented as argmax:
def greedy_sample(logits):
    return np.argmax(logits)  # always returns the index of the highest logit

token_idx = greedy_sample(logits)
print(f'Selected token index: {token_idx}')  # always 0

Suhu = 1: Pengambilan Sampel Standar

Suhu = 1 menerapkan softmax tanpa penskalaan — distribusi probabilitas mencerminkan tingkat keyakinan alami model. Model mengambil sampel berdasarkan probabilitas ini: token yang mungkin muncul lebih sering, sedangkan token yang tidak mungkin muncul jarang, tetapi terkadang tetap muncul.

Ini adalah bawaan untuk sebagian besar kasus penggunaan percakapan. Hasilnya bervariasi dan alami, tetapi tetap koheren.

# Temperature = 1 (standard)
probs_temp1 = softmax(logits, temperature=1.0)
print('Probs at T=1.0:', np.round(probs_temp1, 3))
# [0.567, 0.208, 0.129, 0.095]

# Sampling from this distribution:
def sample_token(probs):
    vocab = ['the', 'a', 'an', 'is']
    return np.random.choice(vocab, p=probs)

# Run 10 times to see variation
for _ in range(10):
    print(sample_token(probs_temp1), end=' ')
# Output varies each time, but 'the' appears most often

Suhu = 2: Pengambilan Sampel Kacau

Suhu tinggi (> 1) meratakan distribusi probabilitas — semua token menjadi lebih kurang sama kemungkinannya. Model menjadi tidak dapat diprediksi dan sering kali tidak koheren.

Suhu > 1,5 jarang digunakan dalam praktik. Suhu ini dapat menghasilkan output kreatif yang tidak terduga, tetapi biasanya menghasilkan omong kosong.

# Temperature = 2 (chaotic)
probs_temp2 = softmax(logits, temperature=2.0)
print('Probs at T=2.0:', np.round(probs_temp2, 3))
# [0.385, 0.261, 0.211, 0.143]
# Much flatter — the 4th token (logit=-1.0) now has 14.3% chance
# (vs 9.5% at T=1.0)

# Visualization: compare distributions
for temp in [0.1, 0.5, 1.0, 1.5, 2.0]:
    probs = softmax(logits, temperature=temp)
    print(f'T={temp}: {np.round(probs, 3)}')

Suhu sebagai Pengontrol Ketajaman

Secara konseptual, suhu mengontrol ketajaman distribusi:

Suhu rendah (0,1–0,4): puncak tajam — model yakin, memilih token yang aman dan umum
Suhu sedang (0,6–1,0): bentuk alami — kreativitas dan koherensi seimbang
Suhu tinggi (1,2–2,0): distribusi datar — model bebas menjelajahi token yang kemungkinannya rendah

Anggaplah suhu sebagai pengatur kreativitas: rendah = presisi, tinggi = berani bereksperimen.

import matplotlib
# Conceptual: what distribution shape looks like at different temps
temps = {'T=0.2 (sharp)': 0.2, 'T=1.0 (normal)': 1.0, 'T=2.0 (flat)': 2.0}
for label, temp in temps.items():
    probs = softmax(logits, temp)
    bar = '#' * int(probs[0] * 40)
    print(f'{label}: top token = {probs[0]:.1%} |{bar}|')
# T=0.2: top token = 97.2% |########################################|
# T=1.0: top token = 56.7% |######################|
# T=2.0: top token = 38.5% |###############|

Suhu dan Determinisme

Nuansa penting: temperature = 0 membuat proses sampling menjadi deterministik. Untuk temperature > 0, setiap proses menghasilkan output yang berbeda karena sampling merupakan proses acak. Distribusinya tetap, tetapi sampelnya bervariasi.

Untuk mendapatkan output yang dapat direproduksi dalam pengujian, selalu atur temperature = 0. Untuk penggunaan produksi dengan variasi yang diinginkan, gunakan seed jika API mendukungnya.

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

# Deterministic: temperature=0
resp1 = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'What is the capital of France?'}],
    temperature=0
)
resp2 = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'What is the capital of France?'}],
    temperature=0
)
print(resp1.choices[0].message.content == resp2.choices[0].message.content)  # True (usually)

Cara Suhu Berinteraksi dengan Top-p

Temperature dan top-p (nucleus sampling) sama-sama membentuk distribusi sampling, tetapi pada tahap yang berbeda:

Temperature: menskalakan logit sebelum softmax — mengubah bentuk distribusi secara keseluruhan
Top-p: memangkas distribusi menjadi massa probabilitas top-p setelah softmax — hanya melakukan sampling dari kumpulan token yang paling mungkin

Menggunakan keduanya secara bersamaan memberikan kendali yang lebih halus. Rekomendasi umumnya: sesuaikan hanya salah satunya pada satu waktu. Mengubah keduanya secara bersamaan membuat dampaknya sulit diprediksi.

# Using temperature with top_p in OpenAI API
resp = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': 'Write a one-line haiku about code.'}],
    temperature=0.9,  # moderately diverse distribution
    top_p=0.95        # sample from top 95% of probability mass
)

Nilai Suhu Praktis Berdasarkan Tugas

Referensi singkat untuk jenis tugas umum:

Tanya jawab faktual: 0 — harus akurat, tidak memerlukan variasi
Pembuatan kode: 0–0.2 — sintaks harus benar
Perangkuman: 0.3–0.5 — sedikit variasi masih dapat diterima
Obrolan / percakapan: 0.7–0.9 — respons yang alami dan bervariasi
Penulisan kreatif: 0.9–1.2 — keberagaman diinginkan
Pencurahan ide / pengembangan gagasan: 1.0–1.5 — mengeksplorasi pilihan yang tidak terduga

TEMPERATURE_PRESETS = {
    'factual_qa': 0.0,
    'code_generation': 0.1,
    'summarization': 0.4,
    'chat': 0.8,
    'creative_writing': 1.1,
    'brainstorming': 1.3
}

def call_with_preset(task_type, prompt):
    temp = TEMPERATURE_PRESETS.get(task_type, 0.7)
    return client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}],
        temperature=temp
    )

Suhu dalam API

Temperature didukung oleh semua API LLM utama. Rentang yang valid adalah 0–2 untuk OpenAI dan 0–1 untuk Anthropic Claude. Melebihi nilai maksimum akan menimbulkan error.

# OpenAI: temperature 0 to 2
client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': prompt}],
    temperature=1.2  # Valid for OpenAI
)

# Anthropic Claude: temperature 0 to 1
import anthropic
claude = anthropic.Anthropic(api_key='sk-ant-...')
claude.messages.create(
    model='claude-opus-4-5',
    max_tokens=1024,
    temperature=0.8,  # Max is 1.0 for Claude
    messages=[{'role': 'user', 'content': prompt}]
)

Ketika Suhu Saja Tidak Cukup

Temperature saja tidak selalu menghasilkan keberagaman atau ketepatan yang Anda perlukan. Jika temperature=0 masih menghasilkan output yang bervariasi (hal ini dapat terjadi pada beberapa model karena nondeterminisme bilangan titik mengambang), gunakan seed untuk mendapatkan reproduktibilitas yang sebenarnya. Jika temperature tinggi menghasilkan keluaran yang tidak masuk akal, batasi kosakata dengan top-p atau top-k alih-alih menaikkan temperature lebih jauh.

# Seed for reproducibility (OpenAI API)
resp = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': prompt}],
    temperature=0,
    seed=42  # Guarantees same output across calls on same model version
)

# Note: same output only guaranteed with same model version
# A model update can change outputs even with the same seed

Uji Pemahaman

Apa yang terjadi pada distribusi probabilitas token ketika temperature diatur ke nilai yang sangat tinggi (misalnya, 2.0)?

Ringkasan: Temperature dalam LLM

Temperature mengendalikan keacakan sampling token dengan menskalakan logit sebelum softmax:

T=0: greedy — selalu memilih token dengan probabilitas tertinggi, deterministik
T=1: standar — melakukan sampling sesuai distribusi probabilitas alami
T>1: kacau — meratakan distribusi, meningkatkan keacakan, dan mengurangi koherensi

Gunakan temperature rendah untuk tugas faktual/kode, sedang untuk obrolan, dan tinggi untuk tugas kreatif. Sesuaikan hanya temperature atau top-p pada satu waktu, bukan keduanya. Pelajaran berikutnya: top-p nucleus sampling.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Apa Itu Temperature pada LLM?” gratis?

Ya — teks lengkap “Apa Itu Temperature pada LLM?” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Prompt Engineering, upgrade ke CoddyKit PRO. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Apa Itu Temperature pada LLM?”?

Temperature sebagai pengendali kreativitas: 0=deterministik, 2=kacau, dan semua nilai di antaranya. Kamu berlatih AI Prompt Engineering 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 Prompt Engineering?

Tidak diperlukan pengalaman sebelumnya. AI Prompt Engineering 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 1 dari 4.

Berapa lama pelajaran “Apa Itu Temperature pada LLM?” 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 Prompt Engineering ini?

Ya. Setiap pelajaran AI Prompt Engineering 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

Apa Itu Temperature pada LLM?
Pengambilan Sampel Nukleus Top-p
Pengambilan Sampel Top-k
Memilih Parameter untuk Kasus Penggunaan Anda

← Kembali ke AI Prompt Engineering