BroadRouter

Paano itakda ang max_tokens sa reasoning model: paraan ng pag-budget

Ng BroadNet Inference team · 6 minutong basa · Nailathala

Sa reasoning model, iisang limit ng max_tokens ang sumasaklaw sa pag-iisip at sa sagot, kaya puwedeng maputol ang reply bago lumabas ang anumang text. Sukatin ang kabuuang completion token kada uri ng task, itakda ang max_tokens sa mga 95th percentile dagdag 20%, panatilihin ang prompt at max_tokens sa loob ng context window, at i-retry ang naputol na reply nang dinobleng budget hanggang sa isang hard cap.

Nag-iisip muna ang reasoning model bago sumagot, at sa karamihan ng OpenAI-compatible na API, iisang budget ang pinanggagalingan ng dalawa: max_tokens. Kapag itinakda mo ito gaya ng sa non-reasoning model, ilang daang token para sa maikling sagot, may mga reply na babalik nang walang laman at may finish_reason: "length". Nasa bakit walang laman ang sagot ng reasoning model ang mabilis na solusyon. Ang post na ito ang paraan sa likod ng budget na mapagkakatiwalaan mo: sukatin, itakda mula sa percentile, igalang ang context window, at hawakan ang mga reply na naputol pa rin.

Para sa gastos ng reasoning at kung paano ito babawasan, tingnan ang reasoning token: bakit mas maraming output ang binabayaran mo kaysa nakikita mo.

Bakit nauubos ang budget bago ang sagot?

Sunod-sunod ang pagbuo ng model: una ang reasoning nito, saka ang nakikitang sagot. Bawat token ng dalawa ay kasama sa max_tokens. Ito ang sinasabi ng docs ng BroadNet para sa DeepSeek V4.1 Flash, GLM 5.3 at Qwen3.8 27B: “the reasoning counts toward max_tokens” (salin: kasama ang reasoning sa max_tokens), at kapag maliit ang limit, “the answer comes back empty” (salin: walang laman ang bumabalik na sagot). Ganoon din ang depinisyon ng reference ng OpenAI Chat Completions sa max_completion_tokens, bilang upper bound “including visible output tokens and reasoning tokens” (salin: kasama ang nakikitang output token at reasoning token).

Kaya ang dapat itanong ay hindi “gaano kahaba ang sagot ko?” Ito ay “gaano kahaba ang reasoning at sagot nang magkasama, sa task na ito, sa effort na ito?” Mas pabago-bago iyan kaysa inaasahan ng marami. Sabi ng guide ng OpenAI, puwedeng bumuo ang mga model nito ng “anywhere from a few hundred to tens of thousands of reasoning tokens” (salin: mula ilang daan hanggang sampu-sampung libong reasoning token), depende sa problema.

Mas mahal ba kapag mas malaki ang max_tokens?

Hindi. Ito ang pinakakaraniwang dahilan kung bakit masyadong masikip ang itinatakdang budget. Kisame ang max_tokens. Ang talagang nabuong token ang sinisingil sa iyo. Pareho ang gastos ng reply na nangangailangan ng 1,800 token kahit 4,000 o 40,000 ang kisame.

Ito ang talagang gastos ng masikip na kisame:

Kisame vs kailangan Binabayaran mo Nakukuha mo
Kisame na lampas sa kailangan Mga token na nabuo Ang sagot
Kisame na kulang sa kailangan Ang buong kisame, puro reasoning Walang magagamit, dagdag pa ang retry

Halimbawa: ipagpalagay na isang-kapat ng mga tawag mo ang nangangailangan ng higit 1,000 token. Sa max_tokens=1000, sinisingil ang bawat isa sa mga tawag na iyon ng 1,000 output token ng pag-iisip, walang ibinabalik, at nire-retry. Nagdaragdag iyan ng 250 nasayang na output token kada tawag sa karaniwan sa lahat ng tawag, bago pa ang mga retry mismo, dagdag ang latency ng ikalawang request. Kapag 4,000 ang kisame, walang nasasayang. Sa Qwen3.8 27B, $2.17 kada 1M token ang output, kaya lumalaki ang sayang kapag malaki ang volume.

Ang totoong panganib ng mataas na kisame ay ang runaway na reply: model na umiikot o sobra mag-isip at bumubuo ng higit pa sa kailangan. Hard cap ang pumipigil diyan. Piliin ang cap mula sa data, gaya ng nasa ibaba.

Paano sukatin ang kailangan ng isang task?

Magpatakbo ng totoong prompt para sa isang uri ng task na may maluwag na kisame, at itala ang completion token at ang bahagi ng reasoning. Kapag iniuulat ito ng model, ibinibigay ng usage.completion_tokens_details.reasoning_tokens ang bahagi ng reasoning; nakalista ang field na iyon sa docs ng 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")))

Mga patakaran para sa numerong mapagkakatiwalaan:

  1. Isang uri ng task kada run. Magkakaibang-magkaiba ang distribution ng classification, extraction, code review at planning. Ang iisang pangkalahatang max_tokens ay nagsasayang ng pera sa retry o nagpapalusot ng runaway na reply.
  2. 50 o higit pang totoong prompt. Ang 95th percentile ng sampung sample ay ang pinakamalaki lang sa mga iyon.
  3. Patakbuhin ito sa bawat effort na ginagamit mo. Binabago ng reasoning_effort="low" ang distribution. low ang dinodokumento ng BroadNet; i-test ang ibang value bago umasa sa mga iyon.
  4. Kung hindi zero ang cut_off, itaas ang kisame at patakbuhin ulit. Itinatago ng naputol na sample ang totoong haba nito.
  5. Patakbuhin ulit kapag nagbago ang model o prompt. Puwedeng mas marami o mas kaunti ang pag-iisip ng bagong bersyon ng model.

Pagkatapos, itakda ang max_tokens kada task mula sa recommend(). Sa 95th percentile dagdag 20%, malayo sa kisame ang karamihan ng tawag, at ang paminsan-minsang mahaba lang ang napupunta sa retry path sa ibaba. Ang libreng reasoning token budget tool ang gagawa ng kuwentang ito sa browser mo kapag hawak mo na ang mga numero mo.

Paano nililimitahan ng context window ang budget?

Magkasama sa context window ang prompt at ang sagot. Ganito ang depinisyon ng price feed ng BroadNet sa context_length: “the most tokens one request can hold, prompt and answer together” (salin: ang pinakamaraming token na kayang hawakan ng isang request, prompt at sagot nang magkasama). Kaya:

max_tokens ≤ context length − prompt token

Model Context Puwang para sa max_tokens kapag 200,000 token ang prompt
GLM 5.3 1,048,576 848,576
DeepSeek V4.1 Flash 1,048,576 848,576
Qwen3.8 27B 262,144 62,144

Mahalaga ito sa long-context na trabaho. Ang agent na umabot na sa 250,000 token ang history sa Qwen3.8 27B ay may mga 12,000 token na lang para sa pag-iisip at sagot. Kadalasang mas maraming reasoning din ang kailangan ng long-context na task, kaya tingnan ang natitirang puwang sa mismong oras ng tawag, hindi minsan lang sa startup. Sinasaklaw ng context window at ng context window calculator ang pagkakasya.

Ano ang gagawin kapag naputol pa rin ang reply?

Tingnan ang finish_reason sa bawat tawag. Kung length ito, kulang o hindi kumpleto ang sagot, kahit may text ang content. Huwag itong i-parse na parang kumpleto; karaniwang pinagmumulan ng error sa susunod na hakbang ang naputol na JSON object (structured output).

Mag-retry nang dinobleng budget, sa loob ng puwang na pinapayagan ng context, hanggang sa isang hard cap:

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

Dalawang alternatibo sa pagdodoble, depende sa task:

  • Mag-retry sa reasoning_effort="low" na pareho ang budget. Sa mga simpleng task, madalas sobra mag-isip ang model, at naaayos ito ng mas mababang effort nang hindi kailangan ng mas malaking kisame.
  • Hatiin ang task. Kung paulit-ulit na tumatama sa mataas na cap ang isang reply, kadalasang sobra ang hinihingi ng request nang sabay-sabay.

I-log ang bawat pagkaputol kasama ang uri ng task. Kapag tumataas ang rate, may nagbago sa prompt, sa model o sa input data, at kailangang sukatin ulit ang budget. Bagong inference ang mga retry at sinisingil ulit, kaya limitahan ang bilang ng subok, gaya ng sa long-running agent: timeout at retry.

Paano binabago ng streaming ang sitwasyon?

Sa stream=True, nangyayari ang reasoning bago ang unang nakikitang token, kaya puwedeng mukhang natigil ang reasoning model sa simula. Sa chat UI, magpakita ng “thinking” na estado hanggang dumating ang content, at itakda ang client timeout para sa oras ng pag-iisip, hindi lang sa sagot.

May mga server din na nag-i-stream ng mismong reasoning text, sa hiwalay na field. Hindi standard ang pangalan: reasoning_content ang gamit ng sariling API ng DeepSeek, at pinalitan ng vLLM ang pangalan ng field nito mula reasoning_content tungong reasoning, na may babalang ang lumang client code ay “could silently read an empty” field (salin: puwedeng tahimik na makabasa ng walang lamang field). Hindi dinodokumento ng docs ng BroadNet ang isang reasoning text field, kaya huwag bumuo ng feature dito nang hindi tinitingnan ang raw response para sa model mo. Kung babasahin mo ito, basahin nang maingat:

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

Kailangan ng stream_options={"include_usage": True} ang usage sa huling chunk, at dinodokumento ito ng BroadNet. Higit pa tungkol sa stream sa streaming guide at sa paliwanag sa SSE.

Aling pangalan ng parameter ang dapat mong ipadala?

API Parameter Kasama ang reasoning
OpenAI Chat Completions max_completion_tokens (deprecated ang max_tokens) Oo
OpenAI Responses max_output_tokens Oo
BroadNet Inference (Chat Completions) max_tokens, ayon sa docs Oo
Mga vLLM server max_tokens, dagdag ang opsyonal na thinking_token_budget Oo

Kapag naglilipat ng code sa pagitan ng mga provider, ipadala ang pangalang dinodokumento ng provider, at kumpirmahin sa isang test call na gumagana ang limit. Mukhang ayos ang limit na tahimik na binabalewala hanggang may dumating na runaway na reply. Sinasaklaw ng migration checklist ang iba pang parameter na nagbabago.

Saan pumapasok ang BroadNet Inference

Iniuulat ng tatlong reasoning model ng BroadNet ang reasoning token sa usage kapag ibinibigay ito ng model, kaya gumagana ang pagsukat sa itaas gaya ng pagkakasulat. Ang DeepSeek V4.1 Flash at GLM 5.3 ang nagbibigay ng pinakamaraming puwang, na may 1,048,576 token na context. 262,144 ang sa Qwen3.8 27B. Kung hindi mo kailangan ng reasoning para sa isang task, hindi nakalista bilang reasoning model ang Gemma 4 VL 26B at naiiwasan nito ang tanong sa budget. Sa flat na DeepSeek V4.1 Flash plan, walang singil kada token ang mga thinking token, pero may gastos pa rin sa oras ang mga naputol na reply, kaya parehong pag-budget ang naaangkop. Hindi dinodokumento ng BroadNet ang hiwalay na limit sa reasoning; kung kailangan mo nito, gumamit ng provider o self-hosted na server na nag-aalok nito.

Mga tanong

Bakit walang laman ang response ng reasoning model ko?

Naubos ng model ang buong budget ng max_tokens sa nakatagong reasoning bago nito naisulat ang sagot. "length" ang finish_reason sa ganoong kaso. Itaas ang max_tokens, ibaba ang reasoning_effort, o pareho. May link sa post na ito sa maikling gabay na may mabilis na solusyon.

Anong max_tokens ang dapat kong itakda sa reasoning model?

Sukatin muna. Magpatakbo ng 50 o higit pang totoong prompt na may maluwag na kisame, kunin ang 95th percentile ng completion_tokens para sa task na iyon, at magdagdag ng mga 20%. 1,000 token o higit pa ang ibinibigay na minimum ng docs ng BroadNet; payo ng OpenAI na magreserba ng 25,000 sa simula sa mga model nito.

Mas mahal ba kapag mas mataas ang max_tokens?

Hindi, sa sarili nito. Ang mga token na binuo ng model ang sinisingil, hindi ang kisame. Mas mahal lang ang mas mataas na kisame kapag mapuputol sana ang reply, at sa ganoong kaso, magagastusan ka rin naman ng retry ng naputol na reply.

Pareho ba ang max_completion_tokens at max_tokens?

Sa OpenAI, pinapalitan ng max_completion_tokens ang deprecated na max_tokens at tahasang kasama rito ang reasoning token. max_tokens naman ang dinodokumento ng maraming OpenAI-compatible na provider. max_tokens ang gamit sa docs ng BroadNet at sinasabi nitong kasama rito ang reasoning.

Puwede ko bang lagyan ng hiwalay na limit ang reasoning at ang sagot?

Kung suportado lang ng server. May thinking_token_budget na parameter ang vLLM, at may sarili ang ilang provider. reasoning_effort na low ang dinodokumento ng BroadNet, hindi hiwalay na limit sa reasoning, kaya i-budget nang magkasama ang dalawa.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity