مروری بر کتابخانه PyTorch ویژه یادگیری عمیق

معرفی PyTorch 

PyTorch، یک بسته محاسبات علمی‌ مبتنی بر پایتون است که از توان پردازشی پردازنده‌های گرافیکی بهره می‌گیرد. این کتابخانه یکی از پلتفرم‌های تحقیق جامع در زمینه یادگیری عمیق محسوب می‌شود که انعطاف‌پذیری و سرعت قابل قبولی را ارائه می‌کند. PyTorch به دلیل دو قابلیت سطح بالای منحصربه‌فرد خود معروف شده که شامل محاسبات تانسور با بهره‌گیری از توان شتاب‌دهنده پردازنده گرافیکی و ساخت شبکه‌های عصبی عمیق در یک سیستم Autograd است.
کتابخانه‌های پایتون زیادی وجود دارند که چگونگی عملکرد و کار با یادگیری عمیق و هوش مصنوعی را تغییر می‌دهند و این یکی از این کتابخانه‌ها است. یکی از عوامل کلیدی موفقیت PyTorch این است که کاملا بر پایه پایتون آماده‌سازی شده و هر کسی می‌تواند به‌سادگی مدل‌هایی از شبکه عصبی را با آن تولید کند. این کتابخانه در مقايسه با سایر رقبای خود قدمت کمتری دارد، اما به‌سرعت در حال پیشرفت است. PyTorch ساختار داده اصلی یا همان Tensor را فراهم می‌کند.

یادگیری عمیق چیست؟ 

یادگیری عمیق، زیرمجموعه‌ای از مفاهیم یادگیری ماشین است که به الگوريتم‌هایی می‌پردازد که از ساختار و عملکرد مغز به نام شبکه‌های عصبی مصنوعی الهام گرفته است. برای نمونه، از این شبکه‌های عصبی مصنوعی برای طبقه‌بندی تصاویر و هوش مصنوعی بر پایه شبکه‌های عصبی استفاده می‌شود. در یادگیری عمیق به‌جای استفاده از نیروی انسانی برای حل مسائل، از کامپیوتر برای یادگیری و حل آن مسئله استفاده می‌شود. حوزه‌هایی مانند بینایی کامپیوتری و ترجمه نمونه‌هایی از موارد کاربردی یادگیری عمیق هستند. در یادگیری عمیق از روش عملکرد مغز الهام گرفته‌شده است.

چرا PyTorch نسبت به سایر کتابخانه‌های یادگیری عمیق پایتون ارجحیت دارد؟ 

به دلایل زیر استفاده از PyTorch نسبت به سایر کتابخانه‌های یادگیری عمیق پایتون ارجحیت دارد:
1. برخلاف سایر کتابخانه‌های دیگر مانند TensorFlow که قبل از اجرا کردن مدل خود باید یک نمودار کامل محاسباتی را تعریف می‌کردید، PyTorch این اجازه را می‌دهد تا نمودار خود را به شکل پویا تعریف کنید.
2. PyTorch برای تحقیق در زمینه یادگیری عمیق بسیار ایده‌آل است و بیشترین میزان انعطاف‌پذیری و سرعت را فراهم می‌کند. 

مطلب پیشنهادی

برنامه‌نویسی الگوریتم‌های یادگیری ماشین

8 کتابخانه حرفه‌ای پایتون در حوزه یادگیری ماشین

PyTorch Tensors

تانسورها در PyTorch به آرایه‌های NumPy بسیار شبیه هستند. با این مزیت که می‌توان آن‌‌ها را روی یک پردازنده گرافیکی اجرا کرد. این موضوع از اهمیت زیادی برخوردار است، زیرا به‌سرعت بخشیدن به محاسبات عددی کمک می‌کند و می‌تواند سرعت شبکه‌های عصبی را تا 50 برابر افزایش دهد. برای استفاده از PyTorch باید به آدرس https://PyTorch.org/ رفته و این کتابخانه را نصب کنید. اگر از Conda استفاده می‌کنید، PyTorch را از طریق فرمان زير نصب کنید:

conda install PyTorch torchvision -c PyTorch

برای تعریف کردن یک تانسور در PyTorch کار را با وارد کردن بسته Torch آغاز کنید. PyTorch این اجازه را می‌دهد تا دو نوع تانسور را که شامل تانسورهای CPU و GPU تعریف کنید. در این مقاله فرض بر این است که از یک پردازنده مرکزی (CPU) برای انجام محاسبات استفاده می‌کنید، اما به روش تعریف تانسورها در یک پردازنده گرافیکی (GPU) نیز خواهیم پرداخت:

import torch

نوع تانسور پیش‌فرض در PyTorch یک تانسور شناور تعریف‌شده به شکل torch.FloatTensor است. به‌عنوان‌مثال، یک تانسور از یک فهرست پایتون ایجاد کنید:

torch.FloatTensor([[20, 30, 40], [90, 60, 70]])

اگر از یک ماشين مجهز به GPU استفاده می‌کنید، تانسور را به شکل زیر تعریف کنید:

torch.cuda.FloatTensor([[20, 30, 40], [90, 60, 70]])

یا با استفاده از تانسورهای PyTorch محاسبات ریاضی مانند جمع و تفریق را انجام دهید:

x = torch.FloatTensor([25])
y = torch.FloatTensor([30])
x + y

همچنین می‌توانید با تعریف ماتریس‌ها عملیات ماتریس را انجام دهید. برای تعریف ماتریس و انتقال آن از فرامین زیر استفاده کنید:

matrix = torch.randn(4, 5)
matrix
matrix.t()

PyTorch Autograd

PyTorch، از یک تکنیک به نام تمایز خودکار (Automatic Differentiation) استفاده می‌کند که مشتق یک تابع را به‌صورت عددی ارزیابی کرده و تمایز خودکار گذرهای رو به عقب (Backward Pass) را در شبکه‌های عصبی محاسبه می‌کند. در یادگیری شبکه‌های عصبی وزن‌ها به‌صورت تصادفی با اعدادی نزدیک به صفر و نه صفر مقدار دهی اولیه می‌شوند. گذر رو به عقب فرآیندی است که توسط آن این وزن‌ها از راست به چپ تنظیم می‌شوند.
torch.autograd کتابخانه‌ای است که از تمایز خودکار در PyTorch پشتیبانی می‌کند. کلاس مرکزی این بسته torch.Tensor است. برای ردگیری تمام عملیات روی آن باید مقدار .requires_grad را به True تغییر دهید. برای محاسبه تمام گرادیان‌ها از فراخوانی .backward() استفاده کنید. 
اگر می‌خواهید یک تانسور را از سابقه محاسبات استخراج کنید باید تابع .detach() را فراخوانی کنید. این کار از محاسبات آینده این تانسور از ابتدای جایی که ردگیری شده جلوگیری می‌کند. یکی دیگر از روش‌های جلوگیری از ردگیری سوابق، قرار دادن کد شما در torch.no_grad() است. 
کلاس‌های Tensor و Function با یکدیگر در تعامل هستند تا یک نمودار ناچرخه‌ای (acyclic graph) را که سابقه کاملی از محاسبات را کدگذاری می‌کند، بسازند. مشخصه .grad_fn از این تانسور به همان کلاس Function که تانسور را ایجاد کرده بود، ارجاع داده می‌شود. برای محاسبه مشتق باید در یک کلاس Tensor تابع .backward() را فراخوانی کنید. اگر Tensor شامل یک عنصر باشد، برای تابع .backward() نیازی به مشخص کردن هیچ پارامتری ندارید. اگر Tensor شامل بیش از یک عنصر باشد، باید یک گرادیان مشخص کنید که مطابق شکل (1) تانسور باشد.
به‌عنوان‌مثال، شما دو تانسور ایجاد می‌کنید، یکی با requires_grad به‌عنوان True و دیگری به‌عنوان False. سپس از این دو تانسور برای اجرای عملیات جمع استفاده می‌کنید. پس از آن گرادیان یکی از این تانسورها را محاسبه می‌کنید.

a = torch.tensor([3.0, 2.0], requires_grad=True)
b = torch.tensor([4.0, 7.0])
ab_sum = a + b
ab_sum
ab_res = (ab_sum*8).sum()
ab_res.backward()
ab_res
a.grad

از آنجا که requires_grad را عنوان True برای متغیر b تنظیم نکرده‌اید، فراخوانی .grad هیچ خروجی نخواهد داشت. 

ماژول PyTorch nn

از این ماژول برای ساخت شبکه‌های عصبی در PyTorch استفاده می‌شود و با توجه به Autograd مدل‌ها و تمایز بین آن‌ها را مشخص می‌کند. اجازه دهید فرآیند کار یک نمونه آزمایشی از شبکه عصبی را بررسی کنیم:
1. شبکه عصبی را با برخی از پارامترهای قابل یادگیری تعریف کنید. 
2. یک مجموعه داده از ورودی‌ها را مشخص کنید.
3. ورودی را از طریق شبکه پردازش کنید.
4. نتایج پیش‌بینی‌شده را با مقادیر واقعی مقايسه کرده و میزان خطا را اندازه‌گیری کنید.
5. گرادیان‌ها را به پارامترهای شبکه اضافه کنید.
6. وزن شبکه را با استفاده از یک قانون به‌روزرسانی ساده، به‌روز کنید:

weight = weight — learning_rate * gradient

از پکیج nn برای ساخت یک شبکه عصبی دو لايه استفاده کنید:

N, D_in, H, D_out = 64, 1000, 100, 10
x = torch.randn(N, D_in)
y = torch.randn(N, D_out)
model = torch.nn.Sequential(
torch.nn.Linear(D_in, H),
torch.nn.ReLU(),
torch.nn.Linear(H, D_out),
)
loss_fn = torch.nn.MSELoss()
learning_rate = 1e-4

در ادامه توضیحاتی در مورد برخی از پارامترهای استفاده شده در بالا را مشاهده می‌کنید:
• N در اینجا Batch size است. Batch size تعداد مشاهداتی است که بعد از به‌روزرسانی وزن‌ها مشخص می‌شود.
• D_in نشان‌دهنده ابعاد ورودی است.
• H نشان‌دهنده ابعاد مخفی است.
• D_out نشان‌دهنده ابعاد خروجی است.
• torch.randn ماتریسی از ابعاد مشخص شده را تعریف می‌کند.
• torch.nn.Sequential یک پشته خطی از لايه‌ها را مقداردهی می‌کند.
• torch.nn.Linear یک انتقال خطی به داده‌های ورودی اعمال می‌کند.
• torch.nn.ReLU تابع واحد خطی اصلاح‌شده را اعمال می‌کند.
• torch.nn.MSELoss یک معیار را ایجاد می‌کند که میانگین خطای مربع بین n عنصر در ورودی x و هدف y را اندازه‌گیری می‌کند. 

مطلب پیشنهادی

چگونه از اثرات هوش مصنوعی بر زندگی خود آگاه شویم؟

رشته دانشگاهی «رفتارشناسی ماشین»

بسته PyTorch optim

در مرحله بعد از بسته optim برای تعریف یک بهینه‌ساز که وزن را برای شما به‌روزرسانی می‌کند، استفاده خواهید کرد. بسته optim خلاصه‌ای از ایده بهینه‌سازی الگوريتم را آماده کرده و امکان پیاده‌سازی الگوريتم‌های بهینه‌سازی رایج مانند AdaGrad, RMSProp و Adam را فراهم می‌کند. ما از بهینه‌ساز Adam که یکی از بهینه‌سازهای معروف است، استفاده خواهیم کرد.
اولین آرگمانی که این بهینه‌ساز دریافت می‌کند، تانسورها هستند که باید به‌روزرسانی شوند. در گذر رو به جلو شما y پیش‌بینی‌شده را با عبور x به مدل محاسبه می‌کنید. قبل از اجرای گذر رو به عقب، تمام گرادیان‌های متغیرهایی را که با استفاده از بهینه‌ساز به‌روزرسانی شده‌اند، صفر می‌کنیم. به‌طور پیش‌فرض، وقتی .backward() فراخوانی می‌شود گرادیان‌ها بازنويسی نمی‌شوند. بعد از آن تابع این بهینه‌ساز را فراخوانی می‌کنیم و این به‌روزرسانی‌‌ها را به‌عنوان پارامترهای آن در نظر می‌گیریم. چگونگی انجام این کار را در زیر مشاهده خواهید کرد:

optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
for t in range(500):
 y_pred = model(x)
 loss = loss_fn(y_pred, y)
 print(t, loss.item())
 optimizer.zero_grad()
 loss.backward()
 optimizer.step()

ماژول‌های nn سفارشی در PyTorch

بعضی از اوقات شما نیاز پیدا می‌کنید تا ماژول‌های سفارشی خود را ایجاد کنید. در چنین مواردی می‌توانید از زیر کلاس nn.Module استفاده کنید، سپس باید یک forward که تانسورهای ورودی را دریافت و تانسورهای خروجی را توليد می‌کند، تعریف کنید. در زیر چگونگی پیاده‌سازی یک شبکه دو لايه با استفاده از nn.Module نشان داده‌شده است. این مدل بسیار شبیه نمونه بالا است، اما تفاوت آن در این است که شما از torch.nn.Module برای ساخت شبکه عصبی استفاده خواهید کرد. تفاوت دیگر استفاده از stochastic gradient descent optimizer به‌جای Adam است. شما می‌توانید یک ماژول nn سفارشی را به این شكل پیاده‌سازی کنید:

import torch

class TwoLayerNet(torch.nn.Module):
  def __init__(self, D_in, H, D_out):
    super(TwoLayerNet, self).__init__()
    self.linear1 = torch.nn.Linear(D_in, H)
    self.linear2 = torch.nn.Linear(H, D_out)

  def forward(self, x):
    h_relu = self.linear1(x).clamp(min=0)
    y_pred = self.linear2(h_relu)
    return y_pred

N, D_in, H, D_out = 64, 1000, 100, 10

x = torch.randn(N, D_in)
y = torch.randn(N, D_out)

model = TwoLayerNet(D_in, H, D_out)

criterion = torch.nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-4)
for t in range(500):
  y_pred = model(x)

  loss = criterion(y_pred, y)
  print(t, loss.item())

  optimizer.zero_grad()
  loss.backward()
  optimizer.step()

PyTorch اجازه می‌دهد انواع مختلفی از لایه‌ها مثل Convolutional Layers, Recurrent layers و Linear Layers را پیاده‌سازی کنید. برای آموزش‌های بیشتر درباره نحوه استفاده از PyTorch به صفحه رسمی‌ اسناد به نشانی https://pytorch.org/docs/stable/ مراجعه کنید.