ເຂົ້າໃຈຄະນິດສາດທີ່ຢູ່ເບື້ອງຫຼັງ Linear Regression

ສະບາຍດີນັກສຶກສາວິທະຍາສາດຄອມພິວເຕີ ແລະ ນັກພັດທະນາຊອບແວທຸກທ່ານ! ເມື່ອເວົ້າເຖິງ Machine Learning (ML), ຫຼາຍຄົນມັກຈະນຶກເຖິງໂມເດວທີ່ຊັບຊ້ອນຄື Deep Learning ຫຼື Neural Networks. ແຕ່ໃນຄວາມເປັນຈິງແລ້ວ, ກ່ອນທີ່ເຮົາຈະກ້າວໄປສູ່ຈຸດນັ້ນ, ພື້ນຖານທີ່ສຳຄັນທີ່ສຸດທີ່ເຮົາຕ້ອງເຂົ້າໃຈຢ່າງເລິກເຊິ່ງກໍຄື Linear Regression.

ບໍ່ວ່າຈະເປັນການຄາດຄະເນລະດັບນ້ຳຂອງໃນຍາມຝົນ, ການວິເຄາະທ່າອ່ຽງລາຄາທີ່ດິນໃນເຂດຈັນທະບູລີ ນະຄອນຫຼວງວຽງຈັນ, ຫຼື ການພະຍາກອນຜົນຜະລິດກາເຟທີ່ເມືອງປາກຊ່ອງ, Linear Regression ຄືເຄື່ອງມືທາງຄະນິດສາດທີ່ສາມາດຊ່ວຍໃຫ້ເຮົາສ້າງໂມເດວພະຍາກອນເຫຼົ່ານີ້ໄດ້. ໃນບົດຄວາມນີ້, ເຮົາຈະມາແກະກ່ອງເບິ່ງຄະນິດສາດທີ່ຢູ່ເບື້ອງຫຼັງໂມເດວນີ້ ກ່ອນທີ່ຈະລົງມືຂຽນໂຄດຈຳລອງດ້ວຍ Python.

1. ສົມຜົນເສັ້ນຊື່ (The Equation of a Straight Line)

Linear Regression ມີເປົ້າໝາຍຫຼັກຄືການຊອກຫາ “ເສັ້ນຊື່ທີ່ເໝາະສົມທີ່ສຸດ” (Line of Best Fit) ທີ່ສາມາດອະທິບາຍຄວາມສຳພັນລະຫວ່າງຕົວປ່ຽນຕົ້ນ (Independent Variable) ແລະ ຕົວປ່ຽນຕາມ (Dependent Variable).

ໃນຄະນິດສາດຊັ້ນມັດທະຍົມ, ເຮົາຄຸ້ນເຄີຍກັບສົມຜົນ: $y = mx + b$

ແຕ່ໃນວົງການ Machine Learning, ເຮົາມັກຈະຂຽນໃນຮູບແບບຂອງ Parameters (ຫຼື Weights) ຄື: $h_\theta(x) = \theta_0 + \theta_1x$

• $h_\theta(x)$: ແມ່ນຄ່າທີ່ໂມເດວຂອງເຮົາທຳນາຍອອກມາ (Hypothesis). ສົມມຸດວ່າແມ່ນ ຜົນຜະລິດກາເຟປາກຊ່ອງ (ໂຕນ).
• $x$: ແມ່ນຄ່າ Input. ສົມມຸດວ່າແມ່ນ ປະລິມານນ້ຳຝົນ (ມິນລີແມັດ).
• $\theta_0$: ແມ່ນຄ່າ Bias (ຈຸດຕັດແກນ y).
• $\theta_1$: ແມ່ນຄ່າ Weight (ຄວາມຊັນຂອງເສັ້ນ).

2. ຟັງຊັນຕົ້ນທຶນ (Cost Function: Mean Squared Error)

ເມື່ອເຮົາສ້າງເສັ້ນຊື່ຂຶ້ນມາ, ເຮົາຈະຮູ້ໄດ້ແນວໃດວ່າເສັ້ນນັ້ນດີຫຼືບ່ອນ? ຄຳຕອບຄືການວັດແທກ “ຄວາມຜິດພາດ” (Error) ລະຫວ່າງຄ່າທີ່ໂມເດວທຳນາຍ ກັບ ຄ່າຈິງທີ່ມີຢູ່ໃນ Data ຂອງເຮົາ.

ໃນ Linear Regression, ເຮົາໃຊ້ຄະນິດສາດທີ່ເອີ້ນວ່າ Mean Squared Error (MSE) ຫຼື ຟັງຊັນຕົ້ນທຶນ (Cost Function), ເຊິ່ງຂຽນແທນດ້ວຍ $J(\theta_0, \theta_1)$:

$J(\theta_0, \theta_1) = \frac{1}{2m} \sum_{i=1}^{m} (h_\theta(x^{(i)}) - y^{(i)})^2$

ອະທິບາຍສູດ:

• $m$: ຈຳນວນຂໍ້ມູນທັງໝົດທີ່ເຮົາມີ (ເຊັ່ນ: ຂໍ້ມູນປະລິມານນ້ຳຝົນ ແລະ ຜົນຜະລິດກາເຟ ຍ້ອນຫຼັງ 10 ປີ).
• $h_\theta(x^{(i)})$ : ຄ່າທີ່ໂມເດວທຳນາຍໄດ້ສຳລັບຂໍ້ມູນຕົວທີ $i$.
• $y^{(i)}$: ຄ່າຈິງຂອງຂໍ້ມູນຕົວທີ $i$.
• ເຮົາເອົາຄ່າທີ່ທຳນາຍມາລົບໃຫ້ຄ່າຈິງ, ແລ້ວ ຍົກກຳລັງສອງ ($^2$) ເພື່ອໃຫ້ຄ່າ Error ກາຍເປັນບວກສະເໝີ ແລະ ລົງໂທດ (Penalize) ຄ່າ Error ທີ່ໃຫຍ່ໃຫ້ມີຜົນຕໍ່ໂມເດວຫຼາຍຂຶ້ນ.

3. ການປັບປຸງໂມເດວດ້ວຍ Gradient Descent

ເປົ້າໝາຍຂອງເຮົາຄືການຊອກຫາຄ່າ $\theta_0$ ແລະ $\theta_1$ ທີ່ເຮັດໃຫ້ Cost Function $J(\theta_0, \theta_1)$ ມີຄ່າ ນ້ອຍທີ່ສຸດ (Minimum). ວິທີທີ່ນິຍົມທີ່ສຸດໃນ Machine Learning ໃນການແກ້ໄຂບັນຫານີ້ຄື Gradient Descent.

Gradient Descent ແມ່ນການຄິດໄລ່ Derivative (ຜົນຕຳລາ) ສ່ວນໜຶ່ງ (Partial Derivatives) ຂອງ Cost Function ເພື່ອຊອກຫາທິດທາງທີ່ຄວາມຊັນຫຼຸດລົງ, ຈາກນັ້ນກໍປັບຄ່າ $\theta$ ລົງເທື່ອລະໜ້ອຍ.

ສູດການອັບເດດຄ່າ Parameters ຈະເປັນດັ່ງນີ້:

$\theta_j := \theta_j - \alpha \frac{\partial}{\partial \theta_j} J(\theta_0, \theta_1)$

ເມື່ອເຮົາຄິດໄລ່ Partial Derivatives ສຳລັບ $\theta_0$ ແລະ $\theta_1$, ເຮົາຈະໄດ້:

• ສຳລັບ $\theta_0$: $\theta_0 := \theta_0 - \alpha \frac{1}{m} \sum_{i=1}^{m} (h_\theta(x^{(i)}) - y^{(i)})$
• ສຳລັບ $\theta_1$: $\theta_1 := \theta_1 - \alpha \frac{1}{m} \sum_{i=1}^{m} (h_\theta(x^{(i)}) - y^{(i)}) \cdot x^{(i)}$

(ໝາຍເຫດ: $\alpha$ ຫຼື Alpha ແມ່ນ Learning Rate ເຊິ່ງເປັນຕົວຄວບຄຸມວ່າເຮົາຈະກ້າວໄປຫາຈຸດນ້ອຍສຸດໄວ ຫຼື ຊ້າສ່ຳໃດ).

4. ມາລົງມືຂຽນໂຄດກັນເລີຍ (Python Implementation)

ເພື່ອໃຫ້ເຂົ້າໃຈຄະນິດສາດຂ້າງເທິງໄດ້ຢ່າງຈະແຈ້ງ, ເຮົາລອງມາຂຽນໂຄດຄິດໄລ່ Linear Regression ຈາກສູນ (From Scratch) ໂດຍໃຊ້ພຽງແຕ່ numpy ເພື່ອຈຳລອງການພະຍາກອນຜົນຜະລິດກາເຟປາກຊ່ອງ.

import numpy as np

# ຂໍ້ມູນຈຳລອງ: x = ປະລິມານນ້ຳຝົນ (ມິນລີແມັດ), y = ຜົນຜະລິດກາເຟ (ໂຕນ/ເຮັກຕາ)
x = np.array([120, 150, 170, 200, 220]) 
y = np.array([1.5, 2.0, 2.3, 2.8, 3.1])

def gradient_descent(x, y, learning_rate=0.0001, epochs=10000):
    # ກຳນົດຄ່າເລີ່ມຕົ້ນຂອງ Theta 0 ແລະ Theta 1
    theta_0 = 0.0
    theta_1 = 0.0
    m = len(x)

    for i in range(epochs):
        # ສົມຜົນເສັ້ນຊື່ (Hypothesis)
        y_predicted = theta_0 + theta_1 * x
        
        # ຄິດໄລ່ Partial Derivatives (Gradients)
        d_theta_0 = (1/m) * sum(y_predicted - y)
        d_theta_1 = (1/m) * sum((y_predicted - y) * x)
        
        # ອັບເດດຄ່າ Parameters ຕາມສູດ Gradient Descent
        theta_0 = theta_0 - learning_rate * d_theta_0
        theta_1 = theta_1 - learning_rate * d_theta_1
        
    return theta_0, theta_1

# ເອີ້ນໃຊ້ຟັງຊັນ
final_theta_0, final_theta_1 = gradient_descent(x, y)

print(f"ຄ່າ Bias (\u03b80): {final_theta_0:.4f}")
print(f"ຄ່າ Weight (\u03b81): {final_theta_1:.4f}")

# ລອງທຳນາຍ: ຖ້າປີໜ້າຝົນຕົກ 180 ມິນລີແມັດ ຜົນຜະລິດຈະເປັນເທົ່າໃດ?
rain_prediction = 180
yield_prediction = final_theta_0 + final_theta_1 * rain_prediction
print(f"ຄາດຄະເນຜົນຜະລິດເມື່ອຝົນຕົກ 180mm: {yield_prediction:.2f} ໂຕນ/ເຮັກຕາ")

ເມື່ອທ່ານເອົາໂຄດນີ້ໄປຮັນ, ທ່ານຈະເຫັນວ່າຄອມພິວເຕີຄ່ອຍໆປັບປ່ຽນຄ່າຊ້າໆຈົນໄດ້ເສັ້ນຊື່ທີ່ເໝາະສົມທີ່ສຸດ ໂດຍອ້າງອີງຈາກທິດສະດີທາງຄະນິດສາດທີ່ເຮົາໄດ້ເວົ້າເຖິງທັງໝົດ.

5. ສິ່ງທີ່ຄວນຈື່ (Key Takeaways)

• Linear Regression ແມ່ນການສ້າງສົມຜົນເສັ້ນຊື່ $y = \theta_0 + \theta_1x$ ເພື່ອຫາຄວາມສຳພັນຂອງຂໍ້ມູນ.
• Mean Squared Error (MSE) ແມ່ນຕົວຊີ້ວັດວ່າເສັ້ນຂະໜາດທີ່ເຮົາຂີດນັ້ນ “ຜິດດ່ຽງ” ຫຼາຍປານໃດຈາກຄວາມເປັນຈິງ.
• Gradient Descent ແມ່ນຂະບວນການທາງຄະນິດສາດ (ໃຊ້ຜົນຕຳລາ) ເພື່ອປັບຄ່າ $\theta_0$ ແລະ $\theta_1$ ຈົນກວ່າຄ່າ Error ຈະຕໍ່າທີ່ສຸດ.
• Learning Rate ($\alpha$) ຕ້ອງຖືກຕັ້ງຄ່າໃຫ້ເໝາະສົມ, ຖ້າໃຫຍ່ເກີນໄປໂມເດວຈະຮຽນຮູ້ບໍ່ໄດ້ (Diverge), ເປັນນ້ອຍເກີນໄປຈະໃຊ້ເວລາດົນ.

ສະຫຼຸບ

ການຮຽນຮູ້ Machine Learning ບໍ່ໄດ້ໝາຍຄວາມວ່າເຮົາຕ້ອງໃຊ້ພຽງແຕ່ Library ສຳເລັດຮູບເຊັ່ນ scikit-learn ເທົ່ານັ້ນ. ສຳລັບນັກສຶກສາວິທະຍາສາດຄອມພິວເຕີແລ້ວ, ຄວາມເຂົ້າໃຈກ່ຽວກັບຄະນິດສາດລະດັບພື້ນຖານ ເຊັ່ນ Algebra ແລະ Calculus ທີ່ຢູ່ເບື້ອງຫຼັງໂມເດວ ແມ່ນກຸນແຈສຳຄັນທີ່ຊ່ວຍໃຫ້ເຮົາສາມາດນຳໄປດັດແປງ ແລະ ແກ້ໄຂບັນຫາທີ່ຫຍຸ້ງຍາກຂຶ້ນໃນອະນາຄົດໄດ້. ບໍ່ວ່າຈະເປັນການເອົາໄປນຳໃຊ້ກັບລະບົບຂໍ້ມູນການກະເສດຢູ່ລາວ, ຂໍ້ມູນຊັບສິນ, ຫຼື ຂໍ້ມູນການລາຈອນ, ພື້ນຖານທີ່ແໜ້ນໜາຄືສິ່ງທີ່ຈະເຮັດໃຫ້ນັກພັດທະນາແຕກຕ່າງຈາກຄົນທົ່ວໄປ. ຂໍໃຫ້ມ່ວນຊື່ນກັບການຂຽນໂຄດຄະນິດສາດ!