Gusto mo bang hindi magtunog robot ng panahon ang iyong AI at mas maging… katulad mo?
Isipin ito: pinapakuha mo sa iyong AI ng buod ng email ng customer, at sumasagot ito na parang nagkukwento ng Shipping Forecast. Tama naman sa teknikal; walang tulong sa espirituwal. Ang gusto mo talaga ay ang iyong AI—ang iyong tono, ang iyong jargon, ang iyong mga kagustuhan—nang hindi mo kailangang magtayo ng research lab sa iyong garahe.
Diyan pumapasok ang fine-tuning. At kung may naririnig kang bulung-bulungan tungkol sa “Tinker API,” nasa tamang lugar ka. Ito ang how-to guide para sa fine-tuning ng sarili mong AI model gamit ang Tinker API—para sa susunod na i-type mo ang “Gumawa ng draft na tugon,” makakakuha ka ng isang bagay na katulad ng sa iyong team, hindi pinsan ni HAL 9000.
Lalakarin natin ang buong proseso: kung ano ang ibig sabihin ng fine-tuning, kung paano ihanda ang iyong data, kung paano magpatakbo ng fine-tune gamit ang Tinker API, at kung paano hindi ubusin ang iyong budget (o ang iyong pasensya). Sasabihin ko pa sa iyo kung saan nakatira ang mga gremlin—dahil ang fine-tuning ay makapangyarihan, ngunit hindi ito isang fairy godmother.
Paalala sa mga keyword: madalas nating sasabihin ang “kung paano gamitin ang Tinker API,” dahil iyan ang tanong na ipinarito mo. Isasama rin natin ang mga long-tail term tulad ng “fine-tune ang iyong sariling AI model,” “Tinker API tutorial,” “paghahanda ng dataset para sa fine-tuning,” at “pag-deploy ng fine-tuned model.” Kung parang ang dami niyan, huwag kang mag-alala—gagawin ko itong madaling maintindihan.
Ano ang fine-tuning—at ano ang hindi
Kung ang isang pangkalahatang AI model ay isang Swiss Army knife, ang fine-tuning ay ikaw na nagsasabing, “Hoy, kutsilyo, gagawin kitang napakagaling sa pagbubukas ng mga pakete.” Hindi mo imbento ang kutsilyo. Tinuturuan mo ito ng paborito mong karton.
Sa pagsasagawa, ang fine-tuning ay nangangahulugang kukuha ka ng base model (na sinanay na sa napakaraming teksto sa internet) at itutulak ito gamit ang iyong mga halimbawa—ang iyong estilo ng pagsulat, ang iyong domain-specific na Q&A, ang iyong mga support script—para tumugon ito sa paraang gusto mo. Parang binibigyan mo ang model ng style guide at isang tambak ng mga practice quiz.
Ngunit ang fine-tuning ay hindi isang magic spell. Hindi ito biglang matututo ng mga katotohanang hindi pa nito nakikita maliban kung ituturo ng iyong data ang mga pattern na iyon. Hindi rin nito “maaalala” ang malalaking proprietary na dokumento maliban kung pakakainin mo ito ng mga kinatawang snippet. At kung ang iyong data ay magulo, magkasalungat, o maliit, mamanahin ng iyong model ang mga ugaling iyon tulad ng isang teenage rock band na nagmana ng tempo ng kanilang drummer.
Ang mabilis na itineraryo
Narito ang pangkalahatang ideya kung paano gamitin ang Tinker API para i-fine-tune ang iyong sariling AI model:
- Pumili ng base model sa Tinker API.
- Maghanda ng malinis at balanseng dataset na may mga prompt at ideal na tugon.
- I-upload ang iyong dataset sa Tinker.
- Gumawa ng fine-tuning job na may malinaw na mga hyperparameter.
- Subaybayan ang pagsasanay, suriin ang mga resulta gamit ang isang held-out test set.
- I-deploy at tawagin ang iyong fine-tuned model sa produksyon.
- Ulitin kapag may nakita kang kakaiba.
Lalakarin natin ito nang hakbang-hakbang, na may mga halimbawa ng code na maaari mong i-paste, at mga tip na pumigil sa akin na sumigaw sa aking screen.
Hakbang 1: Piliin ang iyong base model na parang pumipili ka ng rental car
Hindi ka magre-renta ng 15-seat van para mag-parallel-park sa Manhattan. Katulad nito, huwag pumili ng isang napakalaking model kung kailangan mo ng mabilis at murang mga tugon para sa isang milyong kahilingan araw-araw. Ang Tinker API ay karaniwang nag-aalok ng ilang pamilya ng modelo—magaan, mid-size, at “wow, ang talino.”
- Kung kailangan mo ng bilis at pagtitipid sa gastos: piliin ang mas maliit na base.
- Kung kailangan mo ng nuance, pangangatwiran, o mahabang pagsulat: piliin ang mas malaking base.
- Kung ang iyong domain ay may maraming jargon (medikal, legal, support macros): ang mid hanggang large na mga model ay mas mabunga ang fine-tune.
Pro tip: Magsimula sa mas maliit para sa prototype. Kung tumalon ang iyong mga pangunahing sukatan, ilipat ang parehong dataset sa mas malaking base.
Hakbang 2: Ihanda ang iyong dataset na parang recipe card, hindi ang iyong junk drawer
Ang iyong dataset ang pinakamalaking bagay na makakaapekto sa kalidad. Natututo ang model sa pamamagitan ng paggaya; kung malabo ang mga halimbawa, natututo ang model na maging malabo. Kung malinaw, pare-pareho, at iba-iba ang mga ito, ang iyong model ay nagiging isang kapaki-pakinabang na katrabaho na talagang nagbabasa ng memo.
Maghangad ng format na JSONL (JSON Lines) na may malinaw na mga pares ng instruction-response. Para sa chat-style na fine-tuning, isama ang mga role tulad ng system/user/assistant. Panatilihing maikli hanggang katamtaman ang bawat halimbawa; ang ilang dosenang de-kalidad na halimbawa ay mas mainam kaysa sa isang libong magugulo.
Halimbawa (istilo ng pagtuturo):
{"instruction": "Ibuod ang support ticket na ito sa 2 pangungusap, magiliw na tono.", "input": "Nagsusumbong ang customer ng 404 error kapag nagki-click sa 'Track Order'", "output": "Salamat sa pag-flag nito! Nagpapakita ang site ng 404 kapag nag-click ang mga customer sa 'Track Order.' Iniimbestigahan namin ang isang sirang link sa pahina ng pagsubaybay sa order at susundan namin ito ng isang pag-aayos."}
Halimbawa (istilo ng chat):
{"messages": [
{"role": "system", "content": "Ikaw ay isang maikli at magiliw na support agent. Gumamit ng simpleng Ingles."},
{"role": "user", "content": "Nag-renew ang subscription ko pero expired na ang card. Tulong?"},
{"role": "assistant", "content": "Paumanhin sa abala! Muli kong sinuri ang iyong plano—sinubukang mag-renew gamit ang isang expired na card. Paki-update ang iyong card sa pahina ng Pagsingil; susubukan kong muli ang pag-charge kapag na-save na ito."
]}
Mga tip para sa paghahanda ng dataset para sa fine-tuning:
- Ang pagiging pare-pareho ang pinakamahalaga. Palaging gamitin ang parehong tono, pagbati, at istraktura.
- Balansehin ang iyong mga paksa. Kung 90% ng mga halimbawa ay mga refund, ang iyong model ay magiging Refund Fairy.
- Lagyan ng label ang mga nakakalito na kaso. Isama ang mga negatibong halimbawa (kung ano ang hindi dapat sabihin), kung sinusuportahan ng Tinker API ang isang preference signal.
- Panatilihin itong ligtas. Alisin ang personal na data. Kung nagtatrabaho ka sa sensitibong impormasyon, i-anonymize o i-synthesize ito.
Maglaan ng 10–20% ng iyong data bilang test set. Kung magmamarka ka sa training set, lolokohin mo ang iyong sarili na iniisip na ang model ay isang henyo. Tanungin mo ako kung paano ko nalaman.
Hakbang 3: I-upload ang iyong data sa Tinker API nang walang luha
Karamihan sa mga fine-tuning platform ay nag-aalok ng storage endpoint. Sa Tinker API, karaniwan mong:
- Gumawa ng dataset resource (hal., POST /datasets)
- I-upload ang iyong JSONL file
- I-validate ang schema (karaniwang nagbabalik ang Tinker ng isang madaling gamiting ulat: OK counts, errors, weird fields)
Pseudo-halimbawa (curl-ish):
curl -X POST -H "Authorization: Bearer YOUR_TINKER_KEY" -F "file=@my_finetune_data.jsonl" -F "purpose=finetune"
Kung sinusuportahan ng Tinker API ang isang CLI, mas madali ang buhay:
I-upload
tinker datasets upload my_finetune_data.jsonl --purpose finetune
I-validate
tinker datasets validate DATASET_ID
Ang mga error sa validation ay iyong kaibigan. Parang nanghuhusga sila, ngunit inililigtas ka nila mula sa mga misteryosong pagkabigo sa pagsasanay nang 2 a.m.
Hakbang 4: Simulan ang isang fine-tune job at pumili ng makatwirang mga setting
Magsisimula ka ng isang trabaho na tumuturo sa iyong dataset at sa iyong napiling base model. Karamihan sa mga endpoint ng fine-tuning ng Tinker API ay tumatanggap ng mga parameter tulad ng epochs, learning rate, batch size, at evaluation frequency. Pagsasalin: kung ilang beses dadaan sa iyong data, kung gaano kaagresibo matututo ang model, kung ilang halimbawa ang pinag-aaralan nito nang sabay-sabay, at kung gaano kadalas itong nagpapakita sa iyo ng ulat ng progreso.
Halimbawang kahilingan:
curl -X POST -H "Authorization: Bearer YOUR_TINKER_KEY" -H "Content-Type: application/json" -d '{
"base_model": "tinker-large-1",
"dataset_id": "ds_abc123",
"epochs": 3,
"learning_rate": 1e-5,
"batch_size": 8,
"eval_dataset_id": "ds_eval789",
"suffix": "support-tone-v1"
}'
Makatwirang mga default:
- Epochs: 3–5 para sa maliliit hanggang katamtamang dataset. Hindi palaging mas mainam ang mas marami; minsan ito ay overfitting lamang na may dagdag na hakbang.
- Learning rate: magsimula nang konserbatibo (1e-5 o 2e-5). Kung masyadong mabilis matuto ang model, nakakalimutan nito ang pangkalahatang katalinuhan nito.
- Batch size: anumang pinapayagan ng iyong quota, ngunit huwag mag-alala—ang mga pagpapabuti sa pagganap ay nagmumula sa magandang data.
- Early stopping: kung inaalok ito ng Tinker API, i-enable ito. Ito ang “malayo pa ba tayo?” ng machine learning na paminsan-minsan ay nagsasabing, “Oo.”
Hakbang 5: Subaybayan ang pagsasanay na parang isang lawin—ngunit isang chill na lawin
Karaniwang nag-stream ang Tinker ng mga log: training loss, evaluation loss, at marahil mga custom na sukatan na iyong tinukoy (tulad ng eksaktong tugma para sa Q&A). Narito kung paano basahin ang mga palatandaan:
- Pababa ang training loss, flat o pataas ang eval loss? Nag-ooverfit ka—nagmememorya ng iyong mga sagot sa pagsasanay ngunit bumabagsak sa mga bagong sagot.
- Parehong pababa ang trend? Nasa tamang landas ka.
- Tumatalbog ang loss na parang pogo stick? Maaaring masyadong mataas ang iyong learning rate, o hindi pare-pareho ang iyong dataset.
Suriin ang mga partial output kung nag-aalok ang Tinker ng mga preview generation sa kalagitnaan ng pagsasanay. Mag-sample ng ilang prompt mula sa iyong test set at tingnan ang tono/katumpakan. Oo, ito ay qualitative—ngunit sinasanay mo ang istilo, hindi ang mga patunay sa pisika.
Hakbang 6: Pangalanan ito, i-deploy ito, tawagin ito
Kapag natapos ang trabaho, pagpapalain ka ng Tinker API ng isang model ID tulad ng ft:tinker-large-1:support-tone-v1:abc123. Maaari mo itong i-deploy sa likod ng isang endpoint at tawagin ito tulad ng base model—ngunit ngayon ay nagsasalita na ito tulad ng iyong team.
Halimbawang pagtawag sa generation:
curl -X POST -H "Authorization: Bearer YOUR_TINKER_KEY" -H "Content-Type: application/json" -d '{
"model": "ft:tinker-large-1:support-tone-v1:abc123",
"messages": [
{"role": "system", "content": "Ikaw ay isang maikli at magiliw na support agent."
},
{"role": "user", "content": "Late na ang refund ko at naiinis ako."
}],
"temperature": 0.4
}'
Maaari ka ring magtakda ng mas mataas na “presence_penalty” o mas mababang “temperature” kung masyadong madaldal o masyadong matipid ang iyong model. Ipapaliwanag ng mga dokumento ng Tinker ang mga setting—huwag kang mahiya na mag-eksperimento.
Hakbang 7: Suriin na parang isang coach, hindi isang hukom
Gusto mo ng isang awtomatikong scorecard at isang scorecard ng tao. Ang mga awtomatikong sukatan (BLEU, ROUGE, accuracy) ay maayos ngunit bulag sa tono. Nahuhuli ng mga tao ang problemang “parang suplado ito.”
Mag-set up ng isang maliit na rubric:
- Pagsunod sa pagtuturo (1–5)
- Kaligtasan/pagsunod (1–5)
Mag-sample ng 50–100 output mula sa iyong held-out set. Hilingin sa dalawang tao na i-rate ang mga ito nang magkahiwalay. Kung ang isang kategorya ay may average na mas mababa sa 3, subaybayan ito pabalik sa iyong dataset at magdagdag ng higit pang mga halimbawa na nagpapakita ng pag-uugali na gusto mo.
Hakbang 8: Gastos at pagganap: kung ano ang pinapahalagahan ng iyong CFO at ng iyong server
Ang fine-tuning gamit ang Tinker API ay nagkakahalaga ng pera sa dalawang lugar: pagsasanay at inference. Ang pagsasanay ay isang one-time na sprint; ang inference ay ang marathon.
- Bawasan ang haba ng token. Ang mas maiikling prompt at output = mas maliit na bill.
- Gumamit ng system prompt na nagbabalangkas sa iyong istilo, ngunit huwag ulitin ang malalaking pagtuturo sa bawat pagtawag kung sinusuportahan ng Tinker ang isang default na deployment-level.
- I-cache ang mga karaniwang prompt kung maaari.
- Isaalang-alang ang isang routing strategy: gamitin lamang ang iyong fine-tuned na malaking model kung kinakailangan; kung hindi, bumalik sa isang mas maliit at mas murang model.
Mahalaga rin ang latency. Kung mas mabagal tumakbo ang iyong fine-tuned model, subukan ang mas maliit na mga context window, o gamitin ang maliit na model para sa pag-uuri at ang malaki lamang para sa generative text.
Hakbang 9: Pag-troubleshoot: ang pinakamagagaling na hit ng mga gremlin
- Inuulit ng model ang sarili nito na parang sirang plaka.
- Babaan ang temperature; magdagdag ng mga halimbawa na may malinaw at maikling sagot; bawasan ang beam width kung iyon ay isang opsyon.
- Binabalewala nito ang mga pagtuturo.
- Palakasin ang system prompt at isama ang mga halimbawa ng pagsasanay na nagpapakita ng mahigpit na pagsunod sa pagtuturo.
- Nagha-hallucinate ito ng mga katotohanan nang may yabang.
- Isama ang mga halimbawa na nagsasabing “Hindi ko alam” o mag-link sa mga mapagkukunan; babaan ang temperature; ipares sa retrieval para sa mga sagot.
- Masyado itong mabait. (Oo, totoo iyan.)
- Magdagdag ng mga halimbawa ng pagsasanay na nagtatakda ng mga hangganan at nililinaw ang mga patakaran—“Hindi namin magawa ang X, ngunit narito ang Y.”
- Nabigo ang pagsasanay sa kalagitnaan.
- Suriin ang dataset validation, mga kakaibang karakter, at max token lengths. Subukan ang mas maliit na batch size o mas kaunting epochs.
Hakbang 10: Kailan dapat mag-fine-tune vs. kailan dapat gumamit ng mga prompt o retrieval
Gustung-gusto ko ang fine-tuning, ngunit hindi lamang ito ang tanging paraan. Tatlong karaniwang estratehiya:
- Prompt engineering lamang: Pinakamura, pinakamabilis. Mahusay kapag kailangan mo lamang ng pagbabago sa tono o simpleng pagiging pare-pareho.
- Retrieval-augmented generation (RAG): Mahusay para sa mga bagong katotohanan at malalaking knowledge base. Binabasa ng model ang iyong mga dokumento sa runtime.
- Fine-tuning: Pinakamahusay para sa istilo, istraktura, at mga pattern ng domain na hindi nagbabago araw-araw.
Kadalasan, ang nanalong recipe ay kaunti ng bawat isa: gumamit ng RAG para kumuha ng mga katotohanan, pagkatapos ay ipasa ang mga ito sa iyong fine-tuned na model para sagutin nito sa iyong natatanging boses.
Isang mabilis na Tinker API tutorial na maaari mong kopyahin-i-paste
Narito ang isang pinagsama-sama at kathang-isip na walkthrough na sumasalamin sa maraming platform na istilo ng Tinker. Palitan ang mga endpoint at ID ng iyong mga tunay na endpoint at ID.
- Gumawa at mag-upload ng mga dataset
curl -X POST -H "Authorization: Bearer $TINKER_KEY" -F "[email protected]" -F "purpose=finetune" curl -X POST -H "Authorization: Bearer $TINKER_KEY" -F "[email protected]" -F "purpose=eval" curl -X POST -H "Authorization: Bearer $TINKER_KEY" -H "Content-Type: application/json" -d '{
"base_model": "tinker-medium-1",
"dataset_id": "ds_train",
"eval_dataset_id": "ds_eval",
"epochs": 4,
"learning_rate": 2e-5,
"suffix": "email-summarizer-v1"
}'
curl -N -H "Authorization: Bearer $TINKER_KEY"
- Gamitin ang fine-tuned model
curl -X POST -H "Authorization: Bearer $TINKER_KEY" -H "Content-Type: application/json" -d '{
"model": "ft:tinker-medium-1:email-summarizer-v1:xyz",
"prompt": "Ibuod ang sumusunod na email sa dalawang bullet, magiliw na tono:\n\n[IPASTE ANG EMAIL]",
"max_tokens": 160,
"temperature": 0.4
}'
Mga sitwasyon sa totoong buhay: ano ang mangyayari kapag…
- Nag-fine-tune ka sa iyong mga support macro
- Bigla, sumasagot ang iyong AI sa parehong istraktura na ginagamit ng iyong mga agent: paghingi ng tawad, pagkilos, follow-up. Madalas tumataas ang CSAT dahil mas gusto ng mga tao ang pagiging pare-pareho kaysa sa mga sorpresa.
- Nag-fine-tune ka sa iyong boses ng brand
- Nakukuha ng model ang iyong istilong “kami ay nakakatulong ngunit hindi clingy.” Iniiwasan nito ang 17-exclamation-point na sigasig. Mas nakakatulog nang mahimbing ang Marketing.
- Nag-fine-tune ka para sa mga mungkahi ng code
- Isama ang mga pares ng paglalarawan ng gawain at ideal na mga snippet ng code. Panatilihing maikli at nakatuon ang mga halimbawa; ang magulong code ay humahantong sa magulong pagkumpleto.
- Nag-fine-tune ka para sa pag-uuri
- Oo, maaari mo. Magbigay ng mga may label na halimbawa at tawagin ang model gamit ang mga maikling prompt. Para sa mahigpit na mga label, itakda ang temperature sa zero.
Kaligtasan muna, huli, at palagi
Kung ang iyong use case ay may kinalaman sa mga regulated o sensitibong lugar, gumuhit ng malinaw na mga linya sa iyong system prompt at sa iyong data ng pagsasanay. Magdagdag ng mga halimbawa na nagpapakita ng pagtanggi nang may kagandahang-loob. I-log ang mga output at hayaan ang mga user na mag-ulat ng mga isyu. Ang mga fine-tuned na model ay maaaring maging tiwala—sanayin sila na maging tiwala sa pag-iingat.
Kung saan umaangkop ang Sider.AI (at kung saan hindi)
Narito ang isang sorpresa: ang Sider.AI ay maaaring maging isang mahusay na kasama habang iniisip mo kung paano gamitin ang Tinker API. Parang mayroon kang isang maingat na co-pilot na nagbabasa ng mga dokumento nang hindi nagrereklamo. Maaari kang gumawa ng mga halimbawa ng dataset sa sidebar ng Sider habang nagba-browse sa iyong mga kasalukuyang email o knowledge base, pagkatapos ay i-export ang malinis at pare-parehong JSONL. Hindi nito tatakbuhin ang training job para sa iyo—iyon ang trabaho ng Tinker—ngunit para sa paggawa ng draft, pag-refactor, at pag-QA sa iyong mga halimbawa, ito ay napakagaling. Subukang itanong dito, “Isulat muli ang tugon na ito sa isang kalmado at simpleng Ingles na suportang boses, dalawang pangungusap,” at panoorin ang pagtalon ng kalidad ng iyong dataset. Ang mga gotcha na sana ay may nagsabi sa akin
- Hindi palaging mas mainam ang mas maraming data—mas mainam ang mas maraming kinatawang data.
- Huwag mag-overfit sa tono. Panatilihin ang ilang wildcard na halimbawa para makapag-improvise ang model kapag naging malikhain ang mga user.
- I-version ang lahat: dataset v1.1, model v1.2, prompt template v3.0. Padadalhan ka ng future mo ng isang thank-you muffin.
- Panatilihin ang isang rollback button. Kung lumihis ang isang bagong fine-tune, i-redeploy kaagad ang nakaraang model.
- Suriin gamit ang mga tunay na prompt ng user, hindi lamang ang iyong pinakamagagandang halimbawa. Ang mga user ay mga makata ng kaguluhan.
Isang huling bagay…
Ang fine-tuning gamit ang Tinker API ay hindi tungkol sa pagbuo ng Skynet. Ito ay tungkol sa pag-ahit ng magaspang na mga gilid upang ang iyong AI ay madama na bahagi ng iyong team. Magsimula nang maliit, sukatin nang walang awa, at huwag matakot na aminin kapag nagawa ng isang mas simpleng trick (tulad ng mas mahusay na mga prompt) ang trabaho.
Dahil kapag sa wakas ay sumagot ang iyong AI sa paraang gagawin mo? Hindi lamang iyon kahusayan. Iyon ay katinuan.
Cheat sheet
- Paano gamitin ang Tinker API para i-fine-tune ang iyong sariling AI model: maghanda ng malinis at pare-parehong mga pares ng JSONL; i-upload; magsimula ng fine-tune na may makatwirang mga default; suriin kasama ang mga tao at sukatan; i-deploy at ulitin.
- Gumamit ng fine-tuning para sa istilo at matatag na pattern; gumamit ng retrieval para sa mga bagong katotohanan.
- Kontrolin ang gastos gamit ang mas maiikling prompt, mas maliliit na model, at routing.
- Gawing isang malinaw na bahagi ng iyong dataset ang kaligtasan.
- Hayaan ang mga tool tulad ng Sider.AI na tulungan kang gumawa ng mas mahusay na mga halimbawa bago mo pa man pindutin ang “Sanayin.”
FAQ
Q1:Paano ko ihanda ang data para i-fine-tune ang sarili kong AI model gamit ang Tinker API?
Gumamit ng JSONL na may malinaw na instruction–response o chat-style na mga pares. Panatilihing pare-pareho ang tono, i-anonymize ang sensitibong impormasyon, at maglaan ng 10–20% para sa pagsubok para hindi mo lokohin ang iyong sarili sa pamamagitan ng mga pinalaking score.
Q2: Mas mainam ba ang fine-tuning gamit ang Tinker API kaysa sa prompt engineering?
Gamitin ang mga prompt para sa mabilisang pagbabago ng tono at simpleng mga pag-uugali; gamitin ang fine-tuning kapag kailangan mo ng matibay na istilo, istruktura, o mga pattern ng domain. Maraming team ang pinagsasama ang dalawa—RAG para sa mga katotohanan, fine-tune para sa boses.
Q3: Gaano karaming data ang kailangan ko para sa fine-tune ng isang modelo gamit ang Tinker API?
Mas mahalaga ang kalidad kaysa sa dami. Ang ilang daang matitibay na halimbawa ay maaaring mas mahusay kaysa sa libu-libong magugulong halimbawa. Magsimula sa maliit, suriin, pagkatapos ay magdagdag ng mga naka-target na halimbawa kung saan nahihirapan ang modelo.
Q4: Paano ko ide-deploy ang isang fine-tuned na modelo sa Tinker API?
Pagkatapos ng pagsasanay, ibinabalik ng Tinker ang isang model ID na maaari mong tawagan sa pamamagitan ng mga karaniwang completions o chat endpoint. Magtakda ng isang kapaki-pakinabang na system prompt, ayusin ang temperatura, at subaybayan ang mga output sa totoong trapiko.
Q5: Paano ko pipigilan ang aking fine-tuned na modelo mula sa pagha-hallucinate?
Sanayin gamit ang mga halimbawa na umaamin ng kawalan ng katiyakan, babaan ang temperatura, at ipares sa retrieval para sa mga katotohanan. Gawing bahagi ng pagtuturo at data ng pagsasanay ang “banggitin ang mga pinagkukunan” o “sabihing hindi mo alam”.
