PyTorch

၂၀၀၁ ခုနှစ်တွင် Idiap သုတေသနအဖွဲ့ (Idiap Research Institute) က Torch ကို စတင်ရေးသားပြီး GPL လိုင်စင်ဖြင့် ဖြန့်ချိခဲ့ပါသည်။ ၎င်းသည် C++ နှင့် CUDA ကုဒ်များဖြင့် ရေးသားထားသော ဒေတာအခြေပြုသင်ယူမှုစနစ် (Machine learning) ဆိုင်ရာ ကုဒ်အိမ် (Library) တစ်ခုဖြစ်ပြီး နျူရွန်ကွန်ရက်များ (Neural networks)၊ Support vector machines (SVM) နှင့် Hidden Markov models အစရှိသည့် နည်းလမ်းများကို ပံ့ပိုးပေးနိုင်ပါသည်။ ၂၀၁၀ ပြည့်နှစ်ဝန်းကျင်တွင် Ronan Collobert၊ Clement Farabet နှင့် Koray Kavuckuoglu တို့က ၎င်းကို ပြန်လည်ပြင်ဆင်ရေးသားခဲ့ပြီး Torch7 သို့မဟုတ် LuaTorch ဟု လူသိများခဲ့ပါသည်။ ထိုဗားရှင်းတွင် နောက်ကွယ်လုပ်ဆောင်ချက်စနစ် (Backend) ကို C ဘာသာစကားဖြင့်လည်းကောင်း၊ အရှေ့ကုဒ်မျက်နှာပြင် (Frontend) ကို Lua ဘာသာစကားဖြင့်လည်းကောင်း ရေးသားထားခြင်း ဖြစ်ပါသည်။ ၂၀၁၆ ခုနှစ်လယ်တွင် ဆော့ဖ်ဝဲရေးဆွဲသူအချို့သည် torch-autograd နှင့် Chainer တို့၏ လွှမ်းမိုးမှုဖြင့် အရှေ့ကုဒ်မျက်နှာပြင်နှင့် နောက်ကွယ်လုပ်ဆောင်ချက်စနစ်တို့ကို အပြန်အလှန် သီးခြားစီခွဲထုတ်နိုင်ရန် ကုဒ်တည်ဆောက်ပုံကို ပြန်လည်ပြင်ဆင်ခဲ့ကြပါသည်။ တစ်ဖန် torch-autograd သည်လည်း HIPS/autograd ၏ လွှမ်းမိုးမှုကို ရရှိခဲ့ခြင်း ဖြစ်ပါသည်။ ၂၀၁၈ ခုနှစ်တွင် Torch7 ဆက်လက်မြှင့်တင်မှုကို ရပ်ဆိုင်းခဲ့ပြီး PyTorch စီမံကိန်းအောက်သို့ သွတ်သွင်းခဲ့ပါသည်။

Meta (ယခင် Facebook) ကုမ္ပဏီသည် PyTorch နှင့် Caffe2 (Convolutional Architecture for Fast Feature Embedding) စနစ်နှစ်ခုလုံးကို ကိုင်တွယ်အသုံးပြုခဲ့သော်လည်း ထိုစနစ်နှစ်ခုဖြင့် တည်ဆောက်ထားသော မော်ဒယ်များသည် အချင်းချင်း သဟဇာတမဖြစ်ဘဲ ကိုက်ညီမှုမရှိခဲ့ပါ။ ထို့ကြောင့် အလွှာစုံသင်ယူမှုစနစ် (Deep learning) များကို သီးခြား Hardware မောင်းနှင်မှုစနစ်များပေါ်တွင် မမှီခိုစေရန်နှင့် မော်ဒယ်များကို စနစ်တစ်ခုမှတစ်ခုသို့ ပြောင်းလဲအသုံးပြုနိုင်ရန်အပြင် NVIDIA ၏ TensorRT ကဲ့သို့သော စွမ်းဆောင်ရည်မြင့်စနစ်များတွင် အကောင်းဆုံးလည်ပတ်နိုင်ရန်အတွက် Meta နှင့် Microsoft တို့က ၂၀၁၇ ခုနှစ် စက်တင်ဘာလတွင် ONNX (Open Neural Network Exchange) စီမံကိန်းကို ဖန်တီးခဲ့ကြပါသည်။ ထို့နောက် ၂၀၁၈ ခုနှစ် မတ်လကုန်တွင် Caffe2 ကို PyTorch ထဲသို့ ပေါင်းစည်းခဲ့ပါသည်။ ၂၀၂၂ ခုနှစ် စက်တင်ဘာလတွင်မူ PyTorch ကို Linux Foundation ၏ လက်အောက်ခံအဖွဲ့အစည်းအဖြစ် အသစ်ဖွဲ့စည်းလိုက်သော လွတ်လပ်သည့် PyTorch ဖောင်ဒေးရှင်း (PyTorch Foundation) က စီမံခန့်ခွဲသွားမည်ဖြစ်ကြောင်း Meta က ကြေညာခဲ့ပါသည်။

၂၀၂၃ ခုနှစ် မတ်လ ၁၅ ရက်နေ့တွင် PyTorch 2.0 ဗားရှင်းကို ဖြန့်ချိခဲ့ပါသည်။ ထိုဗားရှင်းတွင် ကုဒ်များကို နှစ်ဆအထိ ပိုမိုမြန်ဆန်စွာ လည်ပတ်စေနိုင်သည့် Python-level compiler အမျိုးအစား ဖြစ်သော TorchDynamo ကို စတင်မိတ်ဆက်ခဲ့သည့်အပြင် အဓိက Cloud Platform များအားလုံးတွင် မော်ဒယ်လေ့ကျင့်ခြင်းနှင့် ရလဒ်ထုတ်ယူခြင်းဆိုင်ရာ စွမ်းဆောင်ရည်များကို သိသာထင်ရှားစွာ မြှင့်တင်ပေးနိုင်ခဲ့ပါသည်။

PyTorch သည် အမျိုးအစားတူ ကိန်းဂဏန်းများဖြင့် ဖွဲ့စည်းထားသော အတိုင်းအတာမျိုးစုံသုံး စတုဂံပုံစံ အခင်းအကျင်း (Homogeneous multidimensional rectangular arrays) များကို သိမ်းဆည်းရန်နှင့် တွက်ချက်ရန်အတွက် 'Tensor' (torch.Tensor) ဟု ခေါ်ဆိုသော Class တစ်ခုကို သတ်မှတ်ပေးထားပါသည်။ PyTorch သည် multi-dimensional arrays သို့မဟုတ် Tensor အမျိုးအစားကွဲပေါင်းများစွာကို ပံ့ပိုးပေးထားပါသည်။ PyTorch Tensor များသည် NumPy Array များနှင့် ဆင်တူသော်လည်း ၎င်းတို့ကို CUDA စနစ်သုံးနိုင်သည့် NVIDIA GPU များပေါ်တွင်ပါ တင်၍ တွက်ချက်နိုင်စွမ်း ရှိပါသည်။ ထို့အပြင် PyTorch သည် AMD ၏ ROCm နှင့် Apple ၏ Metal Framework ကဲ့သို့သော အခြား GPU Platform များအတွက်ပါ အသုံးပြုနိုင်ရန် ဆက်လက်မြှင့်တင်ပေးနေပါသည်။

PyTorch သည် နျူရွန်ကွန်ရက် (Neural networks) များကို ပုံဖော်တည်ဆောက်ရန်နှင့် မော်ဒယ်လေ့ကျင့်ခြင်းလုပ်ငန်းစဉ်များကို ပံ့ပိုးပေးနိုင်ရန် 'nn' (torch.nn) ဟု ခေါ်ဆိုသော Module တစ်ခုကို သတ်မှတ်ပေးထားပါသည်။ ဤ Module သည် ရှုပ်ထွေးသော မော်ဒယ်များကို တည်ဆောက်နိုင်ရန်အတွက် နျူရွန်ကွန်ရက်ဆိုင်ရာ အခြေခံအစိတ်အပိုင်းများဖြစ်သော Layer အမျိုးမျိုးနှင့် Activation function များကို စုံလင်စွာ ပံ့ပိုးပေးထားပါသည်။ နျူရွန်ကွန်ရက်များကို တည်ဆောက်ရာတွင် torch.nn module ကို အခြေခံအဖြစ် ရယူအသုံးပြုရပြီး (Inheriting) ရှေ့သို့တွက်ချက်မှုလမ်းကြောင်းဆိုင်ရာ လုပ်ငန်းစဉ်အဆင့်ဆင့်ကို forward() function ထဲတွင် သတ်မှတ်ပေးရပါသည်။

PyTorch သည် မော်ဒယ်များကို သိမ်းဆည်းရန်နှင့် ပြန်လည်ခေါ်ယူအသုံးပြုရန်အတွက် ကိုယ်ပိုင် ဖိုင်အမျိုးအစား (File format) ကို အသုံးပြုပါသည်။ ၎င်းသည် ZIP64 Archive ဖိုင်အမျိုးအစားဖြစ်ပြီး အတွင်းပိုင်းတွင် မော်ဒယ်၏ အလေးသာချက်ကိန်းဂဏန်း (Weights) များကို Python pickle ဖိုင်အဖြစ်လည်းကောင်း၊ အခြားဒေတာအစီအစဉ်ဆိုင်ရာ အချက်အလက် (Byte order) များကိုလည်းကောင်း ပေါင်းစည်းသိမ်းဆည်းထားခြင်း ဖြစ်ပါသည်။ ထိုသို့ သိမ်းဆည်းရာတွင်.pt နှင့်.pth ဖိုင်နောက်ဆက်တွဲအမည် (Extensions) များကို အများဆုံး အသုံးပြုကြပါသည်။

အောက်တွင် ဖော်ပြထားသော ပရိုဂရမ်သည် ဤ Library ၏ အခြေခံလုပ်ဆောင်ချက်များကို ရိုးရှင်းသော ဥပမာတစ်ခုဖြင့် ပြသထားခြင်း ဖြစ်ပါသည်။

import torch dtype = torch.float device = torch.device("cpu") # တွက်ချက်မှုအားလုံးကို CPU ပေါ်တွင် လုပ်ဆောင်မည်။

#device = torch.device("cuda:0") # တွက်ချက်မှုအားလုံးကို GPU ပေါ်တွင် လုပ်ဆောင်မည်။

#Tensor တစ်ခု တည်ဆောက်ပြီး ကျပန်းကိန်းဂဏန်းများ ထည့်သွင်းမည်။

a = torch.randn(2, 3, device=device, dtype=dtype) print(a)

#ရလဒ်ထွက်ပေါ်မှု- tensor([[-1.1884, 0.8498, -1.7129],[-0.8816, 0.1944, 0.5847]])

b = torch.randn(2, 3, device=device, dtype=dtype) print(b)

#ရလဒ်ထွက်ပေါ်မှု- tensor([[ 0.7178, -0.8453, -1.3403],[ 1.3262, 1.1512, -1.7070]])

print(a * b)

# ရလဒ်ထွက်ပေါ်မှု- tensor([[-0.8530, -0.7183, 2.58],[-1.1692, 0.2238, -0.9981]])

print(a.sum())

#ရလဒ်ထွက်ပေါ်မှု- tensor(-2.1540)

print(a[1, 2]) # ဒုတိယမြောက်အတန်း၏ တတိယမြောက်ကော်လံရှိ ကိန်းဂဏန်းကို ထုတ်ပြမည် (အညွှန်းကိန်းကို သုညမှ စတင်ရေတွက်ပါသည်)

#ရလဒ်ထွက်ပေါ်မှု- tensor(0.5847)

print(a.max())

# ရလဒ်ထွက်ပေါ်မှု- tensor(0.8498)

အောက်တွင် ဖော်ပြထားသော ကုဒ်အပိုင်းအစသည် nn module ကို အသုံးပြု၍ လီနီယာအလွှာ (Linear layers) များဖြင့် ဖွဲ့စည်းထားသည့် နျူရွန်ကွန်ရက်တစ်ခုကို ပုံဖော်တည်ဆောက်ပြထားခြင်း ဖြစ်ပါသည်။

from torch import nn # PyTorch မှ nn sub-module ကို ယူသုံးမည်။

class NeuralNetwork(nn.Module):  # နျူရွန်ကွန်ရက်များကို Class အနေဖြင့် သတ်မှတ်ပါသည်။

    def __init__(self):  # အလွှာများနှင့် ကိန်းရှင်များကို __init__ method ထဲတွင် သတ်မှတ်ပါသည်။

        super().__init__()  # ဤလုပ်ဆောင်ချက်သည် ကွန်ရက်တိုင်းတွင် မဖြစ်မနေ ပါဝင်ရပါမည်။

        self.flatten = nn.Flatten()   # မက်ထရစ်ကို တစ်ဖက်မြင်အဖြစ် ပြောင်းလဲပေးမည့် အလွှာ (Flattening layer) ကို တည်ဆောက်မည်။

        self.linear_relu_stack = nn.Sequential(  # အလွှာများကို ဆင့်ကဲစီထားသော Stack တစ်ခု တည်ဆောက်မည်။

            nn.Linear(28 * 28, 512),  # Linear Layer များတွင် အဝင်နှင့် အထွက် Shape များ ရှိပါသည်။

            nn.ReLU(),  # ReLU သည် nn module မှ ပံ့ပိုးပေးထားသော အသက်သွင်းလုပ်ဆောင်ချက် (Activation function) များထဲမှ တစ်ခု ဖြစ်ပါသည်။

            nn.Linear(512, 512),

            nn.ReLU(),

            nn.Linear(512, 10),

)

    def forward(self, x):  # ဤ Function သည် ရှေ့သို့တွက်ချက်မှုလမ်းကြောင်း (Forward pass) ကို သတ်မှတ်ပေးပါသည်။

        x = self.flatten(x)

        logits = self.linear_relu_stack(x)

        return logits