BroadRouter

ریزننگ ماڈلز کے لیے max_tokens کیسے طے کریں: بجٹ کا طریقہ

BroadNet Inference ٹیم · 6 منٹ کی پڑھائی · شائع شدہ

ریزننگ ماڈل پر max_tokens سوچ اور جواب، دونوں کو ملا کر محدود کرتا ہے، اس لیے تنگ حد نظر آنے والے متن سے پہلے ہی جواب ختم کر سکتی ہے۔ ہر ٹاسک ٹائپ کے کل completion ٹوکن ناپیں، max_tokens کو تقریباً 95ویں percentile سے 20% اوپر رکھیں، پرامپٹ اور max_tokens کو کانٹیکسٹ ونڈو میں رکھیں، اور کٹے ہوئے جواب کو دگنے بجٹ سے ایک مقررہ حد تک دوبارہ بھیجیں۔

ریزننگ ماڈل جواب دینے سے پہلے سوچتا ہے، اور زیادہ تر OpenAI-compatible APIs پر دونوں ایک ہی بجٹ سے نکلتے ہیں: max_tokens۔ اسے ویسے سیٹ کریں جیسے بغیر ریزننگ والے ماڈل کے لیے کرتے، یعنی مختصر جواب کے لیے چند سو ٹوکن، تو کچھ جواب finish_reason: "length" کے ساتھ خالی لوٹتے ہیں۔ فوری حل ریزننگ ماڈل خالی جواب کیوں دیتا ہے میں ہے۔ یہ پوسٹ اس بجٹ کے پیچھے کا طریقہ ہے جس پر آپ بھروسہ کر سکیں: ناپیں، percentiles سے سائز طے کریں، کانٹیکسٹ ونڈو کا خیال رکھیں، اور پھر بھی کٹنے والے جوابوں کو سنبھالیں۔

ریزننگ کی لاگت اور اسے کم کرنے کے لیے دیکھیں ریزننگ ٹوکنز: جتنا نظر آتا ہے اس سے زیادہ آؤٹ پٹ کی ادائیگی کیوں۔

جواب سے پہلے بجٹ ختم کیوں ہو جاتا ہے؟

ماڈل ترتیب سے متن بناتا ہے: پہلے اپنی ریزننگ، پھر نظر آنے والا جواب۔ دونوں کا ہر ٹوکن max_tokens میں گنا جاتا ہے۔ BroadNet کی دستاویزات DeepSeek V4.1 Flash، GLM 5.3 اور Qwen3.8 27B کے لیے یہی کہتی ہیں: “the reasoning counts toward max_tokens” (ترجمہ: ریزننگ max_tokens میں گنی جاتی ہے)، اور چھوٹی حد پر “the answer comes back empty” (ترجمہ: جواب خالی لوٹتا ہے)۔ OpenAI کا Chat Completions ریفرنس max_completion_tokens کو اسی طرح بیان کرتا ہے، ایک بالائی حد کے طور پر “including visible output tokens and reasoning tokens” (ترجمہ: نظر آنے والے آؤٹ پٹ ٹوکنز اور ریزننگ ٹوکنز سمیت)۔

اس لیے پوچھنے والا سوال “میرا جواب کتنا لمبا ہے؟” نہیں ہے۔ سوال یہ ہے: “اس ٹاسک پر، اس effort پر، ریزننگ اور جواب مل کر کتنے لمبے ہیں؟” یہ لوگوں کی توقع سے زیادہ بدلتا ہے۔ OpenAI کی گائیڈ کہتی ہے کہ مسئلے کے لحاظ سے اس کے ماڈلز “anywhere from a few hundred to tens of thousands of reasoning tokens” (ترجمہ: چند سو سے لے کر دسیوں ہزار تک ریزننگ ٹوکنز) بنا سکتے ہیں۔

کیا بڑا max_tokens زیادہ مہنگا پڑتا ہے؟

نہیں۔ بجٹ بہت تنگ رکھنے کی یہی سب سے عام وجہ ہے۔ max_tokens ایک حد ہے۔ بل اصل میں بنے ٹوکنز کا بنتا ہے۔ جس جواب کو 1,800 ٹوکن چاہییں، اس کی لاگت 4,000 کی حد پر بھی اتنی ہی ہے اور 40,000 پر بھی۔

تنگ حد کا خرچ یہ ہے:

حد بمقابلہ ضرورت آپ کیا ادا کرتے ہیں آپ کو کیا ملتا ہے
حد ضرورت سے اوپر بنے ہوئے ٹوکنز جواب
حد ضرورت سے نیچے پوری حد، ساری ریزننگ میں کچھ بھی کام کا نہیں، اوپر سے ایک retry

ایک مثال لیں۔ فرض کریں آپ کی ایک چوتھائی کالز کو 1,000 سے زیادہ ٹوکن چاہییں۔ max_tokens=1000 پر ایسی ہر کال 1,000 آؤٹ پٹ ٹوکنز کی سوچ کا بل بناتی ہے، کچھ نہیں لوٹاتی اور دوبارہ بھیجی جاتی ہے۔ اس سے تمام کالز پر اوسطاً فی کال 250 ضائع آؤٹ پٹ ٹوکن جڑتے ہیں، retries کے اپنے خرچ سے پہلے، اور اوپر سے دوسری درخواست کی تاخیر۔ 4,000 کی حد پر کچھ ضائع نہیں ہوتا۔ Qwen3.8 27B پر آؤٹ پٹ کی لاگت $2.17 فی 1M ٹوکن ہے، اس لیے بڑی مقدار میں یہ ضیاع جمع ہوتا جاتا ہے۔

اونچی حد کا اصل خطرہ بے قابو جواب ہے: ایسا ماڈل جو لوپ میں پھنس جائے یا ضرورت سے کہیں زیادہ سوچے اور کہیں زیادہ ٹوکن بنائے۔ ایک پکی حد اسے باندھ دیتی ہے۔ وہ حد ڈیٹا سے چنیں، جیسا نیچے بتایا گیا ہے۔

کسی ٹاسک کو کتنا چاہیے، یہ کیسے ناپیں؟

ایک ٹاسک ٹائپ کے حقیقی پرامپٹس اونچی حد کے ساتھ چلائیں، اور completion ٹوکنز اور ریزننگ کا حصہ درج کریں۔ جب ماڈل اسے رپورٹ کرتا ہے تو usage.completion_tokens_details.reasoning_tokens ریزننگ والا حصہ دیتا ہے؛ BroadNet کی دستاویزات یہ فیلڈ درج کرتی ہیں۔

import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/qwen3.8-27b"

def measure(prompts, ceiling=16_000, **kw):
    """Run real prompts with a generous ceiling and return per-call token counts."""
    rows = []
    for p in prompts:
        r = client.chat.completions.create(model=MODEL, max_tokens=ceiling,
                                           messages=[{"role": "user", "content": p}], **kw)
        u, d = r.usage, r.usage.completion_tokens_details
        reasoning = (d.reasoning_tokens or 0) if d else 0
        rows.append({"reasoning": reasoning, "answer": u.completion_tokens - reasoning,
                     "finish": r.choices[0].finish_reason})
    return rows

def pct(values, q):
    values = sorted(values)
    return values[min(len(values) - 1, int(q * len(values)))]

def recommend(rows, margin=1.2):
    total = [r["reasoning"] + r["answer"] for r in rows]
    return {"p50": pct(total, 0.5), "p95": pct(total, 0.95), "max": max(total),
            "max_tokens": int(pct(total, 0.95) * margin),
            "cut_off": sum(r["finish"] == "length" for r in rows)}

# print(recommend(measure(my_prompts)))                       # default effort
# print(recommend(measure(my_prompts, reasoning_effort="low")))

قابلِ بھروسہ نمبر کے اصول:

  1. ہر رن میں ایک ٹاسک ٹائپ۔ classification، extraction، code review اور planning کی تقسیم (distribution) بہت مختلف ہوتی ہے۔ ایک global max_tokens یا تو retries پر پیسہ ضائع کرتا ہے یا بے قابو جوابوں کو نکل جانے دیتا ہے۔
  2. 50 یا زیادہ حقیقی پرامپٹس۔ دس سیمپلز کا 95واں percentile بس سب سے بڑا سیمپل ہوتا ہے۔
  3. ہر اس effort پر چلائیں جو آپ استعمال کرتے ہیں۔ reasoning_effort="low" تقسیم بدل دیتا ہے۔ BroadNet low دستاویز کرتا ہے؛ دوسری قدروں پر بھروسہ کرنے سے پہلے انہیں ٹیسٹ کریں۔
  4. اگر cut_off صفر نہیں تو حد بڑھا کر پھر چلائیں۔ کٹا ہوا سیمپل اپنی اصل لمبائی چھپا لیتا ہے۔
  5. ماڈل یا پرامپٹ بدلنے پر پھر چلائیں۔ نیا ماڈل ورژن کم یا زیادہ سوچ سکتا ہے۔

پھر recommend() سے ہر ٹاسک کا max_tokens طے کریں۔ 95واں percentile اور 20% زیادہ تر کالز کو حد سے کافی نیچے رکھتا ہے اور صرف کبھی کبھار آنے والی لمبی کال کو نیچے دیے گئے retry راستے پر بھیجتا ہے۔ مفت ریزننگ ٹوکن بجٹ ٹول آپ کے نمبر ملنے کے بعد یہ حساب آپ کے براؤزر میں کر دیتا ہے۔

کانٹیکسٹ ونڈو بجٹ کو کیسے محدود کرتی ہے؟

کانٹیکسٹ ونڈو میں پرامپٹ اور جواب، دونوں ساتھ آتے ہیں۔ BroadNet کی قیمتوں کی فیڈ context_length کو “the most tokens one request can hold, prompt and answer together” (ترجمہ: ایک درخواست میں زیادہ سے زیادہ جتنے ٹوکن آ سکتے ہیں، پرامپٹ اور جواب ملا کر) بتاتی ہے۔ اس لیے:

max_tokens ≤ context length − prompt tokens

ماڈل کانٹیکسٹ 200,000 ٹوکن کے پرامپٹ کے ساتھ max_tokens کی گنجائش
GLM 5.3 1,048,576 848,576
DeepSeek V4.1 Flash 1,048,576 848,576
Qwen3.8 27B 262,144 62,144

لمبے کانٹیکسٹ والے کام میں یہ اہم ہے۔ جس ایجنٹ کی ہسٹری Qwen3.8 27B پر 250,000 ٹوکن تک پہنچ گئی ہے، اس کے پاس سوچ اور جواب کے لیے صرف تقریباً 12,000 ٹوکن بچے ہیں۔ لمبے کانٹیکسٹ والے ٹاسکس کو عموماً زیادہ ریزننگ بھی چاہیے، اس لیے بچی ہوئی گنجائش کال کے وقت جانچیں، صرف شروع میں ایک بار نہیں۔ کانٹیکسٹ ونڈو اور کانٹیکسٹ ونڈو کیلکولیٹر یہ حساب سمجھاتے ہیں۔

اگر جواب پھر بھی کٹ جائے تو کیا کریں؟

ہر کال پر finish_reason جانچیں۔ اگر وہ length ہے تو جواب غائب یا نامکمل ہے، چاہے content میں کچھ متن ہو۔ اسے مکمل سمجھ کر parse نہ کریں؛ کٹا ہوا JSON آبجیکٹ آگے کے ایررز کی عام وجہ ہے (structured output)۔

کانٹیکسٹ جتنی گنجائش دے، اس کے اندر، ایک پکی حد تک، دگنے بجٹ سے دوبارہ کوشش کریں:

import json, urllib.request

FEED = json.load(urllib.request.urlopen("https://inference.broadnet.ai/pricing.json"))
CONTEXT = {m["id"]: m.get("context_length") for m in FEED["models"]}

def ask(model, messages, budget=4_000, hard_cap=32_000, **kw):
    """Retry a cut-off reply with a doubled budget, never past the cap or the context window."""
    while True:
        r = client.chat.completions.create(model=model, messages=messages,
                                           max_tokens=budget, **kw)
        if r.choices[0].finish_reason != "length":
            return r
        room = CONTEXT[model] - r.usage.prompt_tokens        # context holds prompt + answer
        nxt = min(budget * 2, hard_cap, room)
        if nxt <= budget:
            raise RuntimeError(f"still cut off at max_tokens={budget}")
        print(f"cut off at {budget}, retrying with {nxt}")
        budget = nxt

ٹاسک کے لحاظ سے، دگنا کرنے کے دو متبادل:

  • اسی بجٹ کے ساتھ reasoning_effort="low" پر retry کریں۔ آسان ٹاسکس پر ماڈل اکثر ضرورت سے زیادہ سوچتا ہے، اور کم effort بڑی حد کے بغیر اسے ٹھیک کر دیتا ہے۔
  • ٹاسک کو تقسیم کریں۔ اگر کوئی جواب بار بار اونچی حد سے ٹکراتا ہے تو عموماً درخواست ایک ساتھ بہت زیادہ مانگ رہی ہوتی ہے۔

ہر کٹے ہوئے جواب کو ٹاسک ٹائپ کے ساتھ لاگ کریں۔ بڑھتی شرح کا مطلب ہے کہ پرامپٹ، ماڈل یا ان پٹ ڈیٹا بدل گیا ہے، اور بجٹ پھر سے ناپنا ہوگا۔ retries نئی inferences ہیں اور ان کا بل پھر بنتا ہے، اس لیے کوششوں کی تعداد محدود رکھیں، جیسا لمبے چلنے والے ایجنٹس: timeouts اور retries میں ہے۔

اسٹریمنگ سے تصویر کیسے بدلتی ہے؟

stream=True کے ساتھ ریزننگ پہلے نظر آنے والے ٹوکن سے پہلے ہوتی ہے، اس لیے شروع میں ریزننگ ماڈل اٹکا ہوا لگ سکتا ہے۔ چیٹ UI میں content آنے تک “thinking” والی حالت دکھائیں، اور کلائنٹ کے timeouts سوچنے کے وقت کے حساب سے رکھیں، صرف جواب کے حساب سے نہیں۔

کچھ سرور ریزننگ کا متن بھی ایک الگ فیلڈ میں اسٹریم کرتے ہیں۔ اس کا نام معیاری نہیں: DeepSeek کا اپنا API، reasoning_content استعمال کرتا ہے، اور vLLM نے اپنی فیلڈ کا نام reasoning_content سے بدل کر reasoning کر دیا، یہ خبردار کرتے ہوئے کہ پرانا کلائنٹ کوڈ “could silently read an empty” (ترجمہ: خاموشی سے ایک خالی) فیلڈ پڑھ سکتا ہے۔ BroadNet کی دستاویزات کسی ریزننگ متن والی فیلڈ کو دستاویز نہیں کرتیں، اس لیے اپنے ماڈل کا خام جواب جانچے بغیر ایسی فیلڈ پر فیچرز نہ بنائیں۔ اگر پڑھیں تو احتیاط سے پڑھیں:

for chunk in stream:
    if chunk.choices:
        delta = chunk.choices[0].delta
        thinking = getattr(delta, "reasoning", None) or getattr(delta, "reasoning_content", None)
        # log or display `thinking` only if your provider actually sends it
        if delta.content:
            print(delta.content, end="")
    elif chunk.usage:                                  # last chunk, with include_usage
        print("\nreasoning tokens:", getattr(chunk.usage.completion_tokens_details, "reasoning_tokens", None))

آخری chunk میں usage کے لیے stream_options={"include_usage": True} چاہیے، جسے BroadNet دستاویز کرتا ہے۔ اسٹریمز کے بارے میں مزید اسٹریمنگ گائیڈ اور SSE کی وضاحت میں ہے۔

کون سا پیرامیٹر نام بھیجیں؟

API پیرامیٹر ریزننگ شامل
OpenAI Chat Completions max_completion_tokens (max_tokens متروک) ہاں
OpenAI Responses max_output_tokens ہاں
BroadNet Inference (Chat Completions) max_tokens، جیسا دستاویز کیا گیا ہے ہاں
vLLM سرورز max_tokens، ساتھ میں اختیاری thinking_token_budget ہاں

فراہم کنندہ بدلتے وقت کوڈ میں وہی نام بھیجیں جو فراہم کنندہ دستاویز کرتا ہے، اور ایک ٹیسٹ کال سے یقینی بنائیں کہ حد نافذ ہوتی ہے۔ خاموشی سے نظر انداز کی گئی حد تب تک ٹھیک لگتی ہے جب تک کوئی بے قابو جواب نہیں آتا۔ بدلنے والے باقی پیرامیٹرز مائیگریشن چیک لسٹ میں ہیں۔

BroadNet Inference کہاں فٹ ہوتا ہے

BroadNet کے تینوں ریزننگ ماڈلز، جب ماڈل فراہم کرتا ہے، usage میں ریزننگ ٹوکنز رپورٹ کرتے ہیں، اس لیے اوپر والا ناپ جیسا لکھا ہے ویسا ہی کام کرتا ہے۔ DeepSeek V4.1 Flash اور GLM 5.3 سب سے زیادہ گنجائش دیتے ہیں، 1,048,576 ٹوکن کے کانٹیکسٹ کے ساتھ۔ Qwen3.8 27B میں 262,144 ہے۔ اگر کسی ٹاسک کے لیے ریزننگ نہیں چاہیے تو Gemma 4 VL 26B ریزننگ ماڈل کے طور پر درج نہیں، اور بجٹ کا سوال ہی نہیں اٹھتا۔ مقررہ قیمت والے DeepSeek V4.1 Flash پلان پر سوچ والے ٹوکنز کی فی ٹوکن فیس نہیں لگتی، مگر کٹے ہوئے جواب پھر بھی وقت لیتے ہیں، اس لیے وہی بجٹنگ لاگو ہوتی ہے۔ BroadNet الگ ریزننگ حد دستاویز نہیں کرتا؛ اگر آپ کو چاہیے تو ایسا فراہم کنندہ یا self-hosted سرور استعمال کریں جو یہ دیتا ہو۔

عام سوالات

میرا ریزننگ ماڈل خالی جواب کیوں دیتا ہے؟

ماڈل نے جواب لکھنے سے پہلے پورا max_tokens بجٹ چھپی ہوئی ریزننگ پر خرچ کر دیا۔ تب finish_reason کی قدر "length" ہوتی ہے۔ max_tokens بڑھائیں، reasoning_effort کم کریں، یا دونوں کریں۔ فوری حل والی ایک مختصر گائیڈ کا لنک اس پوسٹ میں ہے۔

ریزننگ ماڈل کے لیے max_tokens کتنا رکھوں؟

پہلے ناپیں۔ 50 یا زیادہ حقیقی پرامپٹس اونچی حد کے ساتھ چلائیں، اس ٹاسک کے completion_tokens کا 95واں percentile لیں اور تقریباً 20% جوڑیں۔ BroadNet کی دستاویزات کم از کم 1,000 یا زیادہ ٹوکن بتاتی ہیں؛ OpenAI اپنے ماڈلز پر شروع میں 25,000 مخصوص کرنے کا مشورہ دیتا ہے۔

کیا زیادہ max_tokens رکھنے سے خرچ بڑھتا ہے؟

خود بخود نہیں۔ بل ماڈل کے بنائے ٹوکنز کا بنتا ہے، حد کا نہیں۔ اونچی حد تبھی زیادہ خرچ کرتی ہے جب جواب ورنہ کٹ جاتا، اور تب کٹے ہوئے جواب پر ویسے بھی retry کا خرچ لگتا۔

کیا max_completion_tokens اور max_tokens ایک ہی ہیں؟

OpenAI پر max_completion_tokens متروک max_tokens کی جگہ لیتا ہے اور واضح طور پر ریزننگ ٹوکن شامل کرتا ہے۔ کئی OpenAI-compatible فراہم کنندگان اس کے بجائے max_tokens دستاویز کرتے ہیں۔ BroadNet کی دستاویزات max_tokens استعمال کرتی ہیں اور کہتی ہیں کہ ریزننگ اس میں گنی جاتی ہے۔

کیا ریزننگ کو جواب سے الگ محدود کیا جا سکتا ہے؟

صرف وہاں جہاں سرور اسے سپورٹ کرتا ہو۔ vLLM میں thinking_token_budget پیرامیٹر ہے، اور کچھ فراہم کنندگان کے اپنے پیرامیٹرز ہیں۔ BroadNet، low پر سیٹ reasoning_effort دستاویز کرتا ہے، الگ ریزننگ حد نہیں، اس لیے دونوں کا بجٹ ساتھ طے کریں۔

Markdown میں پڑھیںChatGPT سے پوچھیںClaude سے پوچھیںPerplexity سے پوچھیں