Ang pinakakapalit ay: walang anumang background sa machine learning ako, hindi ko alam ang standard na proseso ng pag-train ng model, at hindi ko maintindihan ang maraming teknikal na detalye. Ang aking ginagawa ay basic na patuloy na magbigay ng mga hiling at feedback sa Sol, upang ito ay makahanap ng sarili nitong mga problema, magdisenyo ng mga eksperimento, at magpatuloy sa pag-iterate.

May-akda ng artikulo: Anshu

Artikulo na isinulat at pinagkunan: ME News

Ito ang unang beses kong talagang nadarama na “parang dumating na ang AGI”.

Ginawa kong sariling modelo ng automatic correction gamit ang GPT-5.6 Sol. Sa wakas, ang lokal na modelo na may lamang 1.7 bilyong parameter, ay nag-performance nang kaunting higit pa sa GPT-5.6 Sol sa test set.

Ang pinakakapalit ay: walang anumang background sa machine learning ako, hindi ko alam ang standard na proseso ng pag-train ng model, at hindi ko maintindihan ang maraming teknikal na detalye. Ang aking ginagawa ay basic na patuloy na magbigay ng mga hiling at feedback sa Sol, upang ito ay makahanap ng sarili nitong mga problema, magdisenyo ng mga eksperimento, at magpatuloy sa pag-iterate.

Walang gastos sa buong proseso.

Lahat ay nagsimula sa isang lalong lumalalang "problem sa pagtype"

Matapos mag-chat nang mahaba sa AI, napansin kong bumababa ang aking kakayahan sa pagket.

Nakauunlad na ako sa mabilis na pagket, at hindi na ako umaayos sa mga pagkakamali sa pagtype, pagkakasunod-sunod ng mga titik, o mga nawawalang letra. Sa halip na muling matutunan ang aking pagtype, pinili kong gamitin ang isang solusyon na mas nauugnay sa panahon ng AI: patuloy na gamitin ang higit pang AI upang lutasin ang mga problema.

Ang tradisyonal na auto-correction ay patuloy na nagbabago ng teksto habang pinapag-input, na madalas ay nagpapabagal sa pag-iisip. Ang aking ideya ay hayaan ang user na mabilis mag-input nang walang pagkakaabalaa, kahit na puno ng mga kamalian; pagkatapos ng pag-input, i-aayos ng AI ang lahat nang isang beses.

Sambil nais kong ang modelo ay maging pinakamaliit na posibleng.

Mas maliit ang modelo, mas mabilis ang pagpapatakbo, mas mababa ang pagkakagamit ng enerhiya, at mas angkop ito para sa ganap na lokal na pagpapatakbo. Para sa efisensiya, baterya, o kaya'y dahil sa pagnanais na subukan, gusto kong makita: sa anong antas ng pagkakatama ng sarili ang sapat na maliit na lokal na modelo?

Kaya nagpasya akong magtrabaho sa sarili kong pagtratrabaho.

Gawin ang Sol bilang isang automated researcher

Ang inspirasyon ng proyektong ito ay galing sa eksperimento ni Andrej Karpathy na “autoresearch”.

Ginawa kong isang siklikong workflow para sa Sol gamit ang /goal mode ng Codex:

Pumili ng isang eksperimento, isagawa ang eksperimento, at i-record ang resulta sa dokumento; kung nabigo, itigil ang direksyong ito; pagkatapos, isauli ang susunod na eksperimento, habang iiwasan ang pag-uulit ng mga napatunayang pagkakamali.

Simpleng ibinigay ko ang ilang set ng input na kailangang matapos, ang mga mahigpit na layunin sa latency, at ang hinihinging epekto, at pagkatapos ay pinapagana ko na ang Sol.

Ang nangyari pagkatapos ay lalong lumampas sa aking inaasahan.

Sinuri at kinumpara ni Sol ang mga kandidatong pangunahing modelo, kabilang ang Qwen 3.5, Gemma 4, at Liquid LFM 2.5. Pagkatapos, natagpuan niya sa Hugging Face ang isang set ng dataset na may kaugnayan sa totoong pagketik.

Ngunit ang totoong data ay hindi sapat.

Upang makagawa ng mga pagkakamali sa pagsulat na mas malapit sa totoong pag-input ng user, isinulat ni Sol ang isang simulator ng “pagpindot sa keyboard ng Mac”. Ito ay gumagamit ng Gaussian distribution batay sa pisikal na layout ng keyboard upang simulan ang pagkakamali, at naglalikha ng iba’t ibang karaniwang pagkakamali, tulad ng:

• Pindutin ang mga pindutan na kapitbahay;
• Reversed alphabetical order;
• Repeat input;
• Missing character;
• Nakakatok ang mga daliri sa maraming pindutan nang sabay-sabay.

Matapos ang pagkakaroon ng base model, text data, at keyboard error simulator, tinunasan ni Sol ang fine-tuning gamit ang MLX diretso sa aking MacBook.

Hindi nakalipas ang isang oras, nabuo na niya ang isang prototype na gumagana.

Ang problema ay ang accuracy ng unang bersyon ay hindi gaanong mabuti.

Unang bottleneck: Hindi nauunawaan ng tokenizer ang mga pagkakamali sa pagbaybay

Binasa ni Sol ang kaugnay na papel at isinagawa ang isang serye ng pagsubok, at sa huli ay natukoy: ang pangunahing hadlang ng modelo ay hindi sa mga datos ng pagtuturo, kundi sa Tokenizer, o ang tokenizer.

Hindi karaniwang nauunawaan ng malalaking modelo ng wika ang teksto letra-katawan, kundi unang hinahati ito sa mga Token. Ang mga karaniwang salita ay maaaring masira sa mga matatag na semantikong yunit, ngunit ang mga pagkakamali sa pagbaybay ay madalas na nagpapabagsak sa orihinal na istruktura ng Token.

Ibig sabihin nito, ang isang simpleng pagkakamali sa letra na malinaw para sa tao ay maaaring maging isang set ng mga ganap na bagong Token sa pananaw ng modelo.

Mahirap ng modelo na talagang “unawain” ang mga kamalian; kaya lang ito ay nakikita ang mga pagkakamali sa pagkakasulat at ang pagkakasunod-sunod nito sa tamang pagkakasulat. Ang gawaing ito ay hindi lamang may mahinang kakayahang pangkalahatan, kundi hindi rin ito nagpapakita ng buong paggamit ng dating kaalaman ng modelo sa wika.

Sinubukan ng Sol ang ByT5 ng Google.

Ang ByT5 ay isang modelo na hindi nakasalalay sa tradisyonal na Tokenizer at direktang nagpaproseso ng mga byte sequence. Ang pagsubok na ito ay nagdala ng malinaw na pagpapabuti, ngunit dahil sa maagang paglabas ng ByT5, may limitadong kaalaman sa wika ang modelo mismo, kaya hindi pa rin nakakamit ng antas ng GPT-5.6 Sol ang kinalabasan.

Pagkatapos ng karagdagang pag-aaral, nalaman ni Sol na ang problema ay hindi kailangang lutasin sa pamamagitan ng "pangkabuuang pagkansela ng Tokenizer".

Ipinili nito ang T5Gemma, isang modelo na may Encoder-Decoder arkitektura.

Sa pagkakaiba sa mga modelo na nagtataya lamang ng susunod na token, ang Encoder-Decoder model ay maaaring unang maunawaan nang buo ang input sa pamamagitan ng encoder, at pagkatapos ay makagawa ng binago na teksto sa pamamagitan ng decoder. Mas mahalaga pa, ang Sol ay maaari ring magpatuloy sa post-training sa encoder upang mas mabuti pang kilalanin ang mga input na may mga pagkakamali sa pagspeling.

Nagpapataas nang malaki ang antas ng performance ng modelo.

Ikalawang bottleneck: ang tradisyonal na loss function ay nagpapalakas sa modelo na “hindi baguhin”

Pagkatapos baguhin ang arkitektura ng modelo, lumabas ang isang bagong problema.

Ang modelo ay nakakapag-adjust nang tama sa ilang mga error, ngunit madalas na nakakalimutan ang iba pang malinaw na mga pagkakamali sa pagkakasulat. Kahit may mga kamalian sa input, ito ay nagtutuloy na kopyahin ang lahat nang walang pagbabago.

Natuklasan ng Sol na ang problema ay galing sa pinakakaraniwang cross-entropy loss function.

Sa automatic correction data, ang karamihan sa mga karakter ay tama nang mula sa simula, at ang mga karakter na talagang kailangang i-edit ay maliit lamang ang proporsyon. Kung gagamitin nang direkta ang standard cross-entropy para sa pagtuturo, ang pinakaligtas na estratehiya ng modelo ay “huwag masyadong magbago”.

Dahil ang pagkopya sa orihinal na teksto ay nagbibigay ng tamang sagot sa karamihan ng mga posisyon, habang ang aktibong pagbabago ay maaaring magdulot ng kamalian.

Sa ibang salita, ang tradisyonal na layunin sa pagtuturo ay nagbibigay-pugay sa modelo na manatili sa kanyang kalagayan.

Upang lutasin ang problemang ito, isinulat ni Sol isang custom loss function.

Una ito ay nag-aayos sa original na teksto at target na teksto sa antas ng byte, pagkatapos ay gumagamit ng dynamic programming algorithm upang kalkulahin ang minimum edit path sa pagitan ng dalawang teksto, at kilalanin kung saan mga posisyon ang pagkopya, at kung saan mga posisyon ang tunay na pag-insert, pag-delete, o pag-replace.

Sa batayang ito, pinataas ng Sol ang timbang ng pagtuturo para sa “tama na pagbabago” habang pinababa ang benepisyo mula sa pagkopya ng mga karakter lamang.

Matapos ang maraming pagtutuwid ng mga parameter, tumataas nang malaki ang accuracy ng pagkakorekta ng modelo.

Ikatlong bottleneck: Kapag mali ang modelo, hindi na ito makakabalik

Ang huling pangunahing problema ay mula sa autoregressive generation mechanism.

Ang modelo ay maaaring mag-predict lamang ng susunod na Token batay sa nai-generate na mga nilalaman. Kapag may mali sa isang hakbang sa harap, ang mga susunod na pag-generate ay bubuo sa maling resulta, at ang modelo ay hindi makakapagbalik upang baguhin.

Sa teorya, maaaring ituro ang modelo na muna “isipin” bago sagutin, tulad ng isang reasoning model, ngunit ito ay magdudulot ng malaking pagtaas sa latency at hindi angkop para sa mga automatic correction scenarios na nangangailangan ng instant response.

Natagpuan ng Sol ang isang mas elegante na solusyon: Beam Search, o ang束搜索.

Hindi na pumipili ang modelo sa bawat hakbang ng isang solong path na may pinakamataas na probabilidad, kundi nagpapanatili ito ng maraming posibleng branch habang pinag-aaralan nang paralelo ang iba’t ibang resulta ng pagkakorrek. Pagkatapos ng paghahanap, pipili ang sistema ng buong path na may pinakamataas na kumulatibong log probability.

Ito ay katumbas ng pagpapalit ng isang-thread na pag-iisip sa parallel search.

Ang Beam Search ay nagpapabuti nang malinaw sa final result, ngunit nagdudulot ng isang problema sa user experience: bago matapos ang buong paghahanap, hindi makikita ng user ang anumang output.

Sinunod ni Sol ang isang napakatalino mong obserbasyon.

Sa bawat round ng paghahanap, maaaring ihambing ang lahat ng mga branch na nananatili. Kung ang mga branch na ito ay may magkakaparehong simula, ang “pinakamahabang karaniwang prefix” na ito ay lalabas sa final result.

Kaya ang sistema ay agad makakapag-display ng nilalaman na ito sa user.

Habang patuloy ang paghahanap, ang mga mahinang path ay paulit-ulit na tinatanggal, at ang karaniwang prefix ng mga natitirang branch ay lalong lumalalim. Sa wakas, ang mga resulta na nakikita ng user ay hindi isang biglaang pagkakalabas, kundi isang patuloy na pagbuo ng tekstong may pagkakamali.

Isinama ni Sol ang buong proseso bilang isang custom MLX inference pipeline, na gumagamit ng MacBook GPU para sa parallel decoding.

Sa huli, ang unang output delay ng Token ay lamang halos 40 miliyong segundo, sapat na mabilis, at ang buong proseso ay natapos完全 sa lokal.

Final result: 1.7 billion parameter model surpasses GPT-5.6 Sol

Ang huling pagtataya ay gumagamit ng “rate ng pagbabawas ng error” bilang sukat, kung saan mas mataas ang bilang, mas maraming error sa input ang natutulungan ng modelo na ayusin.

Mga resulta ng pagsusuri:

• Apple automatic correction: 49.66%
• GPT-5.6 Luna: 82.47%
• GPT-5.6 Terra: 87.64%
• GPT-5.6 Sol: 90.56%
• Ang aming tinurong modelo na may 1.7 bilyong parameter: 91.02%

Ang lokal na maliit na modelo ay nakalabas sa GPT-5.6 Sol sa napakaliit na pagkakaiba.

Dinig ko rin nang espesyal ang pagkakaroon ng data leak o “cheating” ng model. Sa pagsubok, aming aktibong iniiwasan ang mga salitang nakikita sa training data upang patunayan na hindi lang ito nagsasalita ng mekanikal na pagkakaintindihan sa pagitan ng mga kamalian at sagot.

Ang kabuuang gastos ng proyekto ay:

Isang pag-reset ng quota ng modelo at 0 dolyar na gastos sa salapi.

Hindi lang ang final score ang nagbigay-sabog sa akin

Sa proseso ng proyekto, mayroon pa ring maraming hindi pa nailalabas na eksperimento, kabilang ang contrastive learning, GRPO, DPO, dynamic masking, at iba pang direksyon.

Hindi lahat ng pagsubok ay nakakamit ng tagumpay, ngunit natutuklasan ni Sol ang mga materyales, kinikilala ang mga problema, binubuo ang mga hipotesis, iniihahanda ang mga eksperimento, sinusuri ang mga resulta, at nagpaplano ng susunod na pagsubok batay sa mga aral mula sa pagkabigo.

Para sa akin, ang totoong nakakapanghina ay hindi ang pangyayari na “ang isang modelong may 1.7 bilyong parameter ay lumampas sa GPT-5.6 Sol”.

Mas mahalaga pa, isang tao na walang anumang background sa machine learning ay nakakagawa na ng mga eksperimento na dati ay kailangan ng isang propesyonal na research team, gamit ang AI.

Hindi ko sinasakop ang lahat ng mga batayang kaalaman, at hindi ko rin na-design ang buong teknikal na landas mula sa simula. Tanging malinaw lamang ang aking layunin kung ano ang gustong lutasin ko, at patuloy kong hinuhubog ang Sol upang maghanap ng mga sagot.

Hindi lang ito sumusulat ng code, kundi nagdudulot din ng papel ng researcher, engineer, at designer ng eksperimento.

Ito ang posibleng unang beses kong talagang “naramdaman ang AGI”.

Huwag magpapalit ng kawalan ng karanasan upang pigilan ka magsimula sa pagsubok.

Kapag nakakatulong ang AI sa mga karaniwang tao na lampasin ang mga hadlang sa propesyon, maaaring hindi na malayo ang maraming teknikal na proyekto na dati ay tila hindi makakamit.