高轲用's Blog

跨域推荐的用户偏好的个性化转移(PTUPCDR)论文笔记

gaokeyong@outlook.com (高轲用) — Thu, 14 Jul 2022 17:00:12 +0800

概述

推荐系统在网络和移动应用中发挥着越来越重要的作用，但冷启动问题仍然是一个非常具有挑战性的问题。

幸运的是，辅助源域中冷启动用户的交互可以辅助目标域中的冷启动推荐。如何将用户的偏好从源域转移到目标域，是跨域推荐（CDR）的关键问题，它是处理冷启动问题的一个有前景的解决方案。大多数现有的方法都建立了一个共同的偏好桥来转移所有用户的偏好。

由于用户与用户之间的偏好不同，不同用户的偏好桥应该是不同的。沿着这个思路，论文提出了一个新的框架，名为跨域推荐的个性化用户偏好转移（PTUPCDR）。具体来说，论文学习了一个以用户特征嵌入为基础的元网络，以生成个性化的桥梁函数，实现每个用户的个性化偏好转移。为了稳定地学习元网络，论文采用了一个面向任务的优化程序。通过元生成的个性化桥梁函数，用户在源域的偏好嵌入可以转化为目标域，转化后的用户偏好嵌入可以作为目标域的冷启动用户的初始嵌入。利用大型真实世界数据集，论文进行了广泛的实验，以评估PTUPCDR在冷启动和热启动阶段的有效性。

总的来说，这篇论文的主要贡献归纳为三个方面：

为了解决CDR中的冷启动问题，论文提出了一种名为PTUPCDR的新方法，利用元网络为每个用户生成个性化的桥梁函数，给定源域中的编码用户特征。
为了稳定地学习元网络，论文采用了一个面向任务的优化流程来减轻不合理的用户embedding的副作用。
论文使用亚马逊评论数据集对三个跨域任务进行了广泛的实验，证明了PTUPCDR不仅对冷启动场景而且对暖启动场景的有效性和稳健性，而现有的方法只证明了它们在冷启动场景中的有效性。

论文被WSDM 2022收录，见于https://arxiv.org/abs/2110.11154。

相关代码见于https://github.com/easezyc/WSDM2022-PTUPCDR。

模型

问题背景

在CDR中, 论文有一个源域（source domain）和一个目标域（target domain）。每个域有一个用户集$\mathcal{U} = {u_1, u_2, …}$、一个项目集$\mathcal{V} = {v_1, v_2, … }$和一个评分矩阵$\mathcal{R}$。 $r_{ij} \in \mathcal{R}$表示用户$u_i$和项目$v_j$之间的交互行为。为了区分源域和目标域，论文把源域的用户集、项目集、评分矩阵分别表示为$\mathcal{U}^s, \mathcal{V}^s, \mathcal{R}^s$，目标域的用户集、项目集、评分矩阵分别表示为$\mathcal{U}^t, \mathcal{V}^t, \mathcal{R}^t$。论文将两个领域之间的重叠用户定义为$\mathcal{U}^o = \mathcal{U}^s \cap \mathcal{U}^t$。（*即在源域和目标域都有交互操作的用户*）相反，$\mathcal{V}^s$和$\mathcal{V}^t$是不相交的，这意味着两个域之间没有共享项。（*不存在既属于源域有在目标域的项目*）

在隐变量模型（latent factor models）中，用户和项目被转化为密集的向量，也被称为factors或embeddings。在这篇论文中, $\bm{u}^d_i \in \mathbb{R}^{k}$和$\bm{v}^d_j \in \mathbb{R}^{k}$表示用户$u^d_i$和项目$v^d_j$的embeddings，其中，$k$表示embeddings的维度，$d \in {s ,t}$代表域的类型。对每个用户$u_i$，论文将她在源域的连续互动项目列表表示为$\mathcal{S}_{u_i} = {v^s_{t_1}, v^s_{t_2}, \cdots, v^s_{t_n}}$，其中$n$表示互动的项目的数量，$v^s_{t_n}$表示时间戳为$t_n$时的源域中的互动项目。

特征编码器 Characteristic encoder

生成个性化桥梁函数的第一步是从互动项目中获取用户的个性化可转移特征。然而，冷启动用户在目标域中没有互动项目。因此，必须利用源域中的互动项目$\mathcal{S}$。请注意，论文需要找到对知识迁移有帮助的可迁移特性。

直观地说，各种项目对知识迁移有不同的贡献。注意力机制允许不同的部分在压缩到一个单一的表示时有不同的贡献。因此，论文提出在项目embeding上采用注意力机制，进行加权求和：

$$\bm{p}_{u_i} = \sum_{v^s_j \in \mathcal{S}_{u_i}} a_j \bm{v}^s_j,$$

在这里$\bm{p}_{u_i} \in \mathbb{R}^{k}$表示用户$u_i$的可转移的特征embedding，$a_j$是项目$v_j$的注意力得分(attention score)（可以理解为$v_j$在预测个性化桥梁函数方面的重要性）。对于目标领域来说，一个不相关的项目对所有用户的个性化桥梁功能没有什么帮助。因此，论文通过一个注意力网络从项目的embedding中学习注意力得分。从形式上看，注意力网络被定义为：

$$ \begin{aligned} a'_j &= h(\bm{v}_j;\theta),\\ a_j &= \frac{\exp(a'_j)}{\sum_{v^s_l \in \mathcal{S}_{u_i}} \exp(a'_l)}, \end{aligned} $$

在这里$h(\cdot)$表示这个注意力网络，$\theta$表示$h(\cdot)$的参数。在这篇论文中，$h(\cdot)$是一个两层的前馈网络（two-layer feed-forward network）。请注意这个归一化的注意力得分$a_j$有利于找到对特定用户有用的互动项目。之后，论文可以利用每个用户的特征作为输入，指导个性化桥梁函数的生成。

元网络 Meta Network

论文已经提到，用户在不同域的偏好之间的关系因用户而异。换句话说，偏好转移的过程需要个性化。直观地说，偏好关系和用户的特征之间存在着某种联系。基于这一直觉，论文提出了一个元网络，它将用户的可转移特征作为输入，然后在用户在源域和目标域的embeddings之间生成一个个性化的桥梁函数。提出的元网络的公式为：

$$\bm{w}_{u_i} = g(\bm{p}_{u_i}; \phi),$$

在这里$g(\cdot)$是元网络，参数为$\phi$。在本文中，元网络是一个两层前馈网络。$\bm{w}_{u_i}$ 是一个向量，其大小取决于桥梁函数的结构。个性化的桥梁函数公式为:

$$f_{u_i}(\cdot;\bm{w}_{u_i}),$$

其中利用$\bm{w}_{u_i}$作为桥梁函数$f(\cdot)$的参数。桥梁函数可以被定义为任何结构。在这篇论文中，出于简单明了，论文借鉴EMCDR使用一个线性层$f(\cdot)$。因此，为了适应桥梁参数的大小，论文将向量$\bm{w}_{u_i} \in \mathbb{R}^{k^2}$变形为矩阵$\bm{w}_{u_i} \in \mathbb{R}^{k \times k}$. 注意$\bm{w}_{u_i}$被用作桥梁函数的参数，而不是输入。生成的桥梁函数取决于用户的特点，并因人而异，论文称之为个性化的桥梁函数。

通过个性化的桥梁函数，论文可以得到个性化的转换后的用户的embeddings信息:

$$\hat{\bm{u}}_i^t = f_{u_i}(\bm{u}^s_i;\bm{w}_{u_i}),$$

在这里$\bm{u}^s_i$表示在源域中的用户$u_i$的embedding，$\hat{\bm{u}}_i^t$表示转移后的embedding。最终论文可以利用转移后的embedding $\hat{\bm{u}}_i^t$做预测。

面向任务的优化

为了训练元网络和特征编码器，论文可以依照现有的基于桥梁的方法，使用面向映射的优化(mapping-oriented optimization)流程来最小化距离：

$$\mathcal{L} = \sum_{u_i \in \mathcal{U}^o} || \hat{\bm{u}}^t_i - \bm{u}_i^t ||^2$$

在这里$\hat{\bm{u}}^t_i$表示来自源域中的用户$\bm{u}^s_i$转换后的embedding，$\bm{u}_i^t$表示目标域中的用户embedding。面向映射的优化流程会使转换后的embedding $\hat{\bm{u}}_i^t$靠近目标域中embedding$\bm{u}_i^t$。

然而，由于一些用户只有有限的互动，用户的embedding $\bm{u}_i^t$可能不够合理和准确。对相对不合理的embeddings学习会导致对模型的负面影响。因此，论文提出了一个面向任务的优化方法来训练元网络和特征编码器。面向任务的训练程序直接利用最终推荐任务的性能作为优化目标。在本文中，论文专注于评分任务，所以面向任务的损失可以表述为：

$$\min_{\theta, \phi} \frac{1}{|\mathcal{R}^t_o|} \sum_{r_{ij} \in \mathcal{R}^t_o} (r_{ij} - f_{u_i}(\bm{u}^s_i;\bm{w}_{u_i})\bm{v}_j)^2$$

在这里$\mathcal{R}^t_o = {r_{ij}| u_i \in \mathcal{U}^o, v_j \in \mathcal{V}^t}$表示目标域中重叠用户的互动。

与面向映射的程序相比，面向任务的优化有两个优点：

面向任务的优化可以减轻不合理的embeddings的影响。它直接使用评分数据，是真实值而不是近似的中间结果。
面向任务的学习过程有更多的训练样本，这可以避免过度拟合。例如，有$N$个重叠用户，每个用户有$M$的评分。面向映射的过程使用$|\mathcal{U}^o = N|$个样本学习映射函数，而面向任务的学习过程利用$|\mathcal{R}^t_o| = M \times N$个用户-项目评分。

整体流程

PTUPCDR的整体架构如图所示。训练过程可以分为三个步骤：预训练、元和初始化阶段。训练结束后，该方法可以适用于冷启动(cold-start)和暖启动(warm-start)阶段。

预训练阶段: 这一步是为每个域分别学习隐空间。损失函数表述为: $$\min_{\bm{u}, \bm{v}} \frac{1}{|\mathcal{R}|} \sum_{r_{ij}\in \mathcal{R}} (r_{ij} - \bm{u}_i \bm{v}_j)^2,$$ 在这里$|\mathcal{R}|$表示评分的数量。预训练后，论文可以获得预训练的embeddings $\bm{u}^s, \bm{u}^t, \bm{v}^s, \bm{v}^t$.

元阶段: 现有的方法直接训练一个普通的桥函数，而PTUPCDR则训练特征编码器和元网络。

初始化阶段: 当一个新用户到来时（CDR假设新用户在源域有一些互动），论文使用转换后的embedding $\hat{\bm{u}}_i^t = f_{u_i}(\bm{u}^s_i;\bm{w}_{u_i})$来初始化新用户在目标域的embedding。

测试阶段: 对于在目标领域没有互动的极端冷启动用户，直接利用初始embedding $\hat{\bm{u}}_i^t = f_{u_i}(\bm{u}^s_i;\bm{w}_{u_i})$进行预测。对于在目标域有一些交互的温启动用户来说，用新的交互对初始嵌入进行微调，并利用微调后的嵌入进行预测是很方便的。

论文中的实验

数据集： 数据集采用了Amazon-5cores¹。

基准对照：

TGT：只用了目标域中的数据
CMF：源域和目标域中的用户使用相同的embeddings
EMCDR：它采用矩阵分解法（MF）首先学习嵌入，然后利用网络将用户嵌入从辅助域连接到目标域。
DCDCSR：属于基于桥梁的方法，它考虑了不同领域中单个用户的评分稀疏程度
SSCDR：一个半监督的基于桥梁的方法。

实现细节：

Adam优化器的初始学习率在0.001, 0.005, 0.01, 0.02, 0.1范围内通过网格搜索进行调整
embedding的维度：10
mini-batch大小：512
元网络的隐藏单元为$2\times k$，其中$k$表示嵌入维度，元网络的输出维度为$k\times k$
注意力网络是一个具有$k$隐藏单元的两层网络

实验结果

PTUPCDR在大多数情况下都能明显超过最佳的基准对照，这说明PTUPCDR对冷启动推荐是有效的。

实验数据显示PTUPCDR方法对于暖启动阶段也有很大的帮助。

总结

论文发现现有研究的由所有用户共享的单一桥梁函数很难捕捉到源域和目标域中用户偏好之间的各种关系。因此，论文提出了一个新的框架PTUPCDR。具体来说，通过学习用户特征嵌入的元网络来生成个性化的桥梁函数，实现用户偏好的个性化转移。在真实世界的数据集上进行了广泛的实验来评估所提出的PTUPCDR，结果验证了PTUPCDR在冷启动和热启动阶段的有效性。

总的来说，论文的着眼点在于个性化上，充分考虑域之间的个性化、不同用户的个性化，并将这一抽象概念进行数学建模，捕捉可能有关联的变量并与待预测任务之间建立合适的层次关联，从而形成个性化的知识迁移桥梁函数。将训练后的模型在冷启动、热启动等场景下与现有的最前沿的研究工作进行对比，证明了PTUPCDR不仅对冷启动场景而且对暖启动场景的有效性和稳健性。

http://jmcauley.ucsd.edu/data/amazon/ ↩︎

函数式程序设计（一）——初⻅函数式思维

gaokeyong@outlook.com (高轲用) — Thu, 14 Jul 2022 09:37:53 +0800

列表的操作

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


> head [1,2,3,4,5]
1
> tail [1,2,3,4,5]
[2,3,4,5]
> [1,2,3,4,5] !! 2
3
> take 3 [1,2,3,4,5]
[1,2,3]
> drop 3 [1,2,3,4,5]
[4,5]
> length [1,2,3,4,5]
5
> sum [1,2,3,4,5]
15
> product [1,2,3,4,5]
120
> [1,2,3] ++ [4,5]
[1,2,3,4,5]
> reverse [1,2,3,4,5]
[5,4,3,2,1]

函数应用

在Haskell中，函数应用使用空格来表示，乘法用星号*来表示。

1

f a b + c*d

Mathematics	Haskell
`f(x)`	`f x`
`f(x, y)`	`f x y`
`f(g(x))`	`f (g x)`
`f(g(x), y)`	`f (g x) y`
`f(x)g(y)`	`f x * g y`

Haskell脚本

用户自己定义的函数在一个script中，由一系列定义组成的文本文件，后缀名习惯用.hs。

当开发一个Haskell脚本时，保持两个窗口的打开是很有用的，一个是运行脚本的编辑器，另一个是运行GHCi。

1
2
3


-- test.hs
double x = x + x
quadruple x = double (double x)

终端中运行ghci test.hs，然后输入double 3，得到6，输入quadruple 3，得到12。

我们不关闭GHCi，然后在test.hs中添加阶乘函数和求均值函数：

1
2
3
4


double x = x + x
quadruple x = double (double x)
factorial n = product [1..n]
average ns = sum ns `div` length ns

注意

div是用反引号括起来的，而不是正引号。
x ``f`` y只是f x y的语法糖。

GHCi不会自动检测到脚本已经被改变，所以在使用新的定义之前，必须执行一个重新加载命令:reload。

1
2
3
4
5
6
7


ghci> ::reload
[1 of 1] Compiling Main             ( test.hs, interpreted )
Ok, one module loaded.
ghci> factorial 5
120
ghci> average [1,1,4,5,1,4]
2

常用GHCi命令

命令	作用
`:load` `name`	加载脚本name
`:reload`	重新加载脚本
`:set editor` `name`	设置编辑器为name
`:edit` `name`	编辑脚本文件name
`:edit`	编辑当前脚本
`:type` `expr`	显示表达式expr的类型
`:?`	列出所有命令
`:quit`	退出GHCi

函数式思维

使用数学中的函数作为求解信息处理问题的基本成分。

从零开始定义一些基本函数
把已有的函数组装起来，形成新的函数

自然数上的 `fold` 函数

plus、mult、expn这三个函数之间存在共性，这种共性可以被封装在一个函数中。

$$ \begin{aligned} foldn&:(A\rightarrow A) \rightarrow (A \rightarrow (\mathbb{N} \rightarrow A)) \\ foldn(h)(c)(0)&\doteq c \\ foldn(h)(c)(succ(n))&\doteq h(foldn(h)(c)(n)) \\ \end{aligned} $$

可知

$$ \begin{aligned} h&:A\rightarrow A \\ c&:A \\ \end{aligned} $$

给定函数$h:A\rightarrow A$和值$c:A$，令$f=fold(h)(c)$，则由上述定义可知：

$$ \begin{aligned} f(0)&\doteq c \\ f(succ(n))&\doteq h(f(n)) \\ \end{aligned} $$

注意

从另一个角度理解$foldn$函数：

给定一个自然数$n$，可知：
$$n=(\underbrace{succ\cdot succ\cdots succ}_\text{n $succ$ functions})(0)$$
已知$f=foldn(h)(c)$，可知：
$$f(n)=(\underbrace{h\cdot h\cdots h}_\text{n $h$ functions})(c)$$

利用foldn函数，可以对plus、mult、expr进行更简洁的定义：

$$ \begin{aligned} plus&:\mathbb{N}\rightarrow (\mathbb{N}\rightarrow \mathbb{N}) \\ plus(n)&\doteq foldn(succ)(n) \\ m&=(\underbrace{succ\cdot succ\cdots succ}_\text{m $succ$ functions})(0) \\ plus(n)(m)&=(\underbrace{succ\cdot succ\cdots succ}_\text{m $succ$ functions})(n) \\ \end{aligned} $$

$$ \begin{aligned} mult&:\mathbb{N}\rightarrow (\mathbb{N}\rightarrow \mathbb{N}) \\ mult(n)&\doteq foldn(plus(n))(0) \\ mult(n)(m)&=(\underbrace{plus(n)\cdot plus(n)\cdots plus(n)}_\text{m $plus(n)$ functions})(0) \\ \end{aligned} $$

$$ \begin{aligned} expr&:\mathbb{N}\rightarrow (\mathbb{N}\rightarrow \mathbb{N}) \\ expr(n)&\doteq foldn(mult(n))(1) \\ expr(n)(m)&=(\underbrace{mult(n)\cdot mult(n)\cdots mult(n)}_\text{m $mult(n)$ functions})(1) \\ \end{aligned} $$

`fact`函数

为了使用foldn函数定义fact和fib函数，首先引入两个辅助函数：

$$ \begin{aligned} outl&:A\times B \rightarrow A \\ outl(a,b)&\doteq a \end{aligned} $$

$$ \begin{aligned} outr&:A\times B \rightarrow B \\ outr(a,b)&\doteq b \end{aligned} $$

fact函数定义如下：

$$ \begin{aligned} f&:\mathbb{N}\times \mathbb{N}\rightarrow \mathbb{N}\times \mathbb{N} \\ f(m,n)&\doteq (m+1,(m+1)\times n) \\ fact&:\mathbb{N}\rightarrow \mathbb{N} \\ fact(n)&\doteq outr\cdot foldn(f)(0,1) \\ \\ m&=(\underbrace{succ\cdot succ\cdots succ}_\text{m $succ$ functions})(0) \\ fact(m)&=outr((\underbrace{f\cdot f\cdots f}_\text{m $f$ functions})(0,1)) \\ \end{aligned} $$

`fib`函数

$$ \begin{aligned} g&:\mathbb{N}\times \mathbb{N}\rightarrow \mathbb{N}\times \mathbb{N} \\ g(m,n)&\doteq (n,(m+n)) \\ fib&:\mathbb{N}\rightarrow \mathbb{N} \\ fib(n)&\doteq outl\cdot foldn(g)(0,1) \\ \\ m&=(\underbrace{succ\cdot succ\cdots succ}_\text{m $succ$ functions})(0) \\ fib(m)&=outl((\underbrace{g\cdot g\cdots g}_\text{m $g$ functions})(0,1)) \\ \end{aligned} $$

序列（List）以及序列上的`fold`函数

TBD

List 相关函数的重定义

TBD

一种排序算法

TBD

在Linux上使用MIPSsim模拟器

gaokeyong@outlook.com (高轲用) — Sun, 01 May 2022 07:49:49 +0800

Wine 是一款可以在多个 posix 兼容的操作系统上运行 Windows 应用程序的兼容层，比如 Linux、 macOS 和 BSD。Linux中运行MIPSsim模拟器的最终效果如图：

但使用前需要进行一些适配。

安装 Wine

需要安装wine（64位版本）、wine-gecko、winetricks。您可以使用系统包管理器安装，或参考前述超链接内指引。

以下步骤在wine 7.7版本验证可用。

配置中文字体

直接执行：

1

winetricks fakechinese

安装.NET Framework 4.6

参见：WineHQ - .NET Framework 4.6

运行：

1

LANG=zh_CN.UTF-8 winetricks --force dotnet46 corefonts riched20

警告

请务必安装dotnet46，更高版本或更低版本都有可能出现问题。

可能要经过三轮安装向导完成安装。

运行模拟器

解压计算机系统结构实验指导书及模拟器-发布版.zip，在程序所在目录执行LANG=zh_CN.UTF-8 wine64 "MIPS模拟器(64位).exe"，运行效果如下：

Linux下应用火焰图(Flame Graph)可视化交互程序剖析

gaokeyong@outlook.com (高轲用) — Fri, 22 Apr 2022 21:52:00 +0800

确定CPU繁忙的原因是性能分析的一项常规任务，这通常涉及到对堆栈跟踪的剖析。通过固定速率的采样进行剖析是一种粗略但有效的方法，可以看到哪些代码路径是热的（CPU上的繁忙）。它通常通过创建一个定时中断来收集当前的程序计数器、函数地址或整个堆栈回溯，并在打印总结报告时将其转化为人类可读的东西。

linux-tools中的系统级性能分析工具perf提供一个性能分析框架，通过perf，应用程序可以利用PMU、tracepoint和内核中的计数器来进行性能统计。tracepoints是散落在内核源码中的一些hook，它们可以在特定的代码被执行到时触发，这一特点可以被各种trace/debug工具所使用。perf将tracepoint产生的时间记录下来，生成报告，通过分析这些报告，调优人员便可以了解程序运行期间内核的各种细节，定位程序的性能瓶颈。

然而，perf生成的剖析数据可能有几千行之长，人类是视觉动物，在阅读大量的数字和理解它们方面相当糟糕。火焰图（Flame Graph）是采样堆栈跟踪的一种可视化方式。除CPU剖析外，这种可视化的用途见火焰图的主页。

在这里，我将介绍如何使用Flame Graph生成程序剖析的CPU火焰图，它可以配合perf使用，并且生成的SVG是交互式的，可以放大或搜索定位到程序的特定部分，其效果如下：

安装

首先安装perf，以Arch Linux为例：

1

sudo pacman -S perf

拉取FlameGraph仓库：

1

git clone https://github.com/brendangregg/FlameGraph  # or download it from github

使用

1
2


cd FlameGraph
sudo perf record -F 99 -a -g -- COMMAND [ARGS]

COMMAND [ARGS]为你要剖析的程序及参数，该命令参数的含义是栈帧采样率为99Hz(-F 99)，记录所有CPU核心的事件(-a)，对内核空间和用户空间启动函数调用图记录功能(-g)。除此之外，其它常用的参数如下：

-p, --pid=：记录指定pid进程的事件，可用逗号分隔多个进程pid
-e, --event=：选择指定的PMU事件
-C, --cpu：仅在指定CPU核心上采样。如0,1 0-2
-o, --output=：输出文件名

程序执行完毕后，当前目录下生成perf.data剖析数据。我们将使用FlameGraph仓库中的脚本生成火焰图：

1
2


sudo perf script | ~/FlameGraph/stackcollapse-perf.pl > out.perf-folded
~/FlameGraph/flamegraph.pl out.perf-folded > perf.svg

当前目录下生成perf.svg。用浏览器打开（Firefox为例）：

1

firefox perf.svg

你可以通过鼠标点击来探索火焰图，或者通过右上角的搜索功能定位到某处。

参考

CPU Flame Graphs

Debugging and Profiling - the missing semester of your cs education

一种古老的内容订阅技术——RSS

gaokeyong@outlook.com (高轲用) — Wed, 02 Mar 2022 20:44:59 +0800

何谓RSS?

对于我们当代的年轻人来说，RSS也许是个十分陌生的概念；然而对于老一代网民尤其是其中对互联网有深入了解的人来说，或许并不陌生。在那个时代，微信、微博等社交平台和通讯工具尚未出现，博客、论坛和新闻网站是当时的网民们网上冲浪的经常去处。然而手动打开众多自己喜爱的博客和新闻网站查看有无更新信息非常不方便，于是作为一种信息聚合方式，RSS更快地检查并聚合您所关注的网站更新，同时也能让博主和新闻媒体创建新闻频道并发布至因特网！

RSS（简易信息聚合） 是一种消息来源格式规范，用以聚合经常发布更新数据的网站，例如博客文章、新闻、音频或视频的网摘。RSS文件（或称做摘要、网络摘要、或频更新，提供到频道）包含全文或是节录的文字，再加上发布者所订阅之网摘数据和授权的元数据。 ¹

通过使用 RSS，您可以把需要的信息从不需要的信息（兜售信息，垃圾邮件等）中分离出来，通过使用 RSS，您还可以创建自己的新闻频道，并将之发布到因特网。²

如今，随着互联网日趋中心化，博客、传统论坛等日渐式微，大多数网民的信息聚合主要依赖如微信公众号、知乎、Bilibili、今日头条等平台。但作为一种“去中心化”的协议，RSS仍然具有无可替代的优势。

我的RSS折腾笔记

Kindle

KindleEar可以生成排版精美的杂志模式mobi/epub格式自动每天推送至您的Kindle或其他邮箱。由于搭建服务所需要的Google App Engine(GAE)服务需要绑定境外银行卡，因此笔者没有尝试成功搭建过。

RSSHub Radar

RSSHub是由DIYgod大佬开发的帮助你快速发现和订阅当前网站 RSS 和 RSSHub 的浏览器扩展。作者官方介绍请看这篇文章。

All-about-RSS

最重要的是，你极有可能在这个列表里找到你需要的关于RSS的应用、工具和服务。

后记

深夜写下这篇文章，怀念当年互联网的年代，去中心化、互帮互助、好学、匿名性等这些令人怀念的东西，已然被日趋中心化的互联网磨蚀的稀缺而珍贵。博客、论坛、电子邮件、RSS、IRC这些东西被裹挟着便捷性和商业性的新一代社交媒体抛入历史的洪流中，令人唏嘘。谨以此文，纪念逝去的那段时代。

参考文献

RSS. 中文维基百科 https://zh.wikipedia.org/wiki/RSS ↩︎
RSS 简介. 菜鸟教程 https://www.runoob.com/rss/rss-intro.html ↩︎

C++面向对象复习笔记2021

gaokeyong@outlook.com (高轲用) — Mon, 20 Sep 2021 14:10:38 +0800

简单的复习了C++面向对象的部分知识，并把一些遇到的需要回顾的知识点记录到该笔记。

IO Stream

用提取运算符>>提取数据时，以空白符(如空格、回车、tab)作为数据的分割符，因此提取字符串数据时，不能提取空白字符。如果要每次读入一行，可以用getline。

1
2
3
4
5
6
7
8
9


ifstream myFile;
myFile.open("in");
string str;
while (!myFile.eof())
{
    getline(myFile, str);
    cout << str << endl;
}
myFile.close();

判断打开的文件是否存在，可以调用成员函数is_open()。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


ifstream myFile;
myFile.open("in2");
string str;
if(myFile.is_open()){
    while (!myFile.eof())
    {
        getline(myFile, str);
        cout << str << endl;
    }
}else{
    puts("Not exists. ");
}
myFile.close();

STL

Vector

与C数组对比：

常被称为“动态数组”，因为其大小可以按照需要增长和收缩
有内置的操作元素的成员函数

常用成员函数：

push_back()
size()
pop_back()
clear()
empty()
capacity()
reverse()
resize()

迭代器

要访问顺序容器和关联容器中的元素，需要通过“迭代器（iterator）”进行。迭代器是一个变量，相当于容器和操纵容器的算法之间的中介。迭代器可以指向容器中的某个元素，通过迭代器就可以读写它指向的元素。从这一点上看，迭代器和指针类似。

1
2
3
4
5


for (vector<int>::iterator iter = list.begin(); iter != list.end(); iter++)
{
    cout << *iter << ' ';
}
cout << endl;

Class

访问限定符

public：完全可访问
private：仅该类可以访问
protected：仅该类的成员函数和其派生子类的成员函数可以访问

`static`

静态成员变量

静态成员变量无需对象实例而存在，且一个类的所有对象共享这个类的相同的静态成员变量，即可以理解为每个对象都有该变量的相同的副本。

注意

注意：为了使静态成员变量有意义，必须在定义类时对其赋初值。（在.cpp文件的顶部）

静态成员函数

静态成员函数属于这个类的所有实例，并能被该类的任何一个对象调用。

静态成员函数只能访问静态成员变量、静态成员函数和类以外的数据和函数。

多态(Polymorphism)

成员函数：通过基类指针或引用间接指向派生类子类型时多态性才会起作用。

析构：如果一个类用作基类，我们通常需要virtual来修饰它的析构函数，这点很重要。如果基类的析构函数不是虚析构，当我们用delete来释放基类指针(它其实指向的是派生类的对象实例)占用的内存的时候，只有基类的析构函数被调用，而派生类的析构函数不会被调用，这就可能引起内存泄露。如果基类的析构函数是虚析构，那么在delete基类指针时，继承树上的析构函数会被自低向上依次调用，即最底层派生类的析构函数会被首先调用，然后一层一层向上直到该指针声明的类型。¹

纯虚函数：只有声明没有定义的虚函数，提供了一个可被子类型改写的接口：

1
2
3
4


class Base {
    public:
    virtual int func() = 0;
};

含有一个或多个纯虚函数的类为抽象类，抽象类本身不能产生对象实例，否则代码将不能编译。

参考资料

C++ Virtual详解.悦峰 ↩︎

神经网络笔记（四）——Spatial Batch Normalization & Spatial Group Normalization

gaokeyong@outlook.com (高轲用) — Fri, 10 Sep 2021 12:38:59 +0800

这里我们跟着实验来完成Spatial Batch Normalization和Spatial Group Normalization，用于对CNN进行优化。

Spatial Batch Normalization

回忆之前普通神经网络的BN层，输入为$X_{input}=(N, D)$，输出形状也为$(N, D)$，其作用是将输入进行归一化然后输出。在这里，对于来自卷积层的数据$X_{input}=(N,C,H,W)$，其输出形状也为$(N,C,H,W)$，其中$N$是一个mini-batch的数据数量，$C$是特征映射（feature map）的数量，有几个感受野就会产生几个特征映射，而$(H, W)$则给出特征映射的大小。

如果特征映射是由卷积运算产生的，我们希望对各个特征C映射进行归一化，使得每个特征映射的不同图片（N）和一张图片内的不同位置（H,W）的统计学特征（均值、标准差等）相对一致。也就是说，spatial batch normalization为C个特征通道中的每一个都计算出来对应的均值和方差，而这里的均值和方差则是遍历对应特征通道中N张图片和其空间维度(H,W)计算得出的。可以理解为之前的D是这里的$C$，之前的N在这里则是$N\times H \times W$。

前向传播

对输入$X_{input}=(N, C, H, W)$转置为维度$(N\times H\times W, C)$，转化成普通的BN层输入并传递给普通(vanilla)BN层的前向传播函数，再对输出转化成对应的$(N, C, H, W)$。代码如下：

1
2
3
4
5
6
7
8
9


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    N, C, H, W=x.shape
    x_new=x.transpose((0,2,3,1)).reshape(-1,C)
    out,cache=batchnorm_forward(x_new,gamma,beta,bn_param)
    out=out.reshape(N,H,W,C).transpose((0,3,1,2))
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

反向传播

1
2
3
4
5
6
7
8
9


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    N, C, H, W=dout.shape
    dout_new=dout.transpose((0,2,3,1)).reshape(-1,C)
    dx, dgamma, dbeta = batchnorm_backward_alt(dout_new,cache)
    dx = dx.reshape((N,H,W,C)).transpose((0,3,1,2))
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

Spatial Group Normalization

Spatial Group Normalization可看作解决Layer Normalization在CNN上的表现不能够像Batch Normalization一样好的问题的方案。

前向传播

仿照论文中的代码实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    cache = (x, gamma, beta, G, gn_param)

    N, C, H, W=x.shape
    x_new=x.reshape((N,G,C//G,H,W))
    mean=np.mean(x_new,axis=(2,3,4),keepdims=True)
    var=np.var(x_new,axis=(2,3,4),keepdims=True)
    x_new=(x_new-mean)/np.sqrt(var+eps)
    x_new=x_new.reshape((N, C, H, W))
    out=x_new*gamma+beta
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

反向传播

参考了这篇博客。求导并不复杂，代码实现起来难度较大。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    N, C, H, W=dout.shape
    x, x_new, mean, var, gamma, beta, G, gn_param=cache
    eps=gn_param.get("eps", 1e-5)

    dgamma = np.sum(dout * x_new, axis=(0, 2, 3)).reshape(1, C, 1, 1)
    x = x.reshape(N, G, C // G, H, W)
    # 这里想通过Gradientcheck必须需要将其reshape为(1, C, 1, 1)
    dbeta = np.sum(dout, axis=(0, 2, 3)).reshape(1, C, 1, 1)

    dx_new = (dout * gamma).reshape(N, G, C // G, H, W)
    mean = mean.reshape(N, G, 1, 1, 1)
    var = var.reshape(N, G, 1, 1, 1)
    dL_dvar = -0.5 * np.sum(dx_new * (x - mean), axis=(2, 3, 4)) * np.power(var.squeeze() + eps, -1.5)
    dL_dvar = dL_dvar.reshape(N, G, 1, 1, 1)

    mid = H * W * C // G
    # add L-->y-->x_hat-->x_i
    dx = dx_new / np.sqrt(var + eps)
    # add L-->mean-->x_i
    dx += ((-1 / mid) * np.sum(dx_new / np.sqrt(var + eps), axis=(2, 3, 4))).reshape(N, G, 1, 1, 1) + dL_dvar * (
        np.sum(-2 * (x - mean) / mid, axis=(2, 3, 4))).reshape(N, G, 1, 1, 1)
    # add L-->var-->x_i
    dx += (2 / mid) * (x - mean) * dL_dvar
    dx = dx.reshape((N, C, H, W))

    # dgamma=np.sum(dout*x,axis=(0,2,3)).reshape(1, C, 1, 1)
    # dbeta=dout.sum(axis=(0,2,3)).reshape((1, C, 1, 1))
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

神经网络笔记（三）——卷积神经网络

gaokeyong@outlook.com (高轲用) — Mon, 06 Sep 2021 23:58:41 +0800

这篇文章是我在完成CS231N-2021课程的Labassignment2/ConvolutionalNetworks.ipynb时的学习与实验的摘录与笔记。

卷积运算

前向传播

输入有$N$个数据点，高度$H$宽度$W$，$C$个通道。每个输入与$F$个不同的filters卷积，每个filter维度为$HH\times WW\times C$。输入的参数还有步长与零补。代码实现输出卷积运算结果的前向传播方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    N, C, H, W=x.shape
    F, C, HH, WW=w.shape
    stride,pad=conv_param['stride'],conv_param['pad']
    H_prime=1+(H+2*pad-HH)//stride
    W_prime=1+(W+2*pad-WW)//stride

    x_pad=np.pad(x,((0,0),(0,0),(pad,pad),(pad,pad)))
    out=np.zeros(shape=(N,F,H_prime,W_prime))
    for n in range(N):
      for f in range(F):
        for i in range(H_prime):
          for j in range(W_prime):
            # print(x[n,:,i*stride:i*stride+HH+1,j*stride:j*stride+WW+1].shape)
            out[n,f,i,j]=np.sum(w[f,:,:,:]*x_pad[n,:,i*stride:i*stride+HH,j*stride:j*stride+WW])+b[f]
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

反向传播

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    x, w, b, conv_param=cache
    N, C, H, W=x.shape
    F, C, HH, WW=w.shape
    stride,pad=conv_param['stride'],conv_param['pad']
    H_prime=1+(H+2*pad-HH)//stride
    W_prime=1+(W+2*pad-WW)//stride

    x_pad=np.pad(x,((0,0),(0,0),(pad,pad),(pad,pad)))
    dx_pad=np.zeros(shape=x_pad.shape)
    dw=np.zeros(shape=w.shape)
    db=np.zeros(shape=b.shape)
    for n in range(N):
      for f in range(F):
        for h in range(H_prime):
          for w_mid in range(W_prime):
            dx_pad[n, :, h*stride:h*stride+HH, w_mid*stride:w_mid*stride+WW]+=dout[n,f,h,w_mid]*w[f,:,:,:]
            dw[f, :, :, :]+=dout[n, f, h, w_mid]*x_pad[n, :, h*stride:h*stride+HH, w_mid*stride:w_mid*stride+WW]
            db[f]+=dout[n,f,h,w_mid]
    dx=dx_pad[:,:,pad:H+pad,pad:W+pad]
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

池化层

通常，在连续的卷积层之间会周期性地插入一个汇聚层。它的作用是逐渐降低数据体的空间尺寸，这样的话就能减少网络中参数的数量，使得计算资源耗费变少，也能有效控制过拟合。池化层使用MAX操作，对输入数据体的每一个深度切片独立进行操作，改变它的空间尺寸。最常见的形式是池化层使用尺寸2x2的滤波器，以步长为2来对每个深度切片进行降采样，将其中75%的激活信息都丢掉。直观的说，使用MAX操作的池化层取出每个滤波器中最“神经”的那个激活信息。

前向传播

代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    N,C,H,W=x.shape
    pool_height, pool_width, stride=pool_param['pool_height'], pool_param['pool_width'], pool_param['stride']
    H_prime=1 + (H - pool_height) // stride
    W_prime=1 + (W - pool_width) // stride
    out=np.zeros(shape=(N,C,H_prime,W_prime))
    for n in range(N):
      for c in range(C):
        for i in range(H_prime):
          for j in range(W_prime):
            out[n,c,i,j]=np.max(x[n,c,i*stride:i*stride+pool_height,j*stride:j*stride+pool_width])
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

反向传播

代码如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    x, pool_param=cache
    N,C,H,W=x.shape
    pool_height, pool_width, stride=pool_param['pool_height'], pool_param['pool_width'], pool_param['stride']
    H_prime=1 + (H - pool_height) // stride
    W_prime=1 + (W - pool_width) // stride
    dx=np.zeros(shape=x.shape)
    for n in range(N):
      for c in range(C):
        for h in range(H_prime):
          for w in range(W_prime):
            # print(x[n,c,h*stride:h*stride+pool_height,w*stride:w*stride+pool_width].shape)
            ind=np.unravel_index(np.argmax(x[n,c,h*stride:h*stride+pool_height,w*stride:w*stride+pool_width]),shape=(pool_height,pool_width))
            dx[n,c,h*stride+ind[0],w*stride+ind[1]]+=dout[n,c,h,w]
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

实验中还提供了快速版本的卷积和池化运算的API，快速卷积操作的前向传播和反向传播的加速比分别约为602x和736x。，快速池化操作的前向传播和反向传播的加速比分别约为183x和58x。

三层卷积网络

这里三层卷积网络的结构为conv - relu - 2x2 max pool - affine - relu - affine - softmax，实验中在一个类ThreeLayerConvNet中实现。

参数初始化

实验中卷积层的padding和stride的设置保证其输出与输入具有相同的高度和宽度。具体来说，步长$S=1$，填充$P=\left\lfloor\frac{F-1}{2}\right\rfloor$，其中$F$为感受野filter的尺寸。我推了一下，貌似这里$F$必须为奇数才能保证输出大小与输入的空间规模相同。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        # conv layer parameters
        self.params['W1']=weight_scale*np.random.randn(num_filters,input_dim[0],filter_size,filter_size)
        self.params['b1']=np.zeros(num_filters)
        # hidden affine layer parameters
        self.params['W2']=weight_scale*np.random.randn(num_filters*(input_dim[1]//2)*(input_dim[2]//2),hidden_dim)
        self.params['b2']=np.zeros(hidden_dim)
        # output affine layer parameters
        self.params['W3']=weight_scale*np.random.randn(hidden_dim,num_classes)
        self.params['b3']=np.zeros(num_classes)

        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

损失函数和梯度计算

这里可以使用cs231n/layer_utils.py中提供的“三明治”层，即将多个层例如conv - relu - max_pool的前向传播和反向传播分别整合到一个函数当中去。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76


    def loss(self, X, y=None):
        """
        Evaluate loss and gradient for the three-layer convolutional network.

        Input / output: Same API as TwoLayerNet in fc_net.py.
        """
        W1, b1 = self.params["W1"], self.params["b1"]
        W2, b2 = self.params["W2"], self.params["b2"]
        W3, b3 = self.params["W3"], self.params["b3"]

        # pass conv_param to the forward pass for the convolutional layer
        # Padding and stride chosen to preserve the input spatial size
        filter_size = W1.shape[2]
        conv_param = {"stride": 1, "pad": (filter_size - 1) // 2}

        # pass pool_param to the forward pass for the max-pooling layer
        pool_param = {"pool_height": 2, "pool_width": 2, "stride": 2}

        scores = None
        ############################################################################
        # TODO: Implement the forward pass for the three-layer convolutional net,  #
        # computing the class scores for X and storing them in the scores          #
        # variable.                                                                #
        #                                                                          #
        # Remember you can use the functions defined in cs231n/fast_layers.py and  #
        # cs231n/layer_utils.py in your implementation (already imported).         #
        ############################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        out_conv_relu_pool, cache_conv_relu_pool=conv_relu_pool_forward(X,W1,b1,conv_param,pool_param)
        out_affine_relu, cache_affine_relu=affine_relu_forward(out_conv_relu_pool,W2,b2)
        scores, cache_output_affine=affine_forward(out_affine_relu,W3,b3)

        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        ############################################################################
        #                             END OF YOUR CODE                             #
        ############################################################################

        if y is None:
            return scores

        loss, grads = 0, {}
        ############################################################################
        # TODO: Implement the backward pass for the three-layer convolutional net, #
        # storing the loss and gradients in the loss and grads variables. Compute  #
        # data loss using softmax, and make sure that grads[k] holds the gradients #
        # for self.params[k]. Don't forget to add L2 regularization!               #
        #                                                                          #
        # NOTE: To ensure that your implementation matches ours and you pass the   #
        # automated tests, make sure that your L2 regularization includes a factor #
        # of 0.5 to simplify the expression for the gradient.                      #
        ############################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        loss, grad=softmax_loss(scores,y)
        loss+=0.5*self.reg*np.sum(W1*W1)
        loss+=0.5*self.reg*np.sum(W2*W2)
        loss+=0.5*self.reg*np.sum(W3*W3)

        grad, grads['W3'], grads['b3']=affine_backward(grad,cache_output_affine)
        grads['W3']+=self.reg*np.sum(W3)
        grad, grads['W2'], grads['b2']=affine_relu_backward(grad,cache_affine_relu)
        grads['W2']+=self.reg*np.sum(W2)
        grad, grads['W1'], grads['b1']=conv_relu_pool_backward(grad, cache_conv_relu_pool)
        grads['W1']+=self.reg*np.sum(W1)

        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        ############################################################################
        #                             END OF YOUR CODE                             #
        ############################################################################

        return loss, grads

实验中还有Spatial Batch Normalization和Spatial Group Normalization两部分的实验，留到下一次做吧。

神经网络笔记（二）——Batch Normalization & DropOut

gaokeyong@outlook.com (高轲用) — Sun, 05 Sep 2021 15:41:56 +0800

Batch Normalization

对应的实验是BatchNormalization.ipynb。

引用官方课程笔记的话：

批量归一化（Batch Normalization）。批量归一化是loffe和Szegedy最近（2015年）才提出的方法，该方法减轻了如何合理初始化神经网络这个棘手问题带来的头痛：），其做法是让激活数据在训练开始前通过一个网络，网络处理数据使其服从标准高斯分布。因为归一化是一个简单可求导的操作，所以上述思路是可行的。在实现层面，应用这个技巧通常意味着全连接层（或者是卷积层，后续会讲）与激活函数之间添加一个BatchNorm层。对于这个技巧本节不会展开讲，因为上面的参考文献中已经讲得很清楚了，需要知道的是在神经网络中使用批量归一化已经变得非常常见。在实践中，使用了批量归一化的网络对于不好的初始值有更强的鲁棒性。最后一句话总结：批量归一化可以理解为在网络的每一层之前都做预处理，只是这种操作以另一种方式与网络集成在了一起。搞定！¹

Batch Normalization的论文中提出了Internal Covariate Shift的现象，即每个输入层的分布在训练的过程中会由于前层的参数的改变而发生改变，一个层需要不断地去适应其输入的新的分布。当网络深度较大时，前层参数的变化可能会在后层参数项放大而产生指数级变化，这使得我们很难选择一个合适的学习率，也会产生非线性函数的饱和导致的难以训练的现象。BN能够很好的减小Internal Covariate Shift，使得我们可以使用更高的学习率和在参数初始化上不必过分小心。² ³

BN的思想是通过归一化来修正层的输入，来期望能提升训练的速度。众所周知，如果输入经过了白化(whitened)，网络的训练将收敛的更快。

标准化一个单元的均值和标准差会降低包含该单元的神经网络的表达能力。为了保持网络的表现力，通常会将对于归一化的输入替换为

$$ y^{(k)}=\gamma^{(k)}\hat{x}^{(k)}+\beta^{(k)} $$

特别的，当$\gamma^2=\sigma^2$，$\beta=\mu$时，可以实现等价变换（identity transform）并且保留了原始输入特征的分布信息。通过上面的步骤，我们就在一定程度上保证了输入数据的表达能力。$\gamma$和$\beta$是两个需要被学习的参数。

前向传播与后向传播

前向传播

训练阶段对每个批次更新滑动平均和方差，用于对测试输入的归一化。代码如下：

1
2
3


# momentum是衰减系数, pyTorch里面的值为0.1
running_mean = momentum * running_mean + (1 - momentum) * sample_mean
running_var = momentum * running_var + (1 - momentum) * sample_var

实验代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


if mode == "train":
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    sample_mean=np.mean(x,axis=0)
    sample_var=np.var(x,axis=0)

    x_hat=(x-sample_mean)/np.sqrt(sample_var+eps)

    out=gamma*x_hat+beta
    cache=(x, x_hat, sample_mean, sample_var, gamma, beta, eps)

    running_mean = momentum * running_mean + (1 - momentum) * sample_mean
    running_var = momentum * running_var + (1 - momentum) * sample_var
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

1
2
3
4
5
6
7
8


elif mode == "test":
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    x_hat=(x-running_mean)/np.sqrt(running_var+eps)
    out=gamma*x_hat+beta
    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

后向传播

需要计算的偏导数有$\frac{\partial L}{\partial x_i}$,$\frac{\partial L}{\partial \gamma}$,$\frac{\partial L}{\partial \beta}$。论文中有推导过程可以参考。代码实现如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

N,D = dout.shape
x, x_hat, sample_mean, sample_var, gamma, beta, eps = cache
dx_hat=dout*gamma
dvar=-0.5*np.sum(dx_hat*(x-sample_mean),axis=0)*np.power(sample_var+eps,-1.5)
dmean=np.sum(dx_hat*(-1.0/np.sqrt(sample_var.T+eps)),axis=0)+dvar*np.sum(-2*(x-sample_mean))/N
dx=dx_hat/(np.sqrt(sample_var+eps))+dvar*2*(x-sample_mean)/N+dmean/N
dgamma=np.sum(dout*x_hat,axis=0)
dbeta=np.sum(dout,axis=0)

pass

# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

将BN添加到Fully Connected Net中

初始化

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

self.params['W1']=weight_scale*np.random.randn(input_dim,hidden_dims[0])
self.params['b1']=np.zeros(hidden_dims[0])
if self.normalization=="batchnorm":
self.params['gamma1']=np.ones(hidden_dims[0])
self.params['beta1']=np.zeros(hidden_dims[0])
for i in range(1,len(hidden_dims)):
self.params['W'+str(i+1)]=weight_scale*np.random.randn(hidden_dims[i-1],hidden_dims[i])
self.params['b'+str(i+1)]=np.zeros(hidden_dims[i])
if self.normalization=="batchnorm":
    self.params['gamma'+str(i+1)]=np.ones(hidden_dims[i])
    self.params['beta'+str(i+1)]=np.zeros(hidden_dims[i])
self.params['W'+str(len(hidden_dims)+1)]=weight_scale*np.random.randn(hidden_dims[-1],num_classes)
self.params['b'+str(len(hidden_dims)+1)]=np.zeros(num_classes)
pass

# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

计算scores

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        aff_outs=[]
        bn_outs=[]
        relu_outs=[]
        aff_caches=[]
        bn_caches=[]
        relu_caches=[]
        for i in range(self.num_layers-1):
          # affine forward
          aff_out, aff_cache=None, None
          if i==0:
            aff_out, aff_cache=affine_forward(X,self.params['W1'],self.params['b1'])
          else:
            aff_out, aff_cache=affine_forward(drop_outs[-1],self.params['W'+str(i+1)],self.params['b'+str(i+1)])
          aff_outs.append(aff_out)
          aff_caches.append(aff_cache)
          # BN forward
          if self.normalization=="batchnorm":
            if i!=self.num_layers-1:
              tgamma=self.params['gamma'+str(i+1)]
              tbeta=self.params['beta'+str(i+1)]
              bnp=self.bn_params[i]
              bn_out, bn_cache=batchnorm_forward(aff_out,tgamma,tbeta,bnp)
              bn_outs.append(bn_out)
              bn_caches.append(bn_cache)
            else:
              bn_out=aff_out
          elif self.normalization=="layernorm":
            if i!=self.num_layers-1:
              tgamma=self.params['gamma'+str(i+1)]
              tbeta=self.params['beta'+str(i+1)]
              bnp=self.bn_params[i]
              bn_out, bn_cache=layernorm_forward(aff_out,tgamma,tbeta,bnp)
              bn_outs.append(bn_out)
              bn_caches.append(bn_cache)
            else:
              bn_out=aff_out
          else:
            bn_out=aff_out
          # ReLU forward
          relu_out, relu_cache=relu_forward(bn_out)
          relu_outs.append(relu_out)
          relu_caches.append(relu_cache)
          pass
        i=self.num_layers
        aff_out, aff_cache=affine_forward(drop_outs[-1],self.params['W'+str(i)],self.params['b'+str(i)])
        aff_outs.append(aff_out)
        aff_caches.append(aff_cache)
        scores=aff_outs[-1]

        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

计算梯度

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        # print(self.num_layers, len(drop_caches),len(relu_caches),len(bn_caches),len(aff_caches))
        loss, grad=softmax_loss(scores,y)
        i=self.num_layers
        grad,grads['W'+str(i)],grads['b'+str(i)]=affine_backward(grad,aff_caches[i-1])
        for i in range(self.num_layers):
          loss+=0.5*self.reg*np.sum(np.square(self.params['W'+str(i+1)]))
        # backprop
        for i in range(self.num_layers-1,0,-1):
          grad=relu_backward(grad, relu_caches[i-1])
          if self.normalization=="batchnorm":
            if i!=self.num_layers:
              grad,grads['gamma'+str(i)],grads['beta'+str(i)]=batchnorm_backward_alt(grad,bn_caches[i-1])
          elif self.normalization=="layernorm":
            if i!=self.num_layers:
              grad,grads['gamma'+str(i)],grads['beta'+str(i)]=layernorm_backward(grad,bn_caches[i-1])
          grad,grads['W'+str(i)],grads['b'+str(i)]=affine_backward(grad,aff_caches[i-1])
          grads['W'+str(i)]+=self.reg*self.params['W'+str(i)]


        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

Dropout

随机失活(Dropout)是一个简单又极其有效的正则化方法。与L1正则化，L2正则化和最大范式约束等方法互为补充。在训练的时候，随机失活的实现方法是让神经元以超参数p的概率被激活或者被设置为0。从课程的实验中能够看到Dropout能够有效地对抗过拟合。添加Dropout层后，完整的loss函数实现如下：

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156


    def loss(self, X, y=None):
        """Compute loss and gradient for the fully connected net.
        
        Inputs:
        - X: Array of input data of shape (N, d_1, ..., d_k)
        - y: Array of labels, of shape (N,). y[i] gives the label for X[i].

        Returns:
        If y is None, then run a test-time forward pass of the model and return:
        - scores: Array of shape (N, C) giving classification scores, where
            scores[i, c] is the classification score for X[i] and class c.

        If y is not None, then run a training-time forward and backward pass and
        return a tuple of:
        - loss: Scalar value giving the loss
        - grads: Dictionary with the same keys as self.params, mapping parameter
            names to gradients of the loss with respect to those parameters.
        """
        X = X.astype(self.dtype)
        mode = "test" if y is None else "train"

        # Set train/test mode for batchnorm params and dropout param since they
        # behave differently during training and testing.
        if self.use_dropout:
            self.dropout_param["mode"] = mode
        if self.normalization == "batchnorm":
            for bn_param in self.bn_params:
                bn_param["mode"] = mode
        scores = None
        ############################################################################
        # TODO: Implement the forward pass for the fully connected net, computing  #
        # the class scores for X and storing them in the scores variable.          #
        #                                                                          #
        # When using dropout, you'll need to pass self.dropout_param to each       #
        # dropout forward pass.                                                    #
        #                                                                          #
        # When using batch normalization, you'll need to pass self.bn_params[0] to #
        # the forward pass for the first batch normalization layer, pass           #
        # self.bn_params[1] to the forward pass for the second batch normalization #
        # layer, etc.                                                              #
        ############################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        aff_outs=[]
        bn_outs=[]
        relu_outs=[]
        drop_outs=[]
        aff_caches=[]
        bn_caches=[]
        relu_caches=[]
        drop_caches=[]
        for i in range(self.num_layers-1):
          # affine forward
          aff_out, aff_cache=None, None
          if i==0:
            aff_out, aff_cache=affine_forward(X,self.params['W1'],self.params['b1'])
          else:
            aff_out, aff_cache=affine_forward(drop_outs[-1],self.params['W'+str(i+1)],self.params['b'+str(i+1)])
          aff_outs.append(aff_out)
          aff_caches.append(aff_cache)
          # BN forward
          if self.normalization=="batchnorm":
            if i!=self.num_layers-1:
              tgamma=self.params['gamma'+str(i+1)]
              tbeta=self.params['beta'+str(i+1)]
              bnp=self.bn_params[i]
              bn_out, bn_cache=batchnorm_forward(aff_out,tgamma,tbeta,bnp)
              bn_outs.append(bn_out)
              bn_caches.append(bn_cache)
            else:
              bn_out=aff_out
          elif self.normalization=="layernorm":
            if i!=self.num_layers-1:
              tgamma=self.params['gamma'+str(i+1)]
              tbeta=self.params['beta'+str(i+1)]
              bnp=self.bn_params[i]
              bn_out, bn_cache=layernorm_forward(aff_out,tgamma,tbeta,bnp)
              bn_outs.append(bn_out)
              bn_caches.append(bn_cache)
            else:
              bn_out=aff_out
          else:
            bn_out=aff_out
          # ReLU forward
          relu_out, relu_cache=relu_forward(bn_out)
          relu_outs.append(relu_out)
          relu_caches.append(relu_cache)
          if self.use_dropout:
            drop_out, drop_cache=dropout_forward(relu_out,self.dropout_param)
            drop_caches.append(drop_cache)
          else:
            drop_out=relu_out
          drop_outs.append(drop_out)
          pass
        i=self.num_layers
        aff_out, aff_cache=affine_forward(drop_outs[-1],self.params['W'+str(i)],self.params['b'+str(i)])
        aff_outs.append(aff_out)
        aff_caches.append(aff_cache)
        scores=aff_outs[-1]

        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        ############################################################################
        #                             END OF YOUR CODE                             #
        ############################################################################

        # If test mode return early.
        if mode == "test":
            return scores

        loss, grads = 0.0, {}
        ############################################################################
        # TODO: Implement the backward pass for the fully connected net. Store the #
        # loss in the loss variable and gradients in the grads dictionary. Compute #
        # data loss using softmax, and make sure that grads[k] holds the gradients #
        # for self.params[k]. Don't forget to add L2 regularization!               #
        #                                                                          #
        # When using batch/layer normalization, you don't need to regularize the   #
        # scale and shift parameters.                                              #
        #                                                                          #
        # NOTE: To ensure that your implementation matches ours and you pass the   #
        # automated tests, make sure that your L2 regularization includes a factor #
        # of 0.5 to simplify the expression for the gradient.                      #
        ############################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        # print(self.num_layers, len(drop_caches),len(relu_caches),len(bn_caches),len(aff_caches))
        loss, grad=softmax_loss(scores,y)
        i=self.num_layers
        grad,grads['W'+str(i)],grads['b'+str(i)]=affine_backward(grad,aff_caches[i-1])
        for i in range(self.num_layers):
          loss+=0.5*self.reg*np.sum(np.square(self.params['W'+str(i+1)]))
        # backprop
        for i in range(self.num_layers-1,0,-1):
          if self.use_dropout:
            grad=dropout_backward(grad,drop_caches[i-1])
          grad=relu_backward(grad, relu_caches[i-1])
          if self.normalization=="batchnorm":
            if i!=self.num_layers:
              grad,grads['gamma'+str(i)],grads['beta'+str(i)]=batchnorm_backward_alt(grad,bn_caches[i-1])
          elif self.normalization=="layernorm":
            if i!=self.num_layers:
              grad,grads['gamma'+str(i)],grads['beta'+str(i)]=layernorm_backward(grad,bn_caches[i-1])
          grad,grads['W'+str(i)],grads['b'+str(i)]=affine_backward(grad,aff_caches[i-1])
          grads['W'+str(i)]+=self.reg*self.params['W'+str(i)]


        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        ############################################################################
        #                             END OF YOUR CODE                             #
        ############################################################################

        return loss, grads

参考资料

神经网络笔记（一）——Fully Connected Nets

gaokeyong@outlook.com (高轲用) — Sat, 04 Sep 2021 20:33:38 +0800

这篇文章是我在完成CS231N-2021课程的Labassignment2/FullyConnectedNets.ipynb时的学习与实验的摘录与笔记。

参数初始化

补全cs231n/classifiers/fc_net.py以实现网络初始化、正向传播和反向传播算法。核心代码如下：

参数初始化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


class FullyConnectedNet(object):

    def __init__(
        self,
        hidden_dims,
        input_dim=3 * 32 * 32,
        num_classes=10,
        dropout_keep_ratio=1,
        normalization=None,
        reg=0.0,
        weight_scale=1e-2,
        dtype=np.float32,
        seed=None,
    ):
        self.normalization = normalization
        self.use_dropout = dropout_keep_ratio != 1
        self.reg = reg
        self.num_layers = 1 + len(hidden_dims)
        self.dtype = dtype
        self.params = {}

        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        self.params['W1']=weight_scale*np.random.randn(input_dim,hidden_dims[0])
        self.params['b1']=np.zeros(hidden_dims[0])
        for i in range(1,len(hidden_dims)):
          self.params['W'+str(i+1)]=weight_scale*np.random.randn(hidden_dims[i-1],hidden_dims[i])
          self.params['b'+str(i+1)]=np.zeros(hidden_dims[i])
        self.params['W'+str(len(hidden_dims)+1)]=weight_scale*np.random.randn(hidden_dims[-1],num_classes)
        self.params['b'+str(len(hidden_dims)+1)]=np.zeros(num_classes)
        pass

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

损失函数和梯度计算：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


def loss(self, X, y=None):
    X = X.astype(self.dtype)
    mode = "test" if y is None else "train"

    # Set train/test mode for batchnorm params and dropout param since they
    # behave differently during training and testing.
    if self.use_dropout:
        self.dropout_param["mode"] = mode
    if self.normalization == "batchnorm":
        for bn_param in self.bn_params:
            bn_param["mode"] = mode
    scores = None
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    aff_outs=[]
    relu_outs=[]
    aff_caches=[]
    relu_caches=[]
    for i in range(self.num_layers):
        # affine forward
        aff_out, aff_cache=None, None
        if i==0:
        aff_out, aff_cache=affine_forward(X,self.params['W1'],self.params['b1'])
        else:
        aff_out, aff_cache=affine_forward(relu_outs[-1],self.params['W'+str(i+1)],self.params['b'+str(i+1)])
        aff_outs.append(aff_out)
        aff_caches.append(aff_cache)
        # ReLU forward
        relu_out, relu_cache=relu_forward(aff_outs[-1])
        relu_outs.append(relu_out)
        relu_caches.append(relu_cache)
        pass
    scores=relu_outs[-1]

    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
    
    # If test mode return early.
    if mode == "test":
        return scores

    loss, grads = 0.0, {}
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    loss, grad=softmax_loss(scores,y)
    for i in range(self.num_layers):
        loss+=0.5*self.reg*np.sum(np.square(self.params['W'+str(i+1)]))
    # backprop
    for i in range(self.num_layers,0,-1):
        grad=relu_backward(grad, relu_caches[i-1])
        grad,grads['W'+str(i)],grads['b'+str(i)]=affine_backward(grad,aff_caches[i-1])
        grads['W'+str(i)]+=self.reg*self.params['W'+str(i)]


    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
    
    return loss, grads

参数更新

反向传播计算出的解析梯度用于进行参数的更新。

随机梯度下降(SGD)及各种更新方法

普通更新

沿着负梯度方向改变参数。假设有一个参数向量x及其梯度dx，那么最简单的更新的形式是：

1
2


# Vanilla update
x += - learning_rate * dx

其中learning_rate是一个超参数，它是一个固定的常量。当在整个数据集上进行计算时，只要学习率足够低，总是能在损失函数上得到非负的进展。

动量(Momentum)更新

这个方法在深度网络上几乎总能得到更好的收敛速度。该方法可以看成是从物理角度上对于最优化问题得到的启发。

1
2
3


# Momentum update
v = mu * v - learning_rate * dx # integrate velocity
x += v # integrate position

这里动量的物理意义与摩擦系数更一致。容易理解这里的“动量”抑制了速度，降低了系统的动能，不然质点在山底永远不会停下来。通过交叉验证，这个参数通常设为[0.5,0.9,0.95,0.99]中的一个。和学习率随着时间退火（下文有讨论）类似，动量随时间变化的设置有时能略微改善最优化的效果，其中动量在学习过程的后阶段会上升。一个典型的设置是刚开始将动量设为0.5而在后面的多个周期（epoch）中慢慢提升到0.99。

实验代码

补全cs231n/optim.py的sgd_momentum函数实现动量更新（注意这里不是Nesterov动量），代码片段如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


def sgd_momentum(w, dw, config=None):
    """
    Performs stochastic gradient descent with momentum.

    config format:
    - learning_rate: Scalar learning rate.
    - momentum: Scalar between 0 and 1 giving the momentum value.
      Setting momentum = 0 reduces to sgd.
    - velocity: A numpy array of the same shape as w and dw used to store a
      moving average of the gradients.
    """
    if config is None:
        config = {}
    config.setdefault("learning_rate", 1e-2)
    config.setdefault("momentum", 0.9)
    v = config.get("velocity", np.zeros_like(w))

    next_w = None
    ###########################################################################
    # TODO: Implement the momentum update formula. Store the updated value in #
    # the next_w variable. You should also use and update the velocity v.     #
    ###########################################################################
    # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

    v=config['momentum']*v-config['learning_rate']*dw
    next_w=w+v

    pass

    # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

相对误差输出信息参考如下：

1
2


next_w error:  8.882347033505819e-09
velocity error:  4.269287743278663e-09

在实验中我们可以直观的看到SGD+动量能够更快的收敛。

Nesterov动量

与普通动量有些许不同，最近变得比较流行。在理论上对于凸函数它能得到更好的收敛，在实践中也确实比标准动量表现更好一些。

1
2
3


v_prev = v # back this up
v = mu * v - learning_rate * dx # velocity update stays the same
x += -mu * v_prev + (1 + mu) * v # position update changes form

学习率退火

如果学习率很高，系统的动能就过大，参数向量就会无规律地跳动，不能够稳定到损失函数更深更窄的部分去。

在实践中，我们发现随步数衰减的随机失活（dropout）更受欢迎，因为它使用的超参数（衰减系数和以周期为时间单位的步数）比更有解释性。

二阶方法

需要求解Hessian矩阵，其操作非常耗费时间和空间。在深度学习和卷积神经网络中，使用L-BFGS之类的二阶方法并不常见。相反，基于（Nesterov的）动量更新的各种随机梯度下降方法更加常用，因为它们更加简单且容易扩展。

逐参数适应学习率方法

前面讨论的所有方法都是对学习率进行全局地操作，并且对所有的参数都是一样的。学习率调参是很耗费计算资源的过程，所以很多工作投入到发明能够适应性地对学习率调参的方法，甚至是逐个参数适应学习率调参。很多这些方法依然需要其他的超参数设置，但是其观点是这些方法对于更广范围的超参数比原始的学习率方法有更良好的表现。

在CS231N的实验中需要实现RMSprop和Adam两个方法，这两种方法可以视作对Adagrad方法的改进。

Adagrad

核心思想是接收到高梯度值的权重更新的效果被减弱，而接收到低梯度值的权重的更新效果将会增强。一个缺点是，在深度学习中单调的学习率被证明通常过于激进且过早停止学习。这里是Adagrad方法的一个直观解释。代码如下：

1
2
3


# Assume the gradient dx and parameter vector x
cache += dx**2
x += - learning_rate * dx / (np.sqrt(cache) + eps)

RMSprop

这个方法用一种很简单的方式修改了Adagrad方法，让它不那么激进，单调地降低了学习率。具体说来，就是它使用了一个梯度平方的滑动平均：

1
2


cache =  decay_rate * cache + (1 - decay_rate) * dx**2
x += - learning_rate * dx / (np.sqrt(cache) + eps)

在上面的代码中，decay_rate是一个超参数，常用的值是[0.9,0.99,0.999]。其中x+=和Adagrad中是一样的，但是cache变量是不同的。因此，RMSProp仍然是基于梯度的大小来对每个权重的学习率进行修改，这同样效果不错。但是和Adagrad不同，其更新不会让学习率单调变小。

实验中的代码实现如下：

1
2
3
4
5
6
7


# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

config["cache"] =  config["decay_rate"] * config["cache"] + (1 - config["decay_rate"]) * dw**2
next_w = w - config["learning_rate"] * dw / (np.sqrt(config["cache"]) + config["epsilon"])
pass

# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

Adam

Adam是最近才提出的一种更新方法，它看起来像是RMSProp的动量版。简化的代码是下面这样：

1
2
3


m = beta1*m + (1-beta1)*dx
v = beta2*v + (1-beta2)*(dx**2)
x += - learning_rate * m / (np.sqrt(v) + eps)

注意这个更新方法看起来真的和RMSProp很像，除了使用的是平滑版的梯度m，而不是用的原始梯度向量dx。论文中推荐的参数值eps=1e-8, beta1=0.9, beta2=0.999。在实际操作中，我们推荐Adam作为默认的算法，一般而言跑起来比RMSProp要好一点。但是也可以试试SGD+Nesterov动量。完整的Adam更新算法也包含了一个偏置（bias）矫正机制，因为m,v两个矩阵初始为0，在没有完全热身之前存在偏差，需要采取一些补偿措施。

实验中的Adam方法要求实现偏置（bias）矫正机制。根据论文，实验中的相关代码实现如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

config["t"] += 1
config["m"] = config["beta1"]*config["m"] + (1-config["beta1"])*dw
config["v"] = config["beta2"]*config["v"] + (1-config["beta2"])*(dw**2)
m_hat=config["m"]/(1-config["beta1"]**config["t"])
v_hat=config["v"]/(1-config["beta2"]**config["t"])
next_w = w - config["learning_rate"] * m_hat / (np.sqrt(v_hat) + config["epsilon"])
pass

# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

高轲用's Blog

跨域推荐的用户偏好的个性化转移(PTUPCDR)论文笔记

概述

相关术语

跨域推荐 Cross-domain Recommendation

冷启动推荐 Cold-start Recommendation

元学习 Meta Learning

模型

问题背景

特征编码器 Characteristic encoder

元网络 Meta Network

面向任务的优化

整体流程

论文中的实验

实验结果

总结

函数式程序设计（一）——初⻅函数式思维

列表的操作

函数应用

Haskell脚本

常用GHCi命令

函数式思维

自然数上的 fold 函数

fact函数

fib函数

序列（List）以及序列上的fold函数

List 相关函数的重定义

一种排序算法

在Linux上使用MIPSsim模拟器

安装 Wine

配置中文字体

安装.NET Framework 4.6

运行模拟器

相关问题

分辨率过高，字体过小

载入程序时提示汇编错误

Linux下应用火焰图(Flame Graph)可视化交互程序剖析

安装

使用

参考

一种古老的内容订阅技术——RSS

何谓RSS?

我的RSS折腾笔记

Kindle

RSSHub Radar

All-about-RSS

后记

参考文献

C++面向对象复习笔记2021

IO Stream

STL

Vector

迭代器

Class

访问限定符

static

静态成员变量

静态成员函数

多态(Polymorphism)

参考资料

神经网络笔记（四）——Spatial Batch Normalization & Spatial Group Normalization

Spatial Batch Normalization

前向传播

反向传播

Spatial Group Normalization

前向传播

反向传播

神经网络笔记（三）——卷积神经网络

卷积运算

前向传播

反向传播

池化层

前向传播

反向传播

三层卷积网络

参数初始化

损失函数和梯度计算

神经网络笔记（二）——Batch Normalization & DropOut

Batch Normalization

前向传播与后向传播

自然数上的 `fold` 函数

`fact`函数

`fib`函数

序列（List）以及序列上的`fold`函数

`static`