BroadRouter

Bago mag-fine-tune: tukuyin muna ang problemang lulutasin

Ng BroadNet Inference team · 7 minutong basa · Nailathala · Na-update

Mag-fine-tune lang kapag ipinakita ng isang evaluation ang paulit-ulit na failure na hindi naayos ng mas magandang prompt, mga halimbawa, retrieval at validation. Kadalasang retrieval ang kailangan kapag kulang ang kaalaman, at structured output at mga check kapag mali ang format. Bago humingi ng custom model, mangolekta ng labelled na halimbawa na legal mong magagamit, magtabi ng test set, at itala ang score na dapat talunin.

Madalas na fine-tuning ang unang solusyong naiisip kapag may nagkamali ang model, at madalas din itong maling solusyon. Nangangailangan ito ng pangongolekta ng data, pag-label, mga training run at isang model na kailangan mo nang i-maintain. Maraming failure ang nawawala sa mas malinaw na prompt, sa pag-retrieve ng tamang dokumento, o sa isang check sa code sa output. Tungkol ang post na ito sa pagtukoy kung aling kaso ang sa iyo, at kung ano ang ihahanda kung talagang kailangan mo ng custom model.

Anong problema ang sinusubukan mong lutasin?

Pangalanan muna ang failure bago ang solusyon. Karamihan ng failure ng LLM ay pumapasok sa iilang pattern, at may mas murang unang step ang bawat isa:

Sintomas Subukan muna Nakakatulong ang fine-tuning kapag
Mali o luma ang facts Retrieval (RAG) sa mga dokumento mo Bihira; kailangan pa rin ng retrieval ang mga fact na nagbabago
Maling format, sirang JSON Structured output, schema check, isang retry Kakaiba ang format at hindi sapat ang mga halimbawa sa prompt
Hindi pare-parehong label o kategorya Malinaw na depinisyon at few-shot na halimbawa Malaki o pino ang label set at hindi kasya sa prompt ang mga halimbawa
Maling tono o estilo Style guide sa system prompt, na may mga halimbawa Kailangang manatili ang house style sa libu-libong output
Maling dinig o baybay sa mga salita ng domain Listahan ng bokabularyo sa prompt, post-correction sa code Paulit-ulit na mali ang dinig ng speech model sa parehong pangalan, code o numero
Masyadong mabagal o mahal sa malakihan Mas maliit na model, prompt caching, mas maiikling prompt Kayang pantayan ng maliit na fine-tuned na model ang malaki sa isang makitid na task
Maling wika o dialect Mga instruction sa tamang wika; tingnan ang Arabic prompt engineering Naiintindihan ng model pero ayaw nitong sumulat sa dialect na kailangan mo

Ganito rin ang pagkakasunod na inilalarawan ng sariling gabay ng OpenAI: sumulat muna ng evals, saka paulit-ulit na pagbutihin ang mga prompt, at mag-fine-tune para sa ilang use case. Sinasabi nito na ang proseso ng prompt engineering ay “may be all you need in order to get great results.” (salin: baka iyon lang ang kailangan mo para makakuha ng magagandang resulta.) Inililista nito ang naidaragdag ng fine-tuning kumpara sa prompting: mas maraming halimbawa kaysa sa kasya sa isang prompt, mas maiikling prompt na nakakatipid ng token, pag-train sa data na ayaw mong ipadala sa bawat request, at pagpapagaling sa isang mas maliit na model sa isang task.

Paano patunayan na paulit-ulit ang failure?

Gamit ang eval set. Mangolekta ng 100 hanggang 200 totoong input na may kilalang magandang output, gaya sa pag-evaluate ng LLM bago lumipat. I-score ang kasalukuyang prompt mo. Saka lagyan ng maikling kategorya ang bawat failure: wrong_label, missing_field, dialect, hallucinated_fact, at iba pa.

Kandidato lang para sa fine-tuning ang isang pattern kung totoo ang tatlong ito:

  1. Madalas ito. May makabuluhang bahagi ito ng mga failure, hindi lang isa o dalawang kakaibang kaso.
  2. Nakaligtas ito sa murang mga solusyon. Sinubukan mo na ang mas malinaw na instruction, mga halimbawa, retrieval at validation, at nandoon pa rin ang kategorya.
  3. Pare-pareho ito. Nagkakasundo ang mga tao sa tamang sagot. Kung magkaiba ang label ng dalawa sa sarili mong reviewer sa parehong kaso, matututunan ng model na sinanay sa mga label nila ang hindi pagkakasundo.

Isulat ang resulta bilang maikling pahayag, gaya ng gawa-gawang halimbawang ito: “Sa 200-kasong Arabic support set namin, mali ang label ng pinakamagandang prompt sa 18% ng mga billing ticket bilang delivery; ibinaba ito ng few-shot na halimbawa sa 15%.” Ang pangungusap na iyan ang brief para sa fine-tune, at ang numerong dapat talunin.

Aling mas simpleng pagbabago ang dapat munang i-test?

Patakbuhin ang mga ito ayon sa gastos, at mag-score ulit pagkatapos ng bawat isa:

  1. Instruction. Ilarawan ang bawat label o field. Sabihin kung ano ang gagawin kapag hindi sigurado.
  2. Halimbawa. Magdagdag ng tatlo hanggang sampung totoong halimbawa, kasama ang mahihirap na kaso.
  3. Retrieval. Kung kailangan ng facts sa mga sagot, i-retrieve ang may kinalamang passage. Tinatalakay ng Arabic RAG search at long context vs RAG ang mga pagpipilian.
  4. Constraint. Gumamit ng structured output kung saan sinusuportahan ito ng model, at suriin ang output sa code. Magtanong ulit nang isang beses kasama ang error.
  5. Ibang model. Baka kaya na ng ibang base model ang kailangan mo. Sasabihin ito sa iyo ng parehong eval set sa loob ng isang oras.

Oras, hindi linggo, ang gastos ng bawat step, at nag-iiwan ang bawat isa ng mas magandang baseline na kailangang talunin ng fine-tune kung kailangan mo pa rin ito.

Anong data ang kailangan mo, at may karapatan ka bang gamitin ito?

Bago ang kalidad, suriin ang karapatan. Madalas na galing sa mga usapan ng customer, dokumento o call recording ang training data. Kailangan mo ng legal na batayan at, madalas, ng pahintulot o termino sa kontrata na sumasaklaw sa training. Suriin ang sarili mong privacy notice at mga kontrata sa customer, at alisin ang personal data na hindi mo kailangan. Huwag ipagpalagay na kinokolekta ito ng API provider mo para sa iyo: ang privacy statement ng BroadNet, halimbawa, ay nagsasabing hindi nito itinatago ang inference content at hindi nito ginagamit ang inference data para mag-train, mag-fine-tune o mag-evaluate ng mga model.

Saka suriin ang kalidad. Binabasa ng script na ito ang training file at eval file sa karaniwang chat JSONL format (isang {"messages": [...]} kada linya, na nagtatapos sa sagot ng assistant) at nire-report ang mga problemang tahimik na sumisira sa mga fine-tune: mga sirang row, duplicate, parehong input na magkaiba ang sagot, mga eval item na tumagas sa training, balanse ng mga label at posibleng personal data.

import json, re, sys
from collections import Counter

DIAC = re.compile(r"[ً-ٰٟـ]")          # tashkeel, dagger alef, tatweel
PII = {"email": re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+"),
       "phone": re.compile(r"(?:\+|00)\d[\d\s-]{7,}\d")}

def norm(s: str) -> str:
    s = DIAC.sub("", s.lower())
    s = re.sub("[إأآٱ]", "ا", s).replace("ى", "ي")
    return " ".join(s.split())

def load(path):
    rows, errors = [], []
    for i, line in enumerate(open(path, encoding="utf-8"), 1):
        try:
            ex = json.loads(line)
            roles = [m["role"] for m in ex["messages"]]
            if roles[-1] != "assistant" or "user" not in roles:
                raise ValueError(f"roles {roles}")
            rows.append(ex)
        except (ValueError, KeyError, IndexError, TypeError) as e:
            errors.append(f"line {i}: {e}")
    return rows, errors

def key(ex):     # the input side, normalised: what the model sees
    return norm(" ".join(m["content"] for m in ex["messages"] if m["role"] != "assistant"))

def check(train_path, eval_path):
    train, errs = load(train_path)
    evals, eval_errs = load(eval_path)
    keys = Counter(key(e) for e in train)
    labels = Counter(e["messages"][-1]["content"].strip() for e in train)
    leaked = {key(e) for e in evals} & set(keys)
    pii = Counter(k for e in train for m in e["messages"] for k, rx in PII.items() if rx.search(m["content"]))
    conflicts = Counter()
    seen = {}
    for e in train:
        k, a = key(e), e["messages"][-1]["content"].strip()
        if k in seen and seen[k] != a:
            conflicts[k] += 1
        seen.setdefault(k, a)
    return {"train_examples": len(train), "parse_errors": errs + eval_errs,
            "duplicate_inputs": sum(n - 1 for n in keys.values() if n > 1),
            "same_input_different_answer": len(conflicts),
            "eval_items_also_in_train": len(leaked),
            "answer_distribution": labels.most_common(5),
            "examples_with_possible_pii": dict(pii)}

if __name__ == "__main__":
    print(json.dumps(check(sys.argv[1], sys.argv[2]), ensure_ascii=False, indent=1))

Pinatakbo namin ito sa isang pitong-linyang toy file ng mga support ticket sa Arabic, English at Spanish. Nakahanap ito ng isang row na walang sagot ng assistant, dalawang duplicate na input (ang isa ay nagkaiba lang sa isang diacritic, na inaalis ng normaliser, gaya sa Arabic text normalization), isang input na may label na parehong billing at other, isang eval item na lumabas din sa training, at isang phone number. Bawat isa sa mga iyon ay magpapamukhang mas maganda o mas masama ang fine-tune kaysa sa totoo.

Mahalaga ang normalisation para sa Arabic. Kung wala ito, magkaibang input ang turing sa “متأخر” at “متأخِّر”, at puwedeng makalusot sa training ang halos-kopya ng isang test item.

Paano i-evaluate nang patas ang isang fine-tune?

Gamitin ang parehong held-out test set na ginamit mo para sa baseline, at ilayo ito sa training. Saka ikumpara:

  • Laban sa pinakamagandang prompt, hindi sa una. Walang napapatunayan ang fine-tune na tumalo sa mahinang prompt.
  • Kada kategorya at kada wika. Puwedeng itago ng pangkalahatang pagtaas ang pagbaba sa Arabic habang gumagaling ang English. I-report ang bawat isa.
  • Sa pangkalahatang kilos. Magdagdag ng 20 hanggang 50 ordinaryong request na maayos na nahawakan ng model dati. Puwedeng pasamain ng makitid na training ang kilos sa labas ng task.
  • Sa gastos at latency. Madalas na nabibigyang-katwiran ang fine-tune kapag mas maliit na model ang gumagawa ng trabaho. Sukatin din ang token at oras kada request.

Pagpasyahan ang pass rule bago mo makita ang mga numero, gaya sa eval post: halimbawa, “hindi bababa sa 5 puntos na mas maganda sa mga billing label, walang kategoryang bababa nang higit 2 puntos, pasado ang Arabic at English.”

Ano ang nagbabago kapag hindi mo ma-fine-tune ang mga hosted model?

Mas kaunti kaysa sa inaasahan mo ang mga hosted API na nag-aalok ng self-serve na fine-tuning. Nakatala sa deprecations page ng OpenAI ang isang update sa self-serve fine-tuning platform nito: mula 7 Mayo 2026, hindi na makakagawa ng job ang mga organisasyong hindi pa nakapag-fine-tune; mula 2 Hulyo 2026, hindi na rin makakagawa ang mga organisasyong hindi nagpatakbo ng inference sa fine-tuned na model sa nakaraang 60 araw; at mula 6 Enero 2027, hindi na makakagawa ng bagong fine-tuning job ang mga aktibong kasalukuyang customer. Mananatiling magagamit para sa inference ang mga umiiral na fine-tuned na model hanggang ma-deprecate ang mga base model nila.

Ang karaniwang alternatibo ay isang open-weight model na sinanay gamit ang parameter-efficient na paraan gaya ng LoRA. Iniulat ng LoRA paper (Hu et al.) na, kumpara sa full fine-tuning ng GPT-3 175B gamit ang Adam, kayang bawasan ng LoRA nang 10,000 beses ang bilang ng trainable parameter at nang 3 beses ang kailangang GPU memory. Pagkatapos, kailangan mo ng lugar para i-serve ang resulta, na alinman sa sarili mong hardware o isang provider na nagho-host ng custom weights. Tinatalakay ng open-weight vs closed na mga model ang trade-off na iyon.

Saan pumapasok ang BroadNet Inference

Sariling site ng BroadNet ang BroadRouter. Walang fine-tuning endpoint ang self-serve na API ng BroadNet Inference: chat completions at audio transcription lang ang dinodokumento ng API reference nito. Sinasabi ng parehong page na “private endpoints, our Arabic fine-tunes and other models on request are reached with a private ID issued with the endpoint.” (salin: naaabot ang mga private endpoint, ang aming mga Arabic fine-tune at iba pang model on request gamit ang private ID na ibinibigay kasama ng endpoint.) Inililista ng mga model page ng BroadNet bilang on request ang isang BroadNet fine-tune ng Cohere Transcribe Arabic para sa mga numero, petsa at pangalan sa maingay na audio, na may private model ID kada customer, at sinasabing available ang Gemma 4 VL 26B sa private endpoint “including our Arabic fine-tunes” (salin: kasama ang aming mga Arabic fine-tune). Mga katanungan ito sa pamamagitan ng contact page, hindi isang bagay na mabibili o masasanay mo nang mag-isa; tinatalakay ng pagpaplano ng private endpoint kung ano ang ipapadala.

Para sa lahat ng nauuna sa step na iyon, sapat na ang mga pampublikong model para buuin ang eval set at baseline mo: dinodokumento ng Qwen3.8 27B at GLM 5.3 ang structured output, tumatakbo ang Gemma 4 VL 26B sa $5 na panimulang credit, at hinahawakan ng BroadNet Transcribe Arabic ang pananalita sa $0.0042 kada minuto. Hindi itinatago ang inference content; itinatago ang kinakailangang account, billing at security metadata ayon sa privacy statement ng BroadNet.

Mga tanong

Fine-tuning ba o RAG ang dapat kong gamitin?

Gumamit ng retrieval kapag kulang ang facts ng model, lalo na ang mga fact na nagbabago: mga dokumento, presyo, patakaran. Isaalang-alang ang fine-tuning kapag nasa model na ang impormasyon pero palagiang mali ang kilos nito, gaya ng format, tono, label o bokabularyo ng domain, at hindi ito naayos ng mga prompt na may halimbawa.

Paano ko malalaman kung sapat na ang prompt engineering?

Sukatin ito. Gumawa ng eval set mula sa totoong mga input, i-score ang kasalukuyang prompt, saka subukan ang mas malinaw na instruction, few-shot na halimbawa, structured output at validation. Kung naabot ng score ang target mo, tumigil na. Kung nananatili ang isang uri ng failure sa lahat ng pagbabagong iyon, kandidato iyon para sa fine-tuning.

Gaano karaming data ang kailangan ko para mag-fine-tune?

Walang iisang numero para sa lahat. Nakadepende ito sa task, sa base model at sa paraan. Mangolekta ng sapat na labelled at pare-parehong halimbawa para masakop ang bawat kasong mahalaga sa iyo, dagdag ang hiwalay na held-out test set, at tingnan kung tumataas pa ang score habang nagdaragdag ka ng data.

Puwede ba akong mag-fine-tune ng model sa BroadNet Inference?

Hindi bilang self-serve. Chat completions at audio transcription ang dinodokumento ng API reference ng BroadNet, at walang training endpoint. Inililista ng BroadNet ang mga Arabic fine-tune, gaya ng tuned na Cohere Transcribe Arabic, bilang mga on-request na model na sine-serve sa private endpoint na may private model ID.

Nagte-train ba ang BroadNet sa API traffic ko?

Sinasabi ng privacy statement ng BroadNet na hindi nito ginagamit ang inference data para mag-train, mag-fine-tune o mag-evaluate ng mga model, at hindi nito itinatago ang inference content. Kung gusto mong mag-fine-tune sa sarili mong traffic, ikaw mismo ang dapat mangolekta at mag-store ng data na iyon, nang may karapatang gamitin ito.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity