深度学习——实验4讲解

讲解/深度学习/lab4.tex

@@ -0,0 +1,441 @@
+% 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}