PyTorch & TensorFlow Sinhala Guide: Neural Networks වලට අතපොත තියමු

ආයුබෝවන් යාළුවනේ!

අද අපි කතා කරන්න යන්නේ මේ දවස්වල ලෝකයේ හැමතැනම කතාබහට ලක්වෙන, AI කියන ක්ෂේත්‍රයේ ප්‍රධානම කොටසක් වන Deep Learning ගැන. විශේෂයෙන්ම, Deep Learning models හදන්න පාවිච්චි කරන ප්‍රධාන Frameworks දෙකක් වන PyTorch සහ TensorFlow ගැන අපි සරලව, පියවරෙන් පියවර ඉගෙන ගමු. ඔයාට ප්‍රෝග්‍රෑම් කිරීම ගැන මූලික දැනුමක් තියෙනවා නම්, මේ tutorial එක ඔයාට ගොඩක් වටිනවා!

AI, Deep Learning, Neural Networks - සරලව තේරුම් ගනිමු

අපි මුලින්ම බලමු මේ වචන තුනෙන් මොනවද කියවෙන්නේ කියලා.

• AI (Artificial Intelligence): යන්ත්‍ර වලට මිනිස් බුද්ධිය අනුකරණය කරන්න පුළුවන් තාක්ෂණය. තීරණ ගන්න, ඉගෙන ගන්න, ගැටලු විසඳන්න පුළුවන් පද්ධති හදන එක තමයි මෙහි අරමුණ.
• Machine Learning: AI එකේම කොටසක්. Data වලින් ඉගෙනගෙන, explicit program කිරීමකින් තොරවම predict කරන්න හෝ decision ගන්න පුළුවන් algorithms හදන එක.
• Deep Learning: Machine Learning එකේ විශේෂ උප-ක්ෂේත්‍රයක්. මේකේදී Neural Networks කියලා කියන සංකීර්ණ ව්‍යුහයන් පාවිච්චි කරලා Data analyze කරනවා. මේවා මිනිස් මොළයේ ස්නායු පද්ධතිය ක්‍රියා කරන ආකාරයට සමානයි. මේකට තමයි PyTorch, TensorFlow වගේ frameworks අවශ්‍ය වෙන්නේ.

සරලවම කිව්වොත්, Deep Learning කියන්නේ AI එකට පණ දෙන ක්‍රමවේදයක්. ඒකෙන් තමයි Chatbots, Image Recognition, Self-driving cars වගේ දේවල් වලට පුළුවන්කම ලැබෙන්නේ.

PyTorch vs. TensorFlow - මොකක්ද මේ වෙනස?

Deep Learning models හදන්න තියෙන ජනප්‍රියම frameworks දෙක තමයි PyTorch සහ TensorFlow. මේ දෙකම Powerful tools වුණාට, ඒවායේ තියෙන විශේෂතා ටිකක් වෙනස්.

TensorFlow

• පසුබිම: Google විසින් develop කරන ලද්දක්. Production environments වලට ඉතාම සුදුසුයි.
• ප්‍රධාන විශේෂාංග:
  • Keras API: High-level, user-friendly API එකක් තියෙනවා. මේකෙන් models ඉක්මනින් හදන්න පුළුවන්. (සරලවම කිව්වොත්, Keras කියන්නේ TensorFlow එකේ "පහසුම" පැත්ත.)
  • TensorBoard: Models visualize කරන්න, debug කරන්න ඉතා හොඳ tool එකක්.
  • Deployment: Mobile, web, edge devices වලට models deploy කරන්න පහසුයි (TensorFlow Lite, TensorFlow.js).
• වැඩිපුර සුදුසු: Large-scale deployments, research සහ production environments දෙකටම.

PyTorch

• පසුබිම: Facebook (Meta) විසින් develop කරන ලද්දක්. Research community එක අතර ඉතාම ජනප්‍රියයි.
• ප්‍රධාන විශේෂාංග:
  • Pythonic: Python language එකට ඉතාම සමීපව නිර්මාණය කරලා තියෙන නිසා, code කරන්න ගොඩක් පහසුයි. Debug කරන්නත් පහසුයි.
  • Dynamic Computation Graph: Model එක runtime එකේදී හදන්න පුළුවන්. මේක research වලට සහ complex architectures වලට ගොඩක් වැදගත්. (TensorFlow වල කලින් තිබුණේ static graph එකක්, දැන් TensorFlow 2.0 එක්ක dynamic execution එකටත් support කරනවා).
  • Flexibility: අලුත් research ideas implement කරන්න ගොඩක් පහසුයි.
• වැඩිපුර සුදුසු: Research and rapid prototyping.

දෙකම හොඳයි. ඔයාගේ project එකේ අවශ්‍යතාවය අනුව ඔයාට මේ දෙකෙන් එකක් තෝරාගන්න පුළුවන්. මේ tutorial එකේදී අපි දෙකම පාවිච්චි කරලා සරල Neural Network එකක් හදන හැටි බලමු.

Setting Up Your Environment - ලෑස්ති වෙමු!

අපිට මේක කරන්න Python සහ pip හෝ conda අවශ්‍ය වෙනවා. ඔයාට මේවා install කරලා නැත්නම්, මුලින්ම ඒ ටික කරගන්න.

Command Prompt (Windows) හෝ Terminal (macOS/Linux) එක open කරලා, මේ විධානයන් දෙක execute කරන්න.

pip install torch torchvision torchaudio  # PyTorch සඳහා
pip install tensorflow                    # TensorFlow සඳහා

GPU support එක්ක install කරන්න ඕනේ නම්, ඒ සඳහා නිවැරදි විධානයන් PyTorch සහ TensorFlow documentation වලින් හොයාගන්න පුළුවන්. ඒක ටිකක් සංකීර්ණ නිසා, මුලින් CPU version එකෙන් පටන් ගමු.

Building a Simple Neural Network with PyTorch - PyTorch එක්ක Neural Network එකක් හදමු

අපි දැන් PyTorch පාවිච්චි කරලා සරල linear regression model එකක් හදමු. මේකෙන් අපි data set එකක තියෙන input values වලට අදාළව output values predict කරන විදිය බලමු.

1. අවශ්‍ය Libraries Import කරගැනීම

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import matplotlib.pyplot as plt

2. Sample Data සකස් කරගැනීම

අපි random data ටිකක් හදාගමු. මෙතනදී අපි y = 2x + 1 වගේ සරල සම්බන්ධතාවයක් තියෙන data එකක් හදාගන්නවා.

# Random seed for reproducibility
torch.manual_seed(42)

# Generate some linear data
X_numpy = np.array([[i] for i in range(100)], dtype=np.float32)
y_numpy = 2 * X_numpy + 1 + np.random.randn(100, 1) * 2 # Add some noise

# Convert to PyTorch tensors
X = torch.from_numpy(X_numpy)
y = torch.from_numpy(y_numpy)

print("X shape:", X.shape)
print("y shape:", y.shape)

3. Neural Network Model එක Define කිරීම

PyTorch වලදී අපි Neural Network එකක් හදන්නේ nn.Module එකක් extend කරලා. මේකේදී __init__ method එකේදී layers define කරනවා, forward method එකේදී data network එක හරහා ගලාගෙන යන විදිය define කරනවා.

class SimpleLinearRegression(nn.Module):
    def __init__(self):
        super(SimpleLinearRegression, self).__init__()
        # අපි තනි Linear Layer එකක් පාවිච්චි කරනවා (input 1, output 1)
        self.linear = nn.Linear(1, 1) 

    def forward(self, x):
        return self.linear(x)

# Model එක create කරමු
model = SimpleLinearRegression()

print(model)

4. Loss Function සහ Optimizer Define කිරීම

Loss Function එකෙන් අපි predict කරන අගයයි, ඇත්ත අගයයි අතර තියෙන වෙනස මනිනවා. Optimizer එකෙන් මේ වෙනස අඩු කරන්න model එකේ weights සහ biases adjust කරනවා.

# Mean Squared Error (MSE) loss function එක පාවිච්චි කරමු
criterion = nn.MSELoss() 

# Stochastic Gradient Descent (SGD) optimizer එක පාවිච්චි කරමු
# model.parameters() කියන්නේ model එකේ train කරන්න ඕනේ weights සහ biases.
# lr (learning rate) කියන්නේ model එක කොච්චර වේගයෙන් ඉගෙන ගන්නවද කියන එක.
optimizer = optim.SGD(model.parameters(), lr=0.01) 

5. Model එක Train කිරීම

දැන් අපි model එක train කරමු. මේකට epochs ගණනාවක් අපි data set එක network එක හරහා යවනවා.

num_epochs = 100

for epoch in range(num_epochs):
    # Forward pass: data එක model එකට දාලා prediction එක ගන්න
    outputs = model(X)
    
    # Loss එක calculate කරන්න
    loss = criterion(outputs, y)
    
    # Backward and optimize: gradients reset කරලා, calculate කරලා, weights update කරන්න.
    optimizer.zero_grad() # කලින් epoch එකේ gradients අයින් කරනවා
    loss.backward()       # gradients calculate කරනවා
    optimizer.step()      # weights update කරනවා
    
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

print("Training finished!")

6. Results Visualize කිරීම

අපි predict කරපු අගයන් ඇත්ත අගයන් එක්ක කොච්චර සමීපද කියලා බලන්න graph එකක් අඳිමු.

# Model එක evaluation mode එකට දාමු (dropout, batchnorm වගේ layers වලට වැදගත්)
model.eval() 

with torch.no_grad(): # Gradient calculation disable කරනවා
    predicted = model(X).detach().numpy() # Predictions අරගෙන numpy array එකක් බවට පත් කරනවා

plt.plot(X_numpy, y_numpy, 'ro', label='Original data')
plt.plot(X_numpy, predicted, label='Fitted line')
plt.legend()
plt.show()

# Model එකේ final weights සහ bias බලමු
for name, param in model.named_parameters():
    if param.requires_grad:
        print(f"{name}: {param.data.numpy()}")

Building a Simple Neural Network with TensorFlow/Keras - TensorFlow එක්ක Neural Network එකක් හදමු

දැන් අපි TensorFlow/Keras පාවිච්චි කරලා කලින් වගේම linear regression model එකක් හදමු. Keras නිසා මේක ගොඩක් සරලයි.

1. අවශ්‍ය Libraries Import කරගැනීම

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

2. Sample Data සකස් කරගැනීම

PyTorch වලට හදාගත්ත වගේම data ටිකක් හදාගමු.

# Random seed for reproducibility
tf.random.set_seed(42)

# Generate some linear data
X_numpy = np.array([[i] for i in range(100)], dtype=np.float32)
y_numpy = 2 * X_numpy + 1 + np.random.randn(100, 1) * 2 # Add some noise

print("X shape:", X_numpy.shape)
print("y shape:", y_numpy.shape)

3. Neural Network Model එක Define කිරීම

Keras වලදී Sequential API එක පාවිච්චි කරලා layers එකින් එක එකතු කරලා model එක හදන්න පුළුවන්. මේක ඉතාම සරලයි.

# Model එක create කරමු
model_tf = keras.Sequential([
    # Input layer එක define කරන්නේ input_shape එකෙන්
    # Dense layer එක කියන්නේ අපි කලින් දැක්ක Linear layer එකට සමානයි
    keras.layers.Dense(units=1, input_shape=[1])
])

model_tf.summary()

4. Model එක Compile කිරීම

Model එක compile කරන එකෙන් අපි loss function එක, optimizer එක සහ metrics define කරනවා.

# SGD optimizer එකයි, Mean Squared Error (MSE) loss function එකයි පාවිච්චි කරමු
model_tf.compile(optimizer='sgd', loss='mean_squared_error')

5. Model එක Train කිරීම

Keras වලදී model.fit() method එකෙන් model එක train කරන්න පුළුවන්. PyTorch වලට වඩා ගොඩක් සරලයි.

num_epochs_tf = 100

print("\nStarting TensorFlow model training...")
# Model.fit() method එකෙන් training කරමු
history = model_tf.fit(X_numpy, y_numpy, epochs=num_epochs_tf, verbose=0) # verbose=0 means no output during training

# Training process එකේ loss එක බලමු
print("Last 5 Loss values during training (TensorFlow):")
for loss_val in history.history['loss'][-5:]:
    print(f'Loss: {loss_val:.4f}')

print("TensorFlow training finished!")

6. Results Visualize කිරීම

PyTorch වල වගේම මෙතනත් අපි predict කරපු අගයන් ඇත්ත අගයන් එක්ක බලමු.

# Predictions ගන්න
predicted_tf = model_tf.predict(X_numpy)

plt.plot(X_numpy, y_numpy, 'ro', label='Original data')
plt.plot(X_numpy, predicted_tf, label='Fitted line (TensorFlow)')
plt.legend()
plt.show()

# Model එකේ final weights සහ bias බලමු
weights, bias = model_tf.layers[0].get_weights()
print(f"Weight (TensorFlow): {weights[0][0]:.4f}")
print(f"Bias (TensorFlow): {bias[0]:.4f}")

ඔයාට පේනවා ඇති, දෙකෙන්ම එකම වගේ ප්‍රතිඵල ලැබෙනවා. Keras API එක නිසා TensorFlow වල code එක ටිකක් කෙටියි සහ සරලයි.

අවසාන වශයෙන්...

ඉතින් යාළුවනේ, අපි මේ tutorial එකෙන් PyTorch සහ TensorFlow කියන ප්‍රබල Deep Learning frameworks දෙකම පාවිච්චි කරලා සරල Neural Network එකක් හදන හැටි ඉගෙන ගත්තා. මේක Deep Learning ලෝකයේ ඔයාගේ පළමු පියවර විතරයි!

ඔයා දැන් දන්නවා:

• AI, Deep Learning, Neural Networks කියන්නේ මොනවද කියලා.
• PyTorch සහ TensorFlow අතර තියෙන මූලික වෙනස්කම්.
• සරල Neural Network එකක් PyTorch සහ TensorFlow (Keras) දෙකෙන්ම කොහොමද හදන්නේ කියලා.

මේ code snippets ඔයාගේ පරිගණකයේ Run කරලා බලන්න. Parameters වෙනස් කරලා අත්හදා බලන්න. learning rate, epochs වගේ දේවල් වෙනස් කරාම model එකේ performance එකට මොකද වෙන්නේ කියලා බලන්න.

මතක තියාගන්න, practice කරන තරමට තමයි දක්ෂ වෙන්නේ. මේ වගේම තවත් සංකීර්ණ problems වලට මේ frameworks යොදාගන්න උත්සාහ කරන්න.

ඔයාගේ අත්දැකීම්, ප්‍රශ්න හෝ අදහස් පහලින් comment කරන්න! අපි ඊළඟ tutorial එකෙන් හම්බවෙමු. ජය වේවා!