Peringatan untuk Latensi, Biaya, dan Penurunan Kualitas
Tentukan ambang peringatan untuk latensi p99, biaya per permintaan, dan skor kualitas otomatis, lalu arahkan peringatan ke Slack atau PagerDuty ketika alur pemrosesan LLM Anda mengalami penurunan.
Peringatan untuk Latensi, Biaya, dan Penurunan Kualitas adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 4 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 Peringatan Penting bagi Sistem LLM
Aplikasi LLM dapat gagal dengan cara yang samar dan bertahap. Perubahan prompt mungkin meningkatkan latensi rata-rata sebesar 30%, peningkatan pengambilan mungkin sedikit menurunkan kualitas jawaban, atau lonjakan penggunaan mungkin mendorong biaya harian menjadi 5 kali lipat dari anggaran. Tanpa peringatan proaktif, Anda baru mengetahui masalah ini ketika pengguna mengeluh atau tagihan bulanan tiba. Peringatan mengubah penanganan masalah secara reaktif menjadi operasi proaktif.
Tiga Kategori Peringatan
Peringatan aplikasi LLM terbagi menjadi tiga kategori. Peringatan latensi dipicu ketika waktu respons melebihi ambang pengalaman pengguna (misalnya, p99 > 10 detik). Peringatan biaya dipicu ketika biaya per permintaan atau pengeluaran harian melebihi ambang anggaran, sehingga mencegah kejutan tagihan. Peringatan kualitas dipicu ketika metrik kualitas otomatis (skor LLM sebagai penilai, tingkat kepuasan pengguna, dan skor kesetiaan) turun di bawah batas minimum yang dapat diterima. Setiap kategori memerlukan instrumentasi dan saluran peringatan yang berbeda.
from dataclasses import dataclass
@dataclass
class AlertThresholds:
# Latency (milliseconds)
p50_latency_ms: int = 2000 # median should be under 2s
p99_latency_ms: int = 10000 # 99th percentile under 10s
# Cost (USD)
max_cost_per_request: float = 0.05 # alert if one request costs > 5 cents
max_daily_spend: float = 50.00 # alert if daily spend exceeds $50
# Quality (0.0 to 1.0 scale)
min_quality_score: float = 0.75 # alert if rolling avg drops below 75%
min_faithfulness: float = 0.80 # alert if RAGAS faithfulness drops below 80%
DEFAULT_THRESHOLDS = AlertThresholds()Mengumpulkan Metrik Latensi
Untuk membuat peringatan latensi, Anda harus mengumpulkan data tersebut secara konsisten terlebih dahulu. Ukur tiga komponen latensi secara terpisah: waktu hingga token pertama (TTFT, penting untuk pengalaman pengguna saat streaming), total waktu respons, serta latensi per langkah untuk pengambilan dan generasi. Simpan data ini sebagai data deret waktu (satu titik data per permintaan) agar Anda dapat menghitung persentil dan rata-rata bergerak selama N menit atau jam terakhir.
import time
from collections import deque
from statistics import quantiles
class LatencyTracker:
def __init__(self, window_size=100):
self.window = deque(maxlen=window_size) # rolling window of latencies
def record(self, latency_ms: float):
self.window.append(latency_ms)
def p50(self) -> float:
if not self.window:
return 0
return quantiles(self.window, n=100)[49]
def p99(self) -> float:
if not self.window:
return 0
return quantiles(self.window, n=100)[98]
def check_alert(self, thresholds: AlertThresholds) -> list[str]:
alerts = []
if self.p99() > thresholds.p99_latency_ms:
alerts.append(f'p99 latency {self.p99():.0f}ms exceeds {thresholds.p99_latency_ms}ms')
if self.p50() > thresholds.p50_latency_ms:
alerts.append(f'p50 latency {self.p50():.0f}ms exceeds {thresholds.p50_latency_ms}ms')
return alerts
latency_tracker = LatencyTracker()Melacak dan Memberi Peringatan tentang Biaya
Pemantauan biaya memerlukan pelacakan pengeluaran pada beberapa tingkat perincian: biaya per permintaan (untuk menangkap kueri tidak biasa yang mahal), total per jam dan per hari (untuk menangkap lonjakan penggunaan), serta biaya per fitur (untuk mengidentifikasi bagian aplikasi yang paling mahal). Segera berikan peringatan untuk anomali biaya per permintaan, dan gunakan pemeriksaan terjadwal untuk batas anggaran harian.
from datetime import datetime, date
import threading
class CostTracker:
def __init__(self):
self._lock = threading.Lock()
self._daily_spend = {} # date -> total USD
self._per_request = [] # list of (timestamp, cost)
def record(self, cost_usd: float) -> list[str]:
today = date.today().isoformat()
alerts = []
with self._lock:
# Track daily spend
self._daily_spend[today] = self._daily_spend.get(today, 0) + cost_usd
self._per_request.append((datetime.now(), cost_usd))
# Alert on expensive single requests
if cost_usd > DEFAULT_THRESHOLDS.max_cost_per_request:
alerts.append(f'Expensive request: ${cost_usd:.4f} (threshold: ${DEFAULT_THRESHOLDS.max_cost_per_request})')
# Alert on daily budget exceeded
daily_total = self._daily_spend[today]
if daily_total > DEFAULT_THRESHOLDS.max_daily_spend:
alerts.append(f'Daily budget exceeded: ${daily_total:.2f} > ${DEFAULT_THRESHOLDS.max_daily_spend}')
return alerts
cost_tracker = CostTracker()Peringatan Skor Kualitas
Peringatan kualitas adalah kategori yang paling rumit karena kualitas tidak dapat diukur hanya dari metrik infrastruktur — diperlukan evaluasi semantik. Pendekatan yang paling mudah diskalakan adalah evaluasi otomatis berbasis sampel: untuk sampel acak permintaan produksi (5–10%), jalankan evaluator LLM sebagai penilai secara asinkron, simpan skornya, lalu hitung rata-rata bergerak. Berikan peringatan ketika rata-rata bergerak turun di bawah batas minimum kualitas Anda.
import random
from openai import OpenAI
client = OpenAI()
def evaluate_response_quality(question: str, answer: str) -> float:
judge_prompt = f'''Rate the quality of this AI assistant response on a scale from 0 to 1.
Question: {question}
Answer: {answer}
Return only a JSON object: {{"score": 0.85, "reason": "brief reason"}}
Scoring guide:
1.0 = Perfect, accurate, helpful
0.75 = Good, minor issues
0.5 = Acceptable but incomplete
0.25 = Poor, major gaps
0.0 = Completely wrong or harmful'''
response = client.chat.completions.create(
model='gpt-4o-mini', # cheaper model for evaluation
messages=[{'role': 'user', 'content': judge_prompt}],
response_format={'type': 'json_object'}
)
import json
result = json.loads(response.choices[0].message.content)
return float(result['score'])
def maybe_evaluate(question: str, answer: str, sample_rate=0.1):
if random.random() < sample_rate:
score = evaluate_response_quality(question, answer)
quality_tracker.record(score)
return score
return NoneRata-Rata Bergerak untuk Mendeteksi Tren
Satu respons yang buruk tidak menunjukkan masalah sistemik. Gunakan rata-rata bergerak selama jendela waktu tertentu (misalnya, 1 jam terakhir atau 100 permintaan terakhir) untuk mendeteksi tren. Rata-rata bergerak yang melewati ambang batas dan tetap berada di sana selama lebih dari 10 menit menunjukkan masalah nyata, sedangkan lonjakan singkat mungkin hanya derau. Rata-rata bergerak berbobot eksponensial (EWMA) merespons perubahan terbaru lebih cepat daripada rata-rata bergerak biasa.
class RollingQualityMonitor:
def __init__(self, window=50, alert_threshold=0.75, ewma_alpha=0.1):
self.scores = []
self.window = window
self.alert_threshold = alert_threshold
self.alpha = ewma_alpha # EWMA decay factor
self.ewma_score = None
def record(self, score: float):
self.scores.append(score)
if len(self.scores) > self.window:
self.scores.pop(0)
# Update exponentially weighted moving average
if self.ewma_score is None:
self.ewma_score = score
else:
self.ewma_score = self.alpha * score + (1 - self.alpha) * self.ewma_score
def should_alert(self) -> bool:
if len(self.scores) < 10: # not enough data yet
return False
return self.ewma_score < self.alert_threshold
def summary(self) -> dict:
if not self.scores:
return {}
return {
'rolling_avg': sum(self.scores) / len(self.scores),
'ewma': self.ewma_score,
'sample_count': len(self.scores),
'alert': self.should_alert()
}
quality_tracker = RollingQualityMonitor()Perutean Peringatan: Slack dan PagerDuty
Peringatan hanya berguna jika sampai kepada orang yang tepat melalui saluran yang tepat. Rutekan peringatan berdasarkan tingkat keparahan: peringatan penurunan kualitas dan anggaran biaya dikirim ke kanal Slack yang dipantau tim Anda selama jam kerja. Peringatan latensi di atas ambang kritis (misalnya, p99 > 30 detik) dan lonjakan biaya mendadak (misalnya, 10 kali lipat dari normal dalam 5 menit) dikirim ke PagerDuty untuk eskalasi segera kepada petugas yang sedang berjaga.
import requests
def send_slack_alert(message: str, severity: str, webhook_url: str):
color = {'critical': '#ff0000', 'warning': '#ff9900', 'info': '#36a64f'}[severity]
payload = {
'attachments': [{
'color': color,
'title': f'LLM Alert [{severity.upper()}]',
'text': message,
'footer': 'AI Pipeline Monitor'
}]
}
requests.post(webhook_url, json=payload)
def send_pagerduty_alert(title: str, details: str, routing_key: str):
payload = {
'routing_key': routing_key,
'event_action': 'trigger',
'payload': {
'summary': title,
'severity': 'critical',
'source': 'ai-pipeline-monitor',
'custom_details': {'details': details}
}
}
requests.post('https://events.pagerduty.com/v2/enqueue', json=payload)
def route_alert(alert_text: str, severity: str):
send_slack_alert(alert_text, severity, SLACK_WEBHOOK_URL)
if severity == 'critical':
send_pagerduty_alert(alert_text, alert_text, PAGERDUTY_ROUTING_KEY)Siklus Evaluasi Peringatan
Logika peringatan sebaiknya berjalan dalam siklus terjadwal, bukan secara langsung dalam pemrosesan permintaan. Menjalankan pemeriksaan peringatan secara asinkron mencegah penambahan latensi pada permintaan produksi. Thread latar belakang atau pekerjaan terjadwal yang berjalan setiap 60 detik sudah memadai untuk sebagian besar kebutuhan peringatan. Kumpulkan metrik dalam jalur permintaan, lalu evaluasi ambang batas dalam siklus latar belakang.
import threading
import time
def alert_evaluation_loop(interval_seconds=60):
while True:
try:
# Check latency
latency_alerts = latency_tracker.check_alert(DEFAULT_THRESHOLDS)
for alert in latency_alerts:
route_alert(f'LATENCY: {alert}', 'warning')
# Check quality
quality_summary = quality_tracker.summary()
if quality_summary.get('alert'):
msg = f'QUALITY DEGRADATION: Rolling avg {quality_summary["ewma"]:.2f} below threshold {DEFAULT_THRESHOLDS.min_quality_score}'
route_alert(msg, 'warning')
print(f'Alert check complete. Quality: {quality_summary.get("ewma", "N/A")}')
except Exception as e:
print(f'Alert evaluation error: {e}')
time.sleep(interval_seconds)
# Start in background thread
alert_thread = threading.Thread(target=alert_evaluation_loop, daemon=True)
alert_thread.start()Kelelahan akibat Peringatan dan Penyesuaian Ambang Batas
Kelelahan akibat peringatan terjadi ketika peringatan dipicu begitu sering sehingga tim mulai mengabaikannya. Cegah hal ini dengan: memulai dari ambang batas konservatif (tinggi) dan memperketatnya setelah Anda memahami kondisi dasar, mengharuskan peringatan bertahan selama beberapa siklus evaluasi sebelum dipicu, mengelompokkan peringatan terkait ke dalam satu notifikasi, serta meninjau dan menghentikan peringatan yang tidak pernah menghasilkan tindakan berarti secara berkala.
class AlertDebouncer:
def __init__(self, required_consecutive_fires=3):
self.required = required_consecutive_fires
self.fire_counts = {} # alert_name -> consecutive fires
self.already_firing = set() # alert_names currently active
def should_fire(self, alert_name: str, condition: bool) -> bool:
if condition:
self.fire_counts[alert_name] = self.fire_counts.get(alert_name, 0) + 1
if self.fire_counts[alert_name] >= self.required and alert_name not in self.already_firing:
self.already_firing.add(alert_name)
return True # fire the alert (first time condition sustained)
else:
if self.fire_counts.get(alert_name, 0) > 0:
self.fire_counts[alert_name] = 0
self.already_firing.discard(alert_name) # condition cleared
return False # either not sustained or already firing (no duplicate alert)
debouncer = AlertDebouncer(required_consecutive_fires=3)Memantau Anomali Biaya dengan Metode Statistik
Peringatan ambang batas sederhana dapat melewatkan anomali biaya yang lebih halus, seperti peningkatan biaya bertahap sebesar 50% selama dua hari. Gunakan deteksi anomali statistik: hitung rata-rata dan simpangan baku bergerak dari biaya per jam Anda, lalu berikan peringatan ketika biaya jam saat ini lebih tinggi dari rata-rata sebesar lebih dari N simpangan baku (peringatan skor-Z). Cara ini secara otomatis menyesuaikan diri dengan pola penggunaan alami seperti lalu lintas hari kerja dan akhir pekan.
import statistics
def compute_z_score(recent_value: float, historical_values: list[float]) -> float:
if len(historical_values) < 5:
return 0 # not enough data
mean = statistics.mean(historical_values)
stdev = statistics.stdev(historical_values)
if stdev == 0:
return 0
return (recent_value - mean) / stdev
def check_cost_anomaly(current_hour_cost: float, historical_hourly_costs: list[float]) -> str | None:
z = compute_z_score(current_hour_cost, historical_hourly_costs)
if z > 3.0: # more than 3 standard deviations above mean
mean = statistics.mean(historical_hourly_costs)
return f'Cost anomaly: ${current_hour_cost:.2f} this hour (normal: ${mean:.2f}, z={z:.1f})'
return NoneMembangun Dasbor Operasional
Peringatan adalah lapisan reaktif; dasbor operasi langsung adalah lapisan proaktif. Bangun dasbor sederhana yang menampilkan metrik waktu nyata: latensi p50/p99 saat ini, permintaan per menit, skor kualitas saat ini (EWMA bergerak), biaya harian hingga saat ini dibandingkan dengan anggaran, serta 5 permintaan termahal dalam satu jam terakhir. Dengan demikian, tim Anda dapat melihat kondisi sistem secara sekilas tanpa menunggu peringatan dipicu.
Pemeriksaan Singkat
Uji pemahaman Anda tentang pemberian peringatan berdasarkan metrik aplikasi LLM dari pelajaran ini.
Rangkuman Pelajaran
Dalam pelajaran ini Anda telah mempelajari: tiga kategori peringatan mencakup sistem LLM—latensi, biaya, dan kualitas—yang masing-masing memerlukan instrumentasi berbeda; rata-rata bergerak dan EWMA mendeteksi penurunan kualitas secara bertahap dengan lebih baik daripada pemeriksaan ambang batas pada permintaan individual; dan penundaan peringatan mencegah kelelahan akibat terlalu banyak peringatan dengan mengharuskan kondisi bertahan selama beberapa siklus evaluasi sebelum peringatan dipicu. Selanjutnya kita akan membahas serangan injeksi prompt dan keamanan AI.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Peringatan untuk Latensi, Biaya, dan Penurunan Kualitas” gratis?
Ya — teks lengkap “Peringatan untuk Latensi, Biaya, dan Penurunan Kualitas” 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 “Peringatan untuk Latensi, Biaya, dan Penurunan Kualitas”?
Tentukan ambang peringatan untuk latensi p99, biaya per permintaan, dan skor kualitas otomatis, lalu arahkan peringatan ke Slack atau PagerDuty ketika alur pemrosesan LLM Anda mengalami penurunan. 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 4 dari 4.
Berapa lama pelajaran “Peringatan untuk Latensi, Biaya, dan Penurunan Kualitas” 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
- Mengapa Aplikasi LLM Sulit Di-debug
- Pelacakan dengan LangSmith
- Langfuse untuk Observabilitas yang Tidak Bergantung pada Model
- Peringatan untuk Latensi, Biaya, dan Penurunan Kualitas