0Pricing
AI Engineering Academy · Pelajaran

Mengukur Latensi LLM: TTFT dan TPOT

Definisikan waktu hingga token pertama dan waktu per token keluaran sebagai dua metrik utama latensi, tambahkan instrumentasi untuk mengukur keduanya, dan tetapkan sasaran SLA untuk setiap endpoint.

Mengukur Latensi LLM: TTFT dan TPOT adalah pelajaran AI Engineering Academy 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 Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Mengapa Latensi LLM Memiliki Dua Komponen

Mengukur latensi LLM sebagai satu angka dapat menyesatkan. Sebenarnya ada dua fase yang berbeda: waktu hingga token pertama tiba (kecepatan respons yang dirasakan), dan waktu yang diperlukan untuk menghasilkan token-token berikutnya (kecepatan keluaran). Model dapat memiliki TTFT yang sangat baik tetapi TPOT yang lambat, sehingga respons panjang terasa lamban meskipun respons awal terasa seketika.

TTFT: Waktu hingga Token Pertama

Time to First Token (TTFT) adalah durasi sejak permintaan API dikirim hingga token pertama respons diterima. Durasi ini mencakup latensi jaringan, waktu antrean di server inferensi, dan waktu prefilling (pemrosesan token input). TTFT sangat menentukan kecepatan respons yang dirasakan — pengguna akan menyadari jika tidak ada yang muncul selama lebih dari 1–2 detik, terlepas dari seberapa cepat token mengalir setelahnya.

import time
from openai import OpenAI

client = OpenAI()

def measure_ttft(prompt: str) -> float:
    start = time.perf_counter()
    first_token_time = None
    stream = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}],
        stream=True
    )
    for chunk in stream:
        if chunk.choices[0].delta.content:
            first_token_time = time.perf_counter()
            break  # stop after first token
    return first_token_time - start

TPOT: Waktu per Token Keluaran

Time Per Output Token (TPOT) adalah waktu rata-rata antara token-token berturut-turut setelah pembuatan dimulai. Nilai ini dihitung sebagai total waktu pembuatan dibagi total token keluaran. TPOT menentukan kecepatan membaca — manusia membaca sekitar 250 kata per menit, sehingga TPOT di atas 100 md per token (10 token/detik) akan terasa jelas lambat untuk respons panjang.

import time
from openai import OpenAI

client = OpenAI()

def measure_tpot(prompt: str) -> dict:
    start = time.perf_counter()
    first_token_time = None
    token_count = 0
    stream = client.chat.completions.create(
        model='gpt-4o',
        messages=[{'role': 'user', 'content': prompt}],
        stream=True
    )
    for chunk in stream:
        delta = chunk.choices[0].delta.content or ''
        if delta:
            if first_token_time is None:
                first_token_time = time.perf_counter()
            token_count += 1
    end = time.perf_counter()
    ttft = first_token_time - start
    generation_time = end - first_token_time
    tpot = generation_time / max(token_count, 1)
    return {'ttft_ms': ttft * 1000, 'tpot_ms': tpot * 1000, 'tokens': token_count}

Latensi Total vs TTFT vs TPOT

Hubungan antara metrik-metrik ini adalah: total_latency = TTFT + (output_tokens × TPOT). Untuk respons sepanjang 500 token dengan TPOT 50 md, pembuatan memerlukan waktu 25 detik. Untuk aplikasi streaming, optimalkan TTFT terlebih dahulu — pengguna lebih dapat menerima streaming yang lambat daripada layar kosong. Untuk pemrosesan kumpulan tanpa streaming, latensi total adalah hal yang penting, jadi optimalkan TPOT dengan memilih model yang inferensinya lebih cepat.

# Latency breakdown for a 200-token response
ttft_ms = 450       # half a second to first token
tpot_ms = 25        # 25ms per token = 40 tokens/sec
output_tokens = 200

total_latency = ttft_ms + (tpot_ms * output_tokens)
print(f'TTFT:  {ttft_ms}ms')
print(f'Generation: {tpot_ms * output_tokens}ms')
print(f'Total: {total_latency}ms ({total_latency/1000:.1f}s)')
# Output:
# TTFT:  450ms
# Generation: 5000ms
# Total: 5450ms (5.5s)

Faktor yang Memengaruhi TTFT

TTFT terutama dipengaruhi oleh biaya prefilling, yang meningkat seiring jumlah token input. Prompt sistem sepanjang 10.000 token akan memiliki TTFT 10 kali lebih tinggi daripada prompt sepanjang 1.000 token, jika faktor lainnya sama. Faktor lain mencakup beban server (waktu antrean), waktu pulang-pergi jaringan ke titik akhir API, dan apakah penyimpanan cache prompt mengurangi pekerjaan prefilling yang efektif. Minimalkan panjang prompt sistem untuk mengurangi TTFT.

# TTFT scales approximately linearly with input tokens
# Measured typical values for gpt-4o (2026):
# 500 input tokens:   ~400ms TTFT
# 2000 input tokens:  ~600ms TTFT
# 10000 input tokens: ~1500ms TTFT
# 32000 input tokens: ~4000ms TTFT

# Use prompt caching to avoid paying for repeated long prefixes:
# Cached tokens: ~200ms saved per 1000 cached tokens

Faktor yang Memengaruhi TPOT

TPOT terutama ditentukan oleh ukuran model dan perangkat keras. Model yang lebih kecil (GPT-4o-mini) melakukan dekode jauh lebih cepat daripada model besar (GPT-4o). Pada model yang dihosting sendiri, ukuran kumpulan dan bandwidth memori GPU merupakan faktor utama. Pada model yang dihosting OpenAI, TPOT bervariasi sesuai beban server, tetapi biasanya berkisar antara 15–40 md per token. Anda tidak dapat mengendalikan TPOT secara langsung pada API yang dihosting — pemilihan model adalah kendali utama Anda.

# Typical TPOT benchmarks (approximate, 2026):
# gpt-4o-mini:   15-20ms per token (50-65 tokens/sec)
# gpt-4o:        25-40ms per token (25-40 tokens/sec)
# claude-3.5-haiku: 20-25ms per token
# claude-3.5-sonnet: 30-50ms per token
# local llama-3.1-8B on A100: 8-12ms per token
# local llama-3.1-70B on 4xA100: 25-35ms per token

Menetapkan Target SLA per Titik Akhir

Tidak semua endpoint memerlukan target latensi yang sama. Endpoint chat memiliki SLA TTFT yang ketat (pengguna mengharapkan <500 md), sedangkan endpoint peringkasan batch dapat menoleransi latensi beberapa detik. Tentukan target SLA untuk setiap endpoint secara eksplisit dan ukur masing-masing secara terpisah. Target umum: chat interaktif = p95 TTFT <600 md, ekstraksi dokumen = total p95 <10 dtk, batch = tidak memiliki SLA waktu nyata.

SLA_TARGETS = {
    'chat':       {'ttft_p95_ms': 600,  'total_p95_ms': 8000},
    'extraction': {'ttft_p95_ms': 1500, 'total_p95_ms': 10000},
    'summary':    {'ttft_p95_ms': 2000, 'total_p95_ms': 30000},
    'batch':      {'ttft_p95_ms': None, 'total_p95_ms': None},
}

Mencatat Metrik Latensi

Catat TTFT dan TPOT untuk setiap permintaan produksi menggunakan pencatatan terstruktur. Sertakan nama model, endpoint, jumlah token perintah, jumlah token keluaran, dan apakah terjadi hit tembolok. Dengan demikian, Anda dapat menghitung distribusi persentil (p50, p95, p99), menemukan kemunduran setelah pembaruan model, serta menghubungkan lonjakan latensi dengan kedalaman antrean atau insiden penyedia.

import structlog

log = structlog.get_logger()

def log_latency(endpoint: str, model: str, metrics: dict):
    log.info(
        'llm_latency',
        endpoint=endpoint,
        model=model,
        ttft_ms=round(metrics['ttft_ms'], 1),
        tpot_ms=round(metrics['tpot_ms'], 1),
        output_tokens=metrics['tokens'],
        total_ms=round(metrics['ttft_ms'] + metrics['tpot_ms'] * metrics['tokens'], 1)
    )

Menghitung Persentil dari Sampel

Rata-rata mentah dapat menyesatkan untuk latensi—beberapa pencilan yang lambat dapat menaikkan mean tanpa memengaruhi sebagian besar pengguna. Selalu laporkan persentil p50, p95, dan p99. P95 adalah metrik SLA yang paling umum: artinya 95% permintaan selesai dalam waktu tersebut. Gunakan NumPy atau modul statistics untuk menghitung persentil dari sampel latensi yang Anda catat.

import numpy as np

def compute_percentiles(samples: list, label: str = 'latency_ms'):
    arr = np.array(samples)
    stats = {
        'count': len(arr),
        'p50': np.percentile(arr, 50),
        'p95': np.percentile(arr, 95),
        'p99': np.percentile(arr, 99),
        'mean': np.mean(arr),
        'max': np.max(arr)
    }
    print(f'{label}:')
    for k, v in stats.items():
        print(f'  {k}: {v:.1f}')
    return stats

Mengurangi Latensi dengan max_tokens

Menetapkan batas max_tokens yang sesuai mengurangi latensi total terburuk dengan mencegah respons panjang yang tidak terkendali. Jika kasus penggunaan Anda memerlukan jawaban paling banyak 200 token, tetapkan max_tokens=250. Ini juga membatasi biaya. Gabungkan dengan pengaliran agar pengguna segera melihat keluaran sementara respons lengkap masih dibuat. Jangan pernah membiarkan max_tokens tidak terbatas pada endpoint produksi.

response = client.chat.completions.create(
    model='gpt-4o',
    messages=[{'role': 'user', 'content': question}],
    max_tokens=300,  # cap at 300 tokens
    stream=True
)

# With max_tokens=300 and TPOT=30ms:
# worst-case total generation = 9000ms
# Without limit: could run to 4096+ tokens = 123s+

Prioritas Pengoptimalan Latensi

Saat latensi terlalu tinggi, tangani hambatan sesuai urutan prioritas. Pertama, aktifkan pengaliran agar pengguna segera melihat keluaran meskipun latensi total tinggi. Kedua, persingkat perintah sistem untuk mengurangi TTFT. Ketiga, tambahkan tembolok awalan perintah untuk membagi biaya pra-pengisian pada permintaan berulang. Keempat, beralih ke model yang lebih kecil jika kualitas tetap memadai. Terakhir, pertimbangkan inferensi yang dihosting sendiri untuk memperoleh kendali maksimum atas TTFT dan TPOT.

# Latency optimization checklist (in priority order):
# 1. Enable streaming (perceived latency: immediate)
# 2. Shorten system prompt by 50% (TTFT: -20%)
# 3. Enable prompt prefix caching (TTFT: -40% on cache hits)
# 4. Downgrade to gpt-4o-mini for simple queries (TPOT: -40%)
# 5. Self-host llama-3.1-8B for high-volume simple queries
#    (TPOT: 8ms vs 25ms; TTFT: 100ms vs 450ms)

Pemeriksaan Cepat

Uji pemahaman Anda tentang TTFT dan TPOT sebagai metrik latensi LLM.

Ringkasan Pelajaran

Dalam pelajaran ini Anda mempelajari: TTFT (Time to First Token) mengukur daya tanggap yang dirasakan dan meningkat seiring jumlah token masukan, TPOT (Time Per Output Token) menentukan kecepatan pembuatan dan terutama dikendalikan oleh ukuran model, serta target SLA per endpoint dengan metrik persentil merupakan cara yang tepat untuk memantau latensi dalam produksi. Selanjutnya, kita akan menerapkan penyeimbangan beban pada beberapa kunci API.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Mengukur Latensi LLM: TTFT dan TPOT” gratis?

Ya — teks lengkap “Mengukur Latensi LLM: TTFT dan TPOT” 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 “Mengukur Latensi LLM: TTFT dan TPOT”?

Definisikan waktu hingga token pertama dan waktu per token keluaran sebagai dua metrik utama latensi, tambahkan instrumentasi untuk mengukur keduanya, dan tetapkan sasaran SLA untuk setiap endpoint. 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 1 dari 4.

Berapa lama pelajaran “Mengukur Latensi LLM: TTFT dan TPOT” 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

  1. Mengukur Latensi LLM: TTFT dan TPOT
  2. Penyeimbangan Beban dan Strategi Banyak Kunci
  3. Penyedia Cadangan dan Pemutus Sirkuit
  4. Anggaran Batas Waktu dan Penurunan Layanan yang Terkendali
← Kembali ke AI Engineering Academy