Paano gumawa ng AI sa iyong computer

Paano gumawa ng AI sa iyong Computer. Kumpletong Gabay.

Okay, kaya interesado ka sa pagbuo ng "isang AI." Hindi sa Hollywood na kahulugan kung saan pinag-iisipan nito ang pag-iral, kundi iyong tipong maaari mong patakbuhin sa iyong laptop na gumagawa ng mga hula, nag-uuri ng mga bagay-bagay, o marahil ay nakikipag-usap pa nang kaunti. Ang gabay na ito sa Paano Gumawa ng AI sa Iyong Computer ay ang aking pagtatangka na hilahin ka mula sa wala patungo sa isang bagay na talagang gumagana nang lokal . Asahan ang mga shortcut, prangka na opinyon, at paminsan-minsang paglihis dahil, maging totoo tayo, ang pagkukunwari ay hindi kailanman malinis.

Mga artikulong maaaring gusto mong basahin pagkatapos nito:

🔗 Paano gumawa ng modelo ng AI: ipinaliwanag ang mga kumpletong hakbang
Malinaw na pagsusuri ng paglikha ng modelo ng AI mula simula hanggang katapusan.

🔗 Ano ang simbolikong AI: lahat ng kailangan mong malaman
Matuto ng mga pangunahing kaalaman, kasaysayan, at mga modernong aplikasyon ng simbolikong AI.

🔗 Mga kinakailangan sa pag-iimbak ng data para sa AI: kung ano ang kailangan mo
Unawain ang mga pangangailangan sa imbakan para sa mahusay at nasusukat na mga sistema ng AI.

Bakit ka pa mag-aabala ngayon? 🧭

Dahil wala na ang panahon ng "mga laboratoryong nasa iskala ng Google lamang ang makakagawa ng AI". Sa mga panahong ito, gamit ang isang regular na laptop, ilang open-source na tool, at katigasan ng ulo, makakagawa ka ng maliliit na modelo na nag-uuri ng mga email, nagbubuod ng teksto, o nag-tag ng mga imahe. Hindi kailangan ng data center. Ang kailangan mo lang ay:

  • isang plano,

  • isang malinis na pagkakaayos,

  • at isang layunin na maaari mong tapusin nang hindi nais na itapon ang makina sa bintana.

Ano ang dahilan kung bakit sulit itong sundin ✅

Ang mga taong nagtatanong ng "Paano gumawa ng AI sa iyong Computer" ay karaniwang ayaw ng PhD. Gusto nila ng isang bagay na maaari nilang patakbuhin. Ang isang mahusay na plano ay may ilang mga bagay na dapat tandaan:

  • Magsimula sa maliit na bagay : uriin ang damdamin, hindi ang "lutasin ang katalinuhan."

  • Reproducibility : conda o venv para makapagtayo ka ulit bukas nang walang panic.

  • Katapatan sa hardware : Maayos ang mga CPU para sa scikit-learn, mga GPU para sa malalalim na network (kung ikaw ay mapalad) [2][3].

  • Malinis na datos : walang maling label na basura; laging nahahati sa train/valid/test.

  • Mga sukatan na may kahulugan : katumpakan, katumpakan, paggunita, F1. Para sa kawalan ng balanse, ROC-AUC/PR-AUC [1].

  • Isang paraan para magbahagi : isang maliit na API, CLI, o demo app.

  • Kaligtasan : walang mga kahina-hinalang dataset, walang mga pagtagas ng pribadong impormasyon, tandaan nang malinaw ang mga panganib [4].

Gawin ang mga iyon nang tama, at maging ang iyong "maliit" na modelo ay totoo.

Isang roadmap na hindi mukhang nakakatakot 🗺️

  1. Pumili ng isang maliit na problema + isang sukatan.

  2. I-install ang Python at ilang pangunahing library.

  3. Lumikha ng malinis na kapaligiran (magpapasalamat ka sa iyong sarili mamaya).

  4. I-load ang iyong dataset, hatiin nang maayos.

  5. Magsanay ng isang hangal ngunit tapat na baseline.

  6. Subukan lamang ang neural net kung ito ay nagdaragdag ng halaga.

  7. Mag-empake ng demo.

  8. Magtago ng ilang tala, sa hinaharap—magpapasalamat ka.

Minimum na kit: huwag gawing kumplikado 🧰

  • Python : kunin mula sa python.org.

  • Kapaligiran : Conda o venv na may pip.

  • Mga Kuwaderno : Jupyter para sa paglalaro.

  • Editor : VS Code, palakaibigan at makapangyarihan.

  • Mga pangunahing lib

    • pandas + NumPy (pag-aaway sa datos)

    • scikit-learn (klasikal na ML)

    • PyTorch o TensorFlow (mahalaga ang deep learning, GPU builds) [2][3]

    • Mga Transformer na May Yakap na Mukha, spaCy, OpenCV (NLP + paningin)

  • Pagpapabilis (opsyonal)

    • NVIDIA → Mga build ng CUDA [2]

    • AMD → Mga pagbuo ng ROCm [2]

    • Apple → PyTorch na may Metal backend (MPS) [2]

⚡ Dagdag na tala: karamihan sa "sakit sa pag-install" ay nawawala kung hahayaan mo lang ang mga opisyal na installer na magbigay sa iyo ng eksaktong utos para sa iyong setup. Kopyahin, i-paste, tapos na [2][3].

Panuntunan: mag-crawl muna sa CPU, saka mag-sprint gamit ang GPU.

Pagpili ng iyong patungan: labanan ang mga makintab na bagay 🧪

  • Datos na tabular → scikit-learn. Logistic regression, random forests, gradient boosting.

  • Teksto o mga imahe → PyTorch o TensorFlow. Para sa teksto, ang pag-fine-tune ng isang maliit na Transformer ay isang malaking panalo.

  • Parang Chatbot → ng llama.cpp ang maliliit na LLM sa mga laptop. Huwag umasa ng mahika, pero gumagana ito para sa mga tala at buod [5].

Malinis na kapaligiran 🧼

# Conda way conda create -n localai python=3.11 conda activate localai # O venv python -m venv .venv source .venv/bin/activate # Windows: .venv\Scripts\activate

Pagkatapos ay i-install ang mga mahahalagang bagay:

pip install numpy pandas scikit-learn jupyter pip install torch torchvision torchaudio # o tensorflow pip install transformers datasets

(Para sa mga GPU build, seryoso, gamitin lang ang opisyal na selector [2][3].)

Unang gumaganang modelo: panatilihing maliit ito 🏁

Baseline muna. CSV → mga tampok + mga label → logistic regression.

mula sa sklearn.linear_model import LogisticRegression ... print("Katumpakan:", accuracy_score(y_test, preds)) print(classification_report(y_test, preds))

Kung mas mahusay ito kaysa sa random, magdiwang ka. Kape o cookie, desisyon mo ☕.
Para sa mga hindi balanseng klase, panoorin ang precision/recall + ROC/PR curves sa halip na raw accuracy [1].

Mga neural net (kung makakatulong lamang ang mga ito) 🧠

May text ka ba at gusto mo ng sentimyento? Ayusin ang isang maliit at pre-trained na Transformer. Mabilis, maayos, at hindi nakakapaso sa makina.

mula sa mga transformer, i-import ang AutoModelForSequenceClassification ... trainer.train() print(trainer.evaluate())

Pro tip: magsimula sa maliliit na sample. Ang pag-debug sa 1% ng data ay nakakatipid ng oras.

Datos: mga pangunahing kaalaman na hindi mo maaaring laktawan 📦

  • Mga pampublikong dataset: Kaggle, Hugging Face, mga akademikong repo (suriin ang mga lisensya).

  • Etika: pag-iingat sa personal na impormasyon, paggalang sa mga karapatan.

  • Mga hati: pagsasanay, pagpapatunay, pagsubok. Huwag sumilip.

  • Mga Label: mas mahalaga ang pagiging pare-pareho kaysa sa mga magagarang modelo.

Bomba ng katotohanan: 60% ng mga resulta ay mula sa malilinis na etiketa, hindi sa kahusayan sa arkitektura.

Mga sukatan na magpapanatili sa iyong tapat 🎯

  • Klasipikasyon → katumpakan, katumpakan, paggunita, F1.

  • Mga hindi balanseng set → Mas mahalaga ang ROC-AUC, PR-AUC.

  • Regresyon → MAE, RMSE, R².

  • Pagsusuri ng katotohanan → tumingin sa ilang resulta; maaaring magsinungaling ang mga numero.

Madaling gamiting sanggunian: gabay sa mga sukatan ng scikit-learn [1].

Mga tip sa pagbilis 🚀

  • NVIDIA → Pagbuo ng PyTorch CUDA [2]

  • AMD → ROCm [2]

  • Apple → MPS backend [2]

  • TensorFlow → sundin ang opisyal na pag-install ng GPU + beripikahin [3]

Pero huwag mong i-optimize bago pa man gumana ang baseline mo. Parang pagpapakintab lang iyan ng mga rims bago pa man magkaroon ng gulong ang kotse.

Mga lokal na modelo ng generasyon: mga batang dragon 🐉

  • Wika → mga quantized na LLM sa pamamagitan ng llama.cpp [5]. Mainam para sa mga tala o mga pahiwatig ng code, hindi para sa malalim na pag-uusap.

  • Mga Larawan → May mga variant ng Stable Diffusion; basahin nang mabuti ang mga lisensya.

Minsan, mas natatalo ng isang pinong-tuning na Transformer na partikular sa gawain ang isang namamagang LLM sa maliliit na hardware.

Mga demo ng packaging: hayaang mag-click ang mga tao 🖥️

  • Gradio → pinakamadaling UI.

  • FastAPI → malinis na API.

  • Prasko → mabilisang mga script.

import gradio as gr clf = pipeline("pagsusuri-ng-sentimento") ... demo.launch()

Parang mahika kapag ipinapakita ito ng browser mo.

Mga gawi na nagliligtas ng katinuan 🧠

  • Git para sa pagkontrol ng bersyon.

  • MLflow o mga notebook para sa pagsubaybay sa mga eksperimento.

  • Pag-bersyon ng datos gamit ang DVC o mga hash.

  • Docker kung kailangan ng iba na patakbuhin ang iyong mga gamit.

  • Mga dependency sa pin ( requirements.txt ).

Maniwala ka sa akin, sa hinaharap—magpapasalamat ka.

Pag-troubleshoot: mga karaniwang sandali ng "ugh" 🧯

  • May mga error sa pag-install? I-wipe lang ang env at i-rebuild.

  • Hindi nakita ang GPU? Hindi tugma ang driver, tingnan ang mga bersyon [2][3].

  • Hindi natututo ang modelo? Babaan ang rate ng pagkatuto, pasimplehin, o linisin ang mga label.

  • Overfitting? Regularize, drop out, o mas maraming data lang.

  • Napakagandang sukatan? Nailabas mo ang test set (mas madalas itong nangyayari kaysa sa inaakala mo).

Seguridad + responsibilidad 🛡️

  • Strip PII.

  • Igalang ang mga lisensya.

  • Lokal-una = privacy + kontrol, ngunit may mga limitasyon sa pag-compute.

  • Idokumento ang mga panganib (pagkamakatarungan, kaligtasan, katatagan, atbp.) [4].

Madaling gamiting talahanayan ng paghahambing 📊

Kagamitan Pinakamahusay Para sa Bakit ito gagamitin
scikit-learn Datos na tabular Mabilis na panalo, malinis na API 🙂
PyTorch Mga pasadyang malalalim na lambat Flexible, malaking komunidad
TensorFlow Mga pipeline ng produksyon Ekosistema + mga opsyon sa paghahatid
Mga Transformer Mga gawain sa teksto Mga paunang sinanay na modelo na nagse-save ng compute
spaCy Mga pipeline ng NLP Lakas ng industriya, praktikal
Gradio Mga Demo/UI 1 file → UI
FastAPI Mga API Mga dokumento ng Bilis + Awto
Oras ng Pagtakbo ng ONNX Paggamit ng cross-framework Madadala + mahusay
lama.cpp Maliliit na lokal na LLM Kwantisasyon na angkop sa CPU [5]
Docker Pagbabahagi ng mga env "Gumagana ito kahit saan"

Tatlong mas malalim na pagsisid (magagamit mo talaga) 🏊

  1. Feature engineering para sa mga talahanayan → normalize, one-hot, try tree models, cross-validate [1].

  2. Paglilipat ng pagkatuto para sa teksto → pinuhin ang maliliit na Transformer, panatilihing katamtaman ang haba ng seq, F1 para sa mga bihirang klase [1].

  3. Pag-optimize para sa lokal na hinuha → pag-quantify, pag-export ng ONNX, mga cache tokenizer.

Mga klasikong patibong 🪤

  • Masyadong malaki ang pagtatayo, masyadong maaga.

  • Hindi pinapansin ang kalidad ng datos.

  • Nilalaktawan ang test split.

  • Pag-code gamit ang bulag na kopya at i-paste.

  • Hindi nagdodokumento ng kahit ano.

Kahit ang isang README ay nakakatipid ng ilang oras pagkatapos.

Mga mapagkukunan sa pag-aaral na sulit sa oras 📚

  • Mga opisyal na dokumento (PyTorch, TensorFlow, scikit-learn, Transformers).

  • Kurso sa Pag-crash ng Google ML, DeepLearning.AI.

  • Mga dokumentong OpenCV para sa mga pangunahing kaalaman sa paningin.

  • Gabay sa paggamit ng spaCy para sa mga pipeline ng NLP.

Maliit na life-hack: ang mga opisyal na installer na bubuo ng iyong GPU install command ay mga life saver [2][3].

Pinagsasama-sama ang lahat 🧩

  1. Layunin → uriin ang mga tiket ng suporta sa 3 uri.

  2. Data → Pag-export ng CSV, ginawang hindi nagpapakilala, hinati.

  3. Baseline → scikit-learn TF-IDF + logistic regression.

  4. I-upgrade → Pinuhin ang transformer kung ang baseline ay huminto.

  5. Demo → Aplikasyon para sa textbox na Gradio.

  6. Ipadala → Docker + README.

  7. Ulitin → ayusin ang mga error, palitan ang label, ulitin.

  8. Pangangalaga → mga panganib sa dokumento [4].

Nakakabagot at epektibo ito.

TL;DR 🎂

Pag-aaral Kung Paano Gumawa ng AI sa Iyong Computer = pumili ng isang maliit na problema, bumuo ng baseline, palawakin lamang ang problema kapag nakatulong na, at panatilihing kayang ulitin ang iyong setup. Gawin ito nang dalawang beses at mararamdaman mong may kakayahan ka. Gawin ito nang limang beses at magsisimulang humingi ng tulong sa iyo ang mga tao, na siyang palihim na masayang bahagi.

At oo, minsan parang pagtuturo sa isang toaster na sumulat ng tula. Ayos lang 'yan. Ipagpatuloy mo lang ang pag-aayos. 🔌📝

Mga Sanggunian

[1] scikit-learn — Mga sukatan at pagsusuri ng modelo: link
[2] PyTorch — Lokal na tagapili ng pag-install (CUDA/ROCm/Mac MPS): link
[3] TensorFlow — Pag-install + Pag-verify ng GPU: link
[4] NIST — Balangkas ng Pamamahala ng Panganib ng AI: link
[5] llama.cpp — Lokal na repo ng LLM: link

Hanapin ang Pinakabagong AI sa Opisyal na Tindahan ng AI Assistant

Tungkol sa Amin

Balik sa blog