25개 이상의 토픽을 선택하실 수 없습니다.
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
441 lines
15 KiB
441 lines
15 KiB
% https://zhuanlan.zhihu.com/p/165140693
|
|
% https://zhuanlan.zhihu.com/p/36868831
|
|
|
|
%声明文档类型和比例
|
|
\documentclass[aspectratio=169, 10pt, utf8, mathserif]{ctexbeamer}
|
|
%调用相关的宏包
|
|
% \usepackage{beamerfoils}
|
|
|
|
\usepackage[outputdir=./latex-output]{minted}
|
|
|
|
\usepackage{multicol}
|
|
\setminted{breaklines=true, fontsize=\zihao{-6}}
|
|
% \PassOptionsToPackage{fontsize=\zihao{-6}}{minted}
|
|
|
|
\definecolor{shadecolor}{RGB}{204,232,207}
|
|
|
|
\usetheme{Berlin} %主题包之一，直接换名字即可
|
|
\setbeamertemplate{page number in head/foot}[totalframenumber]
|
|
|
|
\usecolortheme{beaver} %主题色之一，直接换名字即可。
|
|
\usefonttheme{professionalfonts}
|
|
|
|
% 设置用acrobat打开就会全屏显示
|
|
\hypersetup{pdfpagemode=FullScreen}
|
|
|
|
% 设置logo
|
|
% \pgfdeclareimage[height=2cm, width=2cm]{university-logo}{120701101}
|
|
% \logo{\pgfuseimage{university-logo}}
|
|
|
|
\parskip=1.2em
|
|
|
|
%--------------正文开始---------------
|
|
\begin{document}
|
|
|
|
%每个章节都有小目录
|
|
\AtBeginSubsection[]
|
|
{
|
|
\begin{frame}<beamer>
|
|
\tableofcontents[currentsection,currentsubsection]
|
|
\end{frame}
|
|
}
|
|
|
|
\title{《深度学习》实验4讲解}
|
|
\subtitle{多层感知机/全连接层}
|
|
\author[岳锦鹏]{岳锦鹏 \\ \small 10213903403}
|
|
|
|
\date{\today}
|
|
\begin{frame}
|
|
%\maketitle
|
|
\titlepage
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\frametitle{目录}
|
|
\tableofcontents[hideallsubsections]
|
|
\end{frame}
|
|
|
|
\section{整体浏览}
|
|
|
|
\begin{frame}[fragile]
|
|
首先逐个观察每个填空的部分需要完成哪些内容。
|
|
|
|
可以看到需要完成ReLU的反向传播过程。
|
|
\begin{minted}{python}
|
|
class Relu:
|
|
def __init__(self):
|
|
self.mem = {}
|
|
|
|
def forward(self, x):
|
|
self.mem['x'] = x
|
|
return np.where(x > 0, x, np.zeros_like(x))
|
|
|
|
def backward(self, grad_y):
|
|
'''
|
|
grad_y: same shape as x
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请完成激活函数的梯度后传'''
|
|
# ==========
|
|
|
|
\end{minted}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
对于主要的模型部分，需要完成计算损失。
|
|
\begin{minted}{python}
|
|
def compute_loss(self, log_prob, labels):
|
|
'''
|
|
log_prob is the predicted probabilities
|
|
labels is the ground truth
|
|
Please return the loss
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请完成多分类问题的损失计算 损失为： 交叉熵损失 + L2正则项'''
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
按照给定的网络结构完成前向传播过程。
|
|
\begin{minted}{python}
|
|
def forward(self, x):
|
|
'''
|
|
x is the input features
|
|
Please return the predicted probabilities of x
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请搭建一个MLP前馈神经网络 补全它的前向传播 MLP结构为FFN --> RELU --> FFN --> Softmax'''
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
完成主模型的后向传播，注意这里可以使用其中各层的反向传播函数。
|
|
\begin{minted}{python}
|
|
def backward(self, label):
|
|
'''
|
|
label is the ground truth
|
|
Please compute the gradients of self.W1 and self.W2
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''补全该前馈神经网络的后向传播算法'''
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
更新参数，这里要注意不要忘记正则项的损失。
|
|
\begin{minted}{python}
|
|
def update(self):
|
|
'''
|
|
Please update self.W1 and self.W2
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''更新该前馈神经网络的参数'''
|
|
# ==========
|
|
|
|
\end{minted}
|
|
\end{frame}
|
|
|
|
\section{逐个实现}
|
|
\subsection{ReLU的反向传播}
|
|
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
首先看ReLU的反向传播，由于ReLU的公式为（符号和课件中保持一致所以用了$a$和$x$）
|
|
$$
|
|
a = \begin{cases}
|
|
x,\quad & x>0 \\
|
|
0,\quad & x\leqslant 0 \\
|
|
\end{cases}
|
|
$$
|
|
所以显然
|
|
$$
|
|
\frac{\mathrm{d}a}{\mathrm{d}x} = \begin{cases}
|
|
1,\quad & x>0 \\
|
|
0,\quad & x\leqslant 0 \\
|
|
\end{cases}
|
|
$$
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
class Relu:
|
|
def __init__(self):
|
|
self.mem = {}
|
|
|
|
def forward(self, x):
|
|
self.mem['x'] = x
|
|
return np.where(x > 0, x, np.zeros_like(x))
|
|
|
|
def backward(self, grad_y):
|
|
'''
|
|
grad_y: same shape as x
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请完成激活函数的梯度后传'''
|
|
# ==========
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
|
|
\begin{multicols}{2}
|
|
由于要计算梯度时要根据输入$x$是否大于0判断，所以这里使用了\mintinline{python}{self.mem}来记忆上次输入的$x$，在反向传播的时候就可以使用记忆的$x$来进行分支，这里可以利用 numpy的批量操作能力实现，\mintinline{python}{grad_y}是传入的梯度，返回的结果应为本层梯度与传入梯度的乘积：
|
|
$$
|
|
return = \frac{\mathrm{d}a}{\mathrm{d}x} \times grad\_y=\begin{cases}
|
|
grad\_y,\quad & x>0 \\
|
|
0,\quad & x\leqslant 0 \\
|
|
\end{cases}
|
|
$$
|
|
因此写出代码如下：
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
class Relu:
|
|
def __init__(self):
|
|
self.mem = {}
|
|
|
|
def forward(self, x):
|
|
self.mem['x'] = x
|
|
return np.where(x > 0, x, np.zeros_like(x))
|
|
|
|
def backward(self, grad_y):
|
|
'''
|
|
grad_y: same shape as x
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请完成激活函数的梯度后传'''
|
|
return np.where(self.mem['x'] > 0, grad_y, np.zeros_like(grad_y))
|
|
# ==========
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\mint{python}|return np.where(self.mem['x'] > 0, grad_y, np.zeros_like(grad_y))|
|
|
\end{frame}
|
|
|
|
\subsection{交叉熵损失+L2正则项}
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
交叉熵损失的函数为
|
|
$$
|
|
loss=\sum_{\text{每个类别}i} -y_i \log(\hat{y}_i)
|
|
$$
|
|
L2正则项的损失为
|
|
$
|
|
\lambda \left\Vert W \right\Vert
|
|
$，$\lambda$为系数，$W$为权重，距离用的是欧几里得距离，即
|
|
$$\displaystyle \sqrt{\sum_{W\text{中的每个参数}x} x^{2} }$$
|
|
|
|
这里有两层网络，也就是两层权重，所以
|
|
$$
|
|
L2 = \lambda_1 \left\Vert W_1 \right\Vert +\lambda_2 \left\Vert W_2 \right\Vert
|
|
$$
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
def compute_loss(self, log_prob, labels):
|
|
'''
|
|
log_prob is the predicted probabilities
|
|
labels is the ground truth
|
|
Please return the loss
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请完成多分类问题的损失计算 损失为： 交叉熵损失 + L2正则项'''
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
\mintinline{python}{log_prob}应该是希望传入已经经过$\log$计算的$\hat{y}$，但是在lab4.ipynb里发现其实是没有经过$\log$计算的\mintinline{python}{pred_y}，这里还得自己计算$\log(\hat{y})$，但是$\log (\hat{y}_i)$由于在前向传播的时候计算过就提前缓存在\mintinline{python}{self.log_value}了。
|
|
|
|
\mintinline{python}{labels}|$y$和\mintinline{python}{self.log_value}|$\log(\hat{y})$是one-hot编码的，形状为[批大小，类别数]，根据公式在类别数维度求和，所以是\mintinline{python}{axis=1}。注意还要在批大小维度求平均，即\mintinline{python}{.mean(0)}。
|
|
|
|
计算距离这里直接使用了\mintinline{python}{np.linalg.norm}。
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
def compute_loss(self, log_prob, labels):
|
|
'''
|
|
log_prob is the predicted probabilities
|
|
labels is the ground truth
|
|
Please return the loss
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请完成多分类问题的损失计算 损失为： 交叉熵损失 + L2正则项'''
|
|
return - np.sum(labels * self.log_value, axis=1).mean(0) + self.lambda1 * np.linalg.norm(self.W1) + self.lambda1 * np.linalg.norm(self.W2)
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\subsection{主模型的前向传播}
|
|
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
这里$x$的形状是[批大小，28，28]，这里的两个28分别是图像高度和宽度，而且可以观察到\mintinline{python}{self.W1}的形状是[100, 785]，但是$28\times 28=784$，说明需要把高度和宽度拉平后还需要拼接一个\mintinline{python}{np.ones}来替代偏置项的作用。即
|
|
\mint{python}|np.concatenate((x.reshape(x.shape[0], -1), np.ones((x.shape[0], 1))), axis=1)|
|
|
|
|
在\mintinline{python}{Matmul.backward}的注释中可以看到\\
|
|
\mintinline{python}{x: shape(d, N)}，所以拼接好之后还需要进行转置。
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
def forward(self, x):
|
|
'''
|
|
x is the input features
|
|
Please return the predicted probabilities of x
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请搭建一个MLP前馈神经网络 补全它的前向传播 MLP结构为FFN --> RELU --> FFN --> Softmax'''
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
在\mintinline{python}{Softmax.forward}的注释中可以看到\mintinline{python}{x: shape(N, c)}，因此在进行Softmax操作前还需要再转置回来。
|
|
|
|
理论上这时候就可以直接返回了，不需要用到\mintinline{python}{self.log}，$\log$是在计算交叉熵时才会用到的操作，但是在lab4.ipynb中非要先反向传播再计算损失，反向传播需要\mintinline{python}{self.log.backward}，但这又需要先调用过\mintinline{python}{self.log.forward}才能把输入记忆到\mintinline{python}{self.mem}中，才能正确返回梯度。
|
|
|
|
那没办法，只能先调用一下\mintinline{python}{self.log.forward}把结果缓存起来。
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
def forward(self, x):
|
|
'''
|
|
x is the input features
|
|
Please return the predicted probabilities of x
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''请搭建一个MLP前馈神经网络 补全它的前向传播 MLP结构为FFN --> RELU --> FFN --> Softmax'''
|
|
y = np.concatenate((x.reshape(x.shape[0], -1), np.ones((x.shape[0], 1))), axis=1).T # 这形状真难弄
|
|
y = self.mul_h1.forward(self.W1, y)
|
|
y = self.relu.forward(y)
|
|
y = self.mul_h2.forward(self.W2, y).T
|
|
y = self.softmax.forward(y)
|
|
# print(y)
|
|
# 唉没办法，非要先反向传播再计算损失，那只能把log的结果缓存起来了
|
|
self.log_value = self.log.forward(y)
|
|
return y
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\subsection{主模型的反向传播}
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
前面的准备工作都实现了后，这里就很简单了，只需要逐层反向传播就行了。
|
|
|
|
注意交叉熵损失为
|
|
$$
|
|
loss=\sum_{\text{每个类别}i} -y_i \log(\hat{y}_i)
|
|
$$
|
|
所以
|
|
$$
|
|
\frac{\mathrm{d}loss}{\mathrm{d}\log(\hat{y}_i)}= -y_i
|
|
$$
|
|
因此首个梯度为 \mintinline{python}{-label}，后续的反向传播就交给各层的\mintinline{python}{backward}函数了。
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
def backward(self, label):
|
|
'''
|
|
label is the ground truth
|
|
Please compute the gradients of self.W1 and self.W2
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''补全该前馈神经网络的后向传播算法'''
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
仍然要注意在Softmax反向传播后需要转置一下。
|
|
|
|
\mintinline{python}{Matmul.backward}返回的结果为\mintinline{python}{return grad_x, grad_W}，这也提示了全连接层要保留对输入和对参数的求导，对输入的求导用来继续反向传播，对参数的求导用来更新参数。
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
def backward(self, label):
|
|
'''
|
|
label is the ground truth
|
|
Please compute the gradients of self.W1 and self.W2
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''补全该前馈神经网络的后向传播算法'''
|
|
temp = self.log.backward(-label)
|
|
temp = self.softmax.backward(temp).T
|
|
temp, self.gradient2 = self.mul_h2.backward(temp)
|
|
temp = self.relu.backward(temp)
|
|
temp, self.gradient1 = self.mul_h1.backward(temp)
|
|
# ==========
|
|
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\subsection{更新参数}
|
|
\begin{frame}[fragile]
|
|
\begin{multicols}{2}
|
|
更新参数只需要按照公式即可，不要忘记L2正则项的梯度，以下以$W_1$为例，$W_2$同理。
|
|
|
|
$W_1^{(i,j)}$表示$W_1$的第$i$行$j$列的元素，lr表示learning rate，即学习率。
|
|
$$
|
|
\frac{\mathrm{d}L2}{\mathrm{d}W_1^{(i,j)}}= \frac{2 \lambda_1 W_1^{(i,j)}}{\left\Vert W_1 \right\Vert }
|
|
$$
|
|
|
|
$$
|
|
W_1 = W_1 - \left( \frac{\mathrm{d}loss}{\mathrm{d}W_1}+\frac{\mathrm{d}L2}{\mathrm{d}W_1} \right) \times lr
|
|
$$
|
|
\columnbreak
|
|
\begin{minted}{python}
|
|
def update(self):
|
|
'''
|
|
Please update self.W1 and self.W2
|
|
'''
|
|
|
|
# ==========
|
|
# todo '''更新该前馈神经网络的参数'''
|
|
self.W1 -= (self.gradient1 + 2 * self.lambda1 * self.W1 / np.linalg.norm(self.W1)) * self.lr
|
|
self.W2 -= (self.gradient2 + 2 * self.lambda1 * self.W2 / np.linalg.norm(self.W2)) * self.lr
|
|
# ==========
|
|
|
|
\end{minted}
|
|
\end{multicols}
|
|
\end{frame}
|
|
|
|
\begin{frame}
|
|
\zihao{-4}\centering{感谢观看！}
|
|
\end{frame}
|
|
\end{document}
|