AI Engineering Academy · บทเรียน

การคำนวณและคาดการณ์ค่าใช้จ่าย API

เขียนตัวช่วยใน Python เพื่อประมาณค่าใช้จ่ายก่อนส่งคำขอ โดยนับโทเคนและใช้ราคาของแต่ละโมเดล เพื่อไม่ให้ได้รับใบเรียกเก็บเงินที่ไม่คาดคิด

การคำนวณและคาดการณ์ค่าใช้จ่าย API เป็นบทเรียน AI Engineering Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน AI Engineering Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดการคาดการณ์ค่าใช้จ่ายจึงสำคัญ

ค่าใช้จ่าย API สำหรับแอปพลิเคชัน LLM อาจสูงเกินคาดเมื่อใช้งานในระดับใหญ่ คำขอเดียวที่ดูเหมือนมีราคาถูกเพียง $0.002 จะกลายเป็น $200 เมื่อเรียกใช้ 100,000 ครั้ง หากไม่มีการคาดการณ์และติดตามค่าใช้จ่าย ฟีเจอร์ AI อาจสร้างใบเรียกเก็บเงินจากคลาวด์ที่ไม่คาดคิด ซึ่งสูงกว่าค่าใช้จ่ายโครงสร้างพื้นฐานทั้งหมดของคุณหลายเท่า

ข่าวดีคือ คุณสามารถคาดการณ์ค่าใช้จ่าย LLM ได้ทั้งหมดก่อนส่งคำขอ: คุณรู้ว่าใช้โมเดลใด สามารถนับโทเค็นอินพุตด้วย tiktoken และประมาณจำนวนโทเค็นเอาต์พุตจากการตั้งค่า max_tokens หรือค่าเฉลี่ยในอดีต การสร้างระบบคาดการณ์ค่าใช้จ่ายไว้ในแอปพลิเคชันตั้งแต่วันแรกจะช่วยป้องกันค่าเรียกเก็บเงินที่ไม่คาดคิด

โครงสร้างราคาของ OpenAI

OpenAI คิดค่าใช้จ่ายสำหรับ โทเค็นอินพุต และ โทเค็นเอาต์พุต แยกกัน โดยทั่วไปเอาต์พุตมีราคาสูงกว่าประมาณ 3-4 เท่า ราคาแตกต่างกันไปตามโมเดล ตัวเลขอ้างอิงสำหรับปี 2025 มีดังนี้ (ควรตรวจสอบหน้าราคาปัจจุบันเสมอ เนื่องจากราคาอาจเปลี่ยนแปลง):

gpt-4o-mini: ประมาณ $0.15 ต่อโทเค็นอินพุตหนึ่งล้านโทเค็น และประมาณ $0.60 ต่อโทเค็นเอาต์พุตหนึ่งล้านโทเค็น
gpt-4o: ประมาณ $2.50 ต่อโทเค็นอินพุตหนึ่งล้านโทเค็น และประมาณ $10.00 ต่อโทเค็นเอาต์พุตหนึ่งล้านโทเค็น
text-embedding-3-small: ประมาณ $0.02 ต่อโทเค็นหนึ่งล้านโทเค็น

ความแตกต่างด้านค่าใช้จ่ายระหว่างโมเดลนั้นสูงมาก: gpt-4o มีราคาต่อโทเค็นอินพุตแพงกว่า gpt-4o-mini ประมาณ 17 เท่า การเลือกโมเดลคือคันโยกที่สำคัญที่สุดในการควบคุมค่าใช้จ่าย จึงควรเริ่มจากโมเดลที่ถูกที่สุดซึ่งยังตอบโจทย์ข้อกำหนดด้านคุณภาพของคุณ

ฟังก์ชันช่วยประมาณค่าใช้จ่าย

สร้างเครื่องมือประมาณค่าใช้จ่ายที่เรียกใช้ก่อนส่งคำขอใด ๆ เครื่องมือนี้จะนับโทเค็นอินพุตด้วย tiktoken ประมาณโทเค็นเอาต์พุตจากพารามิเตอร์ max_tokens ค้นหาราคาต่อโมเดล และส่งคืนค่าใช้จ่ายโดยประมาณเป็นดอลลาร์ เรียกใช้เครื่องมือนี้ระหว่างการพัฒนาและบันทึกผลลัพธ์ เพื่อสร้างความเข้าใจว่าคำขอแต่ละประเภทมีค่าใช้จ่ายเท่าใด

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

การติดตามค่าใช้จ่ายจริงจากการตอบกลับของ API

หลังการเรียก API แต่ละครั้ง ออบเจ็กต์การตอบกลับจะมีจำนวนโทเค็นจริงที่ถูกใช้ ให้ดึงข้อมูลเหล่านี้ออกมาเพื่อบันทึกค่าใช้จ่ายจริงและเปรียบเทียบกับค่าประมาณ เมื่อเวลาผ่านไป ช่องว่างระหว่างจำนวนโทเค็นเอาต์พุตที่ประมาณไว้กับจำนวนจริงจะบอกคุณว่าคาดการณ์การใช้งานได้แม่นยำเพียงใด และบันทึกเหล่านี้จะช่วยแจกแจงค่าใช้จ่ายตามฟีเจอร์หรือกลุ่มผู้ใช้

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

การคาดการณ์ค่าใช้จ่ายรายเดือน

เมื่อคุณทราบค่าใช้จ่ายเฉลี่ยต่อคำขอและปริมาณคำขอที่คาดไว้แล้ว การคาดการณ์ค่าใช้จ่ายรายเดือนก็ทำได้ง่าย สร้างตารางคำนวณแบบจำลองค่าใช้จ่ายหรือสคริปต์ Python อย่างง่ายที่เปิดให้คุณทดลองสมมติฐานต่าง ๆ เช่น หากจำนวนผู้ใช้ที่ใช้งานในแต่ละวันเพิ่มเป็นสองเท่าจะเป็นอย่างไร หรือหากเราเพิ่มฟีเจอร์ที่เรียก API 3 ครั้งต่อการกระทำของผู้ใช้หนึ่งครั้งแทนที่จะเป็น 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
)

ผลกระทบด้านค่าใช้จ่ายจากการเลือกโมเดล

คันโยกที่สำคัญที่สุดในการลดค่าใช้จ่ายคือการใช้โมเดลที่ถูกที่สุดซึ่งยังผ่านข้อกำหนดด้านคุณภาพ สำหรับงานจำนวนมาก gpt-4o-mini ให้ผลใกล้เคียงกับ gpt-4o แต่มีค่าใช้จ่ายต่ำกว่าประมาณ 17 เท่า ก่อนตั้งค่าให้ใช้โมเดลที่ทรงพลังที่สุดเป็นค่าเริ่มต้น ให้ทดสอบโมเดลที่ถูกกว่ากับงานเฉพาะของคุณก่อน และเปลี่ยนไปใช้โมเดลที่แพงกว่าเฉพาะเมื่อคุณภาพต่ำกว่าเกณฑ์ที่กำหนด

กลยุทธ์การจัดเส้นทางแบบแบ่งระดับมีประสิทธิภาพยิ่งกว่า: จำแนกคำขอที่เข้ามาตามความซับซ้อน แล้วส่งคำถามง่ายไปยังโมเดลราคาถูก และส่งคำถามซับซ้อนไปยังโมเดลราคาแพง แม้จะส่งคำขอ 70% ไปยังโมเดลราคาถูกและ 30% ไปยังโมเดลราคาแพง ก็ช่วยประหยัดค่าใช้จ่ายด้าน AI ได้ประมาณ 70%

ความยาวพรอมต์กับค่าใช้จ่าย

ทุกโทเคนในพรอมป์ของคุณมีค่าใช้จ่าย พรอมป์ระบบที่ยืดยาวและสามารถย่อให้กระชับได้โดยไม่เสียความหมาย จะทำให้ค่าใช้จ่ายเอพีไอของคุณเพิ่มขึ้นโดยตรงในทุกคำขอ ให้เปรียบเทียบจำนวนโทเคนของพรอมป์และมองหาโอกาสในการปรับถ้อยคำให้กระชับขึ้น ในทำนองเดียวกัน ตัวอย่างแบบไม่กี่ช็อตที่ยาวมักแทนที่ได้ด้วยตัวอย่างที่สั้นกว่าโดยไม่ลดความแม่นยำ

สำหรับระบบ RAG บริบทที่ดึงมามักเป็นส่วนที่ใหญ่ที่สุดของพรอมป์ การส่งชิ้นข้อมูลขนาดใหญ่ 10 ชิ้น ทั้งที่ 3 ชิ้นขนาดเล็กที่เลือกมาอย่างดีเพียงพอแล้ว เป็นการใช้โทเคนอย่างสิ้นเปลืองในทุกคำค้น ปรับการดึงข้อมูลให้ลดบริบทที่ซ้ำซ้อนให้น้อยที่สุด พร้อมเพิ่มความเกี่ยวข้องให้มากที่สุด

การรวมคำขอเพื่อประหยัดค่าใช้จ่าย

OpenAI มีเอพีไอแบบกลุ่มที่ประมวลผลคำขอแบบไม่พร้อมกัน โดยลดราคาลง 50% จากราคามาตรฐาน หากกรณีการใช้งานของคุณไม่ไวต่อเวลาแฝง เช่น การประมวลผลเอกสาร งานวิเคราะห์ที่ทำในช่วงกลางคืน หรือการสร้างเนื้อหาจำนวนมาก เอพีไอแบบกลุ่มสามารถลดค่าใช้จ่ายของคุณลงครึ่งหนึ่งได้โดยแทบไม่ต้องแก้ไขโค้ด

คำขอแบบกลุ่มจะส่งเป็นไฟล์ JSONL ประมวลผลภายใน 24 ชั่วโมง แล้วจึงดึงผลลัพธ์จากเอพีไอ วิธีนี้เหมาะอย่างยิ่งสำหรับไปป์ไลน์การเตรียมข้อมูลล่วงหน้าที่ทำงานตามกำหนดเวลาและไม่ต้องการการตอบกลับแบบเรียลไทม์

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')

การกำหนดขีดจำกัดการใช้จ่าย

กำหนดขีดจำกัดการใช้จ่ายเสมอเพื่อป้องกันค่าใช้จ่ายที่เพิ่มขึ้นอย่างควบคุมไม่ได้ ในแดชบอร์ดของ OpenAI คุณสามารถตั้ง เพดานการใช้จ่ายรายเดือน ซึ่งจะระงับการเข้าถึงเอพีไอเมื่อถึงขีดจำกัด ตั้งขีดจำกัดแบบตายตัวไว้ที่จำนวนเงินสูงสุดที่คุณยอมรับได้ และตั้งขีดจำกัดแบบผ่อนปรนไว้ที่ 80% ของจำนวนนั้น เพื่อรับการแจ้งเตือนทางอีเมลก่อนถึงเพดานแบบตายตัว

ในโค้ดแอปพลิเคชัน ให้ใช้ งบประมาณต่อผู้ใช้หรือต่อฟีเจอร์ และติดตามงบประมาณนี้ในฐานข้อมูล ตรวจสอบงบประมาณก่อนการเรียกเอพีไอแต่ละครั้ง และส่งคืนข้อผิดพลาดหากงบประมาณหมด วิธีนี้ป้องกันไม่ให้ผู้ใช้รายเดียวที่ทำงานผิดปกติหรือข้อบกพร่องในงานแบบกลุ่มใช้โควตารายเดือนทั้งหมดของคุณจนหมดภายในไม่กี่ชั่วโมง

การใช้แคชเพื่อหลีกเลี่ยงการเรียกเอพีไอซ้ำซ้อน

การเรียกเอพีไอที่ประหยัดที่สุดคือการเรียกที่คุณไม่เคยทำ ใช้แคชในระดับแอปพลิเคชันเพื่อส่งคำตอบของคำขอที่เหมือนกันจากแคช แทนการเรียกเอพีไออีกครั้ง แม้แต่แคช Redis แบบง่ายที่ใช้ค่าแฮช SHA256 ของพรอมป์เป็นกุญแจก็สามารถลดการเรียกซ้ำซ้อนในแอปพลิเคชันที่ใช้งานจริงได้เป็นจำนวนมาก

สำหรับเวกเตอร์ฝังตัว การใช้แคชมีผลอย่างยิ่ง ข้อความเดียวกันควรผ่านการฝังเพียงครั้งเดียว จัดเก็บเวกเตอร์ฝังตัวไว้ในฐานข้อมูลเวกเตอร์ โดยใช้ข้อความต้นฉบับเป็นกุญแจ และตรวจสอบว่ามีเวกเตอร์ฝังตัวอยู่แล้วหรือไม่ก่อนเรียกเอพีไอเวกเตอร์ฝังตัว ในไปป์ไลน์ RAG เวกเตอร์ฝังตัวของเอกสารจะคำนวณเพียงครั้งเดียวขณะสร้างดัชนี แล้วนำกลับมาใช้ซ้ำสำหรับทุกคำค้นที่ดึงเอกสารเหล่านั้น

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

การสร้างแดชบอร์ดค่าใช้จ่าย

ในระบบที่ใช้งานจริง คุณต้องมองเห็นค่าใช้จ่ายด้าน AI โดยแยกตามฟีเจอร์ ผู้ใช้ และโมเดล สร้างแดชบอร์ดค่าใช้จ่ายโดยบันทึกจำนวนโทเคนและข้อมูลเมตาที่เกี่ยวข้องของการเรียกเอพีไอทุกครั้ง (รหัสผู้ใช้ ชื่อฟีเจอร์ โมเดล) ลงในฐานข้อมูลอนุกรมเวลา จากนั้นรวมข้อมูลเพื่อหาคำตอบ เช่น ฟีเจอร์ใดทำให้เกิดค่าใช้จ่ายสูงสุด ผู้ใช้ที่ใช้งานหนักสร้างค่าใช้จ่ายสูงเกินสัดส่วนหรือไม่ ค่าใช้จ่ายต่อคำค้นเพิ่มขึ้นหลังจากเปลี่ยนพรอมป์หรือไม่

การมองเห็นข้อมูลนี้จำเป็นต่อการตัดสินใจปรับปรุงโดยอาศัยข้อมูล แทนการคาดเดาว่าควรลดค่าใช้จ่ายส่วนใด บริษัทส่วนใหญ่พบว่า 20% ของฟีเจอร์คิดเป็น 80% ของค่าใช้จ่ายด้าน AI และการปรับปรุงฟีเจอร์เหล่านั้นให้เหมาะสมส่งผลกระทบอย่างมาก

ตรวจสอบความเข้าใจ

ทดสอบความเข้าใจแนวคิดวิศวกรรม AI จากบทเรียนนี้

สรุปบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า สามารถคาดการณ์ค่าใช้จ่ายเอพีไอได้ก่อนส่งคำขอ โดยนับโทเคนอินพุตด้วยทิกโทเคนและประมาณจำนวนโทเคนเอาต์พุต การเลือกโมเดลเป็นปัจจัยสำคัญที่สุดในการควบคุมค่าใช้จ่าย โดย gpt-4o-mini อาจมีราคาถูกกว่า gpt-4o ถึง 17 เท่าสำหรับงานที่เหมาะสม และ การใช้แคช การรวมคำขอ และขีดจำกัดการใช้จ่ายช่วยป้องกันค่าใช้จ่ายที่เพิ่มขึ้นอย่างควบคุมไม่ได้ในระบบที่ใช้งานจริง บทถัดไป เราจะสำรวจกลยุทธ์สำหรับจัดการบทสนทนายาวที่เกินหน้าต่างบริบท

คำถามที่พบบ่อย

บทเรียน “การคำนวณและคาดการณ์ค่าใช้จ่าย API” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การคำนวณและคาดการณ์ค่าใช้จ่าย API” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส AI Engineering Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส AI Engineering Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การคำนวณและคาดการณ์ค่าใช้จ่าย API”

เขียนตัวช่วยใน Python เพื่อประมาณค่าใช้จ่ายก่อนส่งคำขอ โดยนับโทเคนและใช้ราคาของแต่ละโมเดล เพื่อไม่ให้ได้รับใบเรียกเก็บเงินที่ไม่คาดคิด คุณปฏิบัติ AI Engineering Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน AI Engineering Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน AI Engineering Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การคำนวณและคาดการณ์ค่าใช้จ่าย API” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน AI Engineering Academy นี้ได้ไหม

ได้ บทเรียน AI Engineering Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ AI Engineering Academy