ການຂຽນໂຄດ Perceptron ຈາກເລີ່ມຕົ້ນດ້ວຍ Python

ສະບາຍດີນັກພັດທະນາທຸກທ່ານ! ເມື່ອເຮົາກ້າວເຂົ້າສູ່ໂລກຂອງ Artificial Intelligence (AI) ແລະ Deep Learning, ຊື່ຂອງ Neural Networks (NN) ແມ່ນສິ່ງທີ່ເຮົາໄດ້ຍິນຢູ່ສະເໝີ. ແຕ່ກ່ອນທີ່ເຮົາຈະໄປສ້າງໂຄງຮ່າງ AI ຂະໜາດໃຫຍ່ເພື່ອວິເຄາະການສັນຈອນໃນນະຄອນຫຼວງວຽງຈັນ ຫຼື ພະຍາກອນລະດັບນໍ້າຂອງ, ມັນສຳຄັນຫຼາຍທີ່ເຮົາຈະຕ້ອງເຂົ້າໃຈ “ຫົວໃຈຮາກຖານ” ຂອງມັນກ່ອນ.

ໃນບົດຄວາມນີ້, ເຮົາຈະມາຮຽນຮູ້ການສ້າງ Perceptron, ເຊິ່ງເປັນຮູບແບບທີ່ງ່າຍດາຍທີ່ສຸດຂອງ Neural Network ໂດຍການຂຽນໂຄດດ້ວຍ Python ແບບບໍ່ເພິ່ງພາ Framework ດັງໆຄື TensorFlow ຫຼື PyTorch.

Perceptron ແມ່ນຫຍັງ?

Perceptron ຖືກຄິດຄົ້ນຂຶ້ນໃນປີ 1957 ໂດຍ Frank Rosenblatt. ມັນເປັນແບບຈຳລອງທາງຄະນິດສາດທີ່ຮຽນແບບການເຮັດວຽກຂອງເຊວປະສາດ (Neuron) ໃນສະໝອງຂອງຄົນເຮົາ. ໜ້າທີ່ຫຼັກຂອງມັນຄືການຮັບຂໍ້ມູນນຳເຂົ້າ (Inputs), ເອົາມາຄູນກັບຄ່ານໍ້າໜັກ (Weights), ບວກກັບຄ່າຄວາມລຳອຽງ (Bias), ແລ້ວສົ່ງຜ່ານຟັງຊັນກະຕຸ້ນ (Activation Function) ເພື່ອຕັດສິນໃຈວ່າຈະໃຫ້ຜົນລັບອອກມາເປັນຫຍັງ (ປົກກະຕິແລ້ວແມ່ນ 0 ຫຼື 1).

ຕົວຢ່າງໃນບໍລິບົດຂອງລາວ: ການຄັດເລືອກເມັດກາເຟປາກຊ່ອງ

ລອງນຶກພາບວ່າທ່ານເປັນເຈົ້າຂອງໂຮງງານຂົ້ວກາເຟຢູ່ເມືອງປາກຊ່ອງ. ທ່ານຕ້ອງການແຍກປະເພດເມັດກາເຟອອກເປັນ “ເກຣດພຣີມຽມ” (1) ແລະ “ເກຣດທຳມະດາ” (0) ໂດຍອີງໃສ່ 2 ປັດໄຈຄື:

1. ຂະໜາດຂອງເມັດ (ມິນລີແມັດ)
2. ຄວາມເຂັ້ມຂອງສີ (ຄະແນນ 1 ເຖິງ 10)

Perceptron ຈະຊ່ວຍເຮົາຂີດເສັ້ນແບ່ງ (Linear Boundary) ເພື່ອແຍກກາເຟສອງປະເພດນີ້ອອກຈາກກັນໂດຍອັດຕະໂນມັດ ຫຼັງຈາກທີ່ມັນໄດ້ຮຽນຮູ້ຈາກຂໍ້ມູນທີ່ເຮົາປ້ອນໃຫ້.

ການເຮັດວຽກຂອງ Perceptron ທາງຄະນິດສາດແບບງ່າຍໆ

ສູດຂອງມັນມີພຽງແຕ່: $f(x) = \begin{cases} 1 & \text{if } \mathbf{w} \cdot \mathbf{x} + b \geq 0 \\ 0 & \text{otherwise} \end{cases}$

• x: ຂໍ້ມູນນຳເຂົ້າ (ຂະໜາດດ ່ແລະ ສີຂອງກາເຟ)
• w: ນໍ້າໜັກ (Weight) ຄືການບອກວ່າປັດໄຈໃດສຳຄັນກວ່າກັນ
• b: ໄບແອັສ (Bias) ຊ່ວຍໃນການປັບຄວາມຍືດຫຍຸ່ນຂອງການຕັດສິນໃຈ
• f(x): ຟັງຊັນກະຕຸ້ນ ແບບ Step Function

ການລົງມືຂຽນໂຄດ (Step-by-Step)

ເຮົາຈະມາຂຽນ Class ໃນ Python ໂດຍໃຊ້ພຽງແຕ່ໄລບຣາຣີ numpy ສຳລັບຊ່ວຍຄຳນວນທາງຄະນິດສາດ.

1. ສ້າງ Class ແລະ ຂະບວນການ Initialization

ເຮົາຕ້ອງກຳນົດອັດຕາການຮຽນຮູ້ (Learning Rate) ແລະ ຈຳນວນຮອບໃນການເຝິກ (Epochs/Iterations).

import numpy as np

class Perceptron:
    def __init__(self, learning_rate=0.01, n_iters=1000):
        self.lr = learning_rate
        self.n_iters = n_iters
        self.weights = None
        self.bias = None
        
    def _unit_step_func(self, x):
        # ຟັງຊັນກະຕຸ້ນ: ໃຫ້ຄ່າເປັນ 1 ຖ້າ x >= 0, ກໍລະນີອື່ນເປັນ 0
        return np.where(x >= 0, 1, 0)

2. ຂະບວນການເຝິກສອນ Model (Training)

ເຮົາຈະສ້າງຟັງຊັນ fit ເພື່ອໃຫ້ Perceptron ປັບຄ່າ Weights ແລະ Bias ຈົນກວ່າຈະທຳນາຍໄດ້ຖືກຕ້ອງທີ່ສຸດ.

    def fit(self, X, y):
        n_samples, n_features = X.shape
        
        # ກຳນົດຄ່າເລີ່ມຕົ້ນຂອງ weights ແລະ bias ເປັນ 0
        self.weights = np.zeros(n_features)
        self.bias = 0
        
        # ຮັບປະກັນວ່າ y ມີພຽງຄ່າ 0 ແລະ 1 ເທົ່ານັ້ນ
        y_ = np.array([1 if i > 0 else 0 for i in y])
        
        # ເລີ່ມຕົ້ນການຮຽນຮູ້ຕາມຈຳນວນຮອບທີ່ກຳນົດ
        for _ in range(self.n_iters):
            for idx, x_i in enumerate(X):
                # 1. Forward Pass: ຄຳນວນຜົນລັບ
                linear_output = np.dot(x_i, self.weights) + self.bias
                y_predicted = self._unit_step_func(linear_output)
                
                # 2. Update Weights: ກົດການຮຽນຮູ້ຂອງ Perceptron (Perceptron Learning Rule)
                update = self.lr * (y_[idx] - y_predicted)
                self.weights += update * x_i
                self.bias += update

3. ຂະບວນການທຳນາຍ (Prediction)

ເມື່ອເຝິກສຳເລັດ ເຮົາຈະໃຊ້ຟັງຊັນ predict ເພື່ອທົດສອບກັບຂໍ້ມູນໃໝ່.

    def predict(self, X):
        linear_output = np.dot(X, self.weights) + self.bias
        return self._unit_step_func(linear_output)

ທົດສອບກັບຂໍ້ມູນກາເຟປາກຊ່ອງຈຳລອງ

ບາດນີ້ ເຮົາມາລອງໃຊ້ Perceptron ທີ່ຂຽນເອງ ກັບຂໍ້ມູນຈຳລອງຂອງເມັດກາເຟ.

if __name__ == "__main__":
    # ຂໍ້ມູນຈຳລອງ: X = [ຂະໜາດເມັດ (mm), ຄວາມເຂັ້ມຂອງສີ (1-10)]
    X_train = np.array([
        [8.5, 7.2], # ເມັດໃຫຍ່, ສີເຂັ້ມ (ພຣີມຽມ)
        [6.1, 4.0], # ເມັດນ້ອຍ, ສີອ່ອນ (ທຳມະດາ)
        [7.8, 8.5], # ເມັດໃຫຍ່, ສີເຂັ້ມ (ພຣີມຽມ)
        [5.3, 3.1], # ເມັດນ້ອຍ, ສີອ່ອນ (ທຳມະດາ)
        [8.0, 6.5], # ພຣີມຽມ
        [5.5, 4.2]  # ທຳມະດາ
    ])
    
    # ປ້າຍກຳກັບ (Labels): 1 = ພຣີມຽມ, 0 = ທຳມະດາ
    y_train = np.array([1, 0, 1, 0, 1, 0])
    
    # ສ້າງ Object ຈາກ Class
    p = Perceptron(learning_rate=0.01, n_iters=1000)
    
    # ສອນ Model
    p.fit(X_train, y_train)
    
    # ທົດສອບທຳນາຍເມັດກາເຟລັອດໃໝ່
    X_new = np.array([
        [8.2, 7.0], # ຄວນຈະເປັນພຣີມຽມ
        [5.8, 3.5]  # ຄວນຈະເປັນທຳມະດາ
    ])
    
    predictions = p.predict(X_new)
    print("ຜົນການທຳນາຍເມັດກາເຟ (1=ພຣີມຽມ, 0=ທຳມະດາ):", predictions)

ຜົນທີ່ໄດ້: ຜົນການທຳນາຍເມັດກາເຟ (1=ພຣີມຽມ, 0=ທຳມະດາ): [1 0]

ສິ່ງສຳຄັນທີ່ຄວນຈື່ (Key Takeaways)

• ຮາກຖານຂອງ NN: Perceptron ແມ່ນຈຸດເລີ່ມຕົ້ນຂອງ Deep Learning. ຖ້າທ່ານເຂົ້າໃຈການອັບເດດ Weights ແລະ Bias ໃນນີ້, ທ່ານສາມາດເຂົ້າໃຈ Neural Network ທີ່ຊັບຊ້ອນຂຶ້ນໄດ້.
• ຂໍ້ຈຳກັດ: Perceptron ສາມາດແຍກປະເພດຂໍ້ມູນທີ່ສາມາດຂີດເສັ້ນກົງແບ່ງໄດ້ຊັດເຈນເທົ່ານັ້ນ (Linearly Separable). ຖ້າຂໍ້ມູນພົວພັນກັນແບບຊັບຊ້ອນ ເຮົາຈຳເປັນຕ້ອງໃຊ້ Multi-Layer Perceptron (ແນວຄິດດຽວກັນ ແຕ່ມີຫຼາຍຊັ້ນ).
• ການບໍ່ໃຊ້ Framework: ຊ່ວຍໃຫ້ເຮົາເຂົ້າໃຈສູດຄະນິດສາດ ແລະ ໂລຈິກ (Logic) ທີ່ເຊື່ອງຢູ່ເບື້ອງຫຼັງກ່ອນທີ່ຈະໄປໃຊ້ເຄື່ອງມືສຳເລັດຮູບ.

ສະຫຼຸບ

ການສ້າງ Perceptron ຈາກເລີ່ມຕົ້ນດ້ວຍ Python ອາດເບິ່ງຄືວ່າມີໂຄດຫຼາຍແຖວ, ແຕ່ມັນຊ່ວຍສ້າງຄວາມເຂົ້າໃຈທີ່ໜັກແໜ້ນໃຫ້ແກ່ນັກພັດທະນາ ຊຶ່ງເປັນປະໂຫຍດຫຼາຍໃນການພັດທະນາລະບົບ AI ໃນອະນາຄົດ. ບໍ່ວ່າຈະເປັນການທຳນາຍຄຸນນະພາບກາເຟປາກຊ່ອງ ຫຼື ການວິເຄາະຂໍ້ມູນ SMEs ໃນລາວ, ທຸກຢ່າງລ້ວນແຕ່ເລີ່ມຕົ້ນຈາກສະໝອງຈຳລອງນ້ອຍໆອັນນີ້. ເມື່ອທ່ານເຂົ້າໃຈພື້ນຖານ ນັ້ນໝາຍຄວາມວ່າທ່ານພ້ອມແລ້ວທີ່ຈະກ້າວໄປສູ່ການຂຽນໂຄດ Deep Learning ທີ່ທ້າທາຍຂຶ້ນໃນບົດຄວາມຕໍ່ໆໄປ.