آموزش گام به گام PyTorch
آموزش‌های پیشرفته هوش مصنوعیبینایی ماشینپردازش زبان طبیعی

آموزش گام به گام PyTorch

    0
    زمان مطالعه: ۲۴ دقیقه

    در حال حاضر PyTorch بیشترین نرخ رشد را در میان چارچوب‌های کاری یادگیری عمیق دارد و در دوره‌های آموزشی Fast.ai، با عنوان «یادگیری عمیق برای برنامه‌نویس‌ها»، و کتابخانه آن مورد استفاده قرار می‌گیرد.

    PyTorch به شدت پایتونی است، به عبارت دیگر برای برنامه نویسان Python، کار کردن با PyTorch بسیار راحت است.

    به علاوه، به قول آندریج کارپاتی استفاده ازPyTorch حتی ممکن است به معنای برای سلامتی شما مفید باشد!

    انگیزه نگارش مقاله آموزش PyTorch

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

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

    مسئله رگرسیون ساده

    بیشتر مقاله‌های آموزشی، PyTorch را با مسئله ساده و جذاب «طبقه‌بندی تصویر» شرح می‌دهند. ظاهراً روش بسیار خوبی است امّا شما را از هدف اصلی یعنی درک سازوکار PyTorch دور می‌کند.

    به همین دلیل در این مقاله آموزشی به یک موضوع ساده و متعارف می‌پردازیم: رگرسیون خطی تک متغیره (x). ساده‌ترین شکل  رگرسیون به صورت زیر است:

    رگرسیون ساده در pytorch

    مدل رگرسیون خطی ساده

    تولید داده

    آموزش را با تولید مقداری داده جعلی آغاز می‌کنیم: ابتدا یک بردار ۱۰۰ نقطه‌ای برای متغیر x داریم و سپس برچسب‌گذاری را به صورت a=1، b=2 انجام داده و پس از آن مقداری نویز گوسی در داده‌ها ایجاد می‌کنیم.

    سپس دیتاست جعلی را به دو بخش دیتاست آموزشی و دیتاست اعتبارسنجی تقسیم می‌کنیم. برای این کار ابتدا آرایه اندیس‌ها را به هم می‌ریزیم و سپس ۸۰ نقطه بهم ریخته اول را به عنوان داده‌های آموزشی انتخاب می‌کنیم.

    تولید داده در pytorch

    داده جعلی ، دیتاست‌های آموزشی و اعتبارسنجی

     

    می‌دانیم که a = 1 و b = 2 است امّا اکنون باید بررسی کنیم که با استفاده از گرادیان کاهشی و ۸۰ نقطه داده‌ی آموزشی تا چه حد می‌توانیم به مقادیر واقعی نزدیک شویم.

    گرادیان کاهشی

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

    گام اول: محاسبه زیان

    در مسائل رگرسیون ساده، زیان از طریق میانگین مربعات خطا (MSE) محاسبه می‌شود. به عبارت دیگر y (برچسب) را از a + bx (مقادیر پیش‌بینی‌شده) کم می‌کنیم و به توان ۲ می‌رسانیم؛ سپس از این مقادیر میانگین می‌گیریم.

    اگر از تمام نقطه‌ داده‌های دیتاست آموزشی (یعنی N) برای محاسبه گرادیان کاهشی استفاده کنیم، در واقع «گرادیان کاهشی بسته‌ای» را اجرا نموده‌ایم. و در صورتی که هر مرتبه تنها یک نقطه را به کار بگیریم، «گرادیان کاهشی تصادفی» را اجرا نموده‌ایم. هر متد دیگری که اتخاذ کنیم، تعداد نقطه‌داده‌ها (n) در آن در بازه ۱ و N خواهد بود و «گرادیان کاهشی زیربسته‌ها» نام دارد.

    محاسبه زیان در pytorch

    زیان: میانگین مربعات خطا (MSE)

    گام دوم: محاسبه گرادیان

    گرادیان در واقع همان «مشتق جزئی» است. به این دلیل آن‌ را «جزئی» می‌نامیم که تنها با یک پارامتر (w.r.t) می‌توان آن را محاسبه کرد. از طرفی، رگرسیون خطی دو پارامتر دارد، a و b، لذا باید دو مشتق جزئی را محاسبه کنیم.

    مشتق به شما می‌گوید که یک کمیّت مشخص با تغییر دیگر کمیّت‌ها چقدر تغییر می‌کند. در این مثال می‌خواهیم بدانیم در صورتی که هر یک از دو پارامتر a و b تغییر کند، زیان MSE چه تغییری خواهد کرد.

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

    گرادیان در pytorch

    محاسبه گرادیان w.r.t برای ضرایب a و b

     

    گام سوم: به‌روزرسانی پارامترها

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

    هنوز باید یک پارامتر دیگر را نیز مد نظر قرار دهیم: نرخ یادگیری، که با حرف یونانی eta (η) نشان داده‌ می‌شود. نرخ یادگیری یک عامل ضرب‌پذیر است و در هنگام به‌روزرسانی پارامترها باید بر روی گرادیان اعمال شود.

    به روز رسانی پارامترها

    به‌روزرسانی ضرایب a و b با استفاده از گرادیان و نرخ یادگیری محاسبه شده

    گام چهارم: تکرار مراحل!

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

    یک دوره، زمانی کامل می‌شود که تمام نقطه‌ها برای محاسبه زیان مورد استفاده قرار گیرند. در نظرگرفتنِ تمام نقاط در محاسبه گرادیان کاهشی بسته‌ای امری ساده و جزئی است زیرا این روش برای محاسبه زیان از تمام نقاط استفاده می‌کند، به عبارت دیگر یک دوره برابر است با یک به‌روزرسانی. در گرادیان کاهشی تصادفی منظور از یک دوره N تا به‌روزرسانی است، اما در گرادیان کاهشی زیربسته‌ها (با سایز n)، یک دوره برابر N/n به‌روزرسانی خواهد بود.

    به طور خلاصه به تکرار این فرآیند به دفعات و در دوره‌های بیشمار آموزش مدل می‌گویند.

    رگرسیون خطی در Numpy

    اگر چه این مقاله آموزشی در مورد PyTorch است، اما بهتر است ابتدا به نحوه پیاده‌سازی مدل رگرسیون خطی در  Numpy بپردازیم. ذکر این نکته دو هدف عمده دارد: اول اینکه ساختارِ مسئله مورد بررسی را معرفی می‌کند (که در تقریباً همه موارد یکسان است) و دوم اینکه نشان می‌دهد نقاط آسیب کدام است و با یادگرفتن آن‌ها متوجه خواهید شد PyTorch چقدر کار شما را آسان‌تر می‌کند.

    در آموزش مدل، مقداردهی اولیه دو مرحله دارد:

    • مقداردهی تصادفی پارامترها یا وزن‌ها (در این مثال تنها دو پارامتر a و b را داریم)؛ خط ۳ و ۴؛
    • مقداردهی اَبَرپارامترها (که در این مقاله تنها شامل نرخ یادگیری و تعداد دوره‌ها می‌شود)؛ خط ۹ و ۱۱؛

    همیشه تابع مقداردهی اولیه را با random seed اجرا کنید تا در صورتی که دوباره اجرا شود به نتایج یکسانی برسد. طبق معمول random seed  را ۴۲، یعنی کمترین مقدار ممکن، قرار می‌دهیم.

    هر دوره شامل چهار مرحله آموزشی است:

    • محاسبه پیش‌بینی‌های مدل: این قسمت forward pass نام دارد؛ خط ۱۵؛
    • محاسبه زیان: با استفاده از پیش‎بینی‌ها، برچسب‌ها و تابع زیانی که برای مسئله مورد نظر مناسب باشد زیان را محاسبه می‌کنیم؛ خط ۱۸ و ۲۰؛
    • محاسبه گرادیان‌ها برای تمام پارامترها: خط ۲۳ و ۲۴؛
    • به‌روزرسانی پارامترها: خط ۲۷ و ۲۸؛

    به خاطر داشته باشید که اگر از گرادیان کاهشی بسته‌‌ای استفاده نمی‌کنید (در این مثال ما از این گرادیان استفاده می‌کنیم)، لازم است یک حقله درونی بنویسید تا این چهار گام آموزشی را یا برای تک تک نقطه‌ها (تصادفی) یا برای n تا نقطه (در گرادیان کاهشی زیربسته‌ها) اجرا کند. در ادامه نمونه کد مدنظر برای گرادیان کاهشی زیربسته‌ها را خواهید دید.

    برای اطمینان از  اینکه در کدنویسی هیچ خطایی مرتکب نشده‌ایم، می‌توانیم برای برازش مدل از رگرسیون خطی Scikit-Learn استفاده کنیم و سپس و ضرایب همبستگی را مقایسه کنیم.

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

    اکنون زمان آن فرا رسیده است به برازش مدل در PyTorch بپردازیم.

    PyTorch

    بهتر است قبل از شروع مدل‌سازی با برخی از مفاهیم اصلی آشنا باشید زیرا در غیر اینصورت ممکن است با مشکل مواجه شوید.

    اولین مفهوی که باید با آن آشنا باشید «تنسورها» هستند. در یادگیری عمیق تنسورها همه جا به چشم می‌خورند. به همین دلیل است که چهارچوب کاری گوگل «تنسورفلو» نام دارد. در ادامه توضیح می‌دهیم تنسور چیست.

    Tensor

    ممکن است در Numpy آرایه‌ای با سه بعد داشته باشید؛ در اصطلاح تخصصی به این آرایه سه بعدی تنسور می‌گویند.

    اسکالر (یا همان عدد) هیچ بُعدی ندارد؛ بردار یک بُعد دارد؛ ماتریس دو بُعد، و تنسور سه یا چند بُعد دارد.

    امّا گاهی برای ساده نمودن مسائل، بردارها و ماتریس‌ها را نیز تنسور می‌نامیم. به عبارتی از این پس همه چیز یا اسکالر هستند یا تنسور.

    برازش مدل در پای تورچ

    تنسور ها در واقع ماتریس‌های چند بُعدی هستند.

     

    بارگیری داده‌ها، دستگاه‌ها و CUDA

    حال این سوال مطرح می‌شود که «چگونه از آرایه‌های Numpy به تنسور PyTorch برسیم؟» برای این کار می‌توانیم از تابع from_numpy استفاده کنیم؛ هر چند خروجی آن یک تنسور CPU است.

    احتمالاً با خود می‌گوید «ولی من می‌خواستم از GPU مورد نظر خود استفاده کنم». نگران نباشید، تابع to()  اینجا به کمک شما می‌آید. این تابع تنسور شما را به هر دستگاهی که انتخاب کنید، از جمله GPU مورد نظر خودتان، ارسال می‌کند ( به این عملیات cuda یا cuda:0 می‌گویند).

    باز هم ممکن است از خود بپرسید «اگر هیچ پردازنده گرافیکی‌ای در دسترس نباشد و لازم باشد کد را در CPU ذخیره کنید، چطور؟» نگران نباشید، PyTorch برای این شرایط نیز راهکار دارد. می‌توانید از تابع cuda.is_available() استفاده کرده و بررسی کنید که آیا GPU در دسترس دارید یا نه و بدین ترتیب دستگاه خود را انتخاب کنید.

    با استفاده از تابع float() به راحتی می‌توانید دقت را بر روی مقادیر پایین‌تری قرار دهید (مثلا ۳۲-bit float).

    اگر نوع دو متغیر x و y را با هم مقایسه کنید مشاهده خواهید کرد که اولی numpy.ndarray و دومی torch.Tensor است.

    امّا مشخص نیست تنسور کجا «ذخیره» شده است، در CPU یا GPU. تابع type()در PyTorch محل ذخیره تنسور را به شما نشان می‌دهد (torch.cuda.FloatTensor). در مثال این مقاله تنسور در GPU ذخیره شده است.

    علاوه بر این می‌توانیم برعکس عمل کرده و با استفاده از numpy() تنسور را به آرایه Numpy بازگردانیم. باید به آسانیِ نوشتنِ کد x_train_tensor.numpy() باشد امّا در صورت اجرای این کد، با این پیغام خطا مواجه خواهید شد:

    متاسفانه در Numpy  نمی‌توانید تنسورهای واقع در  GPU را کنترل کنید و لازم است ابتدا با استفاده از cpu() آن‌ها را به تنسور CPU تبدیل کنید.

    تعریف پارامترها

    وجه تمایز تنسورِ داده‌، مثل تنسوری که ما ایجاد نموده‌ایم، با تنسورِ آموزش‌پذیر یعنی پارامتر یا وزن چیست؟

    برای اینکه بتوانیم مقادیر آن‌ها (یعنی مقادیر پارامترها) را به‌روزرسانی کنیم، لازم است گرادیان تنسور آموزش‌پذیر را محاسبه نماییم. آرگومان requires_grad=True برای محاسبه گرادیان مناسب است. این آرگومان از PyTorch می‌خواهد گرادیان را محاسبه کند.

    ممکن است بخواهید برای یک پارامتر تنسوری ساده ایجاد کرده و سپس آن را به دستگاه مورد نظر خود ارسال کنید، بهتر است عجله نکنید!

    اولین قطعه کد دو تنسور مناسب برای همه چیز از جمله پارامترها و گرادیان‌‌ها ایجاد می‌کند. امّا این تنسورها، تنسور CPU هستند.

    قطعه کد دوم با رویکردی ساده تنسورها را به GPU ارسال می‌کند. اگر چه ارسال آن‌ها به یک دستگاه دیگر موفقیت آمیز است، امّا گرادیان تا حدی «از دست می‌رود».

    در قطعه کد سوم ابتدا تنسورها را به دستگاه منتقل کرده و سپس با استفاده از تابع requires_grad_() پارامتر  requires_grad را برابر True قرار می‌دهیم.

    در PyTorch تمام توابعی که به خط تیره (_) ختم می‌شوند، تغییرات را در جای خود اعمال می‌کنند. به عبارت دیگر این توابع متغیر اصلی را اصلاح می‌کنند.

    با اینکه رویکرد قبلی کارساز بود، بهتر است در همان لحظه‌ی ایجاد تنسور، آن را به یک دستگاه اختصاص دهیم.

    این روش بسیار ساده‌تر است.

    اکنون که با نحوه‌ی ایجاد تنسورهای مبتنی بر گرادیان آشنا شدید، به شما نشان می‌دهیم PyTorch چگونه آن‌ها را کنترل می‌کند. کنترل تنسورها در PyTorch توسط Autograd انجام می‌شود:

    Autograd

    Autograd همان «پکیج مشتق‌گیری خودکار» در PyTorch است. به لطف این پکیج دیگر نگران مشتق جزئی، قاعده زنجیره‌ای و مسائل شبیه به آن نخواهیم بود.

    با استفاده از تابع backward() می‌توانیم از PyTorch بخواهیم که کار خود را انجام دهد و تمام گرادیان‌‌ها را محاسبه کند.

    نقطه شروع محاسبه گرادیان  را به خاطر دارید؟ گرادیان را از «زیان» و همزمان با محاسبه مشتقات جزئی پارامترها (w.r.t.) محاسبه می‌کنیم. در نتیجه لازم است متد backward() را از متغیر متناظر آن در PyTorch، مثل loss.backward()، فرا بخوانیم.

    می‌توانیم مقادیر حقیقی گرادیان‌‌ها را با بررسی ویژگی grad تنسور بدست آوریم.

    توضیحات متد به وضوح بیان می‌کند که گرادیان‌‌ها با هم جمع بسته شده‌اند. بنابراین هر مرتبه که پارامترها را با استفاده از گرادیان به‌روزرسانی می‌کنیم، لازم است پس از به‌روزرسانی مقادر آن را با تابع zero_() صفر کنیم.

    امیدوارم به خاطر داشته باشید که منظور از خط تیره انتهای اسم تابع چیست (در غیر اینصورت به بخش قبل مراجعه کنید).

    بهتر است محاسبه دستی گرادیان‌‌ها را فراموش کرده و در عوض از هر دو تابع backward() و zero_() استفاده کنیم.

    کار تقریباً تمام است. امّا همیشه یک مشکل پنهان وجود دارد. و این بار مشکل پنهان در مورد به‌روزرسانی پارامترها است.

    اگر اولین به‌روزرسانی ساختاری مشابه ساختار مورد استفاده در کد Numpy داشته باشد، با پیغام خطای زیر مواجه می‌شوید. البته با بررسی نمودن تنسور می‌توان متوجه شد که چه مشکلی پیش‌ آمده است: هنگام جایگذاریِ مجددِ نتایجِ به‌روزرسانی در پارامترهای مربوطه، دوباره گرادیان را «از دست داده‌ایم». در نتیجه ویژگی grad برابر none شده و خطا رخ می‌دهد.

    در دومین به‌روزرسانی به کمک ویژگی جایگذاری در محل (in-place)، آن را اندکی تغییر می‌دهیم. این بار هم PyTorch پیغام خطا می‌فرستد.

    علت این امر چیست؟ مشخص گردید که «بیش از حد مناسب بودن» باعث بروز مشکل شده است. مقصر این مشکل قابلیتPyTorch  در ایجاد «گراف محاسباتی پویا» از تمام عملیات‌های پایتون است که شامل نوعی تنسورِ محاسبه گرادیان یا وابستگی‌های آن می‌شود.

    در بخش بعدی گراف محاسبه پویا را به تفصیل توضیح خواهیم داد.

    با استفاده از torch.no_grad() می‌توانیم از PyTorch بخواهیم «عقب بیاستد» و اجازه بدهد خودمان بدون بهم ریختن گراف محاسباتی پویا پارامترها را به‌روزرسانی کنیم. این تابع امکان اجرای عملیات‌های متداول پایتون بر روی تنسور را، مستقل از نمودار محاسبه PyTorch، برای ما فراهم می‌کند.

    بالاخره توانستیم مدل را با موفقیت اجرا نموده و پارامترهای نهایی را بدست‌آوریم. نتایج به‌دست‌آمده هم راستای نتایج حاصل از پیاده‌سازی مدل در Numpy بود.

    گراف محاسباتی پویا

    پکیج PyTorchViz و تابع make_dot(variable) این امکان را به ما می‌دهند که به آسانی گراف مرتبط با متغیر مد نظر خود را ترسیم کنیم.

    دوباره با حداقل‌ها یعنی دو تنسور پارامتر(بدست‌آمده از محاسبه گرادیان)، پیش‌بینی، خطا و زیان، انجام محاسبات را ادامه می‌دهیم.

    با فراخوانی make_dot(yhat) گراف سمت چپ تصویر ۳ را بدست خواهید آورد:

    pytorch

    گراف محاسباتی تمام مراحلِ محاسبه MSE

    مولفه‌های این گراف به شرح زیر است:

    • خانه‌های آبی رنگ: این خانه‌ها مبین تنسورهایی هستند که برای پارامترها استفاده کردیم؛ منظور تنسورهایی است که از PyTorch خواستیم گرادیان آن‌ها را محاسبه کند؛
    • خانه‌های خاکستری: این خانه‌ها عملیات پایتون را نشان می‌دهد که در برگیرنده تنسور محاسباتی گرادیان یا موارد وابسته به آن است؛
    • خانه‌ سبز: همانند خانه‌های خاکستری است با این تفاوت که این خانه‌ نقطه شروع محاسبه گرادیان کاهشی است (با فرض اینکه تابع backward() در متغیر مورد استفاده برای ترسیم گراف، فراخوانده شده باشد). در یک گراف، گرادیان‌‌ها از پایین به بالا محاسبه می‌شوند.

    در صورتی که گراف متغیرهای خطا (گراف وسط) و زیان (گراف سمت راست) را ترسیم کنیم، همانطور که مشاهده می‌کنید تنها تفاوت بین آن‌ها و گراف سمت چپ تعداد گام‌های میانی (خانه‌های خاکستری) است.

    اگر خانه سبزِ گراف yhat (گراف سمت چپ) را با دقت بیشتری بررسی ‌کنید، مشاهده خواهید کرد که دو فلش به سمت آن وجود دارد زیرا این مولفه مقادیر دو متغیر، a و b*x، را با هم جمع می‌کند.

    حال اگر خانه خاکستری همین گراف را بررسی کنید، می‌بینید که عمل ضرب انجام شده است، یعنی b * x؛ ولی تنها یک فلش به سمت آن کشیده شده است. این فلش از سمت خانه آبی که متناظر با پارامتر b است می‌آید.

    سوال اینجاست که چرا در گراف yhat هیچ خانه‌ای متناظر با داده‌ی x وجود ندارد؟ علت این است که گرادیانِ داده‌ی x را محاسبه نمی‌کنیم. بنابراین باوجود اینکه تنسورهای بیشتری در عملیات‌های اجرای شده توسط گراف محاسباتی دخیل هستند، این گراف تنها تنسورهای محاسبه گرادیان و وابستگی‌های آن‌ها را به نمایش می‌گذارد.

    اگر requires_grad  را در متغیر a برابر False قرار دهیم، گراف محاسباتی به شکل زیر در می‌آمد.

    مولفه های گراف در پایتورچ

    در این گراف گرادیان متغیر a محاسبه نشده است. با این حال هنوز هم این متغیر در محاسبه استفاده می‌شود.

    همانطور که مشاهده می‌کنید دیگر خانه آبی متناظر با پارامتر a (که در گراف yhat وجود داشت) در این گراف ترسیم نشده است. دلیل آن بسیار ساده است: چون گرادیانی محاسبه نمی‌گردد، گرافی هم برای آن ترسیم نمی‌شود.

    یکی از مزایای گراف محاسباتی پویا این است که هرچه قدر بخواهید می‌توانید به پیچیدگی آن بیافزایید. حتی می‌توانید برای کنترل جریان محاسبه گرادیان‌ها از عبارت‌های کنترل جریان از قبیل if استفاده کنید.

    نمونه آن را در تصویر ۵ مشاهده می‌کنید. البته اعداد محاسبه شده در این مثال کاملاً بی‌معنا هستند.

    آموزش پایتورچ

    نمونه گراف محاسباتی پیچیده

    بهینه‌سازها

    تا اینجا یاد گرفتیم پارامترها را با استفاده از گرادیان محاسباتی و به طور دستی به‌روزرسانی کنیم. در صورتی که دو پارامتر وجود داشته باشد، کار دشواری نیست. امّا اگر تعداد پارامترها خیلی زیاد باشد باید از بهینه‌سازهای PyTorch مانند SGD و Adam استفاده کنیم.

    بهینه‌سازT پارامتر مورد نظر (مثل نرخ یادگیری مورد استفاده یا هزاران اَبَرپارامتر احتمالی دیگر) را انتخاب نموده و با تابع step() آن را به‌روزرسانی می‌کند.

    به علاوه، دیگر نیازی نیست مقدار تک تک گرادیان‌‌ها را صفر کنیم. تنها کافی است بهینه‌ساز zero_grad() را فرا بخوانیم.

    کد زیر بهینه‌ساز گرادیان کاهشی تصادفی (SGD) برای پارامترهای a و b در مثالِ این مقاله را نشان می‌دهد. شایان ذکر است که ممکن است نام بهینه‌ساز شما را فریب دهد: در صورتی کل داده‌ی آموزشی را به یکباره برای بهینه‌سازی مورد استفاده قرار دهید، درست مانند کد مورد استفاده در این مقاله، بهینه‌ساز، علی رغم نام خود، گرادیان کاهشی بسته‌‌ای را اجرا خواهد کرد.

    فقط برای اطمینان از اینکه همه چیز هنوز خوب کار می‌کند، هر دو پارامتر را قبل و بعد از به‌روزرسانی بررسی می‌کنیم:

    موفق شدیم فرآیند بهینه‌سازی را بهینه کنیم. در ادامه می‌پردازیم به بخش‌های باقی‌مانده.

    زیان

    همانطور که انتظار می‌رود، PyTorch محاسبه زیان را نیز پوشش می‌دهد. تعداد توابع زیانی که می‌توان از میان آن‌ها یکی را متناسب با مسئله موردنظر انتخاب کرد بسیار زیاد است. به دلیل اینکه مسئله مورد بررسی ما رگرسیون ساده است از تابع زیان میانگین مربعات خطا (MSE) استفاده می‌کنیم.

    دقت داشته باشید که nn.MSELoss  فقط تابع زیان را برای ما ایجاد می‌کند و خود تابع زیان نیست. علاوه بر این می‌توانید یک متد کاهشی نیز تعیین کنید؛ متدی که نشان می‌دهد چگونه می‌خواهید نتایجِ نقاط جداگانه را کنار هم قرار دهید. برای مثال می‌توانید میانگین آن‌ها (reduction=’mean’) را محاسبه کنید یا اینکه صرفاً آن‌ها را باهم جمع کنید (reduction=’sum’).

    بعداً و در خط ۲۰، از تابع زیان ایجاد شده برای محاسبه زیان بین پیش‌بینی‌ها و برچسب‌ها استفاده می‌کنیم.

    کد ما به شکل زیر در می‌آید:

    در این مرحله تنها باید یک تکه کد، یعنی کد پیش‌بینی‌ها، را تغییر داد. حال نوبت می‌رسد به ارائه تابع PyTorch برای پیاده‌سازی مدل.

    مدل

    بازنمایی مدل در PyTorch توسط یک کلاس معمولی پایتون انجام می‌شود. این کلاس بر گرفته از کلاس Module است.

    اصلی‌ترین توابعی که باید به اجرا درآیند به شرح زیر هستند:

    • __init__(self): در این تابع بخش‌های مختلف مدل را تعریف می‌کنیم. در مثال ما دو پارامتر وجود دارد: a و b.

    با وجود اینکه در تعریف پارامترها هیچ محدودیتی وجود ندارد، می‌توانید مدل‌های دیگر یا لایه‌های دیگر را به عنوان یک صفت در مدل خود جای دهید. به زودی نمونه این مدل‌ها را نیز خواهیم دید.

    • forward(self, x): این تابع محاسبات اصلی را انجام می‌دهد، یعنی ورودی x را دریافت کرده و خروجی را تولید می‌کند.

    با این حال نباید متد forward(x) را فرا بخوانید. بلکه برای اجرای forward pass و برآورد به پیش‌بینی‌ها باید تمام مدل را به عنوان model(x) فراخوانی کنید.

    برای مسئله رگرسیون مورد بررسی در این مقاله یک مدل مناسب (و ساده) می‌سازیم. کد آن به صورت زیراست:

    در متد __init__  دو پارامتر a و b را با استفاده از کلاس Parameter() تعریف می‌کنیم. به این ترتیب به PyTorch می‌گوییم پارامترهای a و b باید پارامترهای همان مدلی باشند که صفت آن هستند.

    با انجام این کار (به جای اینکه لیستِ پارامترها را به طور دستی بسازیم) می‌توانیم با استفاده از متد parameters()  یک پیمایش‌گر را بازیابی کرده و بر روی تمام پارامترهای مدل پیاده کنیم؛ این تابع حتی پارامترهای مدل‌های تودرتو را نیز پیمایش می‌کند. سپس این پارامتر‌ها را به بهینه‌ساز می‌دهیم.

    علاوه بر این، با استفاده از تابع state_dict() می‌توانیم مقادیر فعلی تمام پارامترها را بدست آوریم.

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

    برای تغییر کد می‌توانیم متد‌های کاربردی زیر را استفاده کنید:

    خروجی متد به شرح زیر است (به دلیل اینکه مقادیر پایانی پارامترهای a و b تغییری نکرده است، پس همه چیز خوب است!):

    توجه شما را به یک عبارت خاص در کد جلب می‌کنم: model.train().

    مدل‌ها در PyTorch یک متد train() دارند که متاسفانه هیچ گام آموزشی را اجرا نمی‌کند. تنها هدف آن قرار دادن مدل در حالت آموزش است. این متد از این جهت حائز اهمیت است که برخی از مدل‌ها ممکن است مکانیزیم‌هایی مثل Dropout یا حذف تصادفی داشته باشند که باعث می‌شود در مراحل آموزش و اعتبارسنجی رفتاری کاملاً متفاوت از خود نشان دهند.

    مدل‌های تودروتو

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

    با اینکه این مثال کاملاً ساختگی است و در آن مدل اصلی را تقریباً بدون اضافه کردن مقوله‌ای مفید برنامه نویسی می‌کنیم، به خوبی مفهوم مدل تودرتو را نشان می‌دهد.

    در متد __init__  صفتی تعریف نمودیم که شامل شبکه خطی تودرتو می‌شود.

    در متد forward() مدل تودرتو را برای اجرای forward pass فرامی‌خوانیم (دقت داشته باشید که self.linear.forward(x) را فراخوانی نمی‌کنیم).

    اکنون اگر متد parameters() این مدل را فرابخوانید، PyTorch پارامترهای صفات را به صورت بازگشتی محاسبه می‌کند. با اجرای کد[*LayerLinearRegression().parameters()] شما هم می‌توانید این روش را امتحان کنید و لیست تمام پارامترها بدست آورید. علاوه بر این می‌توانید صفات خطی جدید نیز اضافه نمایید، صفاتی که حتی اگر در forward pass مورد استفاده قرار نگیرند، بازهم در لیستی تحت عنوان parameters() قرار می‌گیرند.

    مدل‌های توالی

    مدل این مقاله بسیار ساده بود. ممکن است بپرسید «چرا زحمت ساخت کلاس برای مدلی به این سادگی را به خودمان بدهیم؟» به نکته خوبی اشاره می‌کنید.

    برای ساخت مدلی واضح و روشن، یا به عبارتی مدلی که لایه‌های معمولی دارد و خروجی هر لایه ورودی لایه بعدی است، می‌توانیم از مدل‌های توالی استفاده کنیم.

    برای مدل این مقاله تنها با یک آرگومان، که همان لایه خطی مورد استفاده در آموزش رگرسیون خطی است، یک مدل متوالی ساختیم. کد ایجاد مدل به شرح زیر است:

    گام آموزش

    تا کنون بهینه‌ساز، تابع زیان و مدل را تعریف کرده‌ایم. برای اطلاعات بیشتر می‌توانید مطالب بالا را مرور کرده و نگاهی به کدهای داخل حلقه‌ بیاندازید. اکنون این سوال مطرح می‌شود که اگر از یک بهینه‌ساز، تابع زیان یا حتی مدل دیگری استفاده می‌کردیم، چه تفاوتی ایجاد می‌شد؟ در ادامه توضیح می‌دهیم چگونه می‌توان مدل را عمومی‌تر کرد.

    با توجه به سه عنصر بهینه‌ساز، تابع زیان و مدل، و همچنین ویژگی‌ها و برچسب‌ها، تمام خطوط این کد، یک گام آموزشی را اجرا می‌کنند.

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

    سپس می‌توانیم با کمک این تابع همه‌کاره یک تابع train_step() بسازیم و آن را به درون حلقه آموزش فرابخوانیم. اکنون کد ما به شکل زیر خواهد بود. ملاحظه می‌کنید که حلقه آموزش کوچکتر شده است:

    فعلاً حلقه آموزش را کنار گذاشته و به داده‌‌ها می‌پردازیم. تاکنون تنها آرایه‌های Numpy را به تنسورهای PyTorch تبدیل نموده‌ایم. امّا بهتر از این هم می‌توانیم عمل کنیم و یک دیتا‌ست بسازیم.

    دیتاست

    دیتاست در PyTorch به صورت کلاس معمولی پایتونی بازنمایی می‌شود که ویژگی‌های کلاس Dataset را به ارث برده است. Dataset را می‌توانید لیستی از تاپل‌های پایتون در نظر بگیرید به طوری که هر تاپل متناظر با یک نقطه (ویژگی یا برچسب) است.

    مهم‌ترین متد‌های مورد نیاز آن به شرح زیر هستند:

    • __init__(self): این متد تمام آرگومان‌های مورد نیاز برای ایجاد فهرست تاپل‌ها را در بر می‌گیرد و ممکن است حاوی نام فایل CSV باشد که باید بارگذاری و پردازش شود، یا حاوی دو تنسور باشد که یکی برای ویژگی‌ها و دیگری برای برچسب‌ها، و یا هر چیز دیگری ساخته شده است.

    نیازی نیست کل دیتاست را در واحد سازنده (__init__) بارگذاری کنید. اگر دیتاست شما بزرگ است (مثلاً شامل ده‌ها هزار عکس می‌شود) بارگذاری یکباره آن برای حافظه مشکل‌ساز خواهد شد. پیشنهاد می‌کنیم آن‌ها را بر حسب نیاز بارگذاری کنید (یعنی هر زمانی که__get_item__  فراخوانی  می‌شود).

    • __get_item__(self, index): این متد امکان اندیس‌گذاری دیتاست را فراهم می‌کند و در نتیجه این عمل، دیتاست شبیه یک لیست رفتار می‌کند (dataset[i])، یعنی متناسب با نقطه داده درخواستی، خروجی آن باید یک تاپل (ویژگی‌ها، برچسب) باشد. به این ترتیب، می‌توان قطعه‌های مورد نظر از دیتاستی که قبلاً بارگذاری‌شده‌ یا تنسورها خروجی بگیریم یا همانطور که قبلاً مطرح شد، آن‌ها را برحسب نیاز بارگذاری کنیم (مانند این مثال).
    • __len__(self): خروجی این متد صرفاً سایز کل دیتاست است. لذا، هر گاه که از دیتاست نمونه‌برداری می‌شود، اندیس‌گذاری آن به سایز اصلی محدود می‌گردد.

    در ادامه دیتاستی ساده و سفارشی می‌سازیم که آرگومان‌های آن از دو تنسور تشکیل شده است: یکی برای ویژگی و دیگری برای برچسب. برای هر یک از اندیس‌ها، خروجی کلاس دیتاست ما قطعه متناظرِ آن در هر یک از تنسورها خواهد بود. کد نویسی این تابع به شرح زیر است:

    اگر دیتاست تنها متشکل از چند تنسور باشد، می‌توانیم با استفاده از کلاس TensorDataset موجود در PyTorch به راحتی این مسئله را حل کنیم، که تقریباً مشابه کاری است که برای ایجاد دیتاست سفارشی انجام دادیم.

    شایان ذکر است که تنسورهای آموزشی را از آرایه‌های Numpy بدست آوردیم، ولی آن‌ها را به هیچ دستگاهی منتقل نکردیم. بنابراین، این تنسورها، تنسورهای CPU هستند.

    تنسورها را منتقل نکردیم زیرا نمی‌خواهیم مانند تنسورهای GPU تمام داده‌ی آموزشی به دستگاه منتقل شود؛ انتقال کل داده‌ی آموزشی فضای زیادی از RAM کارت گرافیکی را اشغال خواهد کرد.

    پاسخ این سوال که «چرا دیتاست می‌سازیم» این است که می‌خواهیم از یک DataLoader استفاده کنیم.

    DataLoader

    تا این بخش از مقاله در هر گام آموزشی کل داده‌ی آموزشی را به‌کار می‌بردیم. همچنین در تمام مدت از گرادیان کاهشی بسته‌‌ای استفاده می‌کردیم. این امر برای دیتاست‌ کوچک و بی‌معنای مورد استفاده در این مقاله هیچ مشکلی ایجاد نکرد امّا در پروژه‌های جدی باید گرادیان کاهشی زیربسته‌ها را به کار بگیریم. بنابراین لازم است زیربسته داشته باشیم و به طَبَع آن باید دیتاست را به چند قطعه تقسیم کنیم. به طور قطع پیشنهاد نمی‌کنیم این کار را به طور دستی انجام دهید.

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

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

    برای بازیابی یک زیربسته نمونه می‌توانید کد دستوری زیرا اجرا نمایید؛ با اجرای این کد لیستی شامل دو تنسور که یکی مربوط به ویژگی و دیگری مربوط به برچسب است، نمایش داده می‌شود.

    حال این سوال  مطرح می‌شود که این کد چگونه حلقه آموزشی را تغییر می‌دهد.

    اجرای این کد دو تفاوت عمده ایجاد می‌کند: اول اینکه نه تنها برای بارگذاری هر یک از زیربسته‌های موجود در DataLoader یک حلقه داخلی داریم، بلکه اکنون می‌توانیم به طور مجزا فقط یک زیربسته را به دستگاه ارسال کنیم.

    برای دیتاست‌های بزرگ‌تر اگر داده‌ را به صورت نمونه به نمونه (بر روی تنسور CPU) و از طریق تابع __get_item__  در  کلاس Dataset بارگذاری کرده و سپس به یکباره تمام نمونه‌های همان زیربسته را به GPU (یا دستگاه) مورد نظر ارسال کنید، می‌توانید از RAM کارت گرافیکی به بهترین شکل ممکن استفاده کنید.

    به علاوه در صورتی که تعداد GPUهای مورد استفاده برای آموزش مدل زیاد باشد، بهتراست دیتاست را در حالت «agnostic» نگه دارید و بسته‌‌ها را حین آموزش در GPUهای مختلف جایگذاری نمایید.

    مطالب مطرح شده تا این بخش از مقاله آموزشی تنها در مورد دیتاست آموزشی بود. یک دیتاست تولید و سپس برای آن یک dataloader ایجاد کردیم. می‌توانیم برای اعتبارسنجی داده‌ نیز همین کار را انجام دهیم و با همان روشی که ابتدای مقاله مطرح کردیم داده‌ها را به دو قسمت تقسیم کنیم یا از تابع random_split استفاده کنیم.

    Random Split

    در PyTorch تابعی به نام random_split() وجود دارد که روشی آسان و متداول برای تقسیم کردن دیتاست و تبدیل آن به دو دیتاست آموزشی و اعتبار سنجی است. شایان ذکر است که در این مثال لازم است این تابع را بر روی تمام دیتاست اعمال کنیم (و نه صرفاً بر روی دیتاست آموزشی‌ای که در بخش‌های قبل ایجاد نمودیم).

    سپس در ازای هر یک زیرمجموعه‌های دیتاست یک تابع DataLoader می‌سازیم. کد آن به شرح زیر خواهد بود:

    اکنون برای دیتاست اعتبارسنجی نیز یک DataLoader داریم.

    اعتبارسنجی

    اعتبارسنجی آخرین بخش این مقاله است؛ برای اینکه بتوانیم مدل را ارزیابی کنیم، یا به عبارتی «زیان اعتبارسنجی» را محاسبه کنیم، لازم است حلقه آموزش را تغییر دهیم. اولین گام شامل اضافه نمودن یک حلقه درونی دیگر است تا زیربسته‌های حاصل از validation loader را مدیریت کند و آن‌ها را به همان دستگاهی ارسال کند که مدل روی آن قرار دارد. سپس با کمک مدل پیش‌بینی را انجام می‌دهیم (خط ۲۳) و زیان هر یک را محاسبه می‌کنیم (خط ۲۴).

    تقریباً تمام است امّا جای دارد دو نکته کوچک ولی مهم را مد نظر قرار دهید:

    • no_grad(): اگر چه این تابع تغییرات زیادی در مدل‌ ساده ما ایجاد نخواهد کرد، امّا بستنِ حلقه درونی مرحله اعتبارسنجی با این مدیریت‌کننده محتوا روش مناسبی است برای غیر فعال نمودن تمام محاسبات گرادیانی که ممکن است ناخواسته انجام شوند؛ منظور گرادیان‌های آموزشی است نه گرادیان‌های مرحله اعتبارسنجی.
    • eval(): تنها عملیاتی که این تابع انجام می‌دهد قرار دادن مدل در مرحله اعتبارسنجی است. درست مانند همتای خود یعنی تابع train() در دیتاست آموزشی. درنتیجه مدل رفتار خود را متناسب با عملیات‌هایی مثل Dropout یا حذف تصادفی تعدیل خواهد کرد.

    در نهایت حلقه آموزش به شرح زیر خواهد بود:

    البته راه‌های دیگری برای بهبود یا تغییر مدل وجود دارد. همیشه می‌توانید به مدل یک مولفه‌ دیگر اضافه کنید، برای مثال می‌توانید از تابع برنامه‌ریز نرخ یادگیری (learning rate scheduler) استفاده کنید. به دلیل طولانی شدن این نوشتار توضیحات را همین جا به پایان می‌رسانیم.

    برای دریافت کد کامل با تمام جزئیات آن اینجا کلیک کنید.

    این مطلب چه میزان برای شما مفید بوده است؟
    [کل: ۲ میانگین: ۳]

    عدم رغبت مدیران ارشد به اجرایی کردن فناوری هوش مصنوعی در کشور تأسف‌بار است

    مقاله قبلی

    امکان ارزیابی متون خبری با هوش مصنوعی

    مقاله بعدی

    شما همچنین ممکن است دوست داشته باشید

    نظرات

    پاسخ دهید

    نشانی ایمیل شما منتشر نخواهد شد.