बड़े मॉडल API के टोकन और बिलिंग: अनुमान, पठन, बजट और उदाहरण

टोकन क्या है और इसकी कीमत कैसे तय होती है

टोकन मॉडल द्वारा संसाधित पाठ की न्यूनतम इकाई है, न कि अक्षर या शब्द, बल्कि दोनों के बीच का "टुकड़ा" है। इसे पानी के मीटर के स्केल की तरह समझें: जितना अधिक उपयोग, उतनी तेज़ गति। बिलिंग दो भागों में बांटी गई है:

ध्यान दें कि आउटपुट की इकाई लागत इनपुट से चार गुना है, इसलिए मॉडल को "कम बोलने" के लिए कहना आपको "कम संदर्भ भेजने" से अक्सर सस्ता पड़ता है, हालांकि बातचीत के परिदृश्य में इनपुट इतिहास के कारण बढ़ जाता है, इसलिए दोनों ओर नियंत्रण की आवश्यकता होती है। भुगतान प्रीपेड बैलेंस से होता है, सब्सक्रिप्शन से नहीं; बैलेंस कभी समाप्त नहीं होता; नए खाते में $0.50 मुफ़्त ट्रायल क्रेडिट होता है, जो 7 दिनों के लिए मान्य है।

एक अक्सर भ्रमित करने वाली बात: आउटपुट टोकन मॉडल द्वारा वास्तव में जनरेट किए गए टोकन की संख्या है, न कि आपकी सेट की गई max_tokens। max_tokens केवल एक ऊपरी सीमा है। यदि मॉडल 200 अक्षरों में जवाब दे देता है, तो केवल 200 अक्षरों के टोकन के लिए ही चार्ज होगा। लेकिन बजट अनुमान लगाते समय सबसे खराब स्थिति के लिए ऊपरी सीमा का उपयोग करें ताकि लंबे आउटपुट से आप हैरान न हों।

प्री-एस्टिमेट: चीनी और अंग्रेजी टोकन का अनुमान कैसे लगाएं

अनुरोध भेजने से पहले, केवल अनुमान लगाया जा सकता है। नीचे दिए गए सभी मान अनुमानित हैं, सामग्री के आधार पर भिन्न हो सकते हैं:

अनुमान का सही उपयोग 'मैग्निट्यूड एस्टिमेट' करना है: क्या यह लेख लगभग 10,000 या 100,000 टोकन का है, क्या यह 100,000 की कॉन्टेक्स्ट विंडो को तोड़ेगा, और एक कॉल की लागत लगभग कितनी होगी। सटीकता के लिए usage पढ़ें। एक अच्छी आदत यह है कि प्रत्येक बिजनेस सिनेरियो में usage का औसत मान प्राप्त करने के लिए कई बार नमूना चलाएं और उसे अनुमानित मान के बजाय उपयोग करें।

एक उदाहरण जहाँ अनुमान और मापन को मिलाया गया है। मान लीजिए कि आपको लगभग 2000 अक्षरों की चीनी ग्राहक प्रतिक्रियाओं का प्रसंस्करण करना है। प्रति अक्षर 1.3 टोकन के अनुमान के साथ, एक अनुरोध लगभग 2600 टोकन का होगा, और यदि आपके prompt में 200 टोकन हैं, तो इनपुट लगभग 2800 होगा। पहले 30 अनुरोधों को चलाएं और usage का औसत निकालें। यदि औसत 2500 आता है, तो अपने गुणांक को 1.15 तक ठीक करें। इसके बाद पूरे बैच का बजट ठीक किए गए गुणांक के आधार पर लगाएं, जिससे त्रुटि कम होगी। यह मापन संख्या केवल विधि का एक उदाहरण है, आपके डेटा की अपनी संख्याएँ होंगी।

usage पढ़ें: असली 'मीटर रीडिंग'

हर सफल response में usage होता है, जिसमें prompt_tokens, completion_tokens, और total_tokens शामिल हैं। स्ट्रीमिंग response के लिए अतिरिक्त पैरामीटर की आवश्यकता नहीं है, अंत में स्वचालित रूप से usage वाला एक डेटा ब्लॉक जुड़ जाता है। नीचे का कोड दोनों पढ़ने के तरीकों को दिखाता है और रीडिंग को अमेरिकी डॉलर में बदलता है:

复制import os
from openai import OpenAI

client = OpenAI(base_url="https://api.apidamoxing.com/v1", api_key=os.environ["API_KEY"])
PRICE_IN, PRICE_OUT = 0.25, 1.00     # 美元 / 百万 token

def cost(u):
    return (u.prompt_tokens * PRICE_IN + u.completion_tokens * PRICE_OUT) / 1_000_000

# 非流式：usage 在响应对象上
r = client.chat.completions.create(
    model="uncensored", max_tokens=200,
    messages=[{"role": "user", "content": "用三句话解释什么是通货膨胀。"}],
)
print(r.usage.prompt_tokens, r.usage.completion_tokens, f"${cost(r.usage):.6f}")

# 流式：最后一个数据块带 usage，其余块的 usage 为空
usage_last = None
stream = client.chat.completions.create(
    model="uncensored", max_tokens=200, stream=True,
    messages=[{"role": "user", "content": "再用三句话解释什么是通货紧缩。"}],
)
for chunk in stream:
    if chunk.usage:
        usage_last = chunk.usage
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()
if usage_last:
    print(usage_last.prompt_tokens, usage_last.completion_tokens, f"${cost(usage_last):.6f}")

स्ट्रीमिंग के दौरान सावधान रहें: केवल अंतिम चंक में usage होता है, पिछले चंक्स में यह खाली होता है, इसलिए if chunk.usage से जाँच करें। हर रीड को लॉग या डेटाबेस में सेव करें। महीने के अंत में बिलिंग, एनॉमली चेकिंग और प्रति यूजर कॉस्ट की गणना के लिए इस रिकॉर्ड पर निर्भर करें।

एक और आदत अपनाने योग्य है: प्रत्येक व्यावसायिक फ़ंक्शन को टैग करें और बिलिंग के समय इसे नोट करें। उदाहरण के लिए, "सारांश", "कस्टमर सर्विस", "अनुवाद" को अलग-अलग नोट करें; महीने के अंत में बिलिंग करने पर, यह पता चलता है कि कौन सा फ़ंक्शन सबसे अधिक खर्च करता है, क्या प्रॉम्प्ट को अनुकूलित करना है, इतिहास को काटना है, या max_tokens को कम करना है। टैग के बिना, केवल एक कुल संख्या होती है, जिससे अनुकूलन मुश्किल हो जाता है।

तीन उदाहरण (माने गए शर्तें स्पष्ट हैं)

उदाहरण 1: ग्राहक सेवा प्रश्नोत्तर

मान्यता: हर अनुरोध में इनपुट 800 टोकन (system और knowledge snippet सहित), आउटपुट 200 टोकन; प्रतिदिन 10,000 कॉल।

प्रति अनुरोध लागत: 800 × 0.25 ÷ 1,000,000 = $0.0002, आउटपुट 200 × 1.00 ÷ 1,000,000 = $0.0002, कुल $0.0004। प्रतिदिन $4.00, 30 दिन $120। इस गति से, $0.50 का मुफ़्त ट्रायल क्रेडिट लगभग 1250 ऐसे कॉल को सपोर्ट कर सकता है।

उदाहरण 2: लंबे लेख का सारांश

माना: प्रत्येक लेख के लिए 20,000 टोकन इनपुट, सारांश आउटपुट 600 टोकन; कुल 500 लेख।

प्रति लेख: 20,000 × 0.25 ÷ 1,000,000 = $0.005, प्लस 600 × 1.00 ÷ 1,000,000 = $0.0006, कुल $0.0056। 500 लेखों के लिए कुल $2.80। इससे स्पष्ट है कि लंबे इनपुट और छोटे आउटपुट वाले टास्क बहुत सस्ते हैं।

उदाहरण 3: मल्टी-टर्न चैट और इतिहास कटऑफ

मान्यता: system 100 टोकन; हर round में user इनपुट 60 टोकन, response 150 टोकन; एक conversation में 20 rounds।

पूरे इतिहास वाली योजना का इनपुट है: 20 × (100 + 60) + 210 × (0 + 1 + … + 19) = 3,200 + 39,900 = 43,100। कटऑफ योजना के पहले तीन टर्न क्रमशः 160, 370, 580 हैं, चौथे से बीसवें टर्न तक प्रत्येक 790, कुल 14,540। लागत में लगभग आधा अंतर है, और टर्न जितने अधिक होंगे उतना ही अंतर बढ़ता है, क्योंकि पूरे इतिहास वाली योजना में इनपुट टर्न की संख्या के वर्ग के अनुपात में बढ़ता है।

इन तीन उदाहरणों से एक अनुभवजन्य सूत्र निकाला जा सकता है: लागत मुख्य रूप से 'अनुरोध संख्या × प्रति अनुरोध इनपुट/आउटपुट' द्वारा निर्धारित होती है, और प्रति अनुरोध इनपुट में इतिहास और संलग्न सामग्री सबसे अधिक प्रभाव डालने वाले हिस्से हैं। ग्राहक सेवा में ज्ञान खंड की लंबाई कम करना, चैट में इतिहास काटना, सारांश में ब्लॉक-वाइज समानांतर अनुरोध भेजना—ये सभी एक ही सिद्धांत पर काम करते हैं: अनावश्यक टोकन के लिए पैसे मत बर्बाद करो। यह स्पष्ट करना जरूरी है कि इन उदाहरणों के आंकड़े ऊपर बताई गई शर्तों पर आधारित हैं, आपके वास्तविक आंकड़े usage के आधार पर ही देखें।

एक उल्टा अनुमान भी लगाएं: यदि आपका मासिक बजट $30 है और आप जानना चाहते हैं कि चैट प्रोडक्ट 20 टर्न की कन्वर्सेशन कितनी चला सकता है। उदाहरण 3 की 'केवल आखिरी 3 टर्न' योजना के अनुसार, प्रति कन्वर्सेशन लगभग $0.0066, $30 ÷ 0.0066 से लगभग 4545 कन्वर्सेशन। उसी बजट के साथ, यदि पूरे इतिहास वाली योजना का उपयोग करें, तो प्रति कन्वर्सेशन $0.0138, केवल लगभग 2174 कन्वर्सेशन काफी होंगी। यही इतिहास कटऑफ का वास्तविक प्रभाव है।

बजट नियंत्रण: प्रोग्राम में गेट लगाएं

अनुमान केवल भविष्यवाणी है, गेट ही बीमा है। नीचे एक USD-आधारित दैनिक बजेट क्लास का उदाहरण है: अनुरोध से पहले 'सबसे खराब स्थिति' का अनुमान लगाएं (आउटपुट max_tokens तक जाए), अनुरोध के बाद वास्तविक usage के आधार पर बिलिंग करें।

复制class Budget:
    """按美元计的日预算。超出时拒绝新请求。"""
    def __init__(self, daily_usd):
        self.limit = daily_usd
        self.spent = 0.0

    def check(self, est_prompt_tokens, max_tokens):
        # 最坏情况：输出用满 max_tokens
        worst = (est_prompt_tokens * 0.25 + max_tokens * 1.00) / 1_000_000
        if self.spent + worst > self.limit:
            raise RuntimeError(f"预算不足：已用 ${self.spent:.4f}，本次最坏 ${worst:.4f}，上限 ${self.limit}")

    def record(self, usage):
        self.spent += (usage.prompt_tokens * 0.25 + usage.completion_tokens * 1.00) / 1_000_000

budget = Budget(daily_usd=5.0)
budget.check(est_prompt_tokens=1200, max_tokens=500)   # 请求前
# ……发请求……
# budget.record(response.usage)                        # 请求后

प्रोग्राम के गेट के अलावा, कॉन्फ़िगरेशन स्तर पर तीन तरीके हैं:

1. max_tokens को टास्क के अनुसार सेट करें, सभी को अपर सीमा तक न खींचें, डिफ़ॉल्ट 2048, अधिकतम 32,000;
2. चैट इतिहास के लिए लंबाई सीमा सेट करें, चैटबॉट निर्माण में बताए गए तरीके देखें;
3. अकाउंट में केवल उतना ही टॉप-अप करें जितना आपका उपयोग होगा, खत्म होने पर ही पूरा करें, प्रीपेड मोड स्वाभाविक रूप से एक हार्ड अपर सीमा है।

इकाई मूल्य और शेष राशि के नियम मूल्य पृष्ठ पर निर्भर करते हैं, इंटरफ़ेस विवरण पैरामीटर विवरण में है।

अंत में इसे एक चेकलिस्ट में बदलें: प्री-रन में, मात्रा का अनुमान लगाएं, max_tokens सेट करें, इतिहास लंबाई जांचें; रन-टाइम में, स्ट्रीमिंग आउटपुट के दौरान आखिरी ब्लॉक के usage पर ध्यान दें; पोस्ट-रन में, बिलिंग करें और फ़ंक्शन के अनुसार वर्गीकृत करें, बजट से तुलना करें। ये तीन कदम पूरे करने पर बिल साफ़ हो जाता है।