Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

شبکه‌های عصبی و پس‌انتشار

محمود امین‌طوسی، پاییز ۱۴۰۵

گروه علوم کامپیوتر، دانشگاه فردوسی مشهد

باید بگویم مطالب اصلی از درس تاماس بیوزن گرفته شده است.

English · فارسی

هدف‌های یادگیری درس


  • تفاوت آرایه‌های numpy و torch (np.array در برابر torch.Tensor) را توضیح دهید

  • مفاهیم بنیادی شبکه‌های عصبی مانند لایه‌ها، گره‌ها، توابع فعال‌سازی و … را توضیح دهید

  • یک شبکهٔ عصبی ساده در PyTorch برای رگرسیون یا دسته‌بندی بسازید

  • گرادیان‌های یک شبکهٔ کوچک را دستی استنتاج کنید و با backward() بسنجید

واردکردن‌ها


Notebook Cell
Notebook Cell

1. مقدمه


  • PyTorch ابزاری پایتونی برای محاسبات علمی است که چند ویژگی اصلی دارد:

    • torch.Tensor، آرایه‌ای n-بعدی شبیه numpy که می‌تواند روی GPU اجرا شود

    • گراف‌های محاسباتی برای ساختن شبکه‌های عصبی

    • مشتق‌گیری خودکار برای آموزش شبکه‌های عصبی (در درس بعد بیشتر)

  • PyTorch را می‌توانید از https://pytorch.org/ نصب کنید

2. تنسور در PyTorch


  • در PyTorch تنسور دقیقاً مانند ndarray در NumPy است که با آن چنان آشنا شده‌ایم.

  • تفاوت کلیدی torch.Tensor با np.array این است که torch.Tensor برای یکپارچگی با GPU و گراف‌های محاسباتی PyTorch ساخته شده (هرچند در درس بعد بیشتر درباره‌اش می‌گوییم)

2.1. ndarray در برابر tensor

  • ساختن و کار با تنسورها تقریباً همانند ndarrayهای numpy است

  • می‌توانید تنسور را با torch.tensor() بسازید:

tensor([1, 2, 3]), dtype: torch.int64
tensor([1., 2., 3.]), dtype: torch.float32
tensor([1, 2, 3], dtype=torch.int32), dtype: torch.int32
  • PyTorch بیشتر تابع‌های numpy را که می‌شناسیم هم دارد:

tensor([[0., 0.], [0., 0.]])
tensor([[1., 1.], [1., 1.]])
tensor([[ 0.3388, 0.0180], [-0.1241, 0.9065], [-1.6244, 0.1037]])
tensor([[[0.8185, 0.1055], [0.7195, 0.2424], [0.8114, 0.7107]], [[0.8324, 0.9311], [0.1115, 0.8091], [0.0066, 0.2076]]])
  • همانند NumPy می‌توانیم شکل تنسور را با صفت .shape ببینیم:

torch.Size([2, 3, 2, 2])
4

2.2. تنسورها و نوع داده

  • نوع‌های دادهٔ مختلف پیامدهای حافظه‌ای و محاسباتی مختلفی دارند (مستندات نوع‌های دادهٔ NumPy را برای بیشتر ببینید)

  • در PyTorch شبکه‌هایی می‌سازیم که هزاران یا حتی میلیون‌ها محاسبهٔ اعشاری دارند!

  • در چنین حالت‌هایی استفاده از نوع کوچک‌تری مثل float32 می‌تواند محاسبات را به‌شکل چشمگیری سریع تر کند و نیاز حافظه را کم کند

  • نوع اعشاری پیش‌فرض در PyTorch float32 است، برخلاف float64 در numpy

  • در واقع برخی عملیات در PyTorch حتی اگر dtype پرمصرفی بدهید خطا می‌دهند!

float64
torch.float32
  • ولی همانند numpy همیشه می‌توانید نوع دادهٔ دلخواه را با آرگومان dtype تعیین کنید:

torch.float64

2.3. عملیات روی تنسورها

  • تنسورها دقیقاً مانند ndarrayها کار می‌کنند و متدهای آشنای زیادی دارند که می‌توان روی‌شان صدا زد:

tensor([[0.6376, 0.8497, 0.5364], [0.1417, 0.3538, 0.0404], [0.8795, 1.0915, 0.7782]])
tensor([[5.5718e-02, 1.6878e-01, 1.7360e-03], [3.8856e-03, 1.1771e-02, 1.2106e-04], [8.0994e-02, 2.4535e-01, 2.5235e-03]])
tensor(0.1415)
tensor(0.4244)

2.4. اندیس‌گذاری

  • باز هم همانند NumPy!

tensor([[0.5512, 0.5119],
        [0.8011, 0.4224],
        [0.1395, 0.0438],
        [0.5987, 0.7250],
        [0.2124, 0.4778]])
tensor([0.5512, 0.5119])
tensor([0.5512, 0.5119])
tensor([0.5512, 0.8011, 0.1395, 0.5987, 0.2124])

2.5. پل با Numpy

  • بعضی وقت‌ها می‌خواهیم تنسور را به آرایهٔ NumPy برگردانیم

  • این کار را با متد .numpy() می‌کنیم

<class 'torch.Tensor'>
<class 'numpy.ndarray'>

2.6. GPU و تنسورهای CUDA

  • GPU واحد پردازش گرافیکی است (در برابر CPU: واحد پردازش مرکزی)

  • GPUها در آغاز برای بازی ساخته شدند و با انجام موازی عملیات روی حجم زیادی داده بسیار سریع‌اند (به به‌روزرسانی سریع مقدار همهٔ پیکسل‌های صفحه هنگام جابه‌جایی بازیکن در بازی فکر کنید)

  • اخیراً GPUها برای برنامه‌نویسی با کاربرد عمومی‌تر سازگار شده‌اند

  • شبکه‌های عصبی را معمولاً می‌توان به محاسبات کوچک‌تری شکست که روی GPU موازی انجام شوند

  • PyTorch به‌طور تنگ با CUDA یکپارچه است — لایه‌ای نرم‌افزاری که تعامل با GPU را (اگر داشته باشید) آسان می‌کند

  • می‌توانید با این کار توان GPU را بررسی کنید:

False
  • هنگام آموزش روی ماشینی با GPU، باید به PyTorch بگویید که می‌خواهید از آن استفاده کنید

  • در بالای بیشتر کدهای PyTorch چنین چیزی می‌بینید:

cpu
  • بعد می‌توانید هنگام ساختن تنسورها آرگومان device را به کار ببرید و بگویید CPU یا GPU را می‌خواهید

  • یا اگر می‌خواهید تنسوری را میان CPU و GPU جابه‌جا کنید، از متد .to() استفاده کنید:

cpu
  • بعداً در درس، وقتی با مجموعه‌داده‌های بزرگ‌تر و شبکه‌های پیچیده‌تر کار می‌کنیم، به GPU برمی‌گردیم

  • فعلاً روی CPU هم خوب کار می‌کنیم

3. مبانی شبکهٔ عصبی


  • پیش‌تر چند الگوریتم یادگیری ماشین را یاد گرفته‌اید (kNN، جنگل تصادفی، SVM و …)

  • شبکه‌های عصبی هم فقط الگوریتم دیگری هستند و به نظر من یکی از ساده‌ترین‌ها!

  • همان‌طور که می‌بینیم، شبکهٔ عصبی فقط دنباله‌ای از تبدیل‌های خطی و ناخطی است

  • اغلب هنگام یادگیری یا استفاده از شبکه‌های عصبی چنین چیزی می‌بینید:

  • خب، این‌ها به چه معناست؟ گام‌به‌گام شهودی می‌سازیم

3.1. رگرسیون خطی ساده با یک شبکهٔ عصبی

  • بیایید مجموعه‌دادهٔ رگرسیون ساده‌ای با 500 مشاهده بسازیم:

Image produced in Jupyter
  • می‌دانیم چگونه با sklearn یک رگرسیون خطی ساده را به این داده برازش دهیم:

Image produced in Jupyter
  • این پارامترهای خط برازش‌شده‌اند:

w_0: -0.77 (bias/intercept)
w_1: 45.50
  • به‌صورت معادله چنین است:

y^=−0.77+45.50X\hat{y}=-0.77 + 45.50X
  • یا به شکل ماتریسی:

[y1^y2^⋮yn^]=[1x11x2⋮⋮1xn][−0.7745.50]\begin{bmatrix} \hat{y_1} \\ \hat{y_2} \\ \vdots \\ \hat{y_n} \end{bmatrix}=\begin{bmatrix} 1 & x_1 \\ 1 & x_2 \\ \vdots & \vdots \\ 1 & x_n \end{bmatrix} \begin{bmatrix} -0.77 \\ 45.50 \end{bmatrix}
  • یا به شکل گراف، چنین نشانش می‌دهم:

3.2. رگرسیون خطی با یک شبکهٔ عصبی در PyTorch

  • پس بیایید موارد بالا را در PyTorch پیاده کنیم و شهودی دربارهٔ شبکه‌های عصبی بسازیم!

  • هر مدل شبکهٔ عصبی که در PyTorch بسازید از torch.nn.Module ارث می‌برد

  • وراثت به ما اجازه می‌دهد کارکردهای رایج لازم را بدون نوشتن کد خودمان به ارث ببریم! W3 Schools درس‌نامهٔ کوچک خوبی برای وراثت کلاس در پایتون دارد.

در آزمایشگاه torch.nn.Module را بیشتر بررسی می‌کنیم، ولی اگر کمک کند به مدل‌های sklearn فکر کنید: همه‌شان متدهای رایجی مثل .fit()، .predict()، .score() و … را به ارث می‌برند. هنگام ساختن شبکهٔ عصبی معماری خودمان را تعریف می‌کنیم ولی هنوز کارکردهای رایج را می‌خواهیم که از torch.nn.Module به ارث می‌بریم.

  • بیایید مدلی به نام linearRegression بسازیم و بعد نحو آن را برایتان توضیح می‌دهم:

بیایید موارد بالا را گام‌به‌گام ببینیم:

class linearRegression(nn.Module):
    def __init__(self, input_size, output_size):
        super().__init__()

اینجا کلاسی به نام linearRegression می‌سازیم و متدها و صفت‌های nn.Module را به ارث می‌بریم (راهنما: help(linearRegression) را بزنید تا ببینید چه چیزهایی از nn.Module به ارث برده‌ایم).

        self.linear = nn.Linear(input_size, output_size)

اینجا لایه‌ای «خطی» تعریف می‌کنیم که فقط یعنی wX + b، یعنی وزن‌های شبکه ضرب در ویژگی‌های ورودی به‌علاوهٔ بایاس.

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

شبکه‌های PyTorch که با nn.Module ساخته می‌شوند باید متد forward() داشته باشند. دادهٔ ورودی x را می‌گیرد و از عملیات تعریف‌شده می‌گذراند. اینجا x را به لایهٔ خطی می‌دهیم و خروجی out را می‌گیریم.

  • پس از تعریف کلاس مدل، می‌توانیم نمونه‌ای از آن بسازیم:

  • می‌توانیم مدل را با print() ببینیم:

linearRegression(
  (linear): Linear(in_features=1, out_features=1, bias=True)
)
  • یا با summary() مفیدتر (که در بالای این نوتبوک با from torchsummary import summary وارد کردیم):

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Linear-1                    [-1, 1]               2
================================================================
Total params: 2
Trainable params: 2
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.00
Params size (MB): 0.00
Estimated Total Size (MB): 0.00
----------------------------------------------------------------
  • توجه کنید دو پارامتر داریم؟ یکی برای وزن (w1) و یکی برای بایاس (w0)

  • PyTorch هنگام ساختن مدل این‌ها را تصادفی مقداردهی کرد. با model.state_dict() به آن‌ها دسترسی دارید:

OrderedDict([('linear.weight', tensor([[0.3072]])), ('linear.bias', tensor([-0.9891]))])
  • خب، پیش از ادامه، داده‌های x و y ما فعلاً آرایه‌های numpy هستند ولی باید تنسور PyTorch باشند

  • بیایید تبدیلشان کنیم:

  • اکنون مدلی داریم که کار می‌کند و می‌توانیم با این نحو از آن خروجی بگیریم:

Predicted: -0.80
   Actual: 31.08
  • پیش‌بینی ما بد است چون مدل هنوز آموزش ندیده/برازش نشده!

  • همان‌طور که در چند درس گذشته یاد گرفتیم، برای برازش مدل به این‌ها نیاز داریم:

    1. یک تابع هزینه (که در PyTorch «criterion» نامیده می‌شود) تا بگوید پیش‌بینی‌های ما چقدر خوب/بد هستند — از میانگین مربع خطا، torch.nn.MSELoss()، استفاده می‌کنیم

    2. یک الگوریتم بهینه‌سازی برای کمک به بهینه کردن پارامترهای مدل — از GD، torch.optim.SGD() استفاده می‌کنیم

  • پیش از آموزش یک «بارگذار داده» می‌سازم تا به دسته‌بندی داده کمک کند

  • بارگذارهای داده فقط مولدهایی هستند که داده را به‌درخواست yield می‌کنند.

  • از BATCH_SIZE = 50 استفاده می‌کنیم (که با 500 نقطهٔ داده 10 دسته می‌دهد)

  • باید 10 دسته داشته باشیم:

Total number of batches: 10
  • می‌توانیم با این نحو یک دسته را ببینیم:

 Shape of feature data (X) in batch: torch.Size([50, 1])
Shape of response data (y) in batch: torch.Size([50])
  • با این‌ها، شبکهٔ ساده‌مان را ۵ دوره با SGD آموزش دهیم!

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

epoch: 1, loss: 648.7896
epoch: 2, loss: 99.0878
epoch: 3, loss: 94.1367
epoch: 4, loss: 93.6165
epoch: 5, loss: 93.4385
  • اکنون مدل آموزش دیده و پارامترهایمان باید با پیش از این فرق داشته باشند:

OrderedDict([('linear.weight', tensor([[45.7395]])), ('linear.bias', tensor([-0.7178]))])
  • در مقایسه با مدل sklearn همان جواب را می‌گیریم:

Loading...
  • خیلی نزدیک شدیم! می‌توانستیم با تغییر تعداد دوره‌ها یا نرخ یادگیری بهتر شویم

  • پس شبکهٔ ساده‌مان باز هم این است:

  • راستی، ببینید اگر trainer() را دوباره اجرا کنیم چه می‌شود:

epoch: 1, loss: 93.5241
epoch: 2, loss: 94.1431
epoch: 3, loss: 93.9253
epoch: 4, loss: 93.4623
epoch: 5, loss: 93.8662
  • مدل از جایی که رها کردیم ادامه می‌دهد!

  • این شاید آنچه می‌خواستید باشد یا نباشد. با ساختن دوبارهٔ model و optimizer از صفر شروع می‌کنیم.

3.3. رگرسیون خطی چندگانه با یک شبکهٔ عصبی

  • خب، حالا یک رگرسیون خطی چندگانه با 3 ویژگی انجام دهیم

  • پس شبکه‌مان چنین می‌شود:

  • بیایید داده بسازیم:

  • و مدل بالا را بسازیم:

  • اکنون باید 4 پارامتر داشته باشیم (3 وزن و 1 بایاس)

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Linear-1                    [-1, 1]               4
================================================================
Total params: 4
Trainable params: 4
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.00
Params size (MB): 0.00
Estimated Total Size (MB): 0.00
----------------------------------------------------------------
  • به نظر خوب است! مدل را آموزش دهیم و بعد با LinearRegression() در sklearn مقایسه کنیم:

epoch: 1, loss: 1007.8107
epoch: 2, loss: 110.3681
epoch: 3, loss: 102.1059
epoch: 4, loss: 101.9216
epoch: 5, loss: 102.1261
Loading...

3.4. رگرسیون ناخطی با یک شبکهٔ عصبی

  • خب، می‌توانیم شبکهٔ ساده‌ای بسازیم که رگرسیون خطی ساده و چندگانه را تقلید کند

  • احتمالاً فکر می‌کنید که خب، که چه؟ ولی قول می‌دهم به بخش خوبش می‌رسیم!

  • مثلاً وقتی مجموعه‌دادهٔ پیچیده‌تری مثل این داریم چه می‌شود؟

Image produced in Jupyter
  • این آشکارا ناخطی است و باید ناخطی‌بودنهایی به شبکه وارد کنیم

  • همین ناخطی‌بودن‌ها هستند که شبکه‌های عصبی را چنان توانمند می‌کنند و «توابع فعال‌سازی» نام دارند

  • کلاس مدل تازه‌ای می‌سازیم که ناخطی‌بودنی — تابع سیگموید — دارد:

S(X)=11+e−xS(X)=\frac{1}{1+e^{-x}}
Image produced in Jupyter
  • بعداً دربارهٔ توابع فعال‌سازی بیشتر می‌گوییم، ولی توجه کنید تابع سیگموید x را به‌صورت ناخطی به مقداری بین 0 و 1 می‌نگارد

  • خب، شبکهٔ زیر را بسازیم:

  • تمام معنایش این است که مقدار هر گره در لایهٔ پنهان با «تابع فعال‌سازی» دگرگون می‌شود و عنصرهای ناخطی به مدل وارد می‌کند!

  • دو راه اصلی برای ساختن مدل بالا در PyTorch هست، هر دو را نشان می‌دهم:

  • توجه کنید متد forward() ما اکنون x را پس از لایهٔ پنهان از تابع nn.Sigmoid() می‌گذراند

  • روش بالا بسیار روشن و انعطاف‌پذیر است، ولی من استفاده از nn.Sequential() برای ترکیب لایه‌ها در سازنده را ترجیح می‌دهم:

  • بیایید نمونه‌ای از کلاس تازه بسازیم و تأیید کنیم 10 پارامتر دارد (6 وزن و 4 بایاس):

----------------------------------------------------------------
        Layer (type)               Output Shape         Param #
================================================================
            Linear-1                    [-1, 3]               6
           Sigmoid-2                    [-1, 3]               0
            Linear-3                    [-1, 1]               4
================================================================
Total params: 10
Trainable params: 10
Non-trainable params: 0
----------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.00
Params size (MB): 0.00
Estimated Total Size (MB): 0.00
----------------------------------------------------------------
  • خب، آموزش دهیم:

epoch: 1, loss: 32.5818
epoch: 2, loss: 14.8140
epoch: 3, loss: 7.6448
epoch: 4, loss: 5.2685
epoch: 5, loss: 4.8211
epoch: 6, loss: 4.7319
epoch: 7, loss: 4.4413
epoch: 8, loss: 4.2567
epoch: 9, loss: 4.3213
epoch: 10, loss: 4.2639
Image produced in Jupyter
  • به آن پیش‌بینی‌های ناخطی نگاه کنید! جالب است!

  • مدل ما عالی نیست و می‌توانیم با تنظیم نرخ یادگیری، تعداد گره‌ها و تعداد دوره‌ها بهترش کنیم

  • ولی واقعاً می‌خواهم ببینید هر یک از گره‌های پنهانمان یک «ویژگی ناخطی مهندسی می‌کند» تا در پیش‌بینی به کار رود، ببینید:

Image produced in Jupyter

3.5. پرسپترون چندلایه

  • احتمالاً اصطلاح جادویی «MLP» را شنیده‌اید و الان می‌فهمید یعنی چه!

  • واقعاً فقط یک شبکهٔ عصبی با بیش از 1 لایهٔ پنهان است! ساده است!

  • بیایید شبکهٔ «MLP» دو لایه بسازیم:

Image produced in Jupyter
  • ولی فقط چون شبکه لایه‌های بیشتری دارد لزوماً بهتر نیست!

4. توابع فعال‌سازی


  • همان‌طور که بالا یاد گرفتیم، توابع فعال‌سازی همان چیزی هستند که به ما اجازه می‌دهند توابع پیچیدهٔ ناخطی را مدل کنیم

  • توابع فعال‌سازی بسیار متنوع‌اند:

Image produced in Jupyter
  • توابع فعال‌سازی باید ناخطی باشند و معمولاً یکنوا و پیوسته‌مشتق (هموار) هستند

  • ولی همان‌طور که با تابع ReLU بالا می‌بینید، همیشه این‌طور نیست!

  • می‌خواستم این را بگویم چون نشان می‌دهد یادگیری عمیق واقعاً چقدر هنر است.

  • این نقل‌قول خوبی از یوشوا بنجیو (نامدار در کار روی هوش مصنوعی و یادگیری عمیق) دربارهٔ آزمایش گروهش با ReLU است:

«... یکی از بزرگ‌ترین اشتباه‌هایم این بود که مثل همه در دههٔ ۹۰ فکر می‌کردم برای کار کردن پس‌انتشار به ناخطی‌بودن‌های هموار نیاز دارید، چون فکر می‌کردم اگر چیزی مثل ناخطی‌بودن‌های یکسوساز داشته باشیم که بخش تخت دارد، آموزشش واقعاً سخت می‌شود، چون مشتق در جاهای بسیاری صفر می‌شود. و وقتی حدود ۲۰۱۰ با شبکه‌های عمیق آزمایش ReLU را شروع کردیم، وسواس این ایده را داشتم که باید مراقب باشیم نورون‌ها روی بخش صفر زیادی اشباع نشوند. ولی در پایان معلوم شد که ReLU واقعاً بسیار بهتر از سیگموید و tanh کار می‌کرد، و این غافلگیری بزرگی بود... معلوم شد بهتر کار می‌کند، در حالی که فکر می‌کردم آموزشش سخت‌تر است!»

  • به‌هرحال، به کوتاهی ReLU احتمالاً امروز محبوب‌ترین است، ولی می‌توانید توابع فعال‌سازی را ابرپارامتر (برای بهینه‌سازی) بگیرید

5. پس‌انتشار


  • هر شبکه‌ای که تا اینجا برازش کردیم با همان بلوک کوتاه کد آموزش دید، پنهان درون trainer():

optimizer.zero_grad()        # 1. forget the gradients left by the previous batch
y_hat = model(X).flatten()   # 2. forward pass: compute the prediction
loss  = criterion(y_hat, y)  # 3. how wrong are we?
loss.backward()              # 4. backward pass: compute the gradients
optimizer.step()             # 5. move the parameters against the gradient
  • خط loss.backward() همان است که جعبهٔ سیاه گرفته‌ایم. این پس‌انتشار است: قاعدهٔ زنجیره، اعمال‌شده به عقب در شبکه، لایه به لایه.

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

  • برای دیدن این به‌طور ملموس، کوچک‌ترین شبکه‌ای را بگیرید که هنوز ناخطی است: یک ورودی، دو واحد پنهان سیگمویدی و یک خروجی.

5.1. گذر پیش‌رو، دستی

  • وزن‌ها و بایاس‌ها را همانند شکل زیر ثابت کنید و یک مشاهدهٔ x=1x=1 با هدف y=3y=3 به شبکه بدهید.

  • گذر پیش‌رو ضرب، جمع، فشردن است — دو بار:

z1=w1x+b1=2,a1=σ(z1)=0.88z_1=w_1x+b_1=2,\qquad a_1=\sigma(z_1)=0.88
z2=w2x+b2=1,a2=σ(z2)=0.73z_2=w_2x+b_2=1,\qquad a_2=\sigma(z_2)=0.73
y^=w3a1+w4a2+b3=1.34,L=(y^−y)2=2.75\hat{y}=w_3a_1+w_4a_2+b_3=1.34,\qquad \mathcal{L}=(\hat{y}-y)^2=2.75
  • هیچ چیز اینجا تازه نیست: یک لایهٔ خطی، یک سیگموید، لایهٔ خطی دیگر و خطای مربعی، زنجیره‌شده.

5.2. گذر پس‌رو، دستی

  • از هزینه شروع کنید و بپرسید وقتی y^\hat{y} تغییر کند L\mathcal{L} چگونه تغییر می‌کند. برای خطای مربعی، ∂L/∂y^=2(y^−y)=−3.31\partial\mathcal{L}/\partial\hat{y}=2(\hat{y}-y)=-3.31.

  • همین یک عدد گرادیان بالادستی است. هر پارامتر پایین‌ترش گرادیان خودش را با ضرب گرادیان بالادستی در مشتق محلی خودش می‌گیرد:

∂L∂w3=∂L∂y^ a1=−2.91,∂L∂w4=∂L∂y^ a2=−2.42,∂L∂b3=∂L∂y^=−3.31\frac{\partial\mathcal{L}}{\partial w_3}=\frac{\partial\mathcal{L}}{\partial\hat{y}}\,a_1=-2.91,\qquad \frac{\partial\mathcal{L}}{\partial w_4}=\frac{\partial\mathcal{L}}{\partial\hat{y}}\,a_2=-2.42,\qquad \frac{\partial\mathcal{L}}{\partial b_3}=\frac{\partial\mathcal{L}}{\partial\hat{y}}=-3.31
  • برای لایهٔ پنهان به عقب رفتن را ادامه می‌دهیم: لایهٔ خروجی گرادیان نسبت به هر فعال‌سازی را برمی‌گرداند و سیگموید مشتق خودش σ′(z)=σ(z)(1−σ(z))\sigma'(z)=\sigma(z)\big(1-\sigma(z)\big) را می‌دهد. با σ′(z1)=0.105\sigma'(z_1)=0.105 و σ′(z2)=0.197\sigma'(z_2)=0.197:

∂L∂a1=∂L∂y^ w3,∂L∂z1=∂L∂a1 σ′(z1),∂L∂w1=∂L∂z1 x,∂L∂b1=∂L∂z1\frac{\partial\mathcal{L}}{\partial a_1}=\frac{\partial\mathcal{L}}{\partial\hat{y}}\,w_3,\qquad \frac{\partial\mathcal{L}}{\partial z_1}=\frac{\partial\mathcal{L}}{\partial a_1}\,\sigma'(z_1),\qquad \frac{\partial\mathcal{L}}{\partial w_1}=\frac{\partial\mathcal{L}}{\partial z_1}\,x,\qquad \frac{\partial\mathcal{L}}{\partial b_1}=\frac{\partial\mathcal{L}}{\partial z_1}
  • همین دستور روی واحد پنهان دوم ∂L/∂w2=∂L/∂b2=−1.30\partial\mathcal{L}/\partial w_2=\partial\mathcal{L}/\partial b_2=-1.30 و روی اولی ∂L/∂w1=∂L/∂b1=−0.35\partial\mathcal{L}/\partial w_1=\partial\mathcal{L}/\partial b_1=-0.35 می‌دهد.

5.3. همان گرادیان‌ها از PyTorch

  • می‌توانیم شبکه را دقیقاً روی وزن‌های شکل تنظیم کنیم و بگذاریم PyTorch حساب‌داری کند. عددهای زیر باید تا دو رقم اعشار با محاسبهٔ دستی بخوانند.

5.4. معنای این برای trainer()

  • چرا گراف وجود دارد. پارامترهایی که nn.Module می‌سازد با requires_grad=True می‌آیند، پس PyTorch هر عملیاتی را که روی آن‌ها اعمال شود ثبت می‌کند. چیز دیگری لازم نیست ردیابی شود: مشتق را نسبت به پارامترها می‌خواهیم، نه داده.

  • backward() چه چیزی را پر می‌کند. پیش از فراخوانی، p.grad برابر None است؛ بعد از آن ∂L/∂p\partial\mathcal{L}/\partial p را برای دستهٔ جاری دارد. تمام خروجی پس‌انتشار همین است.

  • چرا zero_grad() هست. گرادیان‌ها به‌طور پیش‌فرض تجمع می‌کنند. اگر فراموشش کنید، دستهٔ بعدی گرادیانش را به قبلی می‌افزاید و نرخ یادگیری مؤثر می‌لغزد.

  • step() چه می‌کند. برای SGD خالص، p←p−η p.gradp \leftarrow p-\eta\, p.\mathrm{grad} که دقیقاً گام 4 رویهٔ گرادیان کاهشی از درس رگرسیون است.

  • پس‌انتشار بهینه‌ساز نیست. فقط گرادیان‌ها را حساب می‌کند؛ همان عددها را می‌توان به SGD، Adam یا هر چیز دیگری داد.

6. دسته‌بندی با شبکه‌های عصبی


6.1. دسته‌بندی دودویی

  • این در واقع آسان‌ترین بخش درس خواهد بود

  • تا اینجا شبکه‌هایی برای وظیفه‌های رگرسیون می‌ساختیم، ولی اگر بخواهیم دسته‌بندی دودویی کنیم؟

  • در رگرسیون لجستیک خروجی یک مدل خطی را از سیگموید می‌گذراندیم تا احتمال بین 0 و 1 بگیریم. شبکه هم همین کار را می‌کند، با یک لایهٔ پنهان پیش از سیگموید.

  • بیایید مجموعه‌دادهٔ اسباب‌بازی بسازیم:

Image produced in Jupyter
  • بیایید این شبکه را برای مدل‌سازی آن مجموعه‌داده بسازیم:

  • از ReLU به‌عنوان تابع(های) فعال‌سازی و از Adam به‌عنوان بهینه‌ساز استفاده می‌کنم چون این‌ها امروز در عمل رایج‌اند.

  • الان دسته‌بندی می‌کنیم، پس باید از هزینهٔ لگاریتمی (آنتروپی متقاطع دودویی) به‌عنوان تابع هزینه استفاده کنیم:

f(w)=∑x,y∈D−ylog(y^)−(1−y)log(1−y^)f(w) = \sum_{x,y \in D} -y log(\hat{y}) - (1-y)log(1-\hat{y})
  • در PyTorch معیار هزینهٔ آنتروپی متقاطع دودویی torch.nn.BCELoss است

  • فرمول «احتمال» می‌خواهد و همین دلیل افزودن تابع سیگموید به انتهای شبکه است.

  • ولی صبر کنید!

  • هرچند می‌توانیم موارد بالا را انجام دهیم و بعد با تابع هزینهٔ torch.nn.BCELoss آموزش دهیم، راه بهتری هم هست!

  • می‌توانیم تابع سیگموید را حذف کنیم و فقط از torch.nn.BCEWithLogitsLoss استفاده کنیم (که لایهٔ سیگموید و BCELoss را با هم ترکیب می‌کند)

  • چرا این کار را کنیم؟ از نظر عددی پایدار است! (سؤال log-sum-exp در آزمایشگاه 1 را حل کردید؟ اینجا برای پایداری از آن استفاده می‌کنیم!)

  • از مستندات:

«این نسخه از نظر عددی پایدارتر از استفادهٔ سیگموید ساده و بعد BCELoss است، چون با ترکیب عملیات در یک لایه از ترفند log-sum-exp برای پایداری عددی بهره می‌بریم.»

  • پس در واقع مدل ما چنین است (بدون لایهٔ سیگموید در انتها، چون در تابع هزینه‌ای که به کار می‌بریم گنجانده شده):

  • بیایید مدل را آموزش دهیم:

epoch: 1, loss: 0.6842
epoch: 2, loss: 0.6534
epoch: 3, loss: 0.6097
epoch: 4, loss: 0.5676
epoch: 5, loss: 0.5343
epoch: 6, loss: 0.4916
epoch: 7, loss: 0.4410
epoch: 8, loss: 0.3871
epoch: 9, loss: 0.3299
epoch: 10, loss: 0.2833
epoch: 11, loss: 0.2467
epoch: 12, loss: 0.2135
epoch: 13, loss: 0.1992
epoch: 14, loss: 0.1889
epoch: 15, loss: 0.1800
epoch: 16, loss: 0.1695
epoch: 17, loss: 0.1698
epoch: 18, loss: 0.1687
epoch: 19, loss: 0.1541
epoch: 20, loss: 0.1510
Image produced in Jupyter
  • برای روشن بودن، مدل ما فقط عددی بین -∞ و +∞ خروجی می‌دهد (سیگموید اعمال نمی‌کنیم)، پس:

    • برای گرفتن احتمال‌ها باید آن‌ها را از سیگموید بگذرانیم؛

    • برای گرفتن دسته‌ها می‌توانیم آستانه‌ای اعمال کنیم (معمولاً 0.5)

  • مثلاً انتظار داریم نقطهٔ (0,0) احتمال بالا و نقطهٔ (-1,-1) احتمال پایین داشته باشد:

tensor([[  4.9344],
        [-11.3356]])
tensor([[9.9286e-01],
        [1.1939e-05]])
[[1]
 [0]]

6.2. دسته‌بندی چنددسته‌ای (اختیاری)

  • برای دسته‌بندی چنددسته‌ای، softmax را یادتان هست؟

σ(z⃗)i=ezi∑j=1Kezj\sigma(\vec{z})_i=\frac{e^{z_i}}{\sum_{j=1}^{K}e^{z_j}}
  • اساساً مطمئن می‌شود همهٔ خروجی‌ها احتمال‌های بین 0 و 1 باشند و جمعشان 1 شود.

  • torch.nn.CrossEntropyLoss هزینه‌ای است که softmax را با هزینهٔ آنتروپی متقاطع ترکیب می‌کند.

  • بیایید با شبکهٔ زیر مسئلهٔ دسته‌بندی 4-دسته‌ای را بیازماییم:

Image produced in Jupyter
  • بیایید این مدل را آموزش دهیم:

epoch: 1, loss: 1.1576
epoch: 2, loss: 0.7209
epoch: 3, loss: 0.4848
epoch: 4, loss: 0.3222
epoch: 5, loss: 0.1632
epoch: 6, loss: 0.0652
epoch: 7, loss: 0.0157
epoch: 8, loss: 0.0085
epoch: 9, loss: 0.0040
epoch: 10, loss: 0.0016
Image produced in Jupyter
  • باز هم برای روشن بودن، مدل ما فقط عددی بین -∞ و +∞ خروجی می‌دهد، پس:

    • برای گرفتن احتمال‌ها باید آن‌ها را به Softmax بدهیم؛

    • برای گرفتن دسته‌ها باید بزرگ‌ترین احتمال را برگزینیم.

  • مثلاً انتظار داریم نقطهٔ (-1,-1) احتمال بالایی برای تعلق به دستهٔ 1 و نقطهٔ (0,0) بالاترین احتمال برای تعلق به دستهٔ 2 داشته باشد.

tensor([[-27.5895,  19.3565,   1.1430, -33.1879],
        [-12.4731, -22.3387,   2.0026,  20.8498]])
  • توجه کنید برای هر نقطهٔ داده 4 پیش‌بینی می‌گیریم (یک پیش‌بینی برای هر یک از 4 دسته)

tensor([[4.0889e-21, 1.0000e+00, 1.2302e-08, 1.5144e-23],
        [3.3731e-15, 1.7517e-19, 6.5275e-09, 1.0000e+00]])
  • پیش‌بینی‌ها اکنون باید جمعشان 1 شود:

tensor([1., 1.])
  • می‌توانیم دسته با بیشترین احتمال را با argmax() بگیریم:

tensor([1, 3])

7. تمرین درس: پرسش‌های درست/غلط


برای موارد زیر درست/غلط بگویید:

  1. شبکه‌های عصبی را می‌توان هم برای رگرسیون و هم برای دسته‌بندی به کار برد. (درست)

  2. در شبکه‌های عصبی کاملاً متصل، تعداد پارامترها ≥\geq تعداد ویژگی‌ها است. (درست)

  3. شبکه‌های عصبی مدل‌های پارامتری‌اند. (درست)

  4. هر شبکهٔ عصبی با 3 لایهٔ پنهان پارامتر بیشتری از هر شبکهٔ عصبی با 2 لایهٔ پنهان دارد. (غلط)

  5. معماری یک شبکهٔ عصبی (تعداد لایه‌های پنهان و گره‌های پنهان) یک ابرپارامتر است. (درست)

  6. مانند رگرسیون خطی یا رگرسیون لجستیک، در شبکه‌های عصبی می‌توان مقدار وزن هر ویژگی را سنجهٔ اهمیت آن ویژگی دانست. (غلط)

8. درس در سه گزاره


  1. PyTorch نرم‌افزاری برای شبکه‌های عصبی بر پایهٔ «تنسورها» است (مثل آرایه‌های NumPy با قدرت بیشتر).

  2. شبکه‌های عصبی به‌سادگی:

    • از یک لایهٔ ورودی، 1 یا چند لایهٔ پنهان و یک لایهٔ خروجی ساخته می‌شوند که هر کدام 1 یا چند گره دارند.

    • تعداد گره‌های لایه‌های ورودی/خروجی با مسئله/داده تعیین می‌شود. لایه‌های پنهان می‌توانند هر تعداد گرهٔ دلخواهی داشته باشند.

    • توابع فعال‌سازی در لایه‌های پنهان به ما کمک می‌کنند دادهٔ ناخطی را مدل کنیم.

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

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

تمرین‌ها

  1. گرادیان‌های یک شبکهٔ تک‌لایه‌پنهان y^=w2⊤σ(W1x+b1)+b2\hat y = w_2^\top\sigma(W_1x+b_1)+b_2 را نسبت به W1,b1,w2,b2W_1,b_1,w_2,b_2 استنتاج کنید و بعد هر چهار مورد را روی یک ورودی ثابت با autograd بسنجید.

  2. بررسی گرادیان: گرادیان تحلیلی یک وزن را با تفاضل متناهی مرکزی (f(w+h)−f(w−h))/2h(f(w+h)-f(w-h))/2h مقایسه کنید، خطای نسبی را برحسب hh از 10-12 تا 10-1 رسم کنید و شکل U منحنی را توضیح دهید.

  3. تابع فعال‌سازی پنهان را با همانی جایگزین کنید، مثال رگرسیون ناخطی بخش ۳.۴ را دوباره آموزش دهید و خطای آموزش و آزمون را گزارش کنید. فروپاشی چه ویژگی شبکه را نشان می‌دهد؟

  4. پشته‌ای از لایه‌های خطی یک ماتریس است: نشان دهید W3W2W1x=WxW_3W_2W_1x = Wx و تعداد پارامترهای عمیق‌ترین و کم‌عمق‌ترین نسخه را وقتی ورودی و خروجی هر دو بُعد 10 دارند بشمارید. کدام آزادی بیشتری دارد؟