អត្ថបទនេះបកប្រែពីភាសាអង់គ្លេសដោយ AI។ អានអត្ថបទដើមជាភាសាអង់គ្លេស →
Fine-Tune ម៉ូដែល LLM លើ Mac ដោយប្រើ MLX៖ រត់ QLoRA ត្រឹមតែ 16 វិនាទី (តេស្តជាក់ស្តែង មិនបាច់ប្រើ Cloud)
ការតេស្ត QLoRA ជាក់ស្តែងជាមួយ MLX លើ Mac ទំហំ 16 GB៖ ប្រើ Qwen2.5-3B, បង្វឹកត្រឹម 16 វិនាទី, ស៊ីមេម៉ូរី 2.5 GB និងមូលហេតុដែល checkpoint មានពិន្ទុ loss ល្អបំផុត បែរជាឆ្លើយខុសគេទៅវិញ។
ខ្ញុំបានសាកល្បង fine-tune ម៉ូដែលភាសា (language model) មួយលើកុំព្យូទ័រ Mac។ ការបង្វឹកនេះចំណាយពេលប្រហែល 16 វិនាទី ប្រើមេម៉ូរីត្រឹមតែប្រហែល 2.5 GB ហើយមិនបាច់ពឹងលើ cloud ឬកាតក្រាហ្វិក NVIDIA ឡើយ គឺប្រើតែ MLX របស់ Apple សុទ្ធសាធ។
មុនពេលបង្វឹក ម៉ូដែលនេះឆ្លើយវែងអន្លាយ និងមិនសូវចំចំណុចទេ។ តែក្រោយបង្វឹករួច វាឆ្លើយខ្លីៗ ច្បាស់ៗ ដូចឧទាហរណ៍ដែលខ្ញុំបានដាក់ឱ្យបេះបិទ។ ប៉ុន្តែអ្វីដែលគួរឱ្យភ្ញាក់ផ្អើលនោះគឺ វើសិនដែលមានពិន្ទុ ល្អបំផុត បែរជាឆ្លើយចេញមក អន់បំផុត ទៅវិញ។ ចំណុចត្រឡប់ក្បាលនេះហើយ ជាមេរៀនមានប្រយោជន៍បំផុតក្នុងអត្ថបទនេះ។
តួលេខទាំងអស់ខាងក្រោមនេះ សុទ្ធតែដកស្រង់ចេញពីការតេស្តជាក់ស្តែង ដែលខ្ញុំបានថតបង្ហាញតាំងពីដើមដល់ចប់ក្នុងវីដេអូនេះ៖
▶ WATCH ON YOUTUBEWatch the video
ម៉ាស៊ីនតេស្ត៖ MacBook Pro, M2 Pro, unified memory ទំហំ 16 GB · macOS 26.5 · MLX 0.32.3 · MLX LM 0.32.0។ ចំពោះពាក្យបញ្ជាគឺដូចគ្នាបេះបិទលើ Mac ស៊េរីក្រោយៗ ដូចជា Mac mini M5 Pro ដែរ ខុសគ្នាតែលើល្បឿន និងទំហំមេម៉ូរីប៉ុណ្ណោះ។
តើ fine-tuning ផ្លាស់ប្តូរអ្វីខ្លះឱ្យពិតប្រាកដ? (យល់ដឹងពី LoRA ត្រឹមមួយនាទី)
ម៉ូដែលភាសាដំណើរការដោយទស្សន៍ទាយពាក្យ ឬតូខឹនបន្ទាប់ (next token) ម្តងមួយៗឥតឈប់ឈរ។ ឯការបង្វឹកវិញ គឺយកការទស្សន៍ទាយរបស់វាទៅផ្ទៀងផ្ទាត់ជាមួយចម្លើយដែលត្រឹមត្រូវ រួចវាស់ស្ទង់កម្រិតលម្អៀង (ហៅថា loss) ហើយកែសម្រួលទម្ងន់ទិន្នន័យ (weights) បន្តិចម្តងៗដើម្បីឱ្យកម្រិតលម្អៀងនោះកាន់តែតូច។
ការកែប្រែ weights ទាំង 3 ពាន់លានរបស់ម៉ូដែល 3B នឹងត្រូវស៊ីមេម៉ូរីច្រើនហួសហេតុ។ ដូច្នេះហើយ ទើបគេបង្កើត LoRA ឡើង ដើម្បីចាក់សោ (freeze) weights ទាំងនោះទុកមួយកន្លែង ហើយងាកមកបង្វឹកម៉ាទ្រីសតូចៗពីរនៅក្បែរ layer នីមួយៗជំនួសវិញ ដោយ weight ថ្មី ស្មើនឹង weight ចាស់ បូកជាមួយការកែប្រែបន្តិចបន្តួចគឺ B × A។
ក្នុងការតេស្តលើកនេះ វាមានន័យថា ប៉ារ៉ាម៉ែត្រដែលអាចបង្វឹកបានមានតែ 3.3 លាន ប៉ុណ្ណោះ ក្នុងចំណោម 3.09 ពាន់លាន៖ ស្មើនឹង 0.108% នៃម៉ូដែលទាំងមូល។ ហើយដោយសារតែម៉ូដែលគោលត្រូវបានបង្រួមជា 4-bit នោះវិធីសាស្ត្រនេះត្រូវបានគេហៅថា QLoRA។
ហេតុអ្វីជ្រើសរើស MLX មិនប្រើ PyTorch?
MLX គឺជា framework សម្រាប់ machine learning របស់ Apple ដែលបង្កើតឡើងជាពិសេសសម្រាប់ឈីប Apple Silicon និងបច្ចេកវិទ្យា unified memory របស់វា (CPU និង GPU ប្រើ RAM រួមគ្នា មិនបាច់ចំណាយពេលចម្លងទិន្នន័យម៉ូដែលចុះឡើង)។ ចំណែក MLX LM វិញ គឺបន្ថែមពាក្យបញ្ជាស្រាប់ៗសម្រាប់ដំណើរការ និង fine-tune ម៉ូដែលភាសាបានយ៉ាងងាយស្រួល។
PyTorch លើ Mac ដំណើរការតាមរយៈ backend ផ្សេង (ហៅថា MPS)។ កុំរំពឹងថា គ្រាន់តែយក notebook ដែលរត់លើ CUDA មកដូរពាក្យ cuda ដាក់ mps ហើយអាចបង្វឹកបានដោយរលូនឱ្យសោះ។
1. ដំឡើង MLX LM
នៅក្នុងបរិស្ថាន Python 3.12 ថ្មីមួយ៖
uv pip install "mlx-lm[train]"2. បម្លែងម៉ូដែលទៅជា 4-bit
ខ្ញុំបានប្រើ Qwen2.5-3B-Instruct។ ដោយសារបណ្តាញអ៊ីនធឺណិតរបស់ខ្ញុំជាប់ block មិនឱ្យចូល Hugging Face ខ្ញុំក៏បានទាញយក weights ផ្លូវការពី ModelScope មកវិញ រួចផ្ទៀងផ្ទាត់លេខកូដ SHA-256 របស់វា។ ប្រសិនបើអ្នកអាចភ្ជាប់អ៊ីនធឺណិតបានធម្មតា អ្នកអាចទាញយកម៉ូដែល 4-bit ដែលគេរៀបចំស្រេចពី mlx-community មកប្រើតែម្តងក៏បាន។
mlx_lm.convert --hf-path ./models/qwen2.5-3b-instruct -q --q-bits 4 \
--mlx-path ./models/Qwen2.5-3B-Instruct-4bitចំណាយពេល 9 វិនាទី។ ទំហំ 6.2 GB ធ្លាក់មកសល់ត្រឹម 1.6 GB (ស្មើនឹង 4.501 bits ក្នុងមួយ weight)។ គិតលឿនៗ៖ weights 3B × ~4.5 bits ÷ 8 ≈ 1.7 GB។ សូមចាំថា នេះគ្រាន់តែជាទំហំ weights ប៉ុណ្ណោះ ដល់ពេលបង្វឹកជាក់ស្តែង វានឹងត្រូវការមេម៉ូរីបន្ថែមលើសពីនេះទៀត។
3. វាស់ស្ទង់សមត្ថភាពដើម (baseline) ជាមុនសិន
មុននឹងចាប់ផ្តើមបង្វឹក ខ្ញុំបានសាកល្បងសួរសំណួរដដែលទៅកាន់ម៉ូដែលដើម ដោយប្រើ system prompt ដូចគ្នា និងកំណត់ temperature ត្រឹម 0 ដើម្បីឱ្យលទ្ធផលចេញមកដូចគ្នាជានិច្ច៖
ពន្យល់ពីភាពខុសគ្នារវាង authentication និង authorization។
ចម្លើយដែលទទួលបានគឺត្រឹមត្រូវល្អ ប៉ុន្តែវែងអន្លាយពេក មានទាំងការដាក់ជាលេខរៀង និងអក្សរដិត សរុបដល់ទៅ 151 tokens ក្នុងល្បឿន 84 tokens/s និងស៊ីមេម៉ូរីខ្ពស់បំផុត 1.86 GB។ សូមរក្សាទុកលទ្ធផលនេះ ព្រោះបើគ្មានទិន្នន័យដើម (baseline) ទេ អ្នកនឹងមិនអាចដឹងថា តើម៉ូដែលរបស់អ្នកមានការរីកចម្រើនកម្រិតណានោះឡើយ។
4. បង្កើតទិន្នន័យសម្រាប់បង្វឹក (JSONL)
ឯកសារនេះផ្ទុកការសន្ទនាមួយខ្សែក្នុងមួយបន្ទាត់ រួមមាន៖ សារ system, សំណួររបស់អ្នកប្រើ និងចម្លើយគំរូដ៏ល្អបំផុត។
{"messages": [{"role": "system", "content": "You explain software concepts in one or two short, clear sentences."}, {"role": "user", "content": "What is the difference between authentication and authorization?"}, {"role": "assistant", "content": "Authentication verifies who you are. Authorization decides what you are allowed to do."}]}គោលការណ៍សំខាន់ពីរដែលជួយសន្សំពេលវេលារបស់អ្នកបានច្រើនម៉ោង៖
- ប្រើទម្រង់ chat messages កុំសរសេរ special tokens ដោយដៃផ្ទាល់ ព្រោះ MLX នឹងរៀបចំតាមទម្រង់ chat template របស់ម៉ូដែលនោះដោយស្វ័យប្រវត្ត។
- ដាក់ឧទាហរណ៍ដែលមានលក្ខណៈប្រហាក់ប្រហែលគ្នាទៅក្នុងក្រុមទិន្នន័យតែមួយ កុំឱ្យទិន្នន័យសម្រាប់តេស្ត (test set) ជ្រាបចូលទៅក្នុងទិន្នន័យបង្វឹក (training set)។
ការសាកល្បងរបស់ខ្ញុំមានឧទាហរណ៍ចំនួន 20៖ យក 16 សម្រាប់បង្វឹក (train), 2 សម្រាប់ផ្ទៀងផ្ទាត់ (validation) និង 2 ទៀតទុកសម្រាប់តេស្តសមត្ថភាព (train.jsonl, valid.jsonl, test.jsonl ក្នុងថត ./data)។ ទិន្នន័យប៉ុណ្ណេះល្មមត្រឹមតែតេស្តដំណើរការនៃ pipeline ប៉ុណ្ណោះ។ បើធ្វើគម្រោងជាក់ស្តែង អ្នកត្រូវការឧទាហរណ៍រាប់រយដែលត្រូវបានត្រួតពិនិត្យយ៉ាងហ្មត់ចត់។
5. បង្វឹក LoRA adapter
mlx_lm.lora --model ./models/Qwen2.5-3B-Instruct-4bit --train --data ./data \
--adapter-path ./adapters/smoke --batch-size 1 --num-layers 8 \
--max-seq-length 512 --learning-rate 1e-5 --iters 20 \
--grad-checkpoint --mask-prompt--grad-checkpointជួយសន្សំសំចៃមេម៉ូរី។--mask-promptកំណត់ឱ្យម៉ូដែលរៀនតែពីចម្លើយប៉ុណ្ណោះ មិនរៀនពីសំណួររបស់អ្នកឡើយ។- ដំណើរការ 20 iterations៖ នេះគ្រាន់តែជាការតេស្តសាកល្បងមើលដំណើរការ (smoke test) ប៉ុណ្ណោះ។
លទ្ធផល៖
| ចាប់ផ្តើម | បញ្ចប់ | |
|---|---|---|
| កម្រិត Training loss | 4.95 | 1.70 |
| កម្រិត Validation loss | 7.03 | 2.81 |
ចំណាយពេលប្រហែល 16 វិនាទី ស៊ីមេម៉ូរីខ្ពស់បំផុតប្រហែល 2.5 GB ហើយ checkpoint ត្រូវបានរក្សាទុកនៅ step 10 និង step 20។
6. តើវាពិតជាឆ្លើយបានល្អជាងមុនមែនទេ? (រឿងដែលនឹកស្មានមិនដល់)
កម្រិត Test loss លើឧទាហរណ៍ទាំង 2 ដែលម៉ូដែលមិនធ្លាប់បានឃើញពីមុនមក៖
| ម៉ូដែល | ពិន្ទុ Test loss |
|---|---|
| ម៉ូដែលដើម (Base model) | 3.99 |
| Adapter step-10 | 2.24 |
| Adapter step-20 | 1.89 |
mlx_lm.lora --model ./models/Qwen2.5-3B-Instruct-4bit --test --data ./data --adapter-path ./adapters/smokeមើលទៅ step 20 ហាក់ដូចជាឈ្នះដាច់តែម្តង។ ប៉ុន្តែនៅពេលខ្ញុំសាកល្បងសួរសំណួរដដែលនោះទៅកាន់វា៖
Step 20៖ "Authentication ផ្ទៀងផ្ទាត់ថាអ្នកជាអ្នកណា។"
អស់ប៉ុណ្ណឹង! វាភ្លេចគិតពី authorization បាត់ទៅហើយ។ វាចេះឆ្លើយខ្លីមែន តែខ្លីជ្រុលពេក។ ចំណែកឯ checkpoint នៃ step-10 ដែលមានពិន្ទុ loss អន់ជាង វិញ៖
Step 10៖ "Authentication ផ្ទៀងផ្ទាត់ថាអ្នកជាអ្នកណា។ Authorization កំណត់នូវអ្វីដែលអ្នកមានសិទ្ធិធ្វើ។"
ខ្លី ច្បាស់ និងពេញលេញ៖ ប្រើត្រឹម 47 tokens ជំនួសឱ្យ 151។
ពិន្ទុ loss ទាប មិនប្រាកដថាផ្ដល់ចម្លើយបានល្អជាងនោះឡើយ។ ត្រូវអានចម្លើយផ្ទាល់ភ្នែក និងប្រៀបធៀប checkpoint នីមួយៗជានិច្ច មុននឹងសម្រេចចិត្តជ្រើសយកមួយណា។
ចំណាំ (អរគុណដល់ Ahmet Özel)៖ សំណួរដែលខ្ញុំយកមកប្រៀបធៀបមុន និងក្រោយពេលបង្វឹកនេះ គឺជាសំណួរដដែលដែលមានក្នុងទិន្នន័យបង្វឹកគំរូខាងលើ ដូច្នេះការប្រៀបធៀបនេះគ្រាន់តែបង្ហាញពីរបៀបដែលម៉ូដែលឆ្លើយតបនឹងសំណួរដែលវាធ្លាប់រៀនប៉ុណ្ណោះ មិនមែនជាសំណួរថ្មីឡើយ។ វិធីសាស្ត្រដែលត្រឹមត្រូវជាងនេះ៖ គួរជ្រើសរើស checkpoint ដោយផ្អែកលើលក្ខខណ្ឌវាយតម្លៃ (validation rubric) តូចមួយ រួចទើបយកទៅវាយតម្លៃចុងក្រោយលើសំណួរតេស្តថ្មីសុទ្ធសាធដែលវាមិនធ្លាប់ឃើញពីមុនមក។
7. បញ្ចូល (fuse) adapter ឱ្យទៅជាម៉ូដែលឯករាជ្យមួយ
ដើម្បីយក checkpoint នៃ step-10 មកប្រើ សូមចម្លងឯកសារ 0000010_adapters.safetensors ទៅដាក់ក្នុងថតផ្ទាល់ខ្លួនរបស់វា ដោយប្តូរឈ្មោះជា adapters.safetensors ព្រមជាមួយឯកសារ adapter_config.json (ខ្ញុំដាក់ឈ្មោះថតនោះថា adapters/smoke-it10)។ បន្ទាប់មកដំណើរការ៖
mlx_lm.fuse --model ./models/Qwen2.5-3B-Instruct-4bit \
--adapter-path ./adapters/smoke-it10 --save-path ./models/rainy-qwen-3bទំហំនៅតែ 1.6 GB ដដែល ហើយដំណើរការក្នុងល្បឿន 81 tokens/s។ គន្លឹះមួយគឺ៖ ត្រូវតេស្តម៉ូដែលដែលបញ្ចូលគ្នារួចនោះ ជាមួយ system prompt ដូចគ្នាទៅនឹងពេលដែលអ្នកបានបង្វឹក។ បើគ្មានវាទេ ម៉ូដែលនឹងត្រឡប់ទៅឆ្លើយវែងអន្លាយដូចដើមវិញមិនខាន។
8. ដាក់ឱ្យដំណើរការជា Local API ជាមួយ FastAPI (និងវិធីដោះស្រាយបញ្ហាយ៉ាងសាមញ្ញ)
កម្មវិធី FastAPI តូចមួយអាចទាញយកម៉ូដែល និង adapter មកផ្ទុកក្នុងមេម៉ូរីតែម្តង ហើយបើកដំណើរការ route សម្រាប់ឆាត៖
from fastapi import FastAPI
from pydantic import BaseModel
from mlx_lm import load, generate
SYSTEM = "You explain software concepts in one or two short, clear sentences."
model, tokenizer = load("./models/Qwen2.5-3B-Instruct-4bit", adapter_path="./adapters/smoke-it10")
app = FastAPI()
class Question(BaseModel):
question: str
@app.post("/chat")
async def chat(q: Question): # async: MLX streams belong to the thread that loaded the model
messages = [{"role": "system", "content": SYSTEM}, {"role": "user", "content": q.question}]
prompt = tokenizer.apply_chat_template(messages, add_generation_prompt=True)
return {"answer": generate(model, tokenizer, prompt=prompt, max_tokens=200)}uvicorn app:app --port 8000
curl -X POST localhost:8000/chat -H 'Content-Type: application/json' -d '{"question": "What is a reverse proxy?"}'បើប្រើ route ជាអនុគមន៍ def ធម្មតា ការស្នើសុំ (request) ដំបូងបង្អស់របស់ខ្ញុំបានគាំង (crash) ជាមួយដំណឹងកំហុសថា៖
There is no Stream(cpu, 0) in current threadMLX streams ដំណើរការលើ thread តែមួយ ចំណែកឯ FastAPI វិញរត់ route ប្រភេទ def ធម្មតានៅលើ worker thread ផ្សេង។ ដូច្នេះ ការប្តូរ route ទៅជា async def នឹងរក្សាវាឱ្យដំណើរការលើ thread តែមួយដែលបានផ្ទុកម៉ូដែលនោះ។ នេះគ្រាន់តែជាការបង្ហាញសម្រាប់អ្នកប្រើតែម្នាក់ (មិនមានមុខងារ streaming, authentication ឬ queue ឡើយ) ដូច្នេះគួរប្រើតែលើម៉ាស៊ីនផ្ទាល់ខ្លួនរបស់អ្នកបានហើយ។
ចុះចំពោះ Ollama និង GGUF វិញ?
Ollama គឺជាជម្រើសផ្សេងមួយទៀត៖ វាមិនអាចយក adapter របស់ MLX ទៅប្រើដោយស្វ័យប្រវត្តិនោះទេ ហើយមុខងារ export ជា GGUF ដែលមានស្រាប់ក្នុង MLX LM បច្ចុប្បន្នគាំទ្រតែ Llama, Mistral និង Mixtral ប៉ុណ្ណោះ មិនទាន់គាំទ្រ Qwen ឡើយ។ (ប្រសិនបើអ្នក fine-tune ម៉ូដែល Llama វិញ អ្នកអាច fuse វាបញ្ចូលគ្នា រួចនាំចូលឯកសារ safetensors ទៅក្នុង Ollama បាន ដែលវិធីនេះខ្ញុំបានបង្ហាញរួចហើយនៅក្នុងវគ្គសិក្សា Ollama របស់ខ្ញុំ)។
គន្លឹះគ្រប់គ្រងមេម៉ូរីពីការតេស្តជាក់ស្តែង
- ការឆ្លើយឆាតស៊ីមេម៉ូរីតិចជាងការបង្វឹក៖ 1.9 GB សម្រាប់ឆាត និង 2.5 GB សម្រាប់បង្វឹក ចំពោះម៉ូដែល 3B នេះលើឧទាហរណ៍ខ្លីៗ។
- ប្រយោគកាន់តែវែង (longer sequences) និង batch កាន់តែធំ នឹងធ្វើឱ្យស៊ីមេម៉ូរីកើនឡើងយ៉ាងលឿន។ បើខ្វះមេម៉ូរី៖ កំណត់ batch size 1, បន្ថយប្រវែង
--max-seq-lengthឱ្យខ្លីជាងមុន និងបន្ថយចំនួន--num-layers។ - ត្រូវប្រើ flag ឈ្មោះ
--num-layersមិនមែន--lora-layersចាស់នោះទេ។ - ចម្លើយចេញមកដដែលៗមែនទេ? គួរពិនិត្យមើលទិន្នន័យរបស់អ្នកក្រែងលោមានទិន្នន័យស្ទួន មុននឹងបន្ទោសម៉ូដែល។
- សម្រាប់ការបង្វឹកពិតប្រាកដ គួរបង្កើនចំនួន iterations ជាមួយ gradient accumulation (ឧទាហរណ៍ 400 iterations, accumulation 4 = ការអាប់ដេត weights ចំនួន 100 ដង)។ គួរវាស់ស្ទង់ល្បឿនម៉ាស៊ីនរបស់អ្នកជាមុនសិន៖ បើរត់ក្នុងល្បឿន 0.2 it/s នោះ 400 iterations នឹងចំណាយពេលប្រហែល 33 នាទី។
ប្រៀបធៀបរវាង Fine-tuning, RAG និងការសរសេរ Prompt ឱ្យបានល្អជាងមុន
- បើចង់បានចម្លើយពី ឯកសារដែលមានការផ្លាស់ប្តូរជាប្រចាំ → គួរប្រើ RAG។
- បើគ្រាន់តែចង់បាន ទម្រង់ឆ្លើយខុសប្លែកពីមុន (different tone) → សាកល្បង សរសេរ system prompt ឱ្យល្អជាងមុន ជាមុនសិន។
- ជ្រើសយក Fine-tune នៅពេលអ្នកមានឧទាហរណ៍ជាក់ស្តែង និងឥរិយាបថច្បាស់លាស់ដែលអាចវាស់ស្ទង់បាន។
ការ fine-tune បន្តិចបន្តួច មិនអាចធ្វើឱ្យម៉ូដែលតូចមួយឆ្លាតជាងមុននោះឡើយ ប៉ុន្តែវាជួយឱ្យការឆ្លើយតបរបស់វាមាន ភាពស៊ីសង្វាក់គ្នាល្អជាងមុន (consistent)។
កត់ត្រារាល់ការពិសោធន៍ទាំងអស់ឱ្យបានច្បាស់លាស់
ឈ្មោះម៉ូដែលជាក់លាក់, វើសិនរបស់ package, ពាក្យបញ្ជាដែលបានប្រើ, random seed, ការបែងចែកក្រុមទិន្នន័យ, adapter នីមួយៗ (រួមទាំង checkpoint ដំបូងៗ) ព្រមទាំងចម្លើយមុន និងក្រោយពេលបង្វឹកលើសំណួរតេស្តដដែល។ កំណត់ត្រាទាំងនេះហើយ គឺជាភស្តុតាងបញ្ជាក់ថា ម៉ូដែលរបស់អ្នកពិតជាមានសមត្ថភាពប្រសើរជាងមុនពិតប្រាកដមែន។
សរុបមក តើយើងអាច fine-tune ម៉ូដែល LLM លើ Mac បានដែរឬទេ? ចម្លើយគឺបានយ៉ាងពិតប្រាកដ។ ជាមួយ MLX ម៉ូដែល 3B អាចបង្វឹកបានត្រឹមតែប៉ុន្មានវិនាទី និងស៊ីមេម៉ូរីក្រោម 3 GB ប៉ុណ្ណោះ។ ចាប់ផ្តើមដោយការតេស្តសាកល្បង 20 ជំហាន (steps) ជាមុនសិន អានចម្លើយឱ្យបានច្បាស់ រួចទើបពង្រីកទំហំបង្វឹកជាបន្តបន្ទាប់។
តើអ្នកចង់បង្រៀនម៉ូដែលលើម៉ាស៊ីនផ្ទាល់ខ្លួនរបស់អ្នកឱ្យចេះធ្វើអ្វីខ្លះ? ចែករំលែកមតិរបស់អ្នកនៅក្នុង comment ខាងក្រោម!


