AI Engineering Academy · Pelajaran

Mengira dan Meramalkan Kos API

Tulis pembantu Python yang menganggarkan kos sebelum menghantar permintaan dengan mengira token dan menggunakan harga bagi setiap model, supaya anda tidak menerima bil yang tidak dijangka.

Pelajaran 3 daripada 413 langkah

Mengira dan Meramalkan Kos API ialah pelajaran AI Engineering Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran AI Engineering Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus AI Engineering Academy merangkumi sejumlah 4 pelajaran.

Mengapa Ramalan Kos Penting

Kos API untuk aplikasi LLM boleh menjadi sangat besar pada skala tinggi. Satu pertanyaan yang kelihatan murah pada harga $0.002 menjadi $200 apabila dijalankan 100,000 kali. Tanpa ramalan dan pemantauan kos, ciri AI boleh menghasilkan bil awan yang tidak dijangka, sehingga jauh melebihi keseluruhan perbelanjaan infrastruktur anda.

Berita baiknya ialah kos LLM boleh diramalkan sepenuhnya sebelum anda menghantar permintaan: anda mengetahui model yang digunakan, anda boleh mengira token input dengan tiktoken, dan anda boleh menganggarkan token output berdasarkan tetapan max_tokens atau purata sejarah. Membina ramalan kos ke dalam aplikasi anda sejak hari pertama dapat mengelakkan kejutan bil.

Struktur Harga OpenAI

OpenAI mengenakan caj berasingan untuk token input dan token output, dengan output biasanya berharga 3-4 kali lebih tinggi. Harga berbeza mengikut model. Sebagai panduan untuk tahun 2025 (sentiasa semak halaman harga semasa kerana harga boleh berubah):

gpt-4o-mini: ~$0.15/juta input, ~$0.60/juta output
gpt-4o: ~$2.50/juta input, ~$10.00/juta output
text-embedding-3-small: ~$0.02/juta token

Perbezaan kos antara model sangat besar: gpt-4o kira-kira 17 kali lebih mahal daripada gpt-4o-mini bagi setiap token input. Pemilihan model ialah tuil terbesar anda untuk mengawal kos — sentiasa mulakan dengan model termurah yang memenuhi keperluan kualiti anda.

Fungsi Pembantu Anggaran Kos

Bina penganggar kos yang anda panggil sebelum menghantar sebarang permintaan. Ia mengira token input dengan tiktoken, menganggarkan token output daripada parameter max_tokens anda, mencari harga bagi setiap model, dan mengembalikan anggaran kos dalam dolar. Panggil fungsi ini dalam pembangunan dan catatkan hasilnya supaya anda membina pemahaman tentang kos pelbagai jenis pertanyaan.

import tiktoken

# Prices per million tokens as of early 2025
PRICING = {
    'gpt-4o': {'input': 2.50, 'output': 10.00},
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
    'gpt-4-turbo': {'input': 10.00, 'output': 30.00},
    'text-embedding-3-small': {'input': 0.02, 'output': 0.0},
}

def estimate_cost(messages, model='gpt-4o-mini', expected_output_tokens=500):
    enc = tiktoken.encoding_for_model(model)
    input_tokens = sum(
        len(enc.encode(m.get('content', ''))) + 4
        for m in messages
    ) + 3

    if model not in PRICING:
        raise ValueError(f'Unknown model: {model}')

    rates = PRICING[model]
    input_cost = (input_tokens / 1_000_000) * rates['input']
    output_cost = (expected_output_tokens / 1_000_000) * rates['output']
    total = input_cost + output_cost

    print(f'Model: {model}')
    print(f'Input tokens: {input_tokens} (${input_cost:.6f})')
    print(f'Est. output tokens: {expected_output_tokens} (${output_cost:.6f})')
    print(f'Estimated total: ${total:.6f}')
    return total

Menjejak Kos Sebenar daripada Respons API

Selepas setiap panggilan API, objek respons mengandungi jumlah sebenar token yang digunakan. Ekstrak maklumat ini untuk mencatat kos sebenar dan membandingkannya dengan anggaran anda. Dari semasa ke semasa, perbezaan antara token output yang dianggarkan dan yang sebenar menunjukkan ketepatan ramalan penggunaan anda, manakala catatan tersebut memberikan pecahan kos mengikut ciri atau segmen pengguna.

import openai

client = openai.OpenAI()

PRICING = {
    'gpt-4o-mini': {'input': 0.15, 'output': 0.60},
}

def chat_with_cost_tracking(model, messages):
    response = client.chat.completions.create(
        model=model, messages=messages
    )
    usage = response.usage
    rates = PRICING.get(model, {'input': 0, 'output': 0})
    actual_cost = (
        (usage.prompt_tokens / 1_000_000) * rates['input'] +
        (usage.completion_tokens / 1_000_000) * rates['output']
    )
    print(f'Input: {usage.prompt_tokens} tokens')
    print(f'Output: {usage.completion_tokens} tokens')
    print(f'Total: {usage.total_tokens} tokens')
    print(f'Actual cost: ${actual_cost:.6f}')
    return response, actual_cost

Mengunjurkan Kos Bulanan

Setelah anda mengetahui kos purata setiap permintaan dan jumlah permintaan yang dijangka, mengunjurkan kos bulanan menjadi mudah. Bina hamparan model kos atau skrip Python ringkas yang membolehkan anda menguji andaian berbeza: bagaimana jika pengguna aktif harian berganda? Bagaimana jika kita menambah ciri yang membuat 3 panggilan API bagi setiap tindakan pengguna dan bukannya 1?

def project_monthly_cost(
    avg_cost_per_request,
    requests_per_day,
    days=30
):
    daily_cost = avg_cost_per_request * requests_per_day
    monthly_cost = daily_cost * days

    print(f'Avg cost/request: ${avg_cost_per_request:.6f}')
    print(f'Requests/day: {requests_per_day:,}')
    print(f'Daily cost: ${daily_cost:.2f}')
    print(f'Monthly cost: ${monthly_cost:.2f}')

    # Growth scenarios
    for multiplier in [2, 5, 10]:
        scaled = monthly_cost * multiplier
        print(f'  At {multiplier}x traffic: ${scaled:.2f}/month')

# Example: customer support bot
project_monthly_cost(
    avg_cost_per_request=0.002,  # 2 cents per support query
    requests_per_day=5000
)

Kesan Pemilihan Model terhadap Kos

Tuil terbesar untuk mengurangkan kos ialah menggunakan model termurah yang memenuhi keperluan kualiti anda. Bagi banyak tugasan, gpt-4o-mini memberikan prestasi yang setanding dengan gpt-4o tetapi pada kos kira-kira 17 kali lebih rendah. Sebelum menggunakan model paling berkuasa secara lalai, tanda aras model yang lebih murah pada tugasan khusus anda dan beralih kepada model yang lebih mahal hanya jika kualiti jatuh di bawah ambang anda.

Strategi penghalaan berperingkat lebih berkesan: kelaskan permintaan masuk mengikut kerumitan dan halakan pertanyaan mudah kepada model murah serta pertanyaan kompleks kepada model mahal. Walaupun hanya 70% trafik dihalakan kepada model murah manakala 30% lagi kepada model mahal, anda dapat menjimatkan kira-kira 70% kos AI anda.

Panjang Gesaan dan Kos

Setiap token dalam gesaan anda memerlukan kos. Gesaan sistem yang terlalu panjang dan boleh dipadatkan tanpa kehilangan makna akan meningkatkan bil API anda secara langsung bagi setiap permintaan. Tanda aras bilangan token gesaan anda dan cari peluang untuk memendekkan perkataan. Begitu juga, contoh few-shot yang panjang selalunya boleh digantikan dengan padanan yang lebih pendek tanpa menjejaskan ketepatan.

Bagi sistem RAG, konteks yang diperoleh semula selalunya merupakan bahagian terbesar dalam gesaan. Memulangkan 10 bahagian besar apabila 3 bahagian kecil yang dipilih dengan baik sudah mencukupi akan membazirkan token pada setiap pertanyaan. Laraskan proses mendapatkan semula maklumat anda untuk meminimumkan konteks berlebihan sambil memaksimumkan kerelevanan.

Pemprosesan Kelompok untuk Kecekapan Kos

OpenAI menawarkan Batch API yang memproses permintaan secara tak segerak dengan harga 50% lebih rendah daripada harga standard. Jika kes penggunaan anda tidak sensitif terhadap kependaman — pemprosesan dokumen, tugas analisis waktu malam, penjanaan kandungan secara pukal — Batch API boleh mengurangkan kos anda separuh dengan perubahan kod yang minimum.

Permintaan kelompok dihantar sebagai fail JSONL, diproses dalam tempoh 24 jam, dan hasilnya diperoleh daripada API. Ini amat sesuai untuk saluran pemprosesan awal yang dijalankan mengikut jadual dan tidak memerlukan respons masa nyata.

import openai
import json

client = openai.OpenAI()

# Create batch request file
requests = [
    {'custom_id': f'doc-{i}',
     'method': 'POST',
     'url': '/v1/chat/completions',
     'body': {
         'model': 'gpt-4o-mini',
         'messages': [{'role': 'user', 'content': f'Summarize document {i}'}],
         'max_tokens': 200
     }}
    for i in range(100)
]

# Write to JSONL
with open('/tmp/batch_input.jsonl', 'w') as f:
    for req in requests:
        f.write(json.dumps(req) + '\n')

# Upload and submit (50% off list price)
print('Would submit batch for 100 documents at 50% discount')
# batch_file = client.files.create(file=open('/tmp/batch_input.jsonl','rb'), purpose='batch')
# batch = client.batches.create(input_file_id=batch_file.id, endpoint='/v1/chat/completions', completion_window='24h')

Menetapkan Had Perbelanjaan

Sentiasa konfigurasikan had perbelanjaan untuk mengelakkan kos yang tidak terkawal. Dalam papan pemuka OpenAI, anda boleh menetapkan had perbelanjaan bulanan yang menghentikan akses API apabila had dicapai. Tetapkan had tegas pada jumlah perbelanjaan maksimum yang boleh diterima dan had amaran pada 80% daripada nilai tersebut untuk menerima amaran e-mel sebelum had tegas dicapai.

Dalam kod aplikasi anda, laksanakan bajet bagi setiap pengguna atau ciri yang dijejaki dalam pangkalan data anda. Semak bajet sebelum setiap panggilan API dan pulangkan ralat jika bajet telah habis. Ini menghalang seorang pengguna yang tidak terkawal atau pepijat dalam tugas kelompok daripada menggunakan keseluruhan kuota bulanan anda dalam masa beberapa jam.

Penyimpanan Cache untuk Mengelakkan Panggilan API Berulang

Panggilan API yang paling murah ialah panggilan yang tidak pernah dibuat. Laksanakan penyimpanan cache pada lapisan aplikasi untuk menyampaikan permintaan yang sama daripada cache dan bukannya memanggil API sekali lagi. Malah cache Redis yang ringkas, yang menggunakan cincangan SHA256 gesaan sebagai kunci, boleh menghapuskan sebahagian besar panggilan berulang dalam aplikasi pengeluaran.

Bagi pembenaman, penyimpanan cache amat berkesan: teks yang sama hanya perlu dibenamkan sekali. Simpan pembenaman dalam pangkalan data vektor anda dengan teks asal sebagai kunci, dan semak sama ada pembenaman sedia ada sebelum memanggil API pembenaman. Dalam saluran pemprosesan RAG, pembenaman dokumen dikira sekali pada masa pengindeksan dan digunakan semula bagi setiap pertanyaan yang mendapatkannya.

import hashlib
import json

# Simple in-memory cache (use Redis in production)
_cache = {}

def cached_completion(client, model, messages, **kwargs):
    cache_key = hashlib.sha256(
        json.dumps({'model': model, 'messages': messages}).encode()
    ).hexdigest()

    if cache_key in _cache:
        print('Cache HIT - no API call made')
        return _cache[cache_key]

    response = client.chat.completions.create(
        model=model, messages=messages, **kwargs
    )
    _cache[cache_key] = response
    print('Cache MISS - API call made')
    return response

Membina Papan Pemuka Kos

Dalam persekitaran pengeluaran, anda memerlukan keterlihatan terhadap kos AI yang dipecahkan mengikut ciri, pengguna dan model. Bina papan pemuka kos dengan mencatat setiap kiraan token panggilan API serta metadata berkaitan (ID pengguna, nama ciri, model) ke pangkalan data siri masa. Kemudian, kumpulkan data tersebut untuk menjawab soalan seperti: ciri manakah yang menyumbang perbelanjaan paling banyak? Adakah pengguna tegar menghasilkan kos yang tidak seimbang? Adakah kos bagi setiap pertanyaan meningkat selepas perubahan gesaan?

Keterlihatan ini penting untuk membuat keputusan pengoptimuman berasaskan data, bukannya meneka bahagian yang perlu dikurangkan kosnya. Kebanyakan syarikat mendapati bahawa 20% ciri mereka menyumbang 80% daripada perbelanjaan AI, dan pengoptimuman ciri-ciri tersebut memberikan kesan yang jauh lebih besar.

Semakan Pantas

Uji pemahaman anda tentang konsep Kejuruteraan AI daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa: kos API boleh diramalkan sebelum penghantaran dengan mengira token input menggunakan tiktoken dan menganggarkan token output, pemilihan model ialah pengungkit kos terbesar — gpt-4o-mini boleh 17 kali lebih murah daripada gpt-4o untuk tugas yang sesuai, dan penyimpanan cache, pemprosesan kelompok serta had perbelanjaan menghalang kos yang tidak terkawal dalam persekitaran pengeluaran. Seterusnya, kita akan meneroka strategi untuk mengurus perbualan panjang yang melebihi tetingkap konteks.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Mengira dan Meramalkan Kos API” percuma?

Ya — teks penuh “Mengira dan Meramalkan Kos API” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus AI Engineering Academy, tingkat taraf kepada CoddyKit PRO. Kursus AI Engineering Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Mengira dan Meramalkan Kos API”?

Tulis pembantu Python yang menganggarkan kos sebelum menghantar permintaan dengan mengira token dan menggunakan harga bagi setiap model, supaya anda tidak menerima bil yang tidak dijangka. Anda berlatih AI Engineering Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan AI Engineering Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran AI Engineering Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.

Berapa lamakah pelajaran “Mengira dan Meramalkan Kos API” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke AI Engineering Academy