MM Dataverse

Neural Network Implementation သင်ခန်းစာ

Defi The Open Library မှ အခမဲ့ဖြန့်ဝေပါသည်။

Neural Network များသည် machine learning နယ်ပယ်တွင် အရေးပါသော algorithm တစ်ခုဖြစ်သည်။ ဤဆောင်းပါးတွင် Python နှင့် NumPy ကိုအသုံးပြု၍ neural network တစ်ခုကို အခြေခံမှစတင်၍ တည်ဆောက်နည်းကို လေ့လာသွားမည်ဖြစ်သည်။

အခြေခံသဘောတရား

Neural Network တစ်ခုသည် အောက်ပါအစိတ်အပိုင်းများဖြင့် ဖွဲ့စည်းထားသည်။

1. Input Layer
2. Hidden Layer(s)
3. Output Layer
4. Weights နှင့် Biases
5. Activation Functions

Implementation အဆင့်ဆင့်

1. လိုအပ်သော Libraries များ Import လုပ်ခြင်း

import numpy as np

class NeuralNetwork:
    def __init__(self, layer_sizes):
        self.layer_sizes = layer_sizes
        self.weights = []
        self.biases = []

        # Initialize weights နှင့် biases
        for i in range(len(layer_sizes) - 1):
            w = np.random.randn(layer_sizes[i], layer_sizes[i+1]) * 0.1
            b = np.zeros((1, layer_sizes[i+1]))
            self.weights.append(w)
            self.biases.append(b)

2. Activation Functions များ အကောင်အထည်ဖော်ခြင်း

def sigmoid(self, x):
    return 1 / (1 + np.exp(-x))

def sigmoid_derivative(self, x):
    return x * (1 - x)

3. Forward Propagation အကောင်အထည်ဖော်ခြင်း

def forward_propagation(self, X):
    self.activations = [X]
    current_activation = X

    for i in range(len(self.weights)):
        z = np.dot(current_activation, self.weights[i]) + self.biases[i]
        current_activation = self.sigmoid(z)
        self.activations.append(current_activation)

    return current_activation

4. Backward Propagation အကောင်အထည်ဖော်ခြင်း

def backward_propagation(self, X, y, learning_rate=0.1):
    m = X.shape[0]
    delta = self.activations[-1] - y

    for i in range(len(self.weights) - 1, -1, -1):
        dW = np.dot(self.activations[i].T, delta) / m
        db = np.sum(delta, axis=0, keepdims=True) / m

        if i > 0:
            delta = np.dot(delta, self.weights[i].T) * self.sigmoid_derivative(self.activations[i])

        self.weights[i] -= learning_rate * dW
        self.biases[i] -= learning_rate * db

5. Training Process အကောင်အထည်ဖော်ခြင်း

def train(self, X, y, epochs=1000, learning_rate=0.1):
    for epoch in range(epochs):
        # Forward propagation
        output = self.forward_propagation(X)

        # Backward propagation
        self.backward_propagation(X, y, learning_rate)

        if epoch % 100 == 0:
            loss = np.mean(np.square(y - output))
            print(f"Epoch {epoch}, Loss: {loss}")

နမူနာအသုံးပြုပုံ

အထက်ပါ code များကို လက်တွေ့အသုံးပြုပုံကို XOR problem ဖြင့် စမ်းသပ်ကြည့်မည်:

# Create training data for XOR problem
X = np.array([[0,0], [0,1], [1,0], [1,1]])
y = np.array([[0], [1], [1], [0]])

# Create neural network with architecture: 2-4-1
nn = NeuralNetwork([2, 4, 1])

# Train the network
nn.train(X, y, epochs=1000)

# Test the network
predictions = nn.forward_propagation(X)
print("\\\\nPredictions:")
print(predictions)

အရေးကြီးသော မှတ်သားစရာအချက်များ

1. Weight Initialization: Weight များကို random value များဖြင့် initialize လုပ်ရာတွင် သေးငယ်သော value များကိုသာ အသုံးပြုသင့်သည်။
2. Learning Rate: Learning rate သည် model ၏ performance အပေါ် လွန်စွာသက်ရောက်မှုရှိသည်။ သင့်တော်သောတန်ဖိုးကို ရွေးချယ်ရန် လိုအပ်သည်။
3. Network Architecture: Layer sizes များကို ရွေးချယ်ရာတွင် problem domain ပေါ်မူတည်၍ သင့်တော်သလို ရွေးချယ်ရမည်။
4. Activation Functions: Sigmoid function အပြင် အခြား activation functions များဖြစ်သော ReLU, tanh စသည်တို့ကိုလည်း အသုံးပြုနိုင်သည်။

Performance Optimization

Neural network ၏ performance ကို မြှင့်တင်ရန် အောက်ပါနည်းလမ်းများကို အသုံးပြုနိုင်သည်:

1. Batch Processing:

def train_batch(self, X, y, batch_size=32, epochs=1000, learning_rate=0.1):
    m = X.shape[0]
    for epoch in range(epochs):
        indices = np.random.permutation(m)
        for i in range(0, m, batch_size):
            batch_indices = indices[i:min(i + batch_size, m)]
            X_batch = X[batch_indices]
            y_batch = y[batch_indices]

            self.forward_propagation(X_batch)
            self.backward_propagation(X_batch, y_batch, learning_rate)

1. Momentum: Weight update လုပ်ရာတွင် momentum အသုံးပြုခြင်းဖြင့် convergence မြန်ဆန်စေနိုင်သည်။

ဤဆောင်းပါးတွင် neural network တစ်ခုကို Python နှင့် NumPy အသုံးပြု၍ အခြေခံကျကျ တည်ဆောက်နည်းကို လေ့လာခဲ့ကြသည်။ အခြေခံကောင်းများရရှိပြီးနောက် deep learning frameworks များဖြစ်သော TensorFlow, PyTorch စသည်တို့ကို လေ့လာရန် အထောက်အကူဖြစ်စေမည် ဖြစ်သည်။