روش استفاده از GPU با PyTorch

نقش پردازنده‌های گرافیکی در یادگیری عمیق

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

پردازنده‌های گرافیکی در حال حاضر نقشی اساسی در انقلاب هوش مصنوعی ایفا می‌کنند و عمدتاً باعث پیشرفت سریع در یادگیری عمیق، بینایی کامپیوتر و مدل‌های زبانی بزرگ و غیره می‌شوند.

در این مقاله، استفاده از پردازنده‌های گرافیکی برای تسریع آموزش شبکه‌های عصبی با استفاده از PyTorch، یکی از پرکاربردترین کتابخانه‌های یادگیری عمیق را بررسی خواهیم کرد.

مقدمه ای بر پردازنده های گرافیکی با PyTorch

PyTorch یک چارچوب متن باز، ساده و قدرتمند مبتنی بر یادگیری ماشین است روی پایتون. برای توسعه و آموزش شبکه های عصبی با انجام محاسبات تانسور مانند تمایز خودکار با استفاده از واحدهای پردازش گرافیکی استفاده می شود.

PyTorch از کتابخانه CUDA برای پیکربندی و استفاده از پردازنده‌های گرافیکی NVIDIA استفاده می‌کند. CUDA یک جعبه ابزار محاسباتی GPU است که توسط انویدیا توسعه یافته و برای تسریع عملیات محاسباتی فشرده با موازی کردن آنها در چندین GPU طراحی شده است. PyTorch از CUDA پشتیبانی می کند torch.cuda کتابخانه

استفاده از GPU در Torch از طریق بسته CUDA

کتابخانه CUDA در PyTorch در شناسایی، فعال کردن و استفاده از قدرت پردازنده‌های گرافیکی بسیار مفید است. بیایید با استفاده از PyTorch به برخی از عملکردها بپردازیم.

بررسی در دسترس بودن GPU

قبل از استفاده از GPU ها، می توانیم بررسی کنیم که آیا آنها پیکربندی شده و آماده استفاده هستند یا خیر. کد زیر یک Boolean برمی گرداند که نشان می دهد GPU پیکربندی شده و برای استفاده در دسترس است یا خیر روی ماشین.

import torch
print(torch.cuda.is_available())

True

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

print(torch.cuda.device_count())
print(torch.cuda.current_device())

1
0

این خروجی نشان می دهد که یک واحد پردازش گرافیکی در دسترس است و با شماره دستگاه 0 مشخص می شود.

دستگاه را راه اندازی کنید

دستگاه فعال را می توان مقدار دهی اولیه کرد و در یک متغیر برای استفاده در آینده ذخیره کرد، مانند بارگذاری مدل ها و تانسورها در آن. اگر پردازنده‌های گرافیکی در دسترس باشند، این مرحله ضروری است، زیرا CPUها به‌طور خودکار توسط PyTorch شناسایی و پیکربندی می‌شوند.

را torch.device می توان از عملکرد برای انتخاب دستگاه استفاده کرد.

>>> device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
>>> device

device(type='cuda')

با متغیر دستگاه، اکنون می‌توانیم تانسورها را ایجاد و به آن منتقل کنیم.

ایجاد و انتقال تانسورها به GPU

مدل ها و مجموعه داده ها به صورت تانسور PyTorch نشان داده می شوند که باید مقداردهی اولیه شوند روی، یا قبل از آموزش مدل به GPU منتقل می شود. این را می توان به روش های مختلفی انجام داد که در زیر به آن اشاره شده است:

1. ایجاد تانسور به طور مستقیم روی پردازنده گرافیکی

تانسورها را می توان به طور مستقیم ایجاد کرد روی دستگاه مورد نظر مانند GPU با مشخص کردن device پارامتر. به طور پیش فرض، تانسورها ایجاد می شوند روی CPU با دسترسی به دستگاه می توانید دستگاهی را که تانسور در آن ذخیره می شود تعیین کنید device پارامتر تانسور

x = torch.tensor((1, 2, 3))
print(x)
print("Device: ", x.device)

tensor((1, 2, 3)) 
Device: cpu

حالا بیایید تانسورها را مستقیماً تولید کنیم روی دستگاه

y = torch.tensor((4, 5, 6), device=device)
print(y)
print("Device: ", y.device)

tensor((4, 5, 6), device='cuda:0') 
Device: cuda:0

در نهایت، شماره دستگاهی که تانسورها در آن ذخیره می شوند را می توان با استفاده از آن بازیابی کرد get_device() روش.

print(x.get_device())
print(y.get_device())

-1
0

در خروجی بالا، -1 نشان دهنده CPU است، در حالی که 0 نشان دهنده GPU شماره 0 است.

3. انتقال تانسورها با استفاده از to() روش

تانسورها را می توان از CPU به دستگاه با استفاده از to() روشی که توسط تانسورهای PyTorch پشتیبانی می شود.

x = torch.tensor((1, 2, 3))
x = x.to(device)
print("Device: ", x.device)
print(x.get_device())

Device: cuda:0
0

هنگامی که چندین پردازنده گرافیکی در دسترس هستند، تانسورها را می توان با ارسال شماره دستگاه به عنوان یک پارامتر به GPU های خاص منتقل کرد.

برای مثال، cuda:0 برای اولین GPU است، cuda:1 برای GPU دوم، و غیره روی.

x = torch.tensor((8, 9, 10))
x = x.to("cuda:0")
print(x.device)

cuda:0

تلاش برای انتقال به یک GPU که در دسترس نیست یا به یک شماره GPU نادرست منجر به CUDA error.

4. انتقال تانسورها با استفاده از cuda() روش

در زیر نمونه ای از ایجاد یک تانسور نمونه و انتقال آن به GPU با استفاده از cuda() روشی که توسط تانسورهای PyTorch پشتیبانی می شود.

tensor = torch.rand((100, 30)) 
tensor = tensor.cuda()
print(tensor.device)

device(type='cuda', index=0)

اکنون بیایید تکنیک‌هایی را برای بارگذاری تانسورها در چندین GPU از طریق موازی‌سازی، یعنی یکی از مهم‌ترین ویژگی‌های مسئول سرعت‌های محاسباتی بالا در پردازنده‌های گرافیکی، بررسی کنیم.

آموزش توزیع شده با چند GPU

آموزش توزیع شده شامل استقرار مدل و مجموعه داده در چندین GPU است و در نتیجه آموزش را به طرز چشمگیری تسریع می کند. process از طریق قابلیت موازی سازی ما برخی از کلاس های آموزشی توزیع شده توسط PyTorch را در بخش های بعدی پوشش خواهیم داد.

Source: NVIDIA

داده موازی

DataParallel روشی موثر برای انجام آموزش چند GPU مدل ها است روی یک دستگاه موازی سازی داده ها را در سطح ماژول با تقسیم ورودی در بین دستگاه های تعیین شده از طریق تقسیم کردن، و سپس انتشار آن در مدل با تکرار ورودی ها به دست می آورد. روی همه دستگاه ها

بیایید یک پایه ایجاد و مقداردهی اولیه کنیم LinearRegression کلاس مدل قبل از بسته بندی آن در داخل DataParallel کلاس

import torch.nn as nn

class LinearRegression(nn.Module):
    def __init__(self, input_size, output_size):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(input_size, output_size)

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


model = LinearRegression(2, 5)
print(model)

LinearRegression( 
    (linear): Linear(in_features=2, out_features=5, bias=True) 
)

حال، بیایید مدل را بپیچانیم تا موازی سازی داده ها در چندین GPU اجرا شود. این را می توان با استفاده از nn.DataParallel کلاس و ارسال مدل به همراه لیست دستگاه به عنوان پارامتر.

model = nn.DataParallel(model, device_ids=(0))
print(model)

DataParallel( 
    (module): LinearRegression( 
        (linear): Linear(in_features=2, out_features=5, bias=True) 
    ) 
)

در کد بالا مدل را به همراه لیست شناسه های دستگاه به عنوان پارامتر ارسال کرده ایم. اکنون می توانیم با بارگذاری مستقیم مدل ادامه دهیم روی به دستگاه و انجام آموزش مدل در صورت نیاز.

model = model.to(device) 
input_data = input_data.to(device)

DistributedData Parallel (DDP)

را DistributedDataParallel کلاس PyTorch از آموزش در چند آموزش GPU پشتیبانی می کند روی ماشین های متعدد را DistributedDataParallel کلاس بیش از توصیه می شود DataParallel کلاس، زیرا به طور پیش فرض سناریوهای تک ماشینی را مدیریت می کند و سرعت بالاتری نسبت به آن نشان می دهد DataParallel لفاف

را DistributedDataParallel ماژول عمل می کند روی اصل موازی سازی داده ها در اینجا، مدل و داده‌ها در چندین فرآیند و هر کدام کپی می‌شوند process آموزش انجام می دهد روی یک زیر مجموعه داده

راه اندازی DistributedDataParallel کلاس شامل مقداردهی اولیه محیط توزیع شده و متعاقباً بسته بندی مدل با شی DDP است.

import torch
import torch.nn as nn

class LinearRegression(nn.Module):
    def __init__(self, input_size, output_size):
        super(LinearRegression, self).__init__()
        self.linear = nn.Linear(input_size, output_size)

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


model = LinearRegression(2, 5)

torch.distributed.init_process_group(backend='nccl')


model = nn.parallel.DistributedDataParallelCPU(model)

این یک پوشش اولیه برای بارگذاری مدل برای آموزش چند GPU در چندین گره فراهم می کند.

نتیجه

در این مقاله، روش‌های مختلفی را برای استفاده از پردازنده‌های گرافیکی NVIDIA با استفاده از آن بررسی کرده‌ایم CUDA کتابخانه در کتابخانه PyTorch ML. این استراتژی‌ها به ما کمک می‌کنند تا از قدرت پردازنده‌های گرافیکی قوی استفاده کنیم و آموزش مدل را تسریع کنیم process با ضریب ده در مقایسه با CPU های سنتی در برنامه های یادگیری عمیق. این کاهش قابل توجه در زمان آموزش، مجموعه وسیعی از وظایف محاسباتی را تسریع می کند.