项目地址

Github: https://github.com/OIdiotLin/torchtracer/

PyPI: https://pypi.org/project/torchtracer/

开发 torchtracer 的初衷

在使用 pytorch 框架进行机器学习（尤其是深度学习）实验时，经常需要考虑如何保存以下实验数据：

• 模型的 checkpoints
• 每次训练的 hyper-parameters
• 训练过程中的各种变化参数及其图像（loss, accuracy, learning-rate 等）

除此之外，Keras 之类的其他框架在 fit 时会有一个表示训练进度的进度条，而 pytorch 原生并没有。

其实上述的这些功能完全可以在 tensorboardX 中找到，而且 UI/UX 效果也非常好，但是配置 tensorboardX 太复杂了我太菜了，于是想要自己做个简单的小工具满足上述需求。

如何使用

使用方法在项目地址里有，这里再整理一下。

安装

pip install torchtracer

创建 Tracer 实例

所有操作都是基于 Tracer 类的实例，它是所有数据的控制者。比如我们需要在 checkpoints 目录下新建一个任务 lmmnb：

from torchtracer import Tracer

tracer = Tracer('checkpoints').attach('lmmnb')

需要注意的是，checkpoints 根目录需要提前创建好。为了避免用户一不小心覆盖了某个已存在的任务文件夹，当任务文件夹（比如上面的 lmmnb）已存在时，再尝试创建则会报错。

如果 attach() 不指定任务名，则会以当前的 datetime 作为任务名。

tracer = Tracer('checkpoints').attach()

保存实验配置/超参

原始配置应该以 dict 形式传入 Config 构造函数，并用 tracer.store() 方法保存之。

from torchtracer.data import Config

# `net` is a defined nn.Module
args = {'epoch_n': 120,
        'batch_size': 10,
        'criterion': nn.MSELoss(),
        'optimizer': torch.optim.RMSprop(net.parameters(), lr=1e-3)}

tracer.store(Config(args))

这一步会在 ./checkpoints/lmmnb 下创建一个 config.json，内容如下：

{
  "epoch_n": 120,
  "batch_size": 10,
  "criterion": "MSELoss",
  "optimizer": {
    "lr": 0.001,
    "momentum": 0,
    "alpha": 0.99,
    "eps": 1e-08,
    "centered": false,
    "weight_decay": 0,
    "name": "RMSprop"
  }
}

输出日志

在训练时（实际上什么时候都可以），我们可以使用 tracer.log(msg, file) 方法来输出日志到文件。如果不指定 file 参数，则会输出到 ./checkpoints/lmmnb/log 文件中去，否则会输出到 ./checkpoints/lmmnb/something.log。

tracer.log(msg='Epoch #{:03d}\ttrain_loss: {:.4f}\tvalid_loss: {:.4f}'.format(epoch, train_loss, valid_loss),
           file='losses')

上面这段代码会在 ./checkpoints/lmmnb/ 中创建 losses.log，其中的日志信息如下：

Epoch #001	train_loss: 18.6356	valid_loss: 21.3882
Epoch #002	train_loss: 19.1731	valid_loss: 17.8482
Epoch #003	train_loss: 19.6756	valid_loss: 19.1418
Epoch #004	train_loss: 20.0638	valid_loss: 18.3875
Epoch #005	train_loss: 18.4679	valid_loss: 19.6304
...

保存模型

和 Config 一样，传递给 tracer 的模型也需要构造成 torchtracer.data.Model。

tracer.store(Model(model), file='somename')

如果不指定 file，则模型名缺省为 model。

上面这段代码会在 ./checkpoints/lmmnb/ 中创建两个文件：

• 模型结构描述文件 somename.txt

Sequential(
  (0): Linear(in_features=1, out_features=6, bias=True)
  (1): ReLU()
  (2): Linear(in_features=6, out_features=12, bias=True)
  (3): ReLU()
  (4): Linear(in_features=12, out_features=12, bias=True)
  (5): ReLU()
  (6): Linear(in_features=12, out_features=1, bias=True)
)

• 模型参数文件 somename.pth

保存 matplotlib 图像

训练过程中产生的 matplotlib 图像，我们也希望合理地、有结构地保存下来。使用 tracer.store(figure, file) 在 images 目录下保存图片。

# assume that `train_losses` and `valid_losses` are lists of losses. 
# create figure manually.
plt.plot(train_losses, label='train loss', c='b')
plt.plot(valid_losses, label='valid loss', c='r')
plt.title('Demo Learning on SQRT')
plt.legend()
# save figure. remember to call `plt.gcf()`
tracer.store(plt.gcf(), 'losses.png')

上面这段代码会在 ./checkpoints/lmmnb/images/ 中产生一个 losses.png，表达了 loss 变化曲线。

训练进度条

在训练开始前，使用 tracer.epoch_bar_init(total) 初始化进度条。

tracer.epoch_bar_init(epoch_n)

在训练过程中，使用 tracer.epoch_bar.update(n, **param) 方法来更新进度条和进度条之后的参数。

# this runs in the end of each epoch.
tracer.epoch_bar.update(train_loss=train_loss, valid_loss=train_loss)

Tracer start at /home/oidiotlin/projects/torchtracer/checkpoints
Tracer attached with task: lmmnb
Epoch: 100%|█████████| 120/120 [00:02<00:00, 41.75it/s, train_loss=0.417, valid_loss=0.417]

最后，千万别忘了关闭 progress bar：tracer.epoch_bar.close()

最后

如果你使用了我的 torchtracer，并有什么新的需求/意见/建议，欢迎提交 Issue。当然，也欢迎 Star。万分感谢。

什么是 Travis？

Travis 是一个在线的软件持续集成服务，与 GitHub 之间有着良好的协同关系。

这篇记录将会以 mdzz-web 这个 vuejs 项目举例。

vuejs 项目的手动部署

如果不用 travis，对于一个 vuejs 项目来说，大概有这两种部署方式：

开发环境打包

在开发机上打包出静态文件，再将 dist 上传到生产环境。

npm install
npm run build
rsync ./dist/* <USERNAME>@<HOST>:<TARGET-PATH>

生产环境打包

在生产环境中拉取仓库，打包，再拷贝到目标路径。

npm install
npm run build
cp ./dist/* <TARGET-PATH>

这样做并不复杂，但是想让集成过程更加自动化（比如自动测试），也为了让其他同学更好地贡献代码，还是决定上 travis。

使用 travis 进行 CI/CD

在 travis 中同步 github 仓库

在 travis 主页中，点击 sync now，以同步 github 中的仓库。同时，你也要在 github 中给 travis 设置可访问的仓库有哪些。

在仓库中添加 .travis.yml

你需要在仓库的根目录下新建一个 .travis.yml 来告知 travis CI 的相关配置。在本例中，我们要将项目部署到 gz.oidiotlin.com，且仅对 master 分支上的 commit 做集成，例如：

language: node_js
node_js: stable
branches:
  only:
  - master
addons:
  ssh_known_hosts:
  - gz.oidiotlin.com
install:
- npm install
script:
- npm run build
after_success:
- rsync -az --delete ./dist/* travis@gz.oidiotlin.com:/var/www/mdzz-web/

SSH 卡住了？

如果仅仅是像上面那样配置的话，travis build 的时候会卡住。因为 rsync 工具需要输入 ssh 登录密码，而在 travis build 环境里，我们根本无法输入密码。

使用 ssh-keygen

自然，我们希望不需要输入密码就能登录 gz.oidiotlin.com，这里使用 ssh-keygen 工具产生公/私钥

被逗哥(@Hustcw)安利了一波 CTF 赛，作为萌新我决定找点题目练练手。

什么是 CTF？

CTF（Capture The Flag）中文一般译作夺旗赛，在网络安全领域中指的是网络安全技术人员之间进行技术竞技的一种比赛形式。其大致流程是，参赛团队之间通过进行攻防对抗、程序分析等形式，率先从主办方给出的比赛环境中得到一串具有一定格式的字符串或其他内容，并将其提交给主办方，从而夺得分数。

CTF 主要分为3类比赛模式：
一、解题模式（Jeopardy）
在解题模式CTF赛制中，参赛队伍可以通过互联网或者现场网络参与，这种模式的CTF竞赛与ACM编程竞赛、信息学奥赛比较类似，以解决网络安全技术挑战题目的分值和时间来排名，通常用于在线选拔赛。题目主要包含逆向、漏洞挖掘与利用、Web渗透、密码、取证、隐写、安全编程等类别。
二、攻防模式（Attack-Defense）
在攻防模式CTF赛制中，参赛队伍在网络空间互相进行攻击和防守，挖掘网络服务漏洞并攻击对手服务来得分，修补自身服务漏洞进行防御来避免丢分。攻防模式CTF赛制可以实时通过得分反映出比赛情况，最终也以得分直接分出胜负，是一种竞争激烈，具有很强观赏性和高度透明性的网络安全赛制。在这种赛制中，不仅仅是比参赛队员的智力和技术，也比体力（因为比赛一般都会持续48小时及以上），同时也比团队之间的分工配合与合作。
三、混合模式（Mix）
结合了解题模式与攻防模式的CTF赛制，比如参赛队伍通过解题可以获取一些初始分数，然后通过攻防对抗进行得分增减的零和游戏，最终以得分高低分出胜负。采用混合模式CTF赛制的典型代表如iCTF国际CTF竞赛。

上手题

萌新当然选择解题模式上手啦。找到了一个入门网站 ctflearn.com，特意 随便选了几道 Easy 的题目试试。

Problem A - Basic Injection

传送门： https://ctflearn.com/problems/88

题目给了一个简单的网页 https://web.ctflearn.com/web4/ ，要求我们拖库。

检查 html 文件，发现 input 栏上有注释：

于是我随便试了几个名字，发现查询 Luke 时，会展示 data：

因为这是一道简单题，我猜测很可能通过很简单的 SQL注入 的方式就能拖库，于是键入 ' or '1'='1。（后台很可能就是一条 SQL:

SELECT * FROM users WHERE name = 'SOMENAME_KEYIN'

果然，注入成功。Flag 为 th4t_is_why_you_n33d_to_sanitiz3_inputs

Problem B - FORENSICS 101

传送门： https://ctflearn.com/problems/96

题目给了一个图像文件：

要从二进制文件里取到 Flag，我立马用 python 将图片文件以二进制读入，然后查询其中是不是夹带了 Flag。

果然夹带了 flag！

Problem C - Taking Ls

传送门： https://ctflearn.com/problems/103

题目给了一个 zip 包 The Flag.zip，使用 unzip 解压时发现里面有个隐藏文件夹 .ThePassword，内含 ThePassword.txt，查看此文件发现一份密码 Im The Flag.

The Flag/ 下还有一个 pdf 文件，需要密码打开，输入上一步中得到的密码就行啦。

Problem D - WIKIPEDIA

传送门： https://ctflearn.com/problems/168

题目没有给定任何文件，只给了两个关键字 WIKIPEDIA 和 128.125.52.138。

于是上 WIKIPEDIA 搜索这个 ip，得到以下结果：

发现在词条 Flag 下有一个 diff 来源于 128.125.52.138，查看这个 diff 的详情：

得到 FLAG{cNi76bV2IVERlh97hP}！

什么是 numpy-100？

numpy-100 是一个练习集，来源于 numpy 的邮件列表、stackoverflow 以及 numpy 的官方文档。其目的是为了给新手（如果老玩家也需要的话）提供方便快捷的查询及相关练习。

开始做题吧

1. 导入 numpy 包并命名为 np (★☆☆)

import numpy as np

2. 查看 numpy 版本及配置信息 (★☆☆)

print(np.__version__)
np.show_config()

3. 建立一个 10 维的零向量 (★☆☆)

x = np.zeros(10)
print(x)

4. 获取某个 ndarray 占用的内存大小 (★☆☆)

x = np.zeros((10, 8))
print('{0} bytes'.format(x.size * x.itemsize))

5. 如何在命令行中获取 numpy 中某个函数的帮助文档 (★☆☆)

python -c "import numpy as np; np.info(np.add)"

6. 建立一个 10 维的零向量，并将其第 5 维的数设为 1 (★☆☆)

x = np.zeros(10)
x[5] = 1
print(x)

7. 建立一个向量 [10, 11, ..., 49] (★☆☆)

x = np.arange(10, 50)
print(x)

8. 翻转一个向量（首尾交换）(★☆☆)

x = np.arange(50)
x = x[::-1]
print(x)

9. 建立一个 3×3 的矩阵，值为 [0, 8] (★☆☆)

```python
x = np.arange(9).reshape(3, 3)
print(x)

10. 找出 [1,2,0,0,4,0] 中所有非零数的下标 (★☆☆)

idx = np.nonzero([1,2,0,0,4,0])
print(idx)

11. 建立一个 3×3 的单位矩阵 (★☆☆)

x = np.eye(3)
print(x)

12. 建立一个 3×3×3 的随机数组 (★☆☆)

x = np.random.random((3,3,3))
print(x)

13. 建立一个 10×10 的随机矩阵，并找出其中的最大值和最小值 (★☆☆)

x = np.random.random((10,10))
xmin, xmax = x.min(), x.max()
print(xmin, xmax)

14. 建立一个 30 维的随机向量，并计算均值 (★☆☆)

x = np.random.random(30)
xmean = x.mean()
print(xmean)

15. 建立一个矩阵，最外层为 1，内部用 0 填充 (★☆☆)

x = np.ones((10,10))
x[1:-1, 1:-1] = 0
print(x)

16. 为某个数组添加 padding (★☆☆)

x = np.random.random((5,5))
x = np.pad(x, pad_width=1, mode='constant', constant_values=0)
print(x)

17. 下列表达式的值是什么？(★☆☆)

print(0 * np.nan)                 # nan
print(np.nan == np.nan)           # False
print(np.inf > np.nan)            # False
print(np.nan - np.nan)            # nan
print(0.3 == 3 * 0.1)             # False

18. 建立一个 5×5 的零矩阵，对角线下方的值为 1,2,3,4 (★☆☆)

x = np.diag(np.arange(1,5), k=-1)
print(x)

19. 建立一个 0-1 矩阵，按国际象棋棋盘一样交错分布 (★☆☆)

x = np.zeros((13,13))
x[1::2, ::2] = 1
x[::2, 1::2] = 1
print(x)

20. 在一个 6×7×8 的数组中，第 100 个数的下标 (x,y,z) 是多少？(★☆☆)

print(np.unravel_index(99, (6,7,8)))

21. 用 np.tile() 建立一个按国际象棋棋盘一样交错分布的 0-1 矩阵 (★☆☆)

x = np.tile(np.array([0,1],[1,0]), (4,4))

22. 归一化一个随机矩阵 (★☆☆)

x = np.random.random((5,5))
xmin, xmax = x.min(), x.max()
x = (x-xmin)/(xmax-xmin)
print(x)

23. 创建一个自定义的 dtype，表示 RGBA 颜色 (4 unsigned bytes) (★☆☆)

rgba_color = np.dtype([("r", np.ubyte, 1),
                       ("g", np.ubyte, 1),
                       ("b", np.ubyte, 1),
                       ("a", np.ubyte, 1)])
print(rgba_color)

24. 计算矩阵乘积 (★☆☆)

print(np.dot(np.ones((5,3)), np.ones((3,2))))   # solution A
print(np.ones((4,3)) @ np.ones((3,2)))          # solution B in python35 and later

25. 将向量中所有处于 [3,8] 区间内的数取其相反数 (★☆☆)

x = np.arange(16)
x[(3 <= x) & (x <= 8)] *= -1
print(x)

26. 以下程序会输出什么？(★☆☆)

print(sum(range(5),-1))      # 9
from numpy import *          # import numpy.sum
print(sum(range(5),-1))      # 10

27. 如果 x 是个整型向量，那么以下哪些表达式是合法的？(★☆☆)

x**x             # legal
2 << x >> 2      # illegal
x <- x           # legal
1j*x             # legal
x/1/1            # legal
x<x>x            # illegal

28. 以下表达式的结果是？(★☆☆)

print(np.array(0) / np.array(0))                        # nan
print(np.array(0) // np.array(0))                       # 0
print(np.array([np.nan]).astype(int).astype(float))     # [-9.22337204e+18]

29. 如何四舍五入？(★☆☆)

x = np.random.uniform(-10,+10,10)
print (np.copysign(np.ceil(np.abs(x)), x))

30. 找到两个数组中公有的数 (★☆☆)

x1 = np.random.randint(0,10,10)
x2 = np.random.randint(0,10,10)
print(x1,x2)
print(np.intersect1d(x1,x2))

31. 如何关闭 numpy 的警告？(★☆☆)

with np.errstate(divide='ignore'):
    x = np.ones(1) / 0

32. 这个表达式为 True 吗？(★☆☆)

np.sqrt(-1) == np.emath.sqrt(-1)        # False

33. 如何获取昨天、今天、明天的日期？(★☆☆)

yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')
today     = np.datetime64('today', 'D')
tomorrow  = np.datetime64('today', 'D') + np.timedelta64(1, 'D')

34. 如何获得 2018 年 8 月的所有日期？(★★☆)

dates = np.arange('2018-08', '2018-09', dtype='datetime64[D]')
print(dates)

35. 如何即时计算（无需拷贝地）\((a+b)\cdot(-a/2)\) ? (★★☆)

a = np.random.random(3)
b = np.random.random(3)
np.add(a, b, out=b)
np.negative(a, out=a)
np.divide(a, 2, out=a)
np.multiply(a, b, out=a)
print(a)

36. 为一个随机向量取其整数部分（5种方法）(★★☆)

x = np.random.random(6) * 10
print(x)
print(x - x%1)
print(np.floor(x))
print(np.ceil(x) - 1)
print(x.astype(int))
print(np.trunc(x))

37. 创建一个 5 阶矩阵，每行上的数值都是 0 到 4 (★★☆)

x = np.zeros((5,5))
x += np.arange(5)
print(x)

38. 使用生成器（generator）创建一个向量 (★☆☆)

def gen():
    for i in range(10):
        yield i

x = np.fromiter(gen(), dtype=int, count=-1)
print(x)

39. 创建一个 10 维向量，均分区间 \((0, 1)\) 上 (★★☆)

x = np.linspace(0, 1, 11, endpoint=False)[1:]
print(x)

40. 创建 10 维随机向量，并升序排序 (★★☆)

x = np.random.random(10)
x.sort()
print(x)

41. 当 darray 很小的时候，如何更快地求和？（比 np.sum 快）(★★☆)

x = np.random.random(5)
print(np.add.reduce(x))

42. 对于两个随机向量，判断其是否相等 (★★☆)

# x = np.random.randint(0, 2, 5)
# y = np.random.randint(0, 2, 5)
x = np.array([1,2,3,4,5, 5.999999])
y = np.array([1,2,3,4,5,6])
print(np.allclose(x, y))        # True, 允许误差
print(np.array_equal(x, y))     # False, 不允许误差

43. 使一个数组只读 (★★☆)

x = np.random.random(6)
x.flags.writeable = False
x[0] = 0

44. 有一个 10×2 的矩阵，保存了 10 个笛卡尔坐标，把它们转化成极坐标 (★★☆)

cardesian = np.random.random((10, 2))
x, y = cardesian[:, 0], cardesian[:, 1]
rho = np.sqrt(x**2 + y**2)
theta = np.arctan2(y, x)
polar = np.dstack((rho, theta))[0]
print(polar)

45. 把数组中最大的那个数替换为 0 (★★☆)

x = np.random.random(10)
x[x.argmax()] = 0
print(x)

46. 创建一个结构化数组，其 x 和 y 坐标覆盖 \([0,1]\times [0,1]\) 区域 (★★☆)

coordinates = np.zeros((11, 11), [('x', float), ('y', float)])
coordinates['x'], coordinates['y'] = np.meshgrid(np.linspace(0, 1, 11),
                                                 np.linspace(0, 1, 11))
print(coordinates)

47. 已知两个向量 \(\vec{x}, \vec{y}\)，求它们的柯西矩阵 \(\bf{C}\) (\(\bf{C}_{ij} = \frac{1}{x_i - y_j}\)) (★★☆)

x = np.random.random(10)
y = np.random.random(10)
C = 1.0 / np.subtract.outer(x, y)
print(C)

48. 查询各个 dtype 的最大最小值以及精度 (★★☆)

for dtype in [np.int8, np.int32, np.int64]:
    print(dtype)
    print(np.iinfo(dtype).min)
    print(np.iinfo(dtype).max)
for dtype in [np.float32, np.float64]:
    print(dtype)
    print(np.finfo(dtype).min)
    print(np.finfo(dtype).max)
    print(np.finfo(dtype).eps)

49. 打印整个 darray (★★☆)

np.set_printoptions(threshold=np.nan)
x = np.ones((32,32))
print(x)

50. 找到数组中最接近给定 key 的数 (★★☆)

x = np.random.randint(20, size=(20))
print(x)
key = np.random.uniform(0, 20)
print(key)
idx = np.abs(key-x).argmin()
print(x[idx])

51. 创建一个结构化的数组表示坐标 (x,y) 和颜色 (r,g,b) (★★☆)

foo = np.zeros(10, [('coordinate', [('x', float, 1),
                                    ('y', float, 1)]),
                    ('color', [('r', float, 1),
                               ('g', float, 1),
                               ('b', float, 1)])])
print(foo)

52. 给定一个随机 (100×2) 的数据，表示平面上的 100 个点，求它们之间的距离。 (★★☆)

Z = np.random.random((10,2))
X,Y = np.atleast_2d(Z[:,0], Z[:,1])
D = np.sqrt( (X-X.T)**2 + (Y-Y.T)**2)
print(D)

# Much faster with scipy
import scipy
# Thanks Gavin Heverly-Coulson (#issue 1)
import scipy.spatial

Z = np.random.random((10,2))
D = scipy.spatial.distance.cdist(Z,Z)
print(D)

53. 将 float32 的数组 in place 地转化成 int32 的数组。

x = np.random.random((2,3), dtype=np.float32)
x = x.astype(np.int32, copy=False)
print(x)

54. 如何读入以下文件？(★★☆)

from io import StringIO
# Fake file
s = StringIO("""1, 2, 3, 4, 5\n
                6,  ,  , 7, 8\n
                 ,  , 9,10,11\n""")
                 
# solution
x = np.genfromtext(s, delimiter=',', dtype=np.int)

Continue...

示例系统环境

• Fedora 27
• x86_64

你需要准备

• 下载 StarUML ，这里以 StarUML-v2.8.1-64-bit.deb 为例。
• 下载 libgcrypt。

安装 StarUML

解压 deb

ar vx ./StarUML-v2.8.1-64-bit.deb
tar -xf ./data.tar.xz

解决一些依赖问题

sudo dnf install binutils systemd-libs
rpm -Uvh libgcrypt11-1.4.4-5.1.x86_64.rpm

如果不存在 /usr/lib64/libudev.so.0，那么做一个链接：

sudo ln -s /usr/lib64/libudev.so.1 /usr/lib64/libudev.so.0

拷贝文件

sudo cp -rf opt/staruml/ /opt/
sudo cp -rf usr/share/doc/staruml/ /usr/share/doc/
sudo cp -rf usr/share/icons/hicolor/ /usr/share/icons/

创建启动符号链接

sudo ln -s /opt/staruml/staruml /usr/bin

创建启动图标

在 /usr/share/applications 目录下创建文件 StarUML.desktop，向其写入：

[Desktop Entry]
Name=StarUml
Comment=Uml Modeling tool
TryExec=/usr/bin/staruml
Exec=/usr/bin/staruml
Icon=/opt/staruml/appshell256.png
Type=Application
Categories=Development;GNOME;GTK
StartupNotify=true

至此为止，已经可以在桌面应用中找到 StarUML 并启动它了。

开始破解吧！

安装成功后，修改 StarUML/www/license/node/LicenseManagerDomain.js。

修改其中的 validate(PK, name, product, licenseKey) 函数， 并保存文件：

function validate(PK, name, product, licenseKey) {
    return {
        name: "OIdiotLin",
        product: "StarUML",
        licenseType: "vip",
        quantity: "unlimited",
        licenseKey: "lmmnb!!!"
    }
}

打开 StarUML，在 Help > Enter License... 中输入 name 和 licenseKey （如本例中的 "OIdiotLin" 和 "lmmnb!!!"）。

注册成功，结束操作。

目录

• 图片文件在同一目录下
• 图片文件在不同目录下

通常情况下，待处理的图片数据有两种存放方式：

• 所有图片在同一目录下，另有一份文本文件记录了标签。
• 不同标签的图片放在不同目录下，文件夹名就是标签。

对于这两种情况，我们有不同的解决方法。

图片文件在同一目录下

假设在 ./data/ 目录下有所需的所有的图片，以及一份标记了图片标签的文本文件（列为图片路径+标签）./labels.txt

./data/IZvVCYcuOkcu6Ufj.jpg 0
./data/2wuPp4yYoc2wJbZI.jpg 0
./data/vzlBbG4Z1KKJ4P6L.jpg 1
./data/nR8VZBPbjF92wNGC.jpg 2
......

思路是继承 torch.utils.data.Dataset，并重点重写其 __getitem__ 方法，示例代码如下：

class CustomDataset(Dataset):
    def __init__(self, label_file_path):
        with open(label_file_path, 'r') as f:
            # (image_path(str), image_label(str))
            self.imgs = list(map(lambda line: line.strip().split(' '), f))
    
    def __getitem__(self, index):
        path, label = self.imgs[index]
        img = transforms.Compose([transforms.Scale(224),
                                  transforms.CenterCrop(224),
                                  transforms.ToTensor(),])(Image.open(path).convert('RGB'))
        label = int(label)
        return img, label
    
    def __len__(self):
        return len(self.imgs)

dataset = CustomDataset('./labels.txt')
loader = DataLoader(dataset, batch_size=64, shuffle=True)

至此，可以用 enumerate(loader) 的方式迭代数据了。需要注意的是，在 __getitem__ 时要确保 batch 内图片尺寸相同（上面的例子用了 Scale+CenterCrop 的方法），否则会出现 RuntimeError: inconsistent tensor sizes at ... 的错误。

图片文件在不同目录下

当图片文件依据 label 处于不同文件下时，如：

─── data
    ├── 虾饺
    │   ├── 00856315f0df13536183d8ae6cbaf8d6a54f37ce.jpg
    │   └── 00ce9dccdf9a218d3b891e006c81f8e66524b1b3.jpg
    ├── 八宝粥
    │   ├── 055133235f649411e599ce5dba83627d58996209.jpg
    │   └── 0a72473884cb6c03191ca929a9aa0b2bbe4abb3d.jpg
    └── 钵仔糕
        ├── 1237b1e7b7e7da0ac78f9e1c8317b9462fe92803.jpg
        └── 14a7d6c1a881d1dcfe855bf783064ad2c9d5aba4.jpg

此时我们可以利用 torchvision.datasets.ImageFolder 来直接构造出 dataset，代码如下：

dataset = ImageFolder(path)
loader = DataLoader(dataset)

ImageFolder 会将目录中的文件夹名自动转化成序列，那么 loader 载入时，标签就是整数序列了。

目录

• 传统 CNN 的弊端
• SPP-Net 概述
• SPP-Net 结构细节
• SPP-Net 训练方法
• 在 pytorch 框架中实现 SPP

参考论文：Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition

传统 CNN 的弊端

在传统 CNN 中，由于 Fully-Connected 层的存在，输入图像的尺寸受到了严格限制。通常情况下，我们需要对原始图片进行**裁剪（crop）或变形（warp）**的操作来调整其尺寸使其适配于 CNN。然而裁剪过的图片可能包含不了所需的所有信息，而改变纵横比的变形操作也可能会使关键部分产生非期望的形变。由于图片内容的丢失或失真，模型的准确度会受到很大的影响。

上图中分别表现了两种 resize 的方法：裁剪（左）、变形（右）。它们对原图都造成了非期望的影响。

SPP-Net 概述

从 CNN 的结构来看，我们需要让图像在进入 FC 层前就将尺度固定到指定大小。通过修改卷积层或池化层参数可以改变图片大小，其中池化层不具有学习功能，其参数不会随着训练过程变化，自然而然承担起改变 spatial size 的工作。我们在第一个 FC 层前加入一个特殊的池化层，其参数是随着输入大小而成比例变化的。

图1. 使用 crop 或 warp 方法的 CNN 的层级结构。图2. 在卷积层与第一个全连接层之间加入 SPP 层。

SPP-Net 中有若干个并行的池化层，将卷积层的结果 \([w\times h\times d]\) 池化成 \([1\times 1],[2\times 2], [4\times 4], \cdots\) 的一层层结果，再将其所有结果与 FC 层相连。

当输入为任意大小的图片时，我们可以随意进行卷积、池化，在 FC 层之前，通过 SPP 层，将图片抽象出固定大小的特征（即多尺度特征下的固定特征向量抽取）。

SPP-Net 结构细节

结构如上所示，已知输入 conv5 的大小是 \([w\times h\times d]\)，SPP 中某一层输出结果大小为 \([n\times n\times d]\)，那么如何设定该层的参数呢？

• 感受野大小 \([w_r\times h_r]\)：\(w_r = \lceil\frac{w}{n}\rceil\)，\(h_r = \lceil\frac{h}{n}\rceil\)
• 步长 \((s_w, s_h)\)：\(s_w = \lfloor\frac{w}{n}\rfloor\)，\(s_h = \lfloor\frac{h}{n}\rfloor\)

假设输入是 \([30\times 42\times 256]\)，对于 SPP 中 \([4\times 4]\) 的层而言，其：

• 感受野大小应为 \([\lceil\frac{30}{4}\rceil\times \lceil\frac{42}{4}\rceil] = [8\times 11]\)
• 步长应为 \((\lfloor\frac{30}{4}\rfloor, \lfloor\frac{42}{4}\rfloor) = (7, 10)\)

最后再将 SPP 中所有层的池化结果（池化操作通常是取感受野内的 max）变成 1 维向量，并与 FC 层中的神经元连接。

如上图中的 SPP 有三层(\([1\times 1],[2\times 2],[4\times 4]\))，则通过 SPP 后的特征有 \( (1+4+16)\times 256\) 个。

SPP-Net 训练方法

虽然使用了 SPP，理论上可以直接用变尺度的图像集作为输入进行训练，但是常用的一些框架（如 CUDA-convnet、Caffe等）在底层实现中更适合固定尺寸的计算（效率更高）。原论文中提及了两种训练方法：

• Single-Size：将所有的图片固定到同一尺度。
• Multi-Size：将原图片通过 crop 得到某一尺度 A，再把 A 通过 warp 放缩成更小的尺寸 B。之后用 A 尺度训练一个 epoch，再用 B 尺度训练一个 epoch，交替迭代。

由何凯明等人的实验结果可以发现，采用 Multi-Size 方法训练得到的模型错误率更低，且收敛速度更快。

在 pytorch 框架中实现 SPP

class SpatialPyramidPool2D(nn.Module):
    """
    Args:
        out_side (tuple): Length of side in the pooling results of each pyramid layer. 
    
    Inputs:
        - `input`: the input Tensor to invert ([batch, channel, width, height])
    """
    def __init__(self, out_side):
        super(SpatialPyramidPool2D, self).__init__()
        self.out_side = out_side
    
    def forward(self, x):
        out = None
        for n in self.out_side:
            w_r, h_r = map(lambda s: math.ceil(s/n), x.size()[2:])    # Receptive Field Size
            s_w, s_h = map(lambda s: math.floor(s/n), x.size()[2:])   # Stride
            max_pool = nn.MaxPool2d(kernel_size=(w_r, h_r), stride=(s_w, s_h))
            y = max_pool(x)
            if out is None:
                out = y.view(y.size()[0], -1)
            else:
                out = torch.cat((out, y.view(y.size()[0], -1)), 1)
        return out

可以在模型中插入该模块，如：

nn.Sequential(
    nn.Conv2d(
        in_channels=1,
        out_channels=16,
        kernel_size=5,
        stride=1,
        padding=2,
    ),
    nn.ReLU(),
    SpatialPyramidPool2D(out_side=(1,2,4))
)

目录

• CNN 结构概述
• ConvNet 用到的各种网络层
  • Convolutional Layer 卷积层
  • Pooling Layer 池化层
  • Fully-Connected Layer 全连接层
• ConvNet 常见架构
  • 层级结构
  • 层内大小参数

*以下所有图片援引自 Stanford CS231n

CNN 结构概述

传统神经网络模型不能很好适应整张2维图片。比如一张 32×32×3(长32-宽32-RGB) 的彩色图片，在传统模型中第一层输入为了读入整张图片就需要 32×32×3 = 3072 个神经元，也就是有 3027 组参数，在这个简单的小图数据集（比如 CIFAR-10）好像看上去还能接受，但是一旦图片变成 200×200 的分辨率，就有 120,000 组参数了，这显然是训练时难以接受的。

不同于传统神经网络中的每一层都是一维，CNN 中每层是三维的：width, height, depth. 那么刚才提到的 32×32×3 的 CIFAR-10 图片在 CNN 中的输入层就是 32×32×3 的，而下一层中的每个神经元都是由上一层中的一块区域传递而来（这就和传统模型的全连接不同了）。最后一层输出层则是 1×10，表示着 10 种分类的 score。

左图中是三层的全连接型神经网络。右图是 CNN，红色层是原始图片，层与层之间做了一个 3D 到 3D 的映射。

ConvNet 用到的各种网络层

通过上面的概述，简单的 ConvNet 其实就是一组网络层序列，其中主要用到的类型有：卷积层(Convolutional Layer), 池化层(Pooling Layer), 全连接层(Fully-Connected Layer)。这些层堆叠在一起就构成了简单的 ConvNet。

拿 CIFAR-10 作数据集的模型为例，一个比较简单的模型的架构是【输入-卷积-ReLU-池化-全连接】：

• 输入层 [32×32×3] 是原始图像，长32，宽32，有3个色彩通道。
• 卷积层中每一个卷积核与输入层中的区域作点积，如果我们用8个卷积核，那么得到的结果就是 [32×32×8]。
• 激活层采用 ReLU 函数，它不会改变卷积的大小，结果依然是 [32×32×8]。
• 池化层进行了一个下采样操作，它不会改变深度，但是长与宽因为采样操作被缩小了，结果变成了 [16×16×8]。
• 全连接层用来计算结果，其中的每一个神经元都会与上层中的所有神经元相连，在 CIFAR-10 中，其结果变成了 [1×10]，表达了每种分类的置信度。

所以，通过一层层的计算，CNN 将输入的图像转换成了我们需要的 class score。值得注意的是，其中有的层是携带参数的（如卷积层、全连接层），而有的是没有参数的（激活层、池化层）

以上是一个简单的 ConvNet，有着 [((Conv+ReLU)×2+Pool)×3+FC] 的结构，是一种小型的 VGG Net。这里由于3D卷积不好表示，就将深度切分成 10 张图片了。

Convolutional Layer 卷积层

卷积层里的参数其实是一组可学习的卷积核/过滤器(filter)，每个卷积核贯穿了输入层的深度，比如一个 ConvNet 第一层的 5×5×3 的卷积核就代表着其宽高均为 5，且深度为 3（即输入的原始图像的 3 个颜色通道）。在前向传播过程中，卷积核沿着图像的长与宽进行扫描，将每个扫描区域的像素点与卷积核中的相应位置参数进行点积，得到平面大小不变，深度变为 1 的点积结果，即一个二维图，表示着该卷积核对每个位置的响应。最后把每个卷积核对输入层的卷积结果沿着深度维度堆叠到一起，构成了一个三维的结果。

举个例子，输入层是一张 [32×32×3] 的图片，如果卷积核的大小(filter size/receptive field)是 5×5，那么它就有 5×5×3=75 个参数（这里不算 bias）。如果第一层卷积层有 8 个卷积核，那么最后的结果就是 [32×32×8]。

左图中的红色块是输入的原始图片 [32×32×3](CIFAR-10)，卷积层中有 5 个卷积核，得到的蓝色结果就是 [32×32×5]。右图表示的是卷积核与卷积区域之间的计算方式，这与经典神经元并无二致，只是现在的连通区域被限定在了一个固定的大小（卷积核大小）里。

卷积层结果的大小与以下三个超参数有关：卷积核个数(depth)，步长(stride)，零填充(zero-padding)。

• 卷积核个数决定了输出结果的深度，每一个深度上的神经元对原图都有着不同的相应（可能是边缘朝向，也可能是色彩偏好）。
• 步长指的是卷积核在输入上每次移动的距离。当步长为 1 时，每次移动 1 个像素，得到的结果和输入一样大（宽高）；当步长大于 1 时，得到的结果比输入小；当步长小于 1 时，得到的结果比输入大。
• 零填充指的是某些时候我们要在原图周围填充一些 0，这能方便我们调节平面的大小（通常遇到的情况是用这种方法使输入图片变成宽高相等）。

假设输入的大小是 \(W\)，卷积核大小是 \(F\)，步长为 \(S\)，零填充的大小为 \(P\)。则输出的大小是 \((W-F+2P)/S+1\)。例如输入为 7×7，卷积核大小为 3×3，步长为 1，零填充为 0 时，输出就是 5×5，步长为 2 时，输出就是 3×3。

上图讨论了输入为 5×1，卷积核大小为 3，零填充为 1 时的情况。左图是步长为 1 时，结果为 5×1，中图是步长为 2 时，结果为 3×1。最右侧的图是卷积核内部参数（无 bias）。灰色是输入层，黄色是卷积层结果。

在上面的例子中（左图），输入大小是 5，输出大小恰好也是 5，这是我们喜欢的结果。如果没有零填充的话，输出大小将会变为 3。简单推导出步长为 1 时，让输出与输入大小相等的公式：\(P=\frac{F-1}{2}\)。这是一个非常常用的技巧，之后会讨论到其中的细节。

步长其实也是有限制的，对于一个大小为 10 的输入和大小为 3 的卷积核，如果步长为 2 就会出现输出大小为 \((W-F+2P)/2+1=4.5\) 的情况，这显然是不合法的。一些深度学习的框架里会对步长做检查，此时就会抛出异常。

接下来看一个例子（点击 toggle movement 控制播放），图中的深度由于不好表示依然是被划分成一张张的图。输入宽 \(W=5\)，高为 \(H=5\)，深度为 \(D=3\)，零填充大小为 \(P=1\)，卷积核个数为 \(K=2\)，卷积核大小为 \(F=3\)，步长为 \(S=2\)，所以输出的平面大小为 \((W-F+2P)/S+1=3\)。

Pooling Layer 池化层

在之前的 ConvNet 结构中我们看到往往有个全连接层，为了减少参数量，我们希望最后一个卷积层用尽可能小的体积包含尽可能多的信息。如何减小卷积的体积呢？我们在卷积层之间加入池化层(Pooling Layer)，逐渐减小卷积的空间体积，这同时也会避免过拟合。对上一层输出的每一个深度切片，通过取区域最大值的方法缩减宽高，而深度依然保持不变。最常见的例子就是用 2×2 的过滤器以 2 为步长进行区域最大值选取。对于一个池化区域而言，其大小为 4，而最大值只有一个，所以 \(\frac{3}{4}\) 的值会被抛弃。更一般化来说，池化层应当：

• 输入卷积大小为 \(W_1 \times H_1 \times D_1\)
• 需要两个超参数：
  • 区域大小(spatial extent) \(F\)
  • 步长(stride) \(S\)
• 输出结果的大小为 \(W_2 \times H_2 \times D_2\)，其中：
  • \(W_2=(W_1-F)/S+1\)
  • \(H_2=(H_1-F)/S+1\)
  • \(D_2=D_1\)
• 不具有学习性，没有响应的参数
• 一般在池化层中不使用零填充

值得注意的是 \(F=2,3\), \(S=2\) 是两组经验参数，\(F\) 过大的话会对采样结果造成很不利的影响。除了最大池化层，也可以应用其他一些函数，比如取平均、取L2范数等。但是最近的研究表明，最大池化层表现更胜一筹。

池化层对输入卷积的每一个深度的切片做了一个下采样的操作。左图中输入大小为 [224×224×64]，通过大小为 2，步长为 2 的过滤器池化后，输出变成了 [112×112×64]，其深度没有发生变化。右图中是最常用的最大池化层对于一个 4×4 输入的池化过程

不使用池化层其实也能做到削减卷积大小，只要在卷积中将步长调大，自然平面大小就变小，如 VAEs, GANs 等。但池化层依然是一种主流做法，且收效甚好。

Fully-Connected Layer 全连接层

全连接层中的每一个神经元都与上一层中的所有激活结果完全连接，与经典神经网络模型差别不大，这里不再做赘述。

ConvNet 常见架构

层级结构

最为常见的层级模式就是多个 Conv-ReLU 后接 Pool，再依此重复堆叠，直到图像被转化成较小的尺寸，最后通常再自然地接入全连接层。一般而言，最为常见的 ConvNet 有着这样的结构模式：
Input → [Conv → ReLU]*N → Pool?]*M → [FC → ReLU]*K → FC

其中 * 表示重复，Pool? 表示该处池化是可选层。通常情况下，N,K应当不超过3。

层内大小参数

层内也是有部分超参数需要设置的。

输入层的大小应当能被 2 整除多次。比如 32(如 CIFAR-10), 64, 96(如 STL-10), 224(如 ImageNet Common ConvNets), 384 或 512.

卷积层的卷积核应当小。通常选择 [3×3] 或者 [5×5]（只有在最初的卷积层上才会使用更大的卷积核，如 [7×7]）。之前讨论过利用 \(P=\frac{F-1}{2}\)，使得图像大小不发生改变。

池化层负责下采样操作。通常选择 [2×2] 作为池化区域，步长设为 2。

简单的介绍就到此为止了，以下是一些常用的模型：

• LeNet.
• AlexNet.
• ZF Net.
• GoogLeNet.
• VGGNet.
• ResNet.

为什么写这篇短文

1. 最近在做一个 DL×CV 的 proj，需要大量的广东美食图片数据，刚好写一发爬虫。
2. 发现身边很多同学突然看起了 python，而上手 proj 就是写爬虫，然而网上资料纷繁复杂，纠结是用 bs 还是 scrapy。

这里的介绍非常简要，涉及深层姿势的部分请出门右拐官网。

一些背景姿势

在 bs 和 scrapy 之间做选择前，首先当然要了解他们是什么，差别何在。

• Scrapy 是一个非常成熟的工具包，你只要写很少的东西就能达到你要的效果——创建一个 spider 下载网页并提取其中有用的数据。
• BeautifulSoup 则是一个面向网页的工具，它能够解析 DOM 树并提取某些特定的节点（比如 <img>,<p> 等）。

也就是说，只用 bs 是做不了爬虫的，必须要引入 requests 之类的包用来下载网页，这样 bs 才能对网页进行解析。

所以，二者差别其实挺大的：

• Scrapy 用于从网络上下载，清洗，存储数据，而且内置了很多代码节约你的编写时间。
• 而 BeautifulSoup 仅仅只是对网页进行解析抽取。

如何选择呢？

如果你是想快速撸出一个爬虫，Scrapy 当仁不让。它已经帮你解决了大量的本该由你自己解决的问题，比如：

• 爬取的数据格式错综复杂，Scrapy 能让你用很短的代码完成数据的格式化。
• Scrapy 容错率很高，当出现服务器错误、页面未找到等错误时，你可以通过内置的 tools 轻松返回上一步，跳过或重试该处错误。
• 有的页面需要登录才能访问，Scrapy 内置了优雅的 login 工具，在 scrape 前就能处理好登录动作。
• 有的网站经常改变其布局格式，而 Scrapy 支持 Sensible Spiders，即分离出了布局格式的逻辑，使得我们不需要经常维护修改 spider 来支持变幻无常的页面。
• 有的网站限流，有时超出限定则会锁 ip。Scrapy 内置了控制流速的功能，能轻松调控爬取速度。
• Scrapy 支持多线程，同时能发出多个 requests，提升了速度。

人生苦短不如 python，既然都选择 py 了，为什么不选择用更方便的 Scrapy 呢？

当然，Scrapy 如此方便当然也意味着你的自由度下降了，如果你并不需要以上说的那些特性，如果你希望写出更加自由的爬虫，如果你要深入了解爬虫的内部结构，当然还是推荐用 bs + requests + coroutine 之类的东西慢慢折腾啦。

一时兴起，来推导一下 LSTM（Long Short Term Memory - 长短期记忆）……

LSTM 从何而来？

在处理序列型数据时，我们常常使用循环神经网络（RNN），这正是 LSTM 的前身。

最简单的 RNN

我们先从最简单的无隐层 RNN 开始。它的状态更新方程满足（\(f\) 是某激活函数）：$$\hat y_t = f(x_t*W+\hat y_{t-1}*V+b)$$

通过这种方式，每个神经元都会在计算 \(t\) 时刻输出时考虑上一个神经元得出的 \(\hat y_{t-1}\)。也就是说，在每次做决策时，该神经元都会受到上一个决策结果的影响，通过 \(t-1\) 与 \(t\) 的关系，我们也就对整个序列中的元素建立了联系。

然而事实并非如此，想想人类的在考虑序列式问题时的思维模式，假设你正在打麻将牌，对于一般的人而言，每个时刻（出牌时）都会：

1. 看看摸到了什么牌，手牌又如何。
2. 回顾之前的牌局。
3. 通过 1 和 2 分析出当前的最优策略。

第 1 步中的摸牌和看手牌视为当前时刻的输入数据 \(x_{t}\)。第 2 步中的回顾牌局就是访问记忆。而第 3 步就是通过这些信息做出决策求 \(\hat y_t\)。但是不难发现，我们访问的记忆信息不只是上一步做出的决策 \(\hat y_{t-1}\)，而是对整个牌局的回顾，即使记忆模糊却也包含了许多信息，至少，它应该是根据最近几个回合的牌局产生的抽象记忆。

携带隐层节点的经典 RNN

所谓的抽象记忆，其实就是 RNN 中的隐状态。我们可以把 \(t\) 时刻神经元的输出看作是两部分，一部分是决策 \(\hat y_t\)，另一部分就是隐状态 \(h_t\)。传递给 \(t\) 时刻的信息不再是简单的决策 \(\hat y_{t-1}\) 而已，而是历史记忆的融合 \(h_{t-1}\)。

如上图所示，这就是经典 RNN，它的状态更新满足方程（\(f,g\) 均为激活函数）：
$$ \begin{align} h_t&=g(x_{t}*U+h_{t-1}*W+b)
\\ \hat y_{t}&=f(h_{t}*V+c) \end{align}$$

这样一来，过去某一个 \(\hat y_{i}\) 可能会通过影响 \(h\) 来影响 \(y_{t}\)。

传统 RNN 的弊端

从上面的 RNN 状态更新方程不难发现，作为“历史记忆”的 \(h\) 其实是套在 \(g(\cdot)\)这个函数里的，也就是说，在误差逆传播的时候，由于求导链式法则，梯度会被表示成连积的形式，当 RNN 的长度 \(\tau\) 较长的时候，梯度从第 \(\tau\) 个神经元传至第一个时，终会弥散或是爆炸（不等于 1 的数连乘）。

这会导致什么呢？在某个时刻出现的重要事件由于时间相隔长远，可能无法对记忆造成影响。依然举麻将的例子。某一刻你摸到了一张牌，你发现可以留着这张牌用来听牌，却忘记了你要听的那张牌很久以前的回合中就已经被打完了——长远记忆丢失了。

（虽然可以用梯度截断的 trick，但还是会丢失部分长远的记忆，这里不作详细介绍）

解决梯度弥散/爆炸问题

在传统 RNN 里，梯度信息经过若干时刻后会弥散或爆炸，我们怎样才能将梯度毫无损失地传输给各个神经元呢？

从之前的讨论可以提出问题：什么梯度在经历了连续的乘积作用后依然能够有效传输呢？当然是 1 啦！也就是说，记长时记忆单元为 \(c\)，那么我们要求 \(c_t = c_{t-1}\)，即 \(\nabla c_t = 1\)。

这样就不存在什么弥散 or 爆炸的问题了，\(c\) 以某种方式包含着我们需要的信息，能把梯度反馈若干层也不会有任何损失。

长时记忆单元中的信息如何保存

其实上面说的“某种方式”才是重点，我们在最简 RNN 的基础上讨论一下这个问题。那么这个时候我们的新信息就是 \(t\) 时刻的输入 \(x_t\) 与上一时刻的输出 \(\hat y_{t-1}\) 组合后的结果，记作 \(\hat c_t\)。$$ \hat c_t = f(x_t * W, \hat y_{t-1} * V) $$

现在要做的事情是，把 \(\hat c\) 放进 \(c\) 里。由于链式求导法则，我们肯定摒弃乘法操作。

乘法操作更多的是作为一种对信息进行某种控制的操作（比如任意数与 0 相乘后直接消失，相当于关闭操作；任意数与大于 1 的数相乘后会被放大规模等），主要用于控制或者 scaling。
加法操作则是新信息叠加旧信息的操作。

我们选择用加法操作，那么此时有：$$c_t=c_{t-1}+\hat c_{t}$$

然而，每次有新信息时，我们并不是选择将所有的 \(\hat c_t\) 都添加进 \(c_t\) 里，这也和人类记忆方式是相违背的，我们没有必要将每一时刻的所有信息都放进大脑里，我们只记忆那些我们关注的东西。

如何控制记还是不记？首选乘法操作，我们在 \(\hat c_t\) 前加入一个控制器，决定我们要不要记忆新信息。那么对于单个长时记忆单元，我们有：$$c_t=c_{t-1}+g_{in} * \hat c_t$$

我们称其中的 \(g_{in}\) 为输入门，它需要在 \( [0,1]\) 上取值，通常选用 \(sigmoid(\cdot) \) 函数。

此时我们的简单网络就变成了：$$\begin{align} c_t &= c_{t-1} + g_{in}( \hat c_t) \\ \hat c_{t} &= f(x_t * W + \hat y_{t-1} * V) \\ \hat y_{t} &= f(c_{t}) \end{align}$$

现在输入门会学习该在什么时候开启以读入信息并存入记忆。

信息量巨大时会发生什么？

如果仅仅停留在当前这种架构，一定会发生某些问题，比如，当你的网络读到一段信息量巨大的文本时，输入门大开，试图记录所有的信息，也就是说，\(\hat c\) 会变得非常大。

那么问题来了，输入门我们选择的是 \(sigmoid(\cdot)\)，很显然当自变量过大时，该函数几乎完全饱和了（趋近于1），根本记不住那么多东西了。

（正向无饱和的激活函数如 ReLU 可以解决这个问题，但是会导致更多的问题）

寻找解决方法时，依然往人类身上想。我们可以记得一年前一场麻将输了一千块（拒绝赌博），也记得一天前的麻将赢了20块，大脑并没有一直只是在记东西——我们并没有顺带着记住这之间的其他所有事情，我们还忘记了一些其他的事情（比如几个月前的晚上和舍友斗地主输了一包辣条）。人的大脑是会忘事的。

我们再用一个控制门吧，用一个“遗忘门”来决定要不要忘记之前的一些不太重要的记忆，以记住新信息。

与输入门的设计思路相似，我们给上一时刻的信息添加一个控制遗忘程度的门 \(g_{forget}\)，即：$$c_t = g_{forget}(c_{t-1}) + g_{in}(\hat c_{t})$$

那么现在我们的网络就能解决新旧信息的合理记忆与遗忘问题了，这一点上已经与人类相似。

输出似乎还要再筛选一下

疯狂举例ing：你在打牌时，并不会参考上周六晚吃烧烤摊时拉了肚子这件事。人脑在处理眼前事物时，并不会将所有脑细胞的记忆都拿出来回忆一遍，我们只会选择跟当前事物相关的部分进行输出，给长时记忆单元加一个“输出门”：$$\hat y_{t}=g_{out}(f(c_t))$$

谁来控制控制门？

从当前设计来看，控制门控制了记忆和决策，但是控制门也应收到其他因素的控制。推导：

导言

之前训练了一些深度神经网络模型，几乎都会遇到过拟合的问题，调整过学习率也调整过隐层的层级和数量，但效果依然不尽人意。直到魔改别人代码的时候才发现有个 Dropout，从测试结果来看，它的确不失为一种有效且简单的办法。今天来做个小总结。

Dropout 是怎样工作的？

先来看张图，图(a)是标准的神经网络，所有的神经元都会对最终的输出作出贡献。而图(b)中部分神经元被打上了×，我们称它被 舍弃(dropout) 了。我们设置 Dropout 率为 \(p\)，当一个神经元以概率 \(p\) 被舍弃后，它的输出为 0。也就是说在训练过程中，该神经元不会对 forward 和 backward 作出任何贡献。

对于某个隐层神经元，我们把它的激活函数由 \(f(h)\) 变成 \(g(h) = f(h)\odot D\)，其中 \(D\) 是一个与 \(f(h)\) 等维的 Bernoulli 向量（参数为 \(p\)）。

工作流程

1. 在隐层神经元中以概率 \(p\) 随机选择若干个神经元进行舍弃，输入输出神经元不能舍弃。
2. 将一组 batch 的输入 \(\boldsymbol{x}\) 通过剩余网络进行 BP 训练，更新剩余网络的参数。
3. 重复上述流程。

为什么 Dropout 能这样工作？

从流程来看，应用了 Dropout 的神经网络好像进行了很玄学的训练方式，为什么这样就能解决过拟合呢？

我这里不做抽象的数学理论分析，直观上来看有以下几个方面促成了它的功能：

• 取平均：由于隐层神经元的随机抽取，每次训练的网络结构都不同，但这些不同的网络又共享着部分隐层神经元的权重，这些网络可能会产生不同程度的过拟合，但是将它们取平均之后，一些过拟合会抵消，这便达成了整体上网络的过拟合程度的减少。
• 减少共适应性：我们希望网络在做预测的时候不应该对一些特征片段太过敏感，就算是缺少某些特征，这个网络也应该从其他的特征中学习出一些有用的信息。隐层神经元随机抽取后，由于结构每次都不同，某些本来是有固定关系的隐节点之间的关系被拆散，这样一来，参数的更新就不会依赖这些固定关系，这就避免了某些特征只在其他一些特征下才有效的情况。

参考文献

• Improving neural networks by preventing co-adaptation of feature detectors, G. E. Hinton, et. al.
• Analysis of Dropout, P. Galeone's Blog

什么是 Sentiment Analysis

对于一段文本，我们希望得到这段文本体现的情感倾向——它是积极的（positive）、消极的（negative）还是中性的（neutral）。得出情感倾向的过程，我们称之为 Sentiment Analysis，有时也被称为态度挖掘（opinion mining）。这项技术最为普遍的应用就是分析评论者对某个主题的态度（比如买家评价、影评等等）。

什么是 Target Dependent

在一个情感分类任务中，如果讨论的对象是个在文本中明确出现过的词，那么我们称其为 target。举个例子：

这件衣服款式挺漂亮的，但是尺码也太小了吧！

对于“款式”这个 target，其情感倾向为 positive，而对于“尺码”这个 target，其情感倾向为 negative。
需要注意的是，target 与 aspect 不同，aspect 可能没有出现在文本之中。举个例子：

他很聪明，就是有些不懂礼貌。

这里设计到两个 aspect，一个是“智商”，另一个是“品德”，而这两个词在原句中都没有出现。

我们可以简单地认为，Target-Dependent 是 Aspect-Level 的一个子集。

一些应用到了 LSTM 的神经网络模型

由于是文本序列的处理问题，当然是少不了 RNN。这里列出了部分基于 LSTM 的模型，论文原作者在 LSTM 的基础上又提出了 Target-Dependent LSTM 和 Target-Connection LSTM。

Basic LSTM

• 对于每一个时刻，输入是 word embeddings。
• 采用最后一个时刻的 LSTM 的输出作为最终语义。

Basic Bidirectional LSTM

这种模型和 Basic LSTM 没有太大的差别，只是将 word embeddings 逆序输入给每个时刻的 LSTM。这种方式可以很好地解决重心在文本结尾或者文本开头时对情感分析的影响。举个例子：

句尾：今天中午吃了北二食堂的饭菜，真是太好吃了！

在第这句话中，“太好吃”这个情感强烈的词在整句话的末尾。

句首：真棒！可以去北二食堂吃晚饭了。

在这句话中，“真棒”这个情感强烈的词在整句话的开头。

情感重心无论是在句首还是句尾，通过双向输入的方式，就能得到较好的解决。

Target-Dependent LSTM (TD-LSTM)

• \(\text{LSTM}_L,\text{LSTM}_R\) 的输出合并起来作为最终语义。

不难发现，在 Basic LSTM 的基础上多加了一个 LSTM，TD-LSTM 拥有两个 LSTM —— \(\text{LSTM}_L,\text{LSTM}_R\)

$$ input_{L} = {w_1, w_2, \cdots, w_{r-1}}\\
input_{R} = {w_n, w_{n-1}, \cdots, w_{l+1}}$$

也就是说， \({\text{LSTM}_L}\) 的输入就是从第一个单词到最后一个 target 之间的所有词，而 \({\text{LSTM}_R}\) 的输入就是从最后一个单词到第一个 target 之间的所有词。举个例子：

我搬进了C10公寓楼，环境挺好的，就是水电供应有些讨厌。

这句话包含两个 target，一个是“环境”，一个是“水电供应”。按照之前提到的式子，\({\text{LSTM}_L}\) 的输入就应当是从“我”到“水电供应”之间的所有词，而 \({\text{LSTM}_R}\) 的输入就应当是从“讨厌”到“环境”之间的所有词。

论文作者在文中提到将 target 设为 LSTM 的最后一个时刻的输入，能更充分地利用 target 的语义信息。

We favor this strategy as we believe that regarding target string as the last unit could better utilize the semantics of target string when using the composed representation for sentiment classification.

Target-Connection LSTM (TC-LSTM)

• \(v_{target}=\overline w_{target}\)
• 在 TD-LSTM 的基础上，我们将 \(v_{target}\) 与输入端的 word embeddings 连接起来，这使得每个词都与 target word 有了更为紧密的联系。

实验结果对比

数据源自原论文。

参考文献

• Effective LSTMs for Target-Dependent Sentiment Classification[Tang. et al.]

导言

其实这篇教程是 2016 年入学的时候写的，今年迎新又一次拿了出来，希望能帮到部分学弟学妹吧。Windows 用户多，那么我只写 Windows 就好了（逃

校园网账户开通及缴费

首先要准备好开网所需的各种信息。

查看有线网卡的MAC地址

在win任务栏右击网络连接的图标，选择【打开网络和共享中心】，点击左上方的【更改适配器设置】。

找到网络连接目录里的【本地连接】或【以太网】，双击查看状态。

单击【详细信息】。

记下信息中的【物理地址】，以及上方的网卡【描述】。

查看宿舍内网络端口的编号

在寝室书桌上方有个端口，由于假期墙面装修，端口编码可能看不太清。用工具把墙灰刮下来或者看看舍友或者邻居再推测一下编号吧。注意端口编号中可能会出现大写英文字母（一定要填对端口号，不然修改的时候很麻烦！一定要填对端口号，不然修改的时候很麻烦！一定要填对端口号，不然修改的时候很麻烦！）。

入网申请

访问华南理工大学网上营业厅 ，选择【业务办理】，用统一认证账号登陆。

录入信息。

提交以后处于待审核状态，一般几分钟后如果没有问题就能通过审核。审核通过后系统还要再分配 ip，稍等（这时你可以选择去圈存机缴费办套餐，顺便还能把网线买了）。

办理套餐&缴费

绿卡：圈存机（饭堂，教学楼，教师公寓）-【自助缴费】-【学生网络缴费】。

套餐有3类：包月/包学期/包年。价格优惠不一，请各位酌情选择。在此不详述。

上网信息配置及登陆

填写ip信息

回到寝室，需要在PC上填写ip信息，才能正确连接网络（之前要买好网线啊！！！饭堂和超市都有的！！）

在【入网申请】步骤中的网页上查询个人信息，这时系统应该已经给你分配好ip地址了（没有就先去搞学习），然后插入网线，按第一步的方法找到【本地连接】或【以太网】，右击打开【属性】，双击【TCP/IPv4】，选择【使用下面的ip地址】和【使用下面的DNS服务器】，填入在【个人信息】中查询到的 ip 地址、子网掩码、默认网关，DNS 的地址就按下图的填（或者用一些公共 DNS 也行），确定。

安装入网客户端

这时应该已经正常接入校园内网了，但是我们要访问互联网还需要一个登陆客户端。

访问 http://202.38.193.65/ 下载并安装【新版认证客户端 for Windows】安装完成后，运行该客户端。登陆账号是学号，密码是身份证后8位（大写X换成小写x）。（系统同步信息大概要两三个小时，如果出现无此账号信息，请过几个小时再来登陆）。

（几小时后）登陆成功！恭喜您可以使用校园网了！

校园网使用注意事项

p.s.

有什么技术问题请联系软件学院电脑诊所（报单群QQ号：615576434），竭诚为您服务。

导言

在做 NLP 的时候，我们处理的 features 一般都是字词（words），如何表述这些字词便成为了一个非常基础且十分重要的问题。接下来要介绍的是在搭建NLP模型过程中如何用 PyTorch 这个工具对 words 进行预处理。

One-Hot有用吗？

假设我们有一组词汇\(V\)，其大小为\(|V|\)。采用独热编码（one-hot）的方式，对于单词\( w=V_{i} \)，则

$$ w=\underbrace{[0,0,\cdots,1,\cdots,0,0]}_{|V|}$$

也就是说，在词汇表 \(V\) 中，仅有一个维度的值为1，其余都是0。这种表现方式有不少问题：

• 每一个单词的维度巨大。One-Hot 编码将每一个单词视为词汇集的不同方向，那么每个单词的向量长度就取决于词汇集 \(V\) 的大小，在NLP任务中，这将会是巨大的。
• 各个单词之间没有联系。由于 One-Hot 将不同的单词直接指定到不同的方向，而且各单词之间是独立存在的，这就会导致单词在句群中的语义丢失。

对于语义联系丢失，我们举一个简单的例子，假设在训练文本中，出现了以下的句子：

• 程序员在加班。
• 产品经理在加班。
• 程序员解决了客户提出的一个问题。

而在测试文本中，出现了一个训练文本中没有出现过的句子：

• 产品经理解决了客户提出的一个问题。

正常的思维应当是“程序员”和“产品经理”有着相似性，我们希望模型也能分析出这样的相似性，然而如果用 One-Hot 编码的方法似乎无法理解“程序员”和“产品经理”有哪些相似之处（我们说的相似是语义相似，而不仅仅是拥有简单的正交表示）。

稠密的 Word Embedding

我们怎么才能把语义相似性嵌入到词向量中去呢？我们希望能在语义层面上对词向量做分解，首先肯定是摒弃掉 One-Hot 这种丢失相关性的编码方式了。依然使用之前的例子，我们对“程序员”和“产品经理”做语义层面的分解，例如“程序员”和“产品经理”都是“IT相关人员”，都会“加班”，那么它们在“IT相关人员”和“加班”语义维度上的取值就更大，而“产品经理”在“编写代码”这个语义维度上的取值就比“程序员”要小得多。

只要我们找到一些语义维度，那么每个单词就可以在这些维度上分解，形成一个词向量，比如：

$$w_{Programmer}=[4.3_{(\text{IT})},4.2_{(\text{Overtime})},4.6_{(\text{Coding})}]\\ w_{Product Manager}=[3.9_{(\text{IT})},3.6_{(\text{Overtime})},-2.3_{(\text{Coding})}]$$

通过这样的分解方式，我们就能够衡量出各个词向量之间的相似程度，比如：

$$Similarity(\text{Programmer}, \text{Product Manager})=w_{Programmer}\cdot w_{Product Manager}$$

再将其标准化：

$$Similarity(\text{Programmer}, \text{Product Manager})=\frac{w_{Programmer}\cdot w_{Product Manager}}{||w_{Programmer}||\cdot||w_{Product Manager}||}=\cos(\phi)$$

上式中的 \(\phi\) 即两个词向量的夹角，显然，两个极相似的词的 \(Similarity\) 应当趋近于1，而两个完全相反的词的 \(Similarity\) 应当趋近于-1。

通过这种在许多语义维度上进行分解的方式，对于每个单词，我们得到的是一个稠密的向量（完全不同于 One-Hot 得到的稀疏向量）

语义维度的选择与取值

从上面的分析我们可以看出按语义分解的优势所在，但是随之而来的是一个更难受的问题：如何确定在哪些语义维度上对某个单词进行分解？

如果摆在眼前的是一个词汇量巨大的文本，里面的单词可能包含方方面面（比一两个程序员和产品经理不知道高明到哪里去了），我们完全可以设定出成千上万个语义维度，而各个单词在这些维度上的取值范围更是难以调配。

这时，深度学习就可以派上用场了，让神经网络模型去学习这些分类。当然咯，如果让神经网络模型去学习这些潜在的语义维度的话，它的分类标准就不会像我们之前手写的例子那样清晰明了（至少你还知道“程序员”和“产品经理”之间还有 IT、Coding 这些语义维度），你根本不知道它会按照怎样的维度去学习，毕竟机器还是不知道某个维度究竟代表着什么意思，反正能分解就是了（玄学++）。

在 PyTorch 中使用 word embedding

由于最近实验室采用的也是 PyTorch 这个模块，那么我就用这个来讲好了。

首先要用一个以 word 为 key，id 为 value 的 lookup 顺序表，建立 word 与 index 之间的映射关系，用于查找各个单词的 id。

import torch
from torch.autograd import Variable
import torch.nn as nn

word2index = {
    "programmer": 0, 
    "product manager": 1
}

接下来我们用一个模型来跑出 "programmer" 的初始词向量，假设我们的语义维度为 8。

embedding = nn.Embedding(len(word2index), 8)
index_variable = Variable(torch.LongTensor([word2index['programmer']]))
embedded = embedding(index_variable)

embedded 即通过 nn.Embedding 初始出的词向量：

Variable containing:
-0.0148 -0.7849  1.2612  0.0015  0.9238 -1.2201  1.5755 -0.8467
[torch.FloatTensor of size 1x8]

一定要注意的是，这里的词向量是初始化出来的，并没有经过网络训练优化，因为我们没有指定优化方法，在 embedding 之后，我们还要进行其他的网络训练（比如 N-Gram 模型进行文本预测），才能给这些 enbedded word 赋予特殊的语义。

正事

2016年11月18日上午9时许，“公益进五山，便民一条街”志愿活动在五山花园社区正式启动。电脑诊所和计算机系携手摊位“电脑义诊”，作为先头部队开始架设摊位。这是进入大学以后第一次参与比较大型的志愿活动，出发的时候还是很兴奋的。

上午人不算多，电诊摊位空闲的时候我去其他摊位看了看：

维修

没有想到的是，先来报单的居然是手机故障。多数是些基础功能的使用问题。

在报名志愿活动之前，学长说主要是去鉴赏古董的。社区里多数都是老年人，甚至机型还停留在10年以前，比如下面这两台机器——其中联想-昭阳E360就是03年的机型，从布满锈迹的面板和氧化了的屏幕可见一斑。

虽然正因为是老古董，我们还是才大胆拆开了：

由于硬件老化得实在严重，缺少硬件材料支持的我们也无能为力。不过倒是涨了不少姿势。这两台机器的主人是个和蔼的大叔，带着儿子在其他摊位玩，至于古董电脑能不能修好，他也不抱什么希望，只是来碰碰运气，权当给我们涨姿势了。

除了老旧古董，其实还是有很正常的除尘工作的，下图中的机器开机几分钟就发烫，我们拆机后发现出风口已经被灰尘完全堵死，电路板上也全是灰。

由于场地电源限制，我们没有带大功率的鼓风机来，只好向隔壁摊位借来打气筒，效果也还不错啦。

尴尬的是工具箱里的硅脂用完了，我跑遍了社区附近的所有五金店却毫无收获。走投无路的我们把旧的硅脂拆开，从缝隙中强行挤出一丁点儿来勉强涂了上去。

下午收摊前还是接了一单上门维修，依然是老旧的台式机。

番外

其实今天的维修工作并没有很多，大多数时候我们都是在和社区里的老年人聊天扯谈。有一位娭毑，拿着女儿送她的新手机，问我们怎么用；甚至有位嗲嗲不是来做维修，而是专程找人聊天的。我不能否认那位女儿的孝心，但是事实确实是没有在老人身上看到应有的效果，我们希望手机、电脑能让家里的老人在我们上班养家的时候能找点乐子，却忘了什么才是真正适合老人家的，忘了什么才是真正的“养”家。面对那些老人们带来的毫无技术难度或者是技术难度突破天际的问题，我们在活动后调侃，我们不是来修电脑的，我们是来做心理疏导的，却不由得反思，究竟是哪一代需要心理疏导？