អត្ថបទនេះបកប្រែពីភាសាអង់គ្លេសដោយ AI។ អានអត្ថបទដើមជាភាសាអង់គ្លេស →
បង្កើត Chatbot ជាមួយ Python ដោយខ្លួនឯងពីដំបូង៖ មិនបាច់ប្រើ API Key មិនបាច់ប្រើ AI Library
មេរៀនបង្រៀន «បង្កើត Chatbot» ភាគច្រើន ធាតុពិតគ្រាន់តែបង្រៀន «ហៅ API របស់គេមកប្រើ» ប៉ុណ្ណោះ។ ប៉ុន្តែលើកនេះមិនដូចគេទេ។ យើងនឹងបង្កើត Nova ដែលជា Chatbot តូចមួយចេះរៀនពីឧទាហរណ៍ ដោយប្រើតែ Standard Library របស់ Python សុទ្ធសាធសម្រាប់ផ្នែក AI ហើយថែម FastAPI មួយទៀតដើម្បីបង្កើតជាទំព័រឆាតលើវិបសាយ។
មិនបាច់មាន API key មិនបាច់បង់លុយសេវាកម្មអ្វីទាំងអស់ ហើយក៏មិនបាច់ទាញយក Model មកដែរ។ កូដសម្រាប់បែងចែកទិន្នន័យ (classifier) ទាំងអស់ សរសេរតែមួយផ្ទាំងអេក្រង់គឺអស់ហើយ។
▶ WATCH ON YOUTUBEWatch the video
កូដប្រភពពេញលេញ៖ https://github.com/rainyreaksmey/build-chatbot-from-scratch
គ្រប់តួលេខទាំងអស់នៅក្នុងអត្ថបទនេះ បានមកពីការដំណើរការកូដនៅក្នុង Repo នោះផ្ទាល់។
Nova គឺជា Chatbot បែបស្វែងយល់បំណង (intent) មិនមែនជា Large Language Model នោះទេ។ វាមិនចេះតែងប្រយោគថ្មីៗដោយខ្លួនឯងទេ តែវាស្វែងយល់ពីបំណងរបស់អ្នក រួចជ្រើសរើសចម្លើយដែលត្រូវគ្នាបំផុតមកឆ្លើយ។ នេះហើយជាដំណើរការរបស់ Bot ឆ្លើយសំណួរញឹកញាប់ (FAQ) និង Bot ជំនួយការសេវាកម្មជាច្រើនក្នុងជីវិតពិត។
1. របៀបដែល Intent Chatbot ដំណើរការ
មានបីជំហាន៖
- បែងចែក សារទៅតាមបំណង ឬ intent នីមួយៗ (ដូចជា
greeting,goodbye,python,training…)។ - ជ្រើសរើស ចម្លើយណាមួយដែលត្រូវនឹង intent នោះមកឆ្លើយ។
- បើ Model មិនសូវច្បាស់ក្នុងចិត្តទេ វានឹងប្រាប់ត្រង់ៗតែម្តង (ហៅថា fallback)។
ដំណើរការ Bot ទាំងមូលសង្ខេបមកគឺ៖ ទិន្នន័យបង្វឹក → ការរាប់ពាក្យ → ប្រូបាប៊ីលីតេ។
2. ទិន្នន័យសម្រាប់បង្វឹក៖ intents.json
យើងបង្រៀន Nova ដោយសរសេរឧទាហរណ៍ឱ្យវា មិនមែនសរសេរកូដទេ៖
{
"tag": "greeting",
"patterns": ["hello", "hi", "hey", "good morning", "good evening", "how are you", "hello chatbot"],
"responses": ["Hello! What would you like to learn?", "Hi! Ask me about Python or AI."]
}patterns គឺជាសារគំរូ រីឯ responses គឺជាចម្លើយដែល Nova អាចយកមកឆ្លើយ។ ឯកសារចាប់ផ្តើមមាន 10 intents, 56 ឧទាហរណ៍ និង 90 ពាក្យមិនជាន់គ្នា។
3. Tokenization៖ បំបែកអត្ថបទទៅជាពាក្យ
Model មិនអាចយល់ប្រយោគទាំងមូលបានភ្លាមៗទេ ដូច្នេះយើងត្រូវបំបែកវាទៅជាពាក្យអក្សរតូចៗ ដោយប្រើ Regular Expression តែមួយជួរ៖
TOKEN_RE = re.compile(r"[a-z0-9']+")
def tokenize(text: str) -> list[str]:
return TOKEN_RE.findall(text.lower())>>> tokenize("Hi Nova! How's it going?")
['hi', 'nova', "how's", 'it', 'going']សញ្ញាវណ្ណយុត្តិ និងអក្សរធំនឹងបាត់អស់ ចំណែកសញ្ញាត្រេលើ (apostrophe) នៅរក្សាដដែល ដើម្បីឱ្យពាក្យ "how's" នៅតែជាពាក្យតែមួយ។
4. ការបង្វឹកគ្រាន់តែជាការរាប់ពាក្យ
«ការបង្វឹក» Naive Bayes ធាតុពិតគឺគ្រាន់តែរាប់រឿងបីយ៉ាងសម្រាប់ intent នីមួយៗ៖
- ចំនួនឧទាហរណ៍ដែលមាន
- ភាពញឹកញាប់ដែលពាក្យនីមួយៗបង្ហាញខ្លួននៅក្នុងឧទាហរណ៍ទាំងនោះ
- ចំនួនពាក្យសរុបទាំងអស់
for pattern in patterns:
tokens = tokenize(str(pattern))
self.document_count += 1
self.intent_documents[tag] += 1
self.token_counts[tag].update(tokens)
self.total_tokens[tag] += len(tokens)
self.vocabulary.update(tokens)សម្រាប់ greeting នៅក្នុងទិន្នន័យចាប់ផ្តើម៖ មាន 7 ឧទាហរណ៍, មានពាក្យសរុប 12 ពាក្យ ហើយពាក្យ "hello" បង្ហាញខ្លួន 2 ដង។ នេះហើយជា Model ដែលបានបង្វឹកចប់សព្វគ្រប់។ វារក្សាទុកជាឯកសារ JSON ធម្មតា ដូច្នេះអ្នកអាចបើកមើល និងអានបានយ៉ាងងាយស្រួល។
5. ផ្នែកគណិតវិទ្យា៖ Naive Bayes
ពេលមានសារមួយចូលមក យើងចង់ដឹងថា intent ណាដែលមានប្រូបាប៊ីលីតេខ្ពស់ជាងគេ ផ្អែកលើពាក្យនៅក្នុងសារនោះ។ តាមទ្រឹស្តីបទ Bayes (Bayes' rule) វាសមាមាត្រទៅនឹង៖
P(intent) × P(word₁ | intent) × P(word₂ | intent) × …ពាក្យថា "naive" (សាមញ្ញពេក) គឺសំដៅលើការសន្មតថាពាក្យនីមួយៗមិនទាក់ទងគ្នា។ ការពិតវាមិនសុទ្ធតែត្រូវបែបហ្នឹងទេ ប៉ុន្តែសម្រាប់សារខ្លីៗ វាដំណើរការល្អគួរឱ្យភ្ញាក់ផ្អើល។
The prior (ប្រូបាប៊ីលីតេដើម) បង្ហាញពីភាពញឹកញាប់នៃ intent នោះ៖
P(intent) = (examples in intent + 1) / (all examples + number of intents)The likelihood (លទ្ធភាពកើតឡើង) បង្ហាញថាតើពាក្យនោះស័ក្តិសមប៉ុនណាសម្រាប់ intent នោះ៖
P(word | intent) = (count of word in intent + 1) / (words in intent + vocabulary size)តួលេខជាក់ស្តែងសម្រាប់ពាក្យ "hello" នៅក្នុង greeting៖ (2 + 1) / (12 + 90) = 3 / 102 ≈ 0.029។
ហេតុអ្វីត្រូវ "+1"? (Laplace smoothing)
បើគ្មានវាទេ ពាក្យណាដែល intent មិនធ្លាប់ស្គាល់ នឹងទទួលបានប្រូបាប៊ីលីតេ 0 ហើយពេលគុណនឹង 0 ពិន្ទុទាំងអស់នឹងរលាយបាត់អស់តែម្តង។ គ្រាន់តែពាក្យមិនស្គាល់មួយ ដូចជា "Nova" គឺអាចធ្វើឱ្យ intent ទាំងអស់លែងដំណើរការ។ ការបូក 1 បន្ថែមលើការរាប់គ្រប់ពាក្យ ធ្វើឱ្យពាក្យដែលមិនធ្លាប់ឃើញមានឱកាសបន្តិចបន្តួច ជំនួសឱ្យការទទួលបានសូន្យ។
ហេតុអ្វីប្រើ Log?
ការគុណប្រូបាប៊ីលីតេតូចៗច្រើនចូលគ្នា បង្កើតបានជាលេខតូចខ្លាំងរហូតដល់កុំព្យូទ័រកាត់ទៅជាសូន្យ។ ដូច្នេះហើយ យើងប្រើវិធីបូក Logarithm ជំនួសឱ្យការគុណវិញ៖
score = math.log(prior)
for token in tokens:
likelihood = (self.token_counts[intent][token] + 1) / denominator
score += math.log(likelihood)6. បម្លែងពិន្ទុទៅជាកម្រិតជឿជាក់៖ Softmax
ពិន្ទុដែលបានមកពី Log មិនមែនជាភាគរយទេ។ ដើម្បីបម្លែងវាឱ្យទៅជាប្រូបាប៊ីលីតេដែលបូកបញ្ចូលគ្នាស្មើ 1 យើងប្រើ Softmax ដោយដកពិន្ទុខ្ពស់បំផុតចេញមុនគេ ដើម្បីកុំឱ្យ exp() ជួបបញ្ហា Overflow៖
highest = max(scores.values())
exponentials = {name: math.exp(score - highest) for name, score in scores.items()}
normalizer = sum(exponentials.values())
probabilities = {name: value / normalizer for name, value in exponentials.items()}ប្រូបាប៊ីលីតេដែលខ្ពស់ជាងគេ គឺជាកម្រិតជឿជាក់ (confidence) របស់ Nova។ ប្រសិនបើវាទាបជាងកម្រិតកំណត់ (0.25) នោះ Nova នឹង fallback វិញជាជាងឆ្លើយស្មានៗ។
7. បញ្ហា Cold Start (លទ្ធផលជាក់ស្តែង)
ជាមួយទិន្នន័យដំបូង នេះជាអ្វីដែល Nova ឆ្លើយតបជាក់ស្តែង៖
- "what is python" →
python, 59.5% - "hello" →
greeting, 30.3% - "Hi Nova!" → fallback (greeting ទទួលបានខ្ពស់ជាងគេតែ 23.4% ប៉ុណ្ណោះ ដែលទាបជាងកម្រិតកំណត់ 25%)
- "What's the weather in Paris?" → fallback, 19.3% ដែលនេះពិតជាត្រឹមត្រូវ ព្រោះ Nova មិនដឹងអ្វីទាក់ទងនឹងអាកាសធាតុឡើយ
ហេតុអ្វីបានជា "Hi Nova!" មិនជោគជ័យ? មូលហេតុគឺពាក្យ "Nova" មិនដែលធ្លាប់មាននៅក្នុងទិន្នន័យបង្វឹកឡើយ ដូច្នេះវាមិនបានជួយអ្វីទេ ហើយពាក្យ "hi" គ្រាន់តែជាឧទាហរណ៍ខ្លីមួយក្នុងចំណោម 56 ឧទាហរណ៍ប៉ុណ្ណោះ។
ដំណោះស្រាយគឺទិន្នន័យ មិនមែនកូដទេ។ ខ្ញុំបានបន្ថែមគំរូពាក្យស្វាគមន៍ចំនួនបួនទៀត គឺ "hi nova", "hey nova", "hello nova" និង "hi there nova" រួចបង្វឹកម្តងទៀត៖
- "Hi Nova!" →
greeting, 79.5%
ក្បួនដោះស្រាយ (Algorithm) ដដែល គ្រាន់តែថែម JSON បួនជួរទៀត លទ្ធផលកើនឡើងពី 23% ទៅ 79%។ នៅក្នុងវីដេអូ ខ្ញុំបានបន្តកែលម្អឧទាហរណ៍រហូតដល់ Nova ឆ្លើយត្រូវដល់ 96%។ នេះហើយជាមេរៀនចម្បងនៃគម្រោងទាំងមូល៖ Model តូចមួយដែលមានឧទាហរណ៍ល្អ ប្រសើរជាង Model ឆ្លាតដែលមានឧទាហរណ៍មិនល្អ។
8. បង្កើត API ជាមួយ FastAPI
API នេះមាន Endpoint ចំនួនបីគឺ៖ health, chat និង retrain។
class ChatRequest(BaseModel):
message: str = Field(min_length=1, max_length=1000)
@app.post("/api/chat", response_model=ChatResponse)
def chat(request: ChatRequest) -> ChatResponse:
message = request.message.strip()
if not message:
raise HTTPException(status_code=422, detail="Message cannot be blank")
with model_lock:
reply, prediction = bot.reply(message)
return ChatResponse(reply=reply, intent=prediction.intent,
confidence=round(prediction.confidence, 4))Pydantic ជួយទប់ស្កាត់សារទទេ ឬសារវែងជ្រុលដោយស្វ័យប្រវត្តិ ហើយ lock ជួយការពារកុំឱ្យការបង្វឹកឡើងវិញ (retrain) ទៅផ្លាស់ប្តូរ Model នៅចំពេលដែល Bot កំពុងឆ្លើយសារ។ រីឯទំព័រ HTML/JS តូចមួយនៅក្នុងថត web/ នឹងហៅទៅកាន់ /api/chat ដើម្បីបង្ហាញចម្លើយ រួមទាំង intent និងកម្រិតជឿជាក់ (confidence) របស់វា។
សាកល្បងដំណើរការដោយខ្លួនឯង
git clone https://github.com/rainyreaksmey/build-chatbot-from-scratch
cd build-chatbot-from-scratch
python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
python train.py
uvicorn app:app --reloadបើកចូល http://127.0.0.1:8000 ដើម្បីឆាត ឬចូល http://127.0.0.1:8000/docs ដើម្បីសាកល្បងប្រើ API។
បើចង់បង្រៀន Nova ពីរឿងថ្មីៗ គ្រាន់តែបន្ថែម intent ចូលក្នុង data/intents.json ជាមួយគំរូពាក្យជាច្រើនបែប រួច run python train.py ម្តងទៀត។ សូមកុំបើកឱ្យប្រើ /api/train ជាសាធារណៈដោយគ្មានប្រព័ន្ធផ្ទៀងផ្ទាត់ (Authentication) ឱ្យសោះ។
សង្ខេបចំណុចសំខាន់ៗ
- Intent Chatbot = បែងចែកប្រភេទសារ រួចជ្រើសរើសចម្លើយដែលត្រូវគ្នា។
- ការបង្វឹក Naive Bayes ធាតុពិតគឺគ្រាន់តែរាប់ពាក្យប៉ុណ្ណោះ។
- Laplace smoothing (+1) ជួយកុំឱ្យពាក្យដែលមិនស្គាល់ធ្វើឱ្យពិន្ទុធ្លាក់ដល់សូន្យ។
- Log ជួយការពារបញ្ហាលេខតូចពេក (underflow) ហើយ Softmax បម្លែងពិន្ទុឱ្យទៅជាកម្រិតជឿជាក់។
- ការកំណត់កម្រិត Fallback ប្រសើរជាងការឆ្លើយខុសទាំងជឿជាក់លើខ្លួនឯង។
- ឧទាហរណ៍កាន់តែល្អជួយឱ្យ Bot កាន់តែឆ្លាត មិនមែនមកពីការបន្ថែមតែកូដនោះទេ។
▶ WATCH ON YOUTUBEវីដេអូបង្រៀនលម្អិតពីដើមដល់ចប់ និងសរសេរកូដផ្ទាល់៖
តើអ្នកចង់ឱ្យ Nova រៀនអ្វីបន្ថែមទៀត? ប្រាប់ខ្ញុំនៅក្នុងប្រអប់ Comment ផងណា!
ព្រាងឡើងដោយមានជំនួយពី AI។ កូដ និងតួលេខទាំងអស់បានមកពីការដំណើរការជាក់ស្តែង។ ខ្ញុំធ្វើវីដេអូបង្រៀនអំពី AI ការសរសេរកូដ និងបច្ចេកវិទ្យានៅលើ RainyTech។


