文章概览

• 区块链系统概述
• 区块链隐私问题
• 门罗币隐私保护机制

区块链系统概述

  区块链本质上相当于一个去中心化的账本数据库，以P2P网络作为通信载体，依赖密码学确定所有权和保障隐私。相对于传统的数据库，其核心特征是不可篡改。实现区块链需要解决的两个关键问题是：

• 如何组织数据以确保不被篡改，即数据结构。这里的数据结构有两层含义，一层含义是指区块内部的交易数据的组织形式，常见的组织形式包括Merkle树、Merkle Patircia树等；另一层含义是指区块与区块之间的组织形式，常见的组织形式包括链式结构（比特币）、树状结构（以太坊）、DAG图结构（IOTA）。
• 如何在分布式环境中对账本状态的更新达成共识，即共识机制。共识机制使得参与区块链系统的各个节点都可以参与到记账权的竞争当中，获得记账权的节点将会获得相应的奖励，同时系统中的节点都可以对新加入链中的区块进行验证。常见的共识机制包括Proof of work、Proof of stake等。

  以比特币为例，整个区块链系统的运行机制可以简述为：首先客户端发起一笔交易，将该交易广播至比特币网络中的任意节点，节点在收到交易后需要验证交易是否合法。如果验证不通过，节点将拒绝该交易，并向发送者返回交易被拒绝的消息；如果验证通过，节点会将该交易放入自己的交易池中，并向网络中继续传播。各节点从各自的交易池中打包交易，并通过加入随机数进行计算。最先计算出符合要求哈希值的节点打包的区块有效，即获得记账权。然后，该节点将计算得到的区块广播到区块链网络中，其他节点接收到新的区块后会进行验证。验证成功后将新区块连接到自己的链中，同时删除自己交易池中已经被打包的交易记录，重新开始新一轮的生产区块过程。

区块链隐私问题

  区块链系统中的隐私一般是指用户的身份隐私、位置隐私以及交易内容隐私，我认为造成区块链系统中的隐私问题的原因主要有三个：

• 为了鼓励更多用户参与共识，早期的区块链系统不会对加入的节点进行认证，这就为攻击者窃取隐私数据创造了机会。攻击者可以共享系统中的交易数据、嗅探网络流量，从而挖掘出关于用户的敏感信息。
• 为了增强区块链系统的拓展性，通常将其部署在开放网络环境当中。这就使得攻击者可以任意部署节点,监听网络中各节点隐私信息以及网络通信信息。相关研究表明，攻击者可以对区块链地址及 IP 地址对应关系进行分析，揭露用户与实际物理位置的对应关系。
• 为了更加高效的对交易记录进行验证，区块链系统中的交易记录通常是完全公开的，没有采取额外的保护措施。交易记录通常能够反映一些敏感信息，有可能泄露用户的隐私。例如用户购物的交易记录能够反映用户的消费水平、生活状态等。

  为了解决区块链系统中的隐私问题，以下从三个角度来对当前的防御机制进行总结：

• 对应于导致隐私问题的第一个原因，我们可以通过在区块链系统中加入节点认证机制限制恶意节点的加入。基于这一想法，研究人员提出了私有链和联盟链的架构，这些架构可以适用于对隐私需求更高的一些场景。（应用案例：Hyperledger Fabric）

• 对应于导致隐私问题的第二个原因，我们可以将区块链系统运行在具有隐私保护特性的网络上，例如Tor网络以及I2P网络。这些网络通过多层加密以及特殊的路由转发技术可以能够隐藏用户IP，防止通过网络层信息实现交易溯源。（应用案例：门罗币）

• 对应于导致隐私问题的第三个原因，我们可以在满足区块链正常运行的基础上 ，防止恶意节点获得准确的交易数据。这类技术一般包括以下三类：

  • 基于数据失真的技术：通过将交易内容的部分数据进行混淆 ，使攻击者无法获得准确的数据 ，增加分析难度。这种方案的难点在于不破坏交易结果的条件下 ，防止攻击者发现不同地址之间的交易关系，一般称为混币机制。（去中心化的混币方法CoinJoin）
  • 基于数据加密的技术：通过将交易信息加密，使攻击者无法获得具体的交易信息，从而无法开展分析，这种方案的难点在于实现加密的同时，必须保证原有的验证机制不受影响。（门罗币，Zcash）
  • 基于限制发布的技术：通过发布少量或者不发布交易数据，减少攻击者能够获得的交易数据 ，增加分析难度。（闪电网络）

门罗币隐私保护机制

  以下将以比特币为例，探讨区块链中交易内容隐私保护方法和策略。比特币采用UTXO的方式来对交易内容进行记录，交易记录如下图所示。在交易记录中包含发送方引用的UTXO、发送方的公钥、交易金额、接收方的地址以及发送方对交易内容的签名。发送发生成交易记录之后向其他节点广播，节点收到交易记录之后对其进行验证，主要验证以下内容：

• 每个被引用的输入必须有效，且未被使用过；
• 交易的签名必须与每笔输入的所有者签名匹配；
• 输入的总值必须等于或大于输出的总值。

  在比特币系统中，由于所有的交易记录都是公开的，所以节点可以高效的对交易内容进行验证，从而保证系统的正常运转。如果我们希望提高比特币系统的隐私性，势必要隐藏交易内容中的相关信息，首当其冲面临的问题就是如何实现隐私场景下的交易验证。接下来将以门罗币为例，讲解如何实现交易内容隐私保护以及如何实现隐私场景下的交易验证。

  门罗币（Monero）是一种领先的密码学货币，聚焦交易隐私安全。在一笔交易中主要涉及的隐私信息包括发送方、接收方、交易金额，门罗币使用了一系列密码学方法来隐藏所有隐私细节并阻止任何区块链跟踪。

• 隐藏交易金额：对于大多数密码学货币，交易数额以明文形式发送，任何人都可以看到。门罗币利用RingCT技术来隐藏任何交易中发送的金额。RingCT通过允许发送者证明自己有足够的金额来进行交易，而不会透露该金额的值，从而使得此敏感信息保密。这都要归功于密码学中的承诺和范围证明。当发送方发起交易时，将以一种秘密方式“承诺”该金额，仅向网络披露足够的信息以确认交易的合法性，但不会公开揭露金额本身。一个有效的承诺保证了交易不会欺骗性地创建或超支已有的金额。
• 隐藏发送方：在比特币交易记录中，发送者需要利用自己的私钥对交易进行签名，同时给出自己的公钥方便其他节点来对交易进行验证。因为交易记录中包含发送者的公钥，所以能够很方便的对发送者的交易行为进行追踪。如果我们希望隐藏发送者的身份，那就不能在交易记录中给出公钥。门罗币使用环签名来解决这一问题。在门罗币交易过程中，发送者随机选择几个用户的公钥，并将自己的公钥混入其中，构成一个集合（签名者在签名时无需集合中其他成员的协作，甚至于可以不让其他成员知晓）。发送者利用自己的私钥进行签名，同时给出集合中的公钥。当节点对该交易进行验证时，唯一知道的是该签名来自集合成员，但是无法区分是某个具体成员，从而实现了发送方的匿名性。
• 隐藏接收方：在比特币交易记录中，需要指定接收方的地址。通过对接收方的地址进行追踪，可以获得关于接收方的隐私信息。为了实现对接收方的隐私保护，门罗币使用隐形地址进行交易。每笔交易都被发送到唯一的一次性地址上，接收方可以访问发送到隐形地址的资金，而不暴露其钱包公开地址或其他交易的任何关联。

  由于在交易记录中隐藏了交易金额、发送方、接收方，这就导致节点无法对交易内容进行验证。针对上述提到的三个验证问题，门罗币提供了以下解决方案：

• 在交易过程中，发送方利用环签名技术来隐藏发送方的身份。发送方利用自身的私钥对交易进行签名，验证节点可以通过集合中的公钥对其进行验证。验证通过即证实了发送方对UTXO的所有权，因此引用的UTXO是有效的。那如何证明该UTXO未被使用过呢？门罗币通过利用每次交易生成和记录的密钥镜像来解决这一问题，这些密钥镜像是唯一地从所花费的实际输出中得出的。网络无法确定哪个环成员连接到密钥镜像，但是其他参与者只需要检查密钥镜像是否已被使用过。如果恶意用户尝试花费两次相同的输出，它将两次生成相同的密钥镜像，并且网络会立即拒绝欺诈性的第二笔交易。
• 环签名技术可以确保交易的签名必须与每笔输入的所有者签名匹配。
• RingCT技术利用密码学中的承诺和范围证明，将以一种秘密方式“承诺”该金额，仅向网络披露足够的信息以确认交易的合法性，但不会公开揭露金额本身。

  除此之外，门罗币鼓励用户通过Tor、I2P等匿名网络接入到门罗币系统中，从而隐藏用户的IP地址，进一步增强其隐私性。

文章概览

• 系统选择
• 应用分享

系统选择

  对于开发者而言，Linux系统拥有众多优秀的性能，我也一直尝试着将Linux作为主力使用的操作系统。但是，目前很多痛点问题在Linux场景下没有很好的解决方案，比如很多常用的软件没有Linux版本，因此之前我的电脑使用的是win10和Arch Linux双系统，在做不同的任务时可能需要在两个系统之间进行切换。之所以选择Arch Linux是因为Arch Linux拥有非常丰富的软件库，结合wine，能够很好的解决部分场景的痛点问题。但是Arch Linux的更新策略很激进，滚动更新的模式可能会让你的系统出现各种类型的bug。在平稳运行半年之后，我的Arch还是挂了，推测应该是显卡驱动的原因，一直没能修复好，因此只得作罢。之后，我又回归了windows系统。在windows场景下搭建Linux开发环境一般有三种方式：虚拟机、docker、WSL，前两种方式之前都尝试过，也不太符合我的需求，因此这次选择了WSL。我将所有的开发环境部署在WSL中，IDE安装在windows宿主机，IDE可以识别WSL中的编译环境。使用一段时间后，体验非常好，WSL能够满足我在开发场景中所有的需求，在性能方面也接近原生Linux。

  因此，我准备在新机器上继续沿用windows+WSL的环境。由于新配的机器有一块nvidia的显卡，所以在装系统之前，我查阅了以下相关资料，WSL2已经支持显卡接口调用。但是，我忽略了一个关键细节：只有Build 20145或更高预览版的win10下的WSL2才支持显卡调用。装好系统之后，我才发现这一问题，所以装完之后又将系统升级到最新的预览版。接着需要在windows宿主机上安装显卡驱动程序，根据官网的操作一路安装下去，遇到了很多bug，虽然最后也算是装好了，但是总感觉不够稳定。这些功能目前还在测试阶段，所以不推荐作为主力开发环境。win11已经支持上述功能，等正式发布之后，可以再尝试上述功能。

  以防万一，我还是安装了一套Linux环境，这次使用的是ubuntu。ubuntu的社区很强大，各种资料文档也十分丰富，一旦出现问题，可以找到很多解决方案进行参考。双系统的安装过程这里就不赘述了，网上都能找到很多参考资料。接下来，介绍几个我在Linux系统中经常使用的软件工具。

应用分享

i3wm：linux 平铺式窗口管理器，强力推荐。

zsh：功能强大且美观的Linux终端，安装过程可以参考这篇博客。

ranger：是一款终端下的文件管理器，具有vim式的操作方式。

1
2
3
4
5
6
7
8

sudo apt install ranger # ubuntu下安装ranger
$ sudo apt-get install highlight  # 代码高亮
$ sudo apt-get install w3m        # html页面预览
ranger --copy-config=all # 将在~/.config/ranger中生成一系列配置文件
# rc.conf 常用于设置选项和绑定快捷键.
# scope.sh 常用于设置文件的预览方式.
# rifle.conf 常用于设置使用那个软件来打开文件.
# commands.py python文件,增强和改进ranger的各种功能.

通过对ranger的配置文件进行修改，可以实现很多方便快捷的功能，以下介绍如何对pdf和image进行预览。

1
2
3
4
5
6
7
8
9

# 在scope.sh文件中取消这段内容的注释，即可在ranger中预览pdf
application/pdf)
    pdftoppm -f 1 -l 1 \
       -scale-to-x "${DEFAULT_SIZE%x*}" \
       -scale-to-y -1 \
       -singlefile \
       -jpeg -tiffcompression jpeg \
       -- "${FILE_PATH}" "${IMAGE_CACHE_PATH%.*}" \
    && exit 6 || exit 1;;

1
2
3

# 在rc.conf文件中添加以下内容，即可在ranger中预览图片
set preview_images true
set preview_images_method w3m

flameshot：好用的截图工具

1

sudo apt install flameshot

proxychains：强大的终端代理工具

1
2
3

sudo apt install proxychains
# 配置文件的路径为/etc/proxychains.conf，注释原本的socks4代理配置，添加socks5代理
socks5         127.0.0.1 1080

frp：有一台云服务器，为了随时对主机进行访问，需要配置内网穿透。frp是一款优秀的内网穿透工具，以下给出ssh服务的配置。

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

# 客户端frpc.ini文件配置
[common]
server_addr = 82.58.156.32 # 自己的服务器端IP
server_port = 7000 # 服务器端frp端口
token = 12345678 # 连接口令

[ssh]
type = tcp
local_ip = 127.0.0.1
local_port = 22
remote_port = 2222

# 服务器端frps.ini文件配置
[common]
bind_port = 7000
dashboard_port = 7500 # 监控面板
token = 12345678
dashboard_user = admin # 监控面板用户名
dashboard_pwd = admin # 监控面板密码

Filegator：轻量级的开源网盘，功能比较单一（nextcloud的功能更加复杂），能够满足我的日常需求，推荐使用docker方式进行安装。

bashtop：终端系统监控软件

nvtop：终端显卡监控软件

文章概览

• 口令安全问题分析
• PCFG口令猜测算法实现
• Markov口令猜测算法实现

口令安全问题分析

  对于一个安全问题，往往可以从攻击者和防御者两个角度来考虑，以下分别从这两个角度对口令安全问题进行分析和总结。

攻击者

  对于口令安全问题而言，攻击者的目的是利用各种手段快速方便的获取用户的口令信息，从而获得进入相关系统的权限。首先，攻击者需要对该问题进行分析，找到突破口。对口令安全造成威胁的因素主要有以下两种：

• 系统（或网络应用）的口令安全机制，主要体现在以下几个方面。
  • 口令生成策略：目前很多网站的口令生成策略一般要求字母+数字+特殊字符的组合，口令长度8位以上。如果网站的口令生成策略要求很低，会导致用户倾向于选择更为简单、便于记忆的口令组合，会加剧口令被攻击者成功猜测的风险。
  • 口令强度评估：良好的口令强度评估机制可以帮助用户选择更为安全的口令，增加攻击者猜测的成本。但是出于技术难度或者用户体验等方面的考虑，目前的口令强度评估机制仍然存在很大的问题。
  • 口令认证机制：由于口令传输阶段不涉及人的因素，研究的问题主要是基于口令的身份认证协议，问题容易刻画，目前这方面的研究较为成熟，攻击者很难从这个角度来突破。
  • 口令存储机制：如果系统采用明文方式存储用户口令，一旦口令文件被泄漏，会造成很大的安全威胁。一般情况下，采用较为先进的hash函数来生成口令文件。hash函数的单向性和碰撞约束特性能够保证即使口令文件被泄漏，攻击者也难以恢复用户的口令。
• 用户脆弱口令行为，主要体现在以下几个方面。
  • 用户的倾向性口令构造模式：用户倾向于用特定的模式来构造口令，这种构造模式可能与其所处文化环境、语言特点有关，并且具有群体特征。这些线索可以帮助攻击者缩小口令猜测范围，提高攻击效率。
  • 口令重用：面对大量需要管理的帐号，口令重用是很多用户常见的做法。口令重用可以使得攻击者在获得已知用户口令的情况下，提取用户口令构造特征，从而推测用户未知口令。
  • 基于个人信息构造口令：为了便于记忆，用户在构造口令时往往会掺入个人相关信息。攻击者可以结合已知的用户信息和相关口令构造模型来猜测用户口令。

  通过以上分析可知，用户脆弱口令行为是造成口令安全风险的主要原因，同时系统（或网络应用）中脆弱的口令生成策略和口令强度评估机制也为攻击者成功攻击创造了条件。其实，口令猜测攻击的思路很简单，即提交不同的口令直到认证成功为止。但是，其难点在于如何提高攻击的成功率和效率。因此，口令猜测算法的研究专注于深入挖掘用户脆弱口令行为，针对不同场景构建高效的口令猜测算法。根据攻击过程中是否利用用户个人信息，口令猜测算法可分为漫步攻击和定向攻击。

• 漫步攻击是指攻击者不关心具体攻击对象是谁，其唯一目标是在允许的猜测次数下，猜出越多口令越好。
  • 启发式方法：没有严密的理论体系，很大程度依靠零散的“奇思妙想”，比如构造独特的猜测字典，采用精心设计的猜测顺序等。
  • 概率统计方法：基于概率统计思想，对口令的组成结构进行分析，从而得到概率模型，比如概率上下文无关方法（PCFG）、Markov、NLP。
  • 深度学习方法：核心思想是利用深度学习模型强大的端到端的学习能力，自动提取口令集合潜在的分布特征，从而指导猜测口令的生成，比如PassGAN、FLA。
• 定向攻击是指攻击者利用与攻击相关的个人信息以增强口令猜测的针对性。
  • 口令重用信息：利用用户在其他网站中泄漏的口令来推测用户口令构造特征，这类攻击方法包括TarGuess、pass2path。
  • 人口学相关信息：这类信息包括用户的姓名、年龄、生日、性别、邮箱、手机号以及家庭成员信息，这类攻击方法包括Targeted-Markov、Personal-PCFG、TarGues

  总的来说，口令猜测算法的发展趋势是由漫步攻击慢慢过度到定向攻击，因为定向攻击的更有针对性且效率更高。除此之外，利用深度学习方法来进行口令猜测也是未来的发展趋势之一。因为传统的口令猜测算法大多建立在特定规则和概率统计的基础上，可能无法全面的体现口令的分布特征，深度学习模型强大的表示能力为解决这一问题提供了可能性。

防御者

  从攻击者的分析来看，造成口令安全风险的主要原因是用户的安全意识不足，其次是由于系统（或网络应用）的口令安全策略不严格造成的。由于用户的安全意识等人为因素是无法控制的，所以防御者构建口令安全防御机制主要是立足于口令强度评估等安全策略。口令强度评估机制需要准确的告诉用户，当前构造的口令是否安全，所以这就需要口令强度评估机制足够的健壮。目前的口令强度评估机制主要有以下三类：

• 基于规则的口令强度评价方法：口令强度依据长度和所包含的字符类型而定，比如NIST PSM。
• 基于模式检测的口令强度评估方法：检测口令各个子段所属的构造模式，然后对各个模式赋予相应的分数，得到该口令的总分数，即为强度值，比如zxcvbn。
• 基于攻击算法的口令强度评估方法：使用攻击算法对给定口令进行攻击，根据攻击的难易程度进行强度判定，比如PCFG-based PSM、Markovbased PSM。
• 基于相似度检测的口令强度评估方法：vec-PPSM（口令重用）。

  目前的口令强度评估的研究相对来说不是很成熟，提出的很多评估方法都没能得到大规模的应用。目前大部分的口令强度评估机制都是基于漫步猜测攻击，未考虑到用户个人信息对口令安全性的影响，这一领域值得探索的方向是设计基于定向攻击者模型的口令强度评估机制。

PCFG口令猜测算法实现

  PCFG是一种完全自动的、建立在严密的概率上下文无关法基础之上的漫步口令猜测算法，该算法的核心思想是将每一条口令看作是由字母段L、数字段D、特殊字符段S根据一定的模式互相组合而成的。我们可以通过对大量的口令数据进行分析，统计出这些口令可能的组合模式，从而利用该模式生成更多的口令，进行口令猜测。

实现细节

  该算法的实现主要包括三个部分：口令集预处理、口令集训练、口令猜测，使用的编程语言为python3.7，具体细节如下所示：

• 口令集预处理：实验中所使用的口令集为MySpace，去掉了包含非ASCLL或者空格的口令，剩余口令总数为41251。然后将这些口令随机拆分为训练集和测试集，分别存放在trainword.txt和testword.txt文件中。代码中设置了参数eps可以对训练集和测试集的分配比例进行调节，本文将eps设置为0.4，即测试集占口令总数的40%（16500）。除此之外，在随机拆分训练集和测试集时，设置了随机种子seed，方便实验结果的复现。
• 口令集训练：口令集训练的目的是统计出口令模式频率和字符组件频率。对于字符组件频率的统计，论文中提到的方法只统计了数字段和D和特殊S。在实现过程中，我也统计了字母段L的频率，同时字母段L将作为字典参与口令猜测过程。（根据测试集生成的口令模式一共有1134种）
• 口令猜测：口令猜测的过程类似于树的遍历，这里采用类似于深度优先遍历的方法。分别对所有的口令模式频率表和字符组件频率表由大到小进行排序，从频率最高的口令模式开始进行口令猜测，根据字符组件频率表依次生成该模式下所有可能的口令，然后在进行下一个口令模式的猜测。对于每个生成的口令，需要计算其可能出现的概率，如果该概率值大于预设的阈值（比如0.000000001），则可以将其输出并与测试集中的口令进行比对。反之，则将该口令丢弃。实验中所有的猜测口令都存放在guess文件夹下对应的口令模式文件中。

实验结果

  按照上述实验设置进行了实验，具体代码参考我的GitHub。在代码刚开始运行阶段，正确猜解口令的速度很快。两分钟的时间内大概能够正确猜解6000多个口令，之后正确猜解的速度逐渐降低，下图展示了口令破解速度的变化趋势。由于⽣成口令时我们设置了阈值，只有超过该阈值的口令才会进⾏匹配，所以真正参与口令猜测的 口令数量要远远小于实际⽣成的口令数量，上图横坐标展⽰的就是参与口令猜测的口令数量。这⾥展⽰ 的结果是利⽤口令模式表中前400种左右的模式⽣成的口令，正确猜解的口令数量为6529（总共 16500）

Markov口令猜测算法实现

  ⼀般情况下，⽤⼾构造口令的顺序是从前向后依次进⾏的。根据这⼀特点，Narayanan等⼈在 2005年⾸次将Markov链技术引⼊口令猜测中来。与PCFG算法不同，基于Markov模型的口令猜测算法 对整个口令进⾏训练，通过从左到右的字符之间的联系来计算口令的概率。该算法也分为训练和猜测集 ⽣成两个阶段，以下介绍实现细节。（针对此前代码存在的问题，本次代码进⾏了相应的修改。对于 start symbol问题，已经充分理解并实现；对于阈值问题，优化了阈值的分配⽅式。综合来看，实验效果得到了很⼤的提升）

实现细节

  该算法的实现主要包括三个部分：口令集预处理、口令集训练、口令猜测，使⽤的编程语⾔为 python3.7，具体细节如下所⽰：

• 口令集预处理：实验中所使⽤的口令集为Rockyou，去掉了包含⾮ASCLL或者空格的口令，剩余口 令总数为32460357。由于口令总数很⼤，这⾥我没有使⽤全部的口令进⾏训练和测试。我从数据 集中随机选择了2000000条口令，然后将这些口令拆分为训练集和测试集（各占50%）。代码中设 置了number参数，可以选择使⽤数据的量。除此之外，在随机选择数据时，设置了随机种⼦seed，⽅便实验结果的复现。
• 口令集训练：口令集训练的⽬的是统计出各个字串在训练集中出现的频数。统计频数时，对于口令 开头字⺟出现的频率单独进⾏统计，其余字串的频数均存放在⼀个字典中。我使⽤了End-Symbol 正规化技术，频数统计时也会对口令结束标志符号进⾏统计。频数统计完成之后，利⽤Laplace平 滑技术来计算概率，然后对每个字串后⾯出现的字⺟依据概率值⼤小进⾏排序。
• 口令集猜测：这⾥使⽤优先队列的思想来对猜测口令进⾏存储和遍历，如果当前队列前端的字符串 最后⼀个字符为口令结束标识符，则将其输出进⾏口令猜解，否则根据其字串在概率表中的统计情 况，在该字符串后继续添加字符并计算概率，然后插⼊队列。为了减少队列对内存的损耗，再将每 ⼀个字符串插⼊队列之前，要对其概率值进⾏判断。只有当其概率值⼤于预设阈值时，才准许插⼊队列。

实验结果

  按照上述实验设置进⾏了实验，具体代码参考我的GitHub。由于实验机器性能有限，这⾥使⽤的测试集口令总数为 1000000，猜测次数为1000000，order=3,4,5，下图展⽰了口令破解速度的变化趋势。order=3时，猜测出的口令数⽬为279517；order=4时，猜测出的口令数⽬为378980；order=5时，猜测出的口令数 ⽬为414806。

文章概览

• 概率生成模型
• 生成对抗网络
  • 生成对抗网络的理论解释
  • 生成对抗网络的求解过程
• 生成对抗网络的优化
  • fGAN
  • WGAN
• 生成对抗网络的实现

概率生成模型

  概率生成模型，简称生成模型，是指一系列用于随机生成可观测数据的模型。假设在一个连续或离散的空间$\chi$中，存在一个随机向量$X$服从一个未知的数据分布$P_{data}(x)$，$x \in \chi$。生成模型是根据一些可观测的样本$x^1, x^2, …, x^m$来学习m一个参数化模型$P_G(\theta;x)$来近似未知分布，并可以用这$P_{data}(x)$个模型来生成一些样本，使得生成的样本和真实的样本尽可能的相似。对于一个低维空间中的简单分布而言，我们可以采用最大似然估计的方法来对$p_\theta(x)$进行求解。假设我们要统计全国人民的年均收入的分布情况，如果我们对每个$P_{data}(x)$样本都进行统计，这将消耗大量的人力物力。为了得到近似准确的收入分布情况，我们可以先假设其服从高斯分布，我们比如选取某个$P_G(x;\theta)$城市的人口收入$x^1, x^2, …, x^m$，作为我们的观察样本结果，然后通过最大似然估计来计算上述假设中的高斯分布的参数。
$$
L=\prod_{i=1}^{m} P_{G}\left(x^{i} ; \theta\right)
$$

$$
{\theta}^{*}=arg \max_{\theta} \sum_{i=1}^{m} \log P_{G}(x^{i} ; \theta)
$$

由于$P_G(x;\theta)$服从高斯分布，我们将其带入即可求得最终的近似的分布情况。下面我们对上述过程进行一些拓展，我们从$P_{data}(x)$尽可能采样更多的数据，此时可以得到
$$
{\theta}^{*}=arg \max_{\theta} \sum_{i=1}^{m} \log P_{G}(x^{i} ;\theta)\approx arg \max_{\theta} E_{x \sim P_{\text {data }}}[\log P_{G}(x ; \theta)]
$$

对该式进行一些变换，可以得到
$$
{\theta}^{*}=arg \min_{\theta} K L\left(P_{\text {data }} | P_{G}\right)
$$

  由此可以看出，最大似然估计的过程其实就是最小化$P_{data}(x)$分布和$P_G $分布之间$KL$散度的过程。从本质上讲，所有的生成模型的问题都可以转换成最小化$P_{data}(x)$分布和$P_G $分布之间距离的问题，$KL$散度只是其中一种度量方式。

  如上所述，对于低维空间的简单分布而言，我们可以显式的假设样本服从某种类型的分布，然后通过极大似然估计来进行求解。但是对于高维空间的复杂分布而言，我们无法假设样本的分布类型，因此无法采用极大似然估计来进行求解，生成对抗网络即属于这样一类生成模型。

生成对抗网络

生成对抗网络的理论解释

  在生成对抗网络中，我们假设低维空间中样本$z$服从标准类型分布，利用神经网络可以构造一个映射函数$G$（即生成器）将$z$映射到真实样本空间。我们希望映射函数$G$能够使得$P_G(x)$分布尽可能接近$P_{data}(x)$分布，即$P_G$与$P_{data}$之间的距离越小越好：
$$
G^{*}=arg \min_{G} {\operatorname{Div}}\left(P_{G}, P_{\text {data }}\right)
$$

由于$P_G$与$P_{data}$的分布都是未知的，所以无法直接求解$P_G$与$P_{data}$之间的距离。生成对抗网络借助判别器来解决这一问题。首先我们分别从$P_G$与$P_{data}$中取样，利用取出的样本训练一个判别器：我们希望当输入样本为$P_{data}$时，判别器会给出一个较高的分数；当输入样本为$P_G$时，判别器会给出一个较低的分数。例如，我们可以将判别器的目标函数定义成以下形式（与二分类的目标函数一致，即交叉熵）：
$$
V(G, D)=E_{x \sim P_{\text {data }}}[\log D(x)]+E_{x \sim P_{G}}[\log (1-D(x))]
$$

我们希望得到这样一个判别器（$G$固定）：
$$
D^{*}=arg \max_{D} V(D, G)
$$

从本质上来看，$\max _{D} V(D, G)$即表示$P_G$与$P_{data}$之间的$JS$散度（具体推导参见李宏毅老师的课程），即：
$$
\max_{D} V(G, D)=V\left(G, D^{*}\right)=-2 \log 2+2 J S D\left(P_{\text {data }} | P_{G}\right)
$$

$$
D^{*}(x)=\frac{P_{\text {data }}(x)}{P_{\text {data }}(x)+P_{G}(x)}
$$

因此通过构建判别器可以度量$P_G$与$P_{data}$之间的距离，所以$G^{*}$可以表示为：
$$
G^{*}=arg \min_{G} \max_{D} V(G, D)
$$

生成对抗网络的求解过程

$G^{*}$的求解过程大致如下：

• 初始化生成器$G$和判别器$D$
• 迭代训练
  • 固定生成器$G$，更新判别器$D$的参数
  • 固定生成器$D$，更新判别器$G$的参数

对上述算法过程进行几点说明：

• 在之前的描述中，$V(D,G)$表示的是目标函数的期望，但在实际计算过程中是通过采样平均的方式来逼近其期望值。
• 判别器的训练需要重复$k$次的原因是希望能尽可能使得$V(D,G)$接近最大值，这样才能满足$\max _{D} V(D, G)$即表示$P_G$与$P_{data}$之间的$JS$散度”这一假设。
• 在更新生成器参数时，$\frac{1}{m} \sum_{i=1}^{m} \log D\left(x^{i}\right)$这一项可以忽略，因为$D$固定，其相当于一个常数项。
• 在更新生成器参数时，我们使用$\tilde{V}=\frac{1}{m} \sum_{i=1}^{m} -\log \left(D\left(G\left(z^{i}\right)\right)\right)$代替$\tilde{V}=\frac{1}{m} \sum_{i=1}^{m} \log \left(1-D\left(G\left(z^{i}\right)\right)\right)$，这样做的目的是加速训练过程。

生成对抗网络的优化

fGAN

  通过上面的分析我们可以知道，构建生成模型需要解决的关键问题是最小化$P_G$和$P_{data}$之间的距离，这就涉及到如何对$P_G$和$P_{data}$之间的距离进行度量。在上述GAN的分析中，我们通过构建一个判别器来对$P_G$和$P_{data}$之间的距离进行度量，其中采用的目标函数为：
$$
V(G, D)=E_{x \sim P_{\text {data }}}[\log D(x)]+E_{x \sim P_{G}}[\log (1-D(x))]
$$

通过证明可知，$V(G, D)$其实度量的是$P_G$和$P_{data}$之间的$JS$散度。如果我们希望采用其他方式来衡量两个分布之间的距离，则需要对判别器的目标函数进行修改。根据论文fGAN，可以将判别器的目标函数定义成如下形式：
$$
D_{f^{*}}(P_{\text {data }} | P_{G})=\max_{\mathrm{D}}{E_{x \sim P_{\text {data }}}[D(x)]-E_{x \sim P_{G}}[f^{*}(D(x)]}
$$

则$G^{*}$可以表示为：
$$
G^{*}=arg \min_{G} D_{f^{*}}\left(P_{\text {data }} | P_{G}\right)
$$

$f^{*}$取不同表达式时，即表示不同的距离度量方式。

令$f^{*}(t)=-log(1-exp(t))$，$D(x)$取$log$，代入$D_{f^{*}}\left(P_{\text {data }} | P_{G}\right)$即可得到$V(G,D)$。

WGAN

  自2014年Goodfellow提出以来，GAN就存在着训练困难、生成器和判别器的loss无法指示训练进程、生成样本缺乏多样性等问题。针对这些问题，Martin Arjovsky进行了严密的理论分析，并提出了解决方案，即WGAN（WGAN的详细解读可参考这篇博客)。

• 判别器越好，生成器梯度消失越严重。根据上面的分析可知，当判别器训练到最优时，$\max _{D} V(D, G)$衡量的是$P_G$与$P_{data}$之间的$JS$散度。问题就出在这个JS散度上，我们希望如果两个分布之间越接近它们的JS散度越小，通过优化JS散度就能将$P_G$拉向$P_{adta}$。这个希望在两个分布有所重叠的时候是成立的，但是如果两个分布完全没有重叠的部分，或者它们重叠的部分可忽略，$J S D\left(P_{\text {data }} | P_{G}\right)=log2$。在训练过程中，$P_G$与$P_{data}$都是通过采样得到的，在高维空间中两者之间几乎不存在交集，从而导致$\max _{D} V(D, G)$接近于0，生成器因此也无法得到有效训练。

• 最小化生成器loss函数$E_{x \sim P_{G}}[\log (1-D(x))$，会等价于最小化一个不合理的距离衡量，导致两个问题，一是梯度不稳定，二是collapse mode即多样性不足。假设当前的判别器最优，经过推导可以得到下面等式：
  $$
  E_{x \sim P_{G}}[\log (1-D(x))=KL\left(P_{\text {G }} | P_{data}\right)-2 J S D\left(P_{\text {data }} | P_{G}\right)
  $$
  这个等价最小化目标存在两个严重的问题。第一是它同时要最小化生成分布与真实分布的KL散度，却又要最大化两者的JS散度，一个要拉近，一个却要推远！这在直观上非常荒谬，在数值上则会导致梯度不稳定，这是后面那个JS散度项的毛病。第二，即便是前面那个正常的KL散度项也有毛病，因为KL散度不是一个对称的衡量$KL\left(P_{\text {G }} | P_{data}\right)$和$KL\left(P_{\text {data}} | P_{G}\right)$是有差别的。

• 原始GAN的主要问题就出在距离度量方式上面，Martin Arjovsky提出利用Wasserstein距离来进行衡量。Wasserstein距离相比KL散度、JS散度的优越性在于，即便两个分布没有重叠，Wasserstein距离仍然能够反映它们的远近。
  $$
  W(G, D)=E_{x \sim P_{\text {data }}}[D(x)]-E_{x \sim P_{G}}[D(x)]\
  $$

  由以上算法可以看出，WGAN与原始的GAN在算法实现方面只有四处不同：（1）判别器最后一层去掉sigmoid；（2）生成器和判别器的loss不取log；（3）每次更新判别器的参数之后把它们的绝对值截断到不超过一个固定常数c；（4）不要用基于动量的优化算法（包括momentum和Adam），推荐RMSProp，SGD也行。

生成对抗网络的实现

  本文实现了几种常见的生成对抗网络模型，包括原始GAN、CGAN、WGAN、DCGAN。开发环境为jupyter lab，所使用的深度学习框架为pytorch，并结合tensorboard动态观测生成器的训练效果，具体代码请参考我的github。

GAN

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

real_label = torch.ones(batch_size, 1)
fake_label = torch.zeros(batch_size, 1)

# 训练判别器
d_real = D(real_img)
d_real_loss = criterion(d_real, real_label)

z = torch.normal(0, 1, (batch_size, latent))
fake_img = G(z)
d_fake = D(fake_img)
d_fake_loss = criterion(d_fake, fake_label)

optimizer_D.zero_grad()
d_loss = d_real_loss + d_fake_loss
d_loss.backward()
optimizer_D.step()

# 训练生成器
fake_img = G(z)
d_fake = D(fake_img)
g_loss = criterion(d_fake, real_label)

optimizer_G.zero_grad()
g_loss.backward()
optimizer_G.step()

CGAN

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

real_label = torch.ones(batch_size, 1)
fake_label = torch.zeros(batch_size, 1)

z = torch.normal(0, 1, (batch_size, latent))

# 训练判别器
d_real = D(real_img, label)
d_real_loss = criterion(d_real, real_label)

fake_img = G(z, label)
d_fake = D(fake_img, label)
d_fake_loss = criterion(d_fake, fake_label)

optimizer_D.zero_grad()
d_loss = (d_real_loss + d_fake_loss)
d_loss.backward()
optimizer_D.step()

# 训练生成器
fake_img = G(z, label)
d_fake = D(fake_img, label)
g_loss = criterion(d_fake, real_label)

optimizer_G.zero_grad()
g_loss.backward()
optimizer_G.step()

WGAN

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

# 训练判别器
d_real = D(real_img)
#d_real_loss = criterion(d_real, real_label)
d_real_loss = d_real

z = torch.normal(0, 1, (batch_size, latent))
fake_img = G(z)
d_fake = D(fake_img)
#d_fake_loss = criterion(d_fake, fake_label)
d_fake_loss = d_fake

optimizer_D.zero_grad()
#d_loss = d_real_loss + d_fake_loss
d_loss = torch.mean(d_fake_loss) - torch.mean(d_real_loss)
d_loss.backward()
optimizer_D.step()

for p in D.parameters():
    p.data.clamp_(-clip_value, clip_value)
# 训练生成器
fake_img = G(z)
d_fake = D(fake_img)
#g_loss = criterion(d_fake, real_label)
g_loss = - torch.mean(d_fake)

optimizer_G.zero_grad()
g_loss.backward()
optimizer_G.step()

文章概览

• 卷积神经网络简介
• 卷积层的实现细节
  • 前向计算
  • 反向传播
• 池化层的实现细节
  • 前向计算
  • 反向传播
• 测试结果

卷积神经网络简介

  在前面的文章中我们讲到了全连接前馈网络，并且在FashionMnist数据集上对我们构建的网络框架进行了测试。简单回顾一下当时的数据处理过程，FashionMnist数据集中的图片通道数为1、图片尺寸为28×28，原始数据集表示为$ X=(N, 1, 28 ,28) $。在训练之前，我们需要将训练数据转化为 $ X=(N, 1*28*28) $，相当于将数据集中每一张图片的像素点展开成向量的形式。显而易见，将图片展开为向量会丢失空间信息，这会对模型的泛化性能产生很大的影响。除此之外，利用全连接前馈网络处理图像数据往往会需要很多的参数。举例来说，假设现在数据集中的图片为100×100的彩色图片，此时每张图片中包含的像素点为$ 3*100*100 $，即$ X=(N, 3*100*100) $。如果第一个隐藏层有1000个神经元，那么仅该层包含的参数个数为$ 30000*1000 + 1000 $。过多的参数会给模型的训练过程造成很大的负担，同时也会导致过拟合等问题。综上所述，一般情况下我们不采用全连接前馈网络来处理图像数据。

  卷积神经网络最早主要是用来处理图像信息，是受生物学中感受野机制的启发而提出的（感受野是指卷积神经网络每一层输出的特征图上的像素点在输入图片上映射的区域大小。通俗点的解释是，特征图上的一个点对应输入图上的区域）。1998年，LeCun提出了经典的卷积网络模型LeNet-5，第一次较为完整的阐述了卷积神经网络的框架和结构。卷积神经网络由输入层、卷积层、激活层、池化层、全连接层及输出层构成。卷积层和池化层一般会取若干个，采用卷积层和池化层交替设置，即一个卷积层连接一个池化层，池化层后再连接一个卷积层，依此类推。与全连接前馈网络相比，卷积神经网络在结构上具有局部连接、 权重共享、降采样等特点，并且在训练过程中会完整保留数据的空间信息。这些特性使得卷积神经网络图像处理领域表现更加出色，并且使用的参数更少。

以下主要介绍卷积神经网络中卷积层和池化层的实现细节，激活层和全连接层的实现与全连接前馈网络基本一致，这里不再赘述，具体代码参考我的github（需要注意的是，本文实现代码中，默认输入图片高度和宽度相同）。

卷积层实现细节

  开始介绍之前，简要说明参数设置情况。输入数据尺寸为$s=5$，通道数为$in_channel=3$，即$ input=(n, 3, 5, 5)$；单个卷积核尺寸为$k=2$，卷积层输出通道数为$out_channel=10$，即$kernel=(10, 3, 2, 2)$；假设卷积步幅$stride=1$，$pad=0$，根据特征图大小计算公式
$$
p=\frac{s-k+2*pad}{stride}+1
$$
则卷积层输出为$output=(N, 10, 4, 4)$。

前向计算

  在卷积神经网络中所使用的卷积，一般是指互相关操作，其本质上就是利用卷积核在输入数据上进行滑动，并在滑动窗口内计算点积，计算过程如如下图所示。

  如果将该操作拓展到多通道的情况，我们需要将每一个通道数据与其对应的卷积核分别进行互相关操作，每个通道都会得到一个输出，然后将所有输出相同位置相加，得到最终的特征图，计算过程如下所示。

  这一过程最简单的思路是通过多重循环来实现，但是这种实现方式会极大降低训练过程的效率。im2col算法通过将这一过程转化为矩阵乘法的形式可以极大程度提升计算效率，该算法的主要思想如下图所示。

  im2col的核心思想是将每个卷积核在其对应通道上滑动过程中滑动窗口位置上的数据重新排列，组合成一维行向量的形式，而卷积核自身则排列成列向量的形式。卷积层输出的特征图中的每一个值都能表示成上述行向量和列向量相乘的形式。如果含有多层卷积核，则如下图方式排列。

通过这种方式，我们的输入数据可以成$input=(n*p*p, k*k*in_channel)$，卷积核可表示为$kernel=(k*k*in_channel, out_channel)$。该过程的代码如下所示：

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

def im2col(self, input):
    n, in_channel, s, _ = input.shape
    p = (s - self.k_size) // self.stride + 1
    im = torch.zeros((n*p*p, k*k*in_channel))
    for i in range(p):
        i_start = i*self.stride
        i_end = i_start + self.k_size
        for j in range(p):
            j_start = j*self.stride
            j_end = j_start + self.k_size
            im[i*p+j::p*p, :] = input[:,:,i_start:i_end,j_start:j_end].reshape(n, -1)

    w = self.w.reshape(self.k_size**2*c, self.out_channel)
    output = torch.matmul(im, w) + self.b
    return output.reshape(n, self.out_channel, p, p)

反向传播

  在反向传播过程中，卷积层主要做两件事：（1）利用卷积操作的输出层的误差项$\delta^l$来求卷积操作输入层的误差项$\delta^{l-1}$，并将结果继续反向传播；（2）求解卷积核的梯度，并对其进行更新（反向传播的过程可以参考这篇博客）。首先我们来求解输入层的误差项$\delta^{l-1}$，在将具体实现之前，我们先看下面这幅图

图的左侧表示输入，右侧表示输出。在输入数据中，数字0所标识的位置分别经历了四次卷积过程，分别对输出层的四个位置产生影响，卷积核中的4、3、2、1标识的是其每次参与运算的权重。如果我们现在需要计算0所在位置的误差项，只需要将卷积核中4、3、2、1四个权重与输出层对应位置的误差项进行点积运算即可。这种做法与互相关相同，但是需要注意的是这里的卷积核与之前的不同，是前向传播中的卷积核旋转180度的结果。我们给出输入层的误差项$\delta^{l-1}$的公式
$$
\delta^{l-1}=\delta^{l} * \operatorname{rot} 180\left(W^{l}\right)
$$
除此之外，由于输出层的尺寸要小于输入层，所以在进行卷积之前需要对输出层进行padding，如下图所示。

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

def nexteta(self, grad):
    # 计算卷积输入层的误差项
    n, c, s, _ = grad.shape
    ln, lc, ls, _ = self.param['inputshape']
    pad = math.ceil((self.stride*(ls-1) + self.k_size - s) / 2) 
    grad = self.paddings(grad, pad)
    w = torch.flip(self.w, dims=[2,3]) # 卷积核翻转

    p = (s - self.k_size) // self.stride + 1
    w = w.reshape(lc, self.k_size**2*c)
    im = self.im2col(grad, n, c, s, p)
    eta = torch.matmul(im, w.T).reshape(n, lc, p, p)
    return eta   

def paddings(self, input, pad):
    # padding实现接口
    n, c, s, _ = input.shape
    outshape = pad*2 + s
    out = torch.zeros((n, c, outshape, outshape))
    out[:,:,pad:outshape-pad,pad:outshape-pad] = input
    return out

接下来，我们要对卷积核进行更新。首先我们给出计算公式，
$$
\frac{\partial J(W, b)}{\partial W^{l}}=a^{l-1} * \delta^{l}
$$
其中$a^{l-1}$表示卷积层的输入， $\delta^{l}$表示卷积操作的输出层的误差项。根据前面的描述我们可以知道，$a^{l-1}$是一个$(n, 3, 5, 5)$的矩阵，$\delta^{l}$是$(n, 10, 4, 4)$的矩阵，而我们要求解的卷积核的梯度是$(10, 3, 2, 2)$的矩阵。大致的计算过程是这样的：将$\delta^{l}$视为卷积核，每次取第$i$通道$(n, i, 4, 4)$分别与对应数据的$(n, 3, 5, 5)$的三个通道进行卷积操作，由此可以得到$(n, 3, 2, 2)$，然后对$n$维数据进行求和取平均即得到$(1, 3, 2, 2)$。将此过程进行10次，即可得到卷积核的梯度值，具体代码如下所示。

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

def backward(self, input, grad):
    dw = torch.zeros(self.w.shape)
    db = torch.zeros(self.b.shape)
    n, c, s, _ = grad.shape
    for i in range(self.k_size):
        for j in range(self.k_size):
            cons = input[:,:,i*self.stride:i*self.stride+s,\n 
                         i*self.stride:i*self.stride+s]
            for k in range(c):
                dw[k,:,i,j] = torch.sum(cons * (grad[:, \n
                         k, :, :])[:, None], axis=(0,2,3)) / n
                db = torch.sum(grad, axis=(0,2,3)) / n
    self.w -= self.learning_rate*dw # 更新权重
    self.b -= self.learning_rate*db # 更新偏置
    eta = self.nexteta(grad)
    return eta

池化层

  池化层又称为降采样层，作用是对感受域内的特征进行筛选，提取区域内最具代表性的特征，能够有效地降低输出特征尺度，进而减少模型所需要的参数量。按操作类型通常分为最大池化、平均池化和求和池化，它们分别提取感受域内最大、平均与总和的特征值作为输出，最常用的是最大池化（这里主要介绍最大池化）。

  开始介绍之前，简要说明参数设置情况。输入数据尺寸为$s=4$，通道数为$in_channel=10$，即$ input=(n, 10, 4, 4)$；池化窗口尺寸为$k=2$，池化步幅$stride=2$，根据特征图大小计算公式
$$
p=\frac{s-k}{stride}+1
$$
则池化层输出为$output=(N, 10, 2, 2)$。

前向计算

  与卷积操作相比，池化层的计算较为简单，且池化层不改变通道数量，不包含训练参数。最大池化提取感受域内最大的值作为输出，计算过程如下图所示

需要注意的是，进行池化操作时需要记录感受域内最大值的位置，在反向传播时会用到，具体代码如下所示（因为需要记录位置，暂时没想到好的解决办法，所以直接用的循环）。

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

def pool(self, input):
    self.param['shape'] = input.shape
    n, c, s, _ = input.shape
    p = (s - self.k_size) // self.stride + 1
    pl = torch.zeros((n, c, p, p))
    index = []
    for i in range(n):
        for j in range(c):
            for k in range(p):
                for z in range(p):
                    inp = input[i,j,k*self.stride:k*self.stride+self.k_size,
                                z*self.stride:z*self.stride+self.k_size]
                    pl[i,j,k,z] = torch.max(inp)
                    ix = torch.where(inp==pl[i,j,k,z])
                    index.append((i,j,k*self.stride+ix[0],z*self.stride+ix[1])) 
                    self.param['index'] = index
    return pl

反向传播

  池化操作的反向传播主要是计算其输入层的误差项。首先我们定义一个全0矩阵，其大小与池化操作输入相同，对于最大池化而言，将池化操作输出层的误差项的值放在之前做前向传播算法得到最大值的位置，如下图所示。

1
2
3
4
5
6
7

def backward(self, input, grad):
    # 反向传播
    grad = grad.reshape(-1)
    eta = torch.zeros(self.param['shape'])
    for i in range(len(self.param['index'])):
    eta[self.param['index'][i]] = grad[i]
    return eta

测试结果

  我们定义了一个简单的卷积神经网络模型，并在FashionMnist做了一组测试。由于在池化层等操作上使用了循环操作，再加上笔记本性能不是特别好，跑了一个epoch，模型在测试集上的预测准确率达到了71.3%，但是花费的时间较长，大概40分钟，整体的代码确实需要做一些优化。

1
2
3
4
5
6
7
8
9

learning_rate = 0.1
network = []
network.append(Convolutional(1,16,5,2,learning_rate=learning_rate))
network.append(ReLU())
network.append(MaxPooling(16,2,2))
network.append(Dense(576,20,learning_rate=learning_rate))
network.append(ReLU())
network.append(Dense(20,10,learning_rate=learning_rate))
network.append(Softmax())

  总的来说，完整实现一个卷积神经网络还是有难度的。整个过程我觉得最难的是理解数据在卷积网络中的流动过程，因为这些数据都是以张量的形式呈现，所以理解起来有些困难。除此之外就是代码的调试，因为其中存在很多细节，一个地方出问题就会对整个结果产生影响。但是，经历这个过程之后，确实对卷积网络有了更多的认识。

文章概览

• 深度神经网络简介
• 深度神经网络框架实现
  • 整体思路
  • 前向计算
  • 反向传播
• 交叉熵损失函数与softmax激活函数

深度神经网络简介

  网上对深度神经网络（DNN）介绍的文章很多，这里不再赘述。推荐一些资料：刘建平博客 、复旦大学邱锡鹏教授神经网络与深度学习。

深度神经网络框架实现

整体思路

  在使用pytorch、tensorflow等框架来构建一个深度神经网络模型的时候，通常全连接层和激活函数层分开进行定义的。通过这种模块化的方式有利于自由的设计模型，在本文的代码中依然沿用这种方式。首先，我们需要定义一个父类，所有的全连接层以及激活函数层均继承自该父类。神经网络中的每一层都实现统一的方法接口，包括前向计算和反向传播，这样我们可以实现数据在神经网络模型中流动时的一致性。每一层可以根据自身的处理逻辑来重写继承自父类的方法，并且可以根据需要来增加成员方法和变量，例如全连层需要定义权重和偏值，而激活函数层则不需要。除此之外，在反向传播过程中，我们使用SGD算法来对参数进行更新。由于我们采用模块化的方式构建模型，所以神经网络的不同层之间相对独立，对于不同的层我们可以设置不同的学习率。

1
2
3
4
5
6
7
8

# 全连接层以及激活函数层均继承自该父类
class Layer:
    def __init__(self):
        pass
    def forward(self, input):
        return input
    def backward(self, input, grad):
        pass

前向计算

  前向计算的过程较为简单，网络中每一层所需要做的就是将该层输入传入self.forward函数，根据内部逻辑返回输出，该输出又将作为下一层的输入。对于全连接层，假设输入为$a^{l-1}$，计算$z^l=(W^l)^T*a^{l-1}+b^l$，再将$z^l$传递到下一层；对于激活函数层，假设输入为$z^l$，计算$a^l=\sigma(z^l)$，再将$a^l$传递到下一层。需要注意的是，我们需要记录下神经网络中的每一层的输入值$a^i$，在反向传播更新权重时会用到。

1
2
3
4
5
6
7
8

def forward(network, x):
    # 前向传播
    activations = []
    input = x
    for layer in network:
        activations.append(layer.forward(input))
        input = activations[-1]      
    return activations

反向传播

  对于反向传播而言，每一层的处理逻辑大致相同，即将该层输出值的误差项作为self.backward函数的输入，经过计算得到该层输入值的误差项，继续反向传播。需要注意的是，由于全连接层含有偏置和权重，在反向传播时除了需要计算误差项之外，还需要更新偏置和权重。反向传播算法的推导过程可以参考这篇博客，这里给出以下结论：
$$
\delta^{l}=(W^{l+1})^{T} \delta^{l+1} \odot \sigma^{\prime}(z^{l})
$$

  在很多介绍神经网络的书中，通常将一个全连接层和一个激活函数构成的整体当作神经网络的一层。但是，在我们代码中是将二者分开的，所以我们需要对上式进行改写。上式中$\delta^{l+1}$表示神经网络第$l+1$层输入值的误差项，即$a^l$的误差项；$\delta^{l}$表示神经网络第$l$层输入值的误差项，即$a^{l-1}$的误差项。由于我们将第$l$层拆分为两层，所以我们先要计算激活函数层输入值的误差项（记做$\delta^l_*$)，再计算全连接层输入值的误差项$\delta^{l}$。所以我们得到下面的公式：
$$
\delta^{l}_{*}= \delta^{l+1} \odot \sigma^{\prime}(z^{l})
$$

$$
\delta^{l}=(W^{l+1})^{T} \delta^{l}_{*}
$$

  通过这种转换，实现了不同层之间数据流动的一致性，即反向传播时，不论是全连接层还是激活函数层都是接受其输出值的误差项，返回其输入值的误差项。除此之外，由于在全连接层需要对权重和偏置进行更新，需要$a^{l-1}$作为参数，所以在self.backward的参数列表中加入该项。虽然激活函数层不需要更新参数，但是为了统一写法，也会加入这一参数。以下给出全连接层的backward函数。
$$
\frac{\partial J(W, b, x, y)}{\partial W^{l}}=\delta^{l}\left(a^{l-1}\right)^{T}
$$

$$
\frac{\partial J(W, b, x, y)}{\partial b^{l}}=\delta^{l}
$$

1
2
3
4
5
6
7

def backward(self, input, grad):
    grad_input = torch.mm(grad, self.w.T)
    dw = torch.mm(input.T, grad) / input.shape[0]
    db = torch.sum(grad, axis=0) / input.shape[0]
    self.w -= self.learning_rate*dw
    self.b -= self.learning_rate*db
    return grad_input

交叉熵损失函数与softmax激活函数

  使用神经网络处理多分类问题的时候，我们往往会使用交叉熵损失函数与softmax激活函数组合的形式，即将神经网络最后一层的激活函数设置为softmax，模型整体的损失采用交叉熵来进行计算。在这之前，我对二者的理解停留在比较浅显的层面：softmax函数将多个神经元的输出，映射到（0,1）区间内，可以看成概率来理解；交叉熵损失函数可以衡量两个概率分布之间的相似性，即softmax的输出和训练数据标签onehot编码之间的相似性。除此之外，交叉熵损失函数与softmax激活函数组合更深层次的原因体现在计算层面，它能够简化反向传播的计算过程。以下，我们对该问题进行分析。

  假设我们现在要计算softmax激活函数层输入值的误差项$\delta^{l}_{*}$，根据我们上面的得到的公式，我们需要分别计算$\delta^{l+1}$和$\sigma^{\prime}(z^{l})$。因为softmax是神经网络的最后一层，所以这里的$\delta^{l+1}$等于交叉熵损失函数对softmax输出值的导数$\frac{\partial J}{\partial a^{l}}$。而$\sigma^{\prime}(z^{l})$则表示softmax函数对其输入进行求导$\frac{\partial a^{l}}{\partial z^{l}}$。

  按照常规思路，我们需要单独计算这两个过程。但是对于交叉熵损失函数与softmax激活函数组合情况而言，可以将这两个过程进行合并，可以直接推导出$\frac{\partial J}{\partial z^{l}}$的值。具体的推导过程，可以参考这篇博客，这篇博客是我目前看过最简单易懂的，这里给出结论：
$$
\delta^{l}_{*}=\frac{\partial J}{\partial z^{l}}=a^l-y
$$
可以看出这个结论十分简洁优美，所以当我们使用交叉熵损失函数与softmax激活函数组合形式的时候，softmax层的backwrad函数只需要将$a^l-y$返回即可，无需进行任何操作。

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

# softmax激活函数作为神经网络最后一层
class Softmax(Layer):
    def __init__(self):
        pass
    
    def forward(self,input):
        exp = torch.exp(input)
        exp_sum = torch.sum(exp, axis=1, keepdims=True)
        return exp / exp_sum
    
    def backward(self,input,grad):
        return grad

  值得注意的一点是，在使用pytorch框架构建神经网络来实现多分类任务时，如果我们的代价函数使用torch.nn.CrossEntropyLoss()（交叉熵），网络的最后一层无需再定义softmax层，并且数据标签也不需要修改为onehot编码，这些逻辑在其内部应该都会实现，具体操作请参考我的代码。

文章概览

• 论文解读
  • 攻击模型
  • JSMA算法
• JSMA代码实现

论文解读

  JSMA由Papernot等人提出，其论文发表于2016年S&P。论文的主要工作包括：从攻击者的目标和背景知识（或能力）两个方面来构建攻击模型、提出JSMA对抗样本生成算法、对对抗性扰动进行度量并构建防御机制。

攻击模型

  分析攻击模型，主要从两个角度进行考虑：攻击者的目标和攻击者的背景知识。对于攻击者的目标而言，主要可以分为以下四类：

• Confidence reduction：减小输入分类的置信度，从而引入歧义
• Misclassification：将输出分类更改为与原始类不同的任何类
• Targeted misclassification：生成输入，强制输出分类为特定目标类
• Source/target misclassification：强制将特定输入的输出分类强制为特定目标类

对于攻击者的背景知识而言，主要可以分为以下五类：

• Training data and network architecture：最强大的背景知识，包含训练数据以及模型的结构和详细的参数信息
• Network architecture：了解目标模型的网络架构
• Training data：了解生成目标模型的训练数据
• Oracle：攻击者可以访问模型提供的接口，输入数据并获得反馈，并且可以观察到输入和输出的变化之间的关系
• Sample：攻击者可以访问模型提供的接口，输入数据并获得反馈，但是不能观察到输入和输出的变化之间的关系

针对不同的场景，攻击者将采用不同的攻击手法，这也是对抗样本领域研究的重点。

JSMA算法

  JSMA算法的灵感来自于计算机视觉领域的显著图。简单来说，就是不同输入特征对分类器产生不同输出的影响程度不同。如果我们发现某些特征对应着分类器中某个特定的输出，我们可以通过在输入样本中增强这些特征来使得分类器产生指定类型的输出。JSMA算法主要包括三个过程：计算前向导数，计算对抗性显著图，添加扰动，以下给出具体解释。

  所谓前向导数，其实是计算神经网络最后一层的每一个输出对输入的每个特征的偏导。以MNIST分类任务为例，输入的图片的特征数（即像素点）为784，神经网络的最后一层一般为10个输出（分别对应0-9分类权重），那对于每一个输出我们都要分别计算对784个输入特征的偏导，所以计算结束得到的前向导数的矩阵为（10，784）。前向导数标识了每个输入特征对于每个输出分类的影响程度，其计算过程也是采用链式法则。这里需要说明一下，前面讨论过的FGSM和DeepFool不同在计算梯度时，是通过对损失函数求导得到的，而JSMA中前向导数是通过对神经网络最后一层输出求导得到的。前向导数$\nabla \mathbf{F}(\mathbf{X})$具体计算过程如下所示，$j$表示对应的输出分类，$i$表示对应的输入特征。
$$
\nabla \mathbf{F}(\mathbf{X})=\frac{\partial \mathbf{F}(\mathbf{X})}{\partial \mathbf{X}}=\left[\frac{\partial \mathbf{F_j}(\mathbf{X})}{\partial x_i}\right]_{i \in 1 \ldots M, j \in 1 . . N}
$$

$$
\begin{aligned} \frac{\partial \mathbf{F_j}(\mathbf{X})}{\partial x_i}=&\left(\mathbf{W}_{n+1, j} \cdot \frac{\partial \mathbf{H_n}}{\partial x_i}\right) \times \frac{\partial f_{n+1, j}}{\partial x_i}\left(\mathbf{W}_{n+1, j} \cdot \mathbf{H_n}+b_{n+1, j}\right) \end{aligned}
$$

  通过得到的前向导数，我们可以计算其对抗性显著图，即对分类器特定输出影响程度最大的输入。首先，根据扰动方式的不同（正向扰动和反向扰动），作者提出了两种计算对抗性显著图的方式，即：

但是在文章中第四部分的应用中作者发现，找到单个满足要求的特征很困难，所以作者提出了另一种解决方案，通过对抗性显著图寻找对分类器特定输出影响程度最大的输入特征对，即每次计算得到两个特征
$$
\arg \max _{\left(p_1, p_2\right)}\left(\sum_{i=p_1, p_2} \frac{\partial \mathbf{F_t}(\mathbf{X})}{\partial \mathbf{X_i}}\right) \times\left|\sum_{i=p_1, p_2} \sum_{j \neq t} \frac{\partial \mathbf{F_j}(\mathbf{X})}{\partial \mathbf{X_i}}\right|
$$
具体的计算过程可以参考文章中的算法3。（注：根据扰动方式的不同，这种算法也有两种计算对抗性显著图的方式）

  根据对抗性显著图所得到的特征，可以对其添加扰动。扰动方式包括正向扰动和反向扰动（$+\theta$或$-\theta$）。如果添加的扰动不足以使分类结果发生转变，我们利用扰动后的样本可以重复上述过程（计算前向导数->计算对抗性显著图->添加扰动)。这个过程需要注意两点

• 扰动过程的重复次数需要被约束，即修改的特征数有限
• 一旦添加扰动后，该特征达到临界值，那么该特征不再参与扰动过程

JSMA算法实现

  同样，为了便于理解，这里给出相关代码段（与之前的数据集和网络模型一致）。所有的代码基于python实现，使用的深度学习框架为pytorch，更加完整的算法实现参见我的github。（注：本文JSMA算法实现部分代码参考了DEEPSEC)

• 网络模型

  1 2 3 4 5 6 7 8 9 10 11

  class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.fc1 = nn.Linear(28*28, 300) self.fc2 = nn.Linear(300, 100) self.fc3 = nn.Linear(100, 10) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x

• 数据集（这里只给出测试集的数据定义）

  1 2 3 4 5

  # 定义数据转换格式 mnist_transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x : x.resize_(28*28))]) # 导入数据，定义数据接口 testdata = torchvision.datasets.MNIST(root="./mnist", train=False, download=True, transform=mnist_transform) testloader = torch.utils.data.DataLoader(testdata, batch_size=256, shuffle=True, num_workers=0)

  对于前向导数，如果根据链式法则一层层的推导，计算过程十分复杂。但是在深度学习框架中，对于反向传播过程的梯度的计算都已经封装好，我们只需要简单的调用即可，所以前向导数的计算过程十分简单，如下所示

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

def compute_jacobian(model, input):

    output = model(input)
    num_features = int(np.prod(input.shape[1:]))
    jacobian = torch.zeros([output.size()[1], num_features])
    mask = torch.zeros(output.size())  # chooses the derivative to be calculated
    for i in range(output.size()[1]):
        mask[:, i] = 1
        zero_gradients(input)
        output.backward(mask, retain_graph=True)
        # copy the derivative to the target place
        jacobian[i] = input._grad.squeeze().view(-1, num_features).clone()
        mask[:, i] = 0  # reset
    return jacobian

  计算对抗性显著图的过程也较为简单，一般根据算法的描述一步步实现并不难。但是在该过程中存在一个问题，我们每次需要找到满足要求的一对特征，那组合的方式一共有784*783种，如果采用普通的循环来实现计算代价很大。参考了DEEPSEC的代码，我发现他们将这个问题巧妙的转化为矩阵求解的问题，大大缩短了计算时间。

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

def saliency_map(jacobian, target_index, increasing, search_space, nb_features):


    domain = torch.eq(search_space, 1).float()  # The search domain
    # the sum of all features' derivative with respect to each class
    all_sum = torch.sum(jacobian, dim=0, keepdim=True)
    target_grad = jacobian[target_index]  # The forward derivative of the target class
    others_grad = all_sum - target_grad  # The sum of forward derivative of other classes

    # this list blanks out those that are not in the search domain
    if increasing:
        increase_coef = 2 * (torch.eq(domain, 0)).float()
    else:
        increase_coef = -1 * 2 * (torch.eq(domain, 0)).float()
    increase_coef = increase_coef.view(-1, nb_features)

    # calculate sum of target forward derivative of any 2 features.
    target_tmp = target_grad.clone()
    target_tmp -= increase_coef * torch.max(torch.abs(target_grad))
    alpha = target_tmp.view(-1, 1, nb_features) + target_tmp.view(-1, nb_features, 1)  
    # calculate sum of other forward derivative of any 2 features.
    others_tmp = others_grad.clone()
    others_tmp += increase_coef * torch.max(torch.abs(others_grad))
    beta = others_tmp.view(-1, 1, nb_features) + others_tmp.view(-1, nb_features, 1)

    # zero out the situation where a feature sums with itself
    tmp = np.ones((nb_features, nb_features), int)
    np.fill_diagonal(tmp, 0)
    zero_diagonal = torch.from_numpy(tmp).byte()

    # According to the definition of saliency map in the paper (formulas 8 and 9),
    # those elements in the saliency map that doesn't satisfy the requirement will be blanked out.
    if increasing:
        mask1 = torch.gt(alpha, 0.0)
        mask2 = torch.lt(beta, 0.0)
    else:
        mask1 = torch.lt(alpha, 0.0)
        mask2 = torch.gt(beta, 0.0)
    # apply the mask to the saliency map
    mask = torch.mul(torch.mul(mask1, mask2), zero_diagonal.view_as(mask1))
    # do the multiplication according to formula 10 in the paper
    saliency_map = torch.mul(torch.mul(alpha, torch.abs(beta)), mask.float())
    # get the most significant two pixels
    max_value, max_idx = torch.max(saliency_map.view(-1, nb_features * nb_features), dim=1)
    p = max_idx // nb_features
    q = max_idx % nb_features
    return p, q

  算法其余的实现可以参考我的gihub。代码完成后进行了一些测试，选取原始样本0，目标分类结果分别为0-9。我们采用JSMA算法对其添加噪声，得到的结果如下所示。

我们将这些图片分别丢入原始分类器中，分类结果与我们的目标全都一致。由此看来，一般情况下，JSMA算法的效果还是很不错的。

文章概览

• FGSM
  • 算法概述
  • 代码实现
• DeepFool
  • 算法概述
  • 代码实现
• Universal Perturbation

FGSM

算法概述

  在机器学习领域，对抗样本的问题始终存在。特别是在入侵检测、垃圾邮件识别等传统的安全应用场景，对抗样本的生成和识别一直是攻击者和防御者博弈的战场。2013年，Szegedy等人首次提出针对深度学习场景下的对抗样本生成算法–BFGS，作者认为，深度神经网络所具有的强大的非线性表达能力和模型的过拟合是可能产生对抗性样本原因之一。2014年，Goodfellow等人（包括Szegedy）对该问题进行了更深层次的研究，它们认为高维空间下深度神经网络的线性线性行为是导致该问题的根本原因。并根据该解释，设计出一种快速有效的生成对抗性样例的算法–FGSM。以下是对论文的解读。

  对于线性模型$f(x)=w^Tx+b$来说，如果我们对输入$ x $添加一些扰动，使得$ \tilde{x}=x+\eta $。为了确保添加的扰动是极小的或者说是无法感知的，我们要求$ \left|\eta\right|_\infty<\epsilon $。所以我们可以得到加噪后的模型输出为
$$
f(\tilde{x})=w^Tx+w^T\eta+b
$$
为了尽可能增大添加的噪声对输出结果的影响，令$\eta=\epsilon sign(w)$（sign()函数的定义)。如果$w$是一个$n$维的向量，每一维的均值为$m$，则$w^T\eta=\epsilon nm$。虽然$\epsilon$的值很小，但是当$w$的维度$n$很大时，$\epsilon nm$将是一个很大的值，这将会给模型的预测带来很大的影响。因此，高维特征和线性行为可以成为对抗性样本存在的一种解释。

  上面的解释是基于线性模型而言的，而深度神经网络作为一种高度非线性模型，为什么会存在对抗性样例呢？深度神经网络的非线性单元赋予了其强大的表达能力，但是非线性单元的存在会降低学习的效率。为了提高学习效率，需要对非线性单元进行改进，通常的做法是通过降低其非线性来实现。从早期的sigmoid到tanh再到ReLU，我们会发现这些非线性单元的线性行为在不断增强，这也导致了深度神经网络中的线性能力的增强，这在一定程度上解释了深度神经网络中对抗性样例存在的原因。

  根据这种解释，作者提出了生成对抗性样例的算法FGSM。我们将深度神经网络模型看作是一个线性模型，即类似于$f(x)=w^Tx+b$。在线性模型中，$w$为$f(x)$关于$x$的导数，而在深度神经网络模型中我们可以将$w$视为代价函数关于输入$x$的导数，即
$$
w=\nabla_{x}J(\theta,x,y)
$$

$$
\eta=\epsilon sign(\nabla_{x}J(\theta,x,y))
$$

  在文章的后半部分主要介绍了针对对抗性样本的防御机制，即通过对抗性训练来提高模型的鲁棒性，这些内容会在之后的工作中讨论。

代码实现

  为了更好的理解算法的实现过程，以下给出本文相关的代码段。这些代码段给出的定义，对于后面的DeepFool和Universal Perturbation算法的解读依赖有效。所有的代码基于python实现，使用的深度学习框架为pytorch，更加完整的算法实现参见我的github.

• 网络模型

  1 2 3 4 5 6 7 8 9 10 11

  class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.fc1 = nn.Linear(28*28, 300) self.fc2 = nn.Linear(300, 100) self.fc3 = nn.Linear(100, 10) def forward(self, x): x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x

• 数据集（这里只给出测试集的数据定义）

  1 2 3 4 5

  # 定义数据转换格式 mnist_transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x : x.resize_(28*28))]) # 导入数据，定义数据接口 testdata = torchvision.datasets.MNIST(root="./mnist", train=False, download=True, transform=mnist_transform) testloader = torch.utils.data.DataLoader(testdata, batch_size=256, shuffle=True, num_workers=0)

• 代价函数

  1	loss_function = nn.CrossEntropyLoss()

  FGSM算法的实现较为简单，其核心在于利用代价函数求解已知样本的梯度值。我们假设模型已经训练完成，首先我们加载已训练完成的深度网络模型

1

net = torch.load('mnist_net_all.pkl') # 加载模型

然后我们选择一个测试样本，针对该测试样本生成其对应的对抗性样例。其原始图片格式如图所示。

1
2
3

index = 100 # 选择测试样本
image = Variable(testdata[index][0].resize_(1,784), requires_grad=True) # requires_grad存储梯度值
label = torch.tensor([testdata[index][1]])

接着将测试样本作为网络模型的输入，通过前向传播的过程计算其损失，然后利用其损失进行反向传播（即求导）。

1
2
3

outputs = net(image) # 前向传播
loss = loss_function(outputs, label) # 计算损失
loss.backward() # 反向传播

在深度学习框架中，反向传播的过程对用户来说是透明的。计算结束后，其梯度值存储在image.data.grad中，添加扰动的过程如下

1
2
3
4

# FGSM添加扰动
epsilon = 0.1 # 扰动程度
x_grad = torch.sign(image.grad.data)
x_adversarial = torch.clamp(image.data + epsilon * x_grad, 0, 1)

添加扰动后，得到对抗性样本如下所示

实验过程中我们发现，深度网络模型对于原始的图片能够正确的分类，而对于扰动之后的的样本不能正确分类（分类结果为2）。

DeepFool

算法概述

  FGSM算法能够快速简单的生成对抗性样例，但是它没有对原始样本扰动的范围进行界定（扰动程度$\epsilon$是人为指定的），我们希望通过最小程度的扰动来获得良好性能的对抗性样例。2016年，Seyed等人提出的DeepFool算法很好的解决了这一问题。文章的核心思想是希望找到一种对抗性扰动的方法来作为对不同分类器对对抗性扰动鲁棒性评估的标准。简单来说就是，现在我需要两个相同任务的分类器A、B针对同一个样本生成各自的对抗性样例。对于分类器A而言，其生成对抗性样例所需要添加的最小扰动为$a$；对于分类器B而言，其生成对抗性样例所需要添加的最小扰动为$b$；通过对$a$、$b$的大小进行比较，我们就可以对这两个分类器对对抗性样例的鲁棒性进行评估。由于FGSM产生扰动是人为界定的，所以它不能作为评估的依据。DeepFool可以生成十分接近最小扰动的对抗性样例，因此它可以作为衡量分类器鲁棒性的标准。

  DeepFool源于对分类问题的思考。对于如图所示的线性二分类问题，令$f(x)=w^Tx+b$，其中$\mathscr{F}={x : f(x)=0}$。此时$x_0$位于直线的下方，即$f(x_0)>0$。现在我们希望对$x_0$添加扰动$r$，使得分类器$f(x_0+r)<0$。那么如何添加扰动才能使得扰动的程度最小呢？这个问题可以转化为求点到直线之间的距离，我们通过$x_0$做直线$\mathscr{F}$的垂线，与$\mathscr{F}$相交于$p$（投影点），则$p$与$x_0$之间的距离即为$x_0$到分类边界$\mathscr{F}$的最短距离。所以当我们沿着分类边界法线方向对$x_0$进行扰动，可以保证扰动的程度最小
$$
r(x_0):={\arg\min_k}{|{r}|_{2}}=-{\frac{f(x_0)}{|{w}|_{2}^{2}}{w}}
$$
添加扰动之后将$x_0$映射到分类边界的投影点$p$，即$p=x_0+r(x_0)$。

  同样，对于非线性的二分类问题（分类边界为曲线或者曲面），我们也需要计算从目标样本点到分类边界的最短距离。这个计算过程较为复杂，一般采用垂直逼近法来逐步的逼近$x_0$在分类边界上的投影点，所以在论文中算法1会有一个迭代过程。值得注意的是，我们得到最终的$\sum_i{r_i}$表示的是从$x_0$到分类边界投影点的距离向量，满足$f(x_0+\sum_i{r_i})=0$。如果要使分类结果改变，需要再添加一些极小的扰动，如$f(x_0+(1+\eta)\sum_i{r_i})<0$（文中$\eta$取0.02）。

  对于多分类任务，思路也大致相同。在线性多分类任务中，需要注意的大致有两点：首先，对于多分类任务的分类边界要重新进行定义。我们令$f(x)$为分类器，$\hat{k}(x)=\mathop{\arg\max}_{k}{f_k(x)}$表示其对应的分类结果（一共有$k$个类别）。分类边界定义为
$$
\mathscr{F}_k={x : f_k(x)-f_{\hat{k}(x_0)}(x)=0}
$$
其次，由于分类边界有多个，我们需要以此求出$x_0$到每个分类边界的距离（类似于进行多次二分类的计算过程），然后进行比较，选择其中最短距离向量作为最终的扰动。
$$
\hat{l}(x_0)=\mathop{\arg\min_{k \neq \hat{k}_{x_0} }}{\frac{|f_k(x_0)-f_{\hat{k}(x_0)}(x_0)|}{|{w_k -w_{\hat{k}_{x_0}}}|_2}}
$$
之后通过计算$\boldsymbol{r}(x_0)$得到$x_0$在分类边界上的投影。

  在非线性多分类任务中，与线性多分类的区别在于其分类边界是不确定的，所以我们需要采用类似于非线性二分类任务中的方法来逼近分类边界。获得分类边界之后的计算与线性多分类的过程类似。此后，重复该过程多次，即可获得最终$x_0$在分类边界的投影。

代码实现

  以下讨论多分类情况下DeepFool算法的代码实现，模型结构以及数据集等与上述一致，不再重复。首先，我们选择一个测试样本，生成该样本的对抗性样例。

1
2
3
4

net = torch.load('mnist_net_all.pkl') # 加载模型
index = 100 # 选择测试样本
image = Variable(testdata[index][0].resize_(1,784), requires_grad=True)
label = torch.tensor([testdata[index][1]])

接下来，通过前向传播的过程，我们获得该样本对每一类别可能的取值情况，并将其从大到小排列起来，列表$I$对应其索引值，$label$即$\hat{k}_{x_0}$。

1
2
3
4
5
6
7

f_image = net.forward(image).data.numpy().flatten() 
# f_image: [-1.1256416 , -1.0344085 ,  2.0596995 , -2.0181773 , -0.24274658, -0.53373957,  6.6361637 , -2.250309  ,  0.06580263, -3.0854702 ]

I = (np.array(f_image)).flatten().argsort()[::-1]
# I: [6, 2, 8, 4, 5, 1, 0, 3, 7, 9]

label = I[0] # 该样本的标签为6

然后，我们定义一些需要用到的变量

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

input_shape = image.data.numpy().shape # 获取原始样本的维度
pert_image = copy.deepcopy(image) # 深度复制原始样本
w = np.zeros(input_shape) 
r_tot = np.zeros(input_shape)

loop_i = 0 
max_iter = 50 # 最多迭代次数
overshoot = 0.02  
x = Variable(pert_image, requires_grad=True)
fs = net.forward(x)
fs_list = [fs[0][I[k]] for k in range(len(I))] # 每个类别的取值情况，及其对应的梯度值
k_i = label

下面是算法实现的核心部分，参考论文中的伪代码，其中orig_grad表示$\nabla f_{\hat{k}_{x_0}}(x_i)$，cur_grad表示$\nabla f_k(x_i)$，fs[0][I[k]]表示$f_k(x_i)$，fs[0][I[0]]表示$f_{\hat{k}_{x_0}}(x_i)$。通过内部的for循环可以获得x到各分类边界的距离；在外部的while循环中，我们利用内部循环获得的所有边界距离中的最小值对x进行更新。重复这一过程，直到$x$的分类标签发生变化。

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

while k_i == label and loop_i < max_iter:
    pert = np.inf
    fs[0][I[0]].backward(retain_graph=True)
    orig_grad = x.grad.data.numpy().copy() 
    
    for k in range(len(I)):
        zero_gradients(x)
        fs[0][I[k]].backward(retain_graph=True)
        cur_grad = x.grad.data.numpy().copy()
        
        w_k = cur_grad - orig_grad
        f_k = (fs[0][I[k]] - fs[0][I[0]]).data.numpy()
        
        pert_k = abs(f_k) / np.linalg.norm(w_k.flatten())
        if pert_k < pert: # 获得最小的分类边界距离向量
            pert = pert_k
            w = w_k
    r_i = (pert + 1e-4) * w / np.linalg.norm(w) 
    r_tot = np.float32(r_tot + r_i) # 累积扰动
    
    pert_image = image + (1+overshoot)*torch.from_numpy(r_tot) # 添加扰动
    x = Variable(pert_image, requires_grad=True)
    fs = net.forward(x)
    k_i = np.argmax(fs.data.numpy().flatten()) # 扰动后的分类标签
    loop_i += 1
r_tot = (1+overshoot)*r_tot # 最终累积的扰动

对原始图片，添加扰动获得如下图片（分类器将其错误分类为2，有些奇怪的地方在于其扰动的程度要大FGSM，算法应该没有问题，一直没找到原因）。

Universal Perturbation

  前面介绍的FGSM和DeepFool算法，它们都是针对单个样本生成其对抗性样例，也就是说每个对抗性样例的扰动程度都不同。那么是否能找到一种通用性的扰动边界，能够为不同的样本生成对抗性样例。在DeepFool工作的基础上，Seyed 等人提出了Universal Perturbation，该算法为寻找通用性扰动边界提供了可能。以下简单介绍一下论文的核心思想：

• 从数据集中随机选取部分测试样本作为生成通用性扰动边界的范例，通过这些测试样本生成的通用性扰动适用于整个数据集。
• 算法的计算过程：输入第一个样本后，通过DeepFool算法找到该样本的最小扰动距离向量，将其累积到通用扰动向量$v$中（对$v$的扰动程度会有限制和调整，${|v|_p<\xi}$）；当输入第二个样本之后，对其添加$v$的扰动之后，然后再通过DeepFool计算扰动后的样本的最小扰动距离向量，将其累积到通用扰动向量$v$中（对$v$的扰动程度会有限制和调整,${|v|_p<\xi}$）。重复这一过程，直到最后一个测试样本。然后，我们使用通用扰动向量$v$，对原始的测试样本进行扰动，测试其生成对抗性样例的成功率。如果小于预先设置的阈值$1-\delta$，则跳出循环返回结果。否则，重复上述过程。
• 通用性扰动对不同的网络模型依然有效。也就是说，利用网络模型A生成的通用性扰动，同样适用于生成网络模型B的对抗性样例（A、B是不同类型的网络架构）。

摘要：最近一段时间在忙着写论文、看论文，博客一直没有更新了。这几天实验室添了两台交换机和五台服务器，这对于我这个爱折腾的人来说，确实是个大喜事，老师也把实验室设备的管理工作全权交予我来负责。忙活了几天时间，装好了系统，建立了一个小型的Hadoop集群和私有云。这其中我觉得最有意思的是关于实验室网络环境的配置，所以在这里做一些分享。

文章概览

• 网络环境简介

• 双网卡配置

• Linux密码

网络环境简介

  一开始，实验室的服务器都没有分配校园网固定IP，为了对服务器进行安装配置，我用了一台闲置的交换机和一个二手路由器组建了一个简单的网络环境（服务器—>交换机—>路由器）。但是存在的问题是，服务器只能在实验室的网络环境才能访问，无法通过校园网访问。一些内网映射的工具又不太稳定，使用起来很不方便，最关键的是路由器成为了整个网络的瓶颈（几十块钱的路由器）。后来通过学校网络中心分配了几个固定的校园网IP，但是校园网IP不能直接连接外网，需要拨号才能联网。五台服务器也就意味着需要五个账号才能使所有的服务器同时连接外网，我也没有这么多账号。仔细考虑了一下我们当前的需求和配置：

• 所有的服务器能通过校园网直接访问
• 所有的服务器能同时连接外网
• 宽带账号只有一个，路由器一个，交换机一个

综合这些因素，配置服务器双网卡可能是一个好的选择。每台服务器都有多个网口，将每台服务器同时连接在校园网和路由器两个网络中就能满足这些需求。通过给连接在校园网的网口配置校园网固定IP，可以保证校园网对服务器的访问；通过路由器拨号上网，将服务器的另一个网口连接到路由器上，即可保证服务器对外网的访问。

双网卡配置

  配置过程需要注意以下几点：

• 再给两个网卡配置静态IP的时候，不需要GATEWAY字段
• 删除系统默认的网关（在 /etc/sysconfig/network文件中修改）
• 使用ip route命令添加默认网关 （ip route add default via 网关地址 dev 网卡1）。一般我们将路由器的网关地址作为服务器的默认网关，这样能保证服务器可以访问外网。
• 添加默认路由（ip route add 校园网网段 via 校园网静态ip的网关地址 dev 网卡2）。为了在校园网内部可以对服务器进行访问，我们需要添加一条默认的路由。对于校园网网段的访问，不通过路由器，而是通过校园网静态ip的网关地址。

Linux密码

  之前一个同学在实验室主机上装过centos，可能太长时间没用，所以root密码忘了。找回LInux密码的过程挺有意思，一般情况下，通过单用户模式可以对root密码进行修改，但是系统设置了grub密码（防止修改用户密码）。至于grub密码就更不记得了，于是我们又想通过救援模式去修改grub密码，然后再修改root密码。参考了很多教程，我们发现修改不了grub密码。就在准备放弃的时候，我发现救援模式下可以直接访问/etc/shadow文件，我试着将文件中root用户记录删除，竟然修改成功了。重新开机之后，奇迹发生了，可以使用root用户直接登录了。这里给出参考的博客链接，希望对大家有所帮助。

文章概览

• 基本概念
  • 深网
  • 暗网
  • 黑暗网络
• tor匿名网络
  • tor基本概述
  • tor网络结构
  • tor路由技术
  • tor匿名服务
• tor客户端代理

基本概念

  在介绍暗网之前，我们先来了解一下经常会混淆的三个概念“深网”(Deep web)、“暗网”(Dark web) 和“黑暗网络”(Darknet) 。

深网

  深网是指服务器上可通过标准的网络浏览器和连接方法访问的页面和服务，但主流搜索引擎不会收录这些页面和服务。搜索引擎之所以不会收录深网，通常是因为网站或服务的配置错误、拒绝爬虫爬取信息、需要付费查看、需要注册查看或其他内容访问限制。据不完全统计，互联网世界中只有4％是对公众开放，剩下的96％的网站和数据则隐藏在深网中。

暗网

  暗网是深网中相对较小的一部分，与被故意隐藏的 Web 服务和页面有关。仅使用标准浏览器无法直接访问这些服务和页面，必须依靠使用覆盖网络 (Overlay Network)；而这种网络需要特定访问权限、代理配置、专用软件或特殊网络协议。

黑暗网络

  黑暗网络是在网络层访问受限的框架，例如 tor 或 I2P，私有 VPN 也属于这个类别。通过这些框架的网络流量会被屏蔽。当进行数据传输时，系统只会显示您连接的黑暗网络以及您传输了多少数据，而不一定会显示您访问的网站或所涉及数据的内容。与之相反的是，直接与明网（Clean Net）或与未加密的表网服务和深网服务交互。在这种情况下，您与所请求资源之间的互联网服务提供商和网络运营商可以看到您传输的流量内容。

tor匿名网络

基本概述

  经过上面的描述，我们对暗网整体的框架有个大致的了解。暗网不同于普通的互联网络，它拥有特殊的运作方式和网络协议，tor 是目前世界范围内是最大的暗网。tor又名洋葱网络，最初是由美国军方的情报机构开发并且提供财务支持的。洋葱网络使用特殊的路由转发技术，即洋葱路由技术。洋葱路由技术利用 P2P 网络,把网络流量随机地通过 P2P 的节点进行转发，这样可以掩盖源地址与目标地址的路径，使得在 Internet 上难以确定使用者的身份和地址。这就类似于你给某人送一封匿名信，你不是自己去送或者通过邮局的邮差去送，而是在大街上随便找几个不认识的人让他帮你送，这样收信人就很难往回追踪找到你。

  洋葱路由项目最初进展缓慢,废弃了其中的几个版本。直到 2002 年才由麻省理工的两位毕业生 Roger Dingledine 和 Nick Mathewson 以及原项目组成员 PaulSyverson 一起开发出一个新版的洋葱路由，也就是Tor。“洋葱路由”的最初目的并不是保护大众的隐私，它的目的是帮助政府情报人员隐藏身份，网上活动不被敌对国家监控。后来为了混淆系统的流量，而不是让系统仅仅拥有来自美国安全部门网络的流量，他们又让系统中加入来自其它网络的流量。于是，tor 的普通版本被推广给了普通大众，让普通大众也能使用 tor 来保护自己的隐私。这样就可以把政府情报人员的流量与社会上各行各业用户的复杂流量混在一起，能让流量分析更加困难，提供更强地隐私保护。

  目前全球范围内，tor网络由超过一万七千个中继节点组成，每个中继节点都是由全球志愿者免费提供，这些中继节点大部分分布在欧洲和北美。暗网除了能给我们提供匿名的网络服务之外，在按暗网中也存在各种类型的网站，这些网站只有通过暗网才能够访问。暗网中的网站大部分都是提供一些“特殊的服务”，包括枪支、毒品、网络攻击等等。

网络结构

Tor 匿名网络结构主要由目录服务器、洋葱代理、洋葱路由器这三部分组成。

• 目录服务器：它负责收集和更新网络中所有可运行的中继节点信息，为客户端提供节点公钥等建立链路所需的必要信息。目前，绝大多数的目录服务器在欧美地区,只有极少数分布在亚洲。
• 洋葱代理：它是 tor 用户的客户端代理程序，负责下载目录服务器中的路由信息，选择节点和建立路径，并对通信信息进行加解密。
• 洋葱路由器（又称中继节点）：它是构建匿名通信链路的基础，负责转发 tor 客户端和网络服务器的通信信息，是实现匿名通信的关键。目前整个 tor 网络中有几千个路由节点分布在世界各地，这些中继节点又分为三种类型:
  • Entry/Guard 中继节点──这是 tor 网络的入口节点。这些中继节点运行一段时间后，如果被证明是稳定的，并具有高带宽，就会被选来作为 Guard 中继节点。
  • Middle 中继节点──Middle 中继节点是位于中间节点位置上的洋葱路由器，充当流量从 Guard 中继节点传输到 Exit 中继节点的桥梁，这可以避免 Guard 中继节点和 Exit 中继节点探查到彼此的位置。
  • Exit 中继节点──位于出口节点位置上的洋葱路由器，负责将 Tor 网络内的流量转发到网络外部的互联网中去。每个出口节点都有一个相关的出口政策，该政策规定该节点能通过哪个端口转发何种协议的流量来防止滥用 tor 网络。

  tor 网络主要依赖于这些中继节点转发用户流量，tor 通过随机选取遍布于全球由志愿者运行的三个中继节点，然后分别与选择的入口节点、中间节点、出口节点协商会话密钥。用这些协商的密钥将通信数据先进行多层加密，然后再将加密的数据在三个洋葱路由器组成的通信链路上传送。数据每经过一个洋葱路由器就像是剥去一层洋葱皮一样解密去掉一个加密层，以此得到下一跳路由信息，然后将数据继续发往下一个洋葱路由器，不断重复此过程,直到数据送达目的地。这种转发方式能防止那些知道数据发送端以及接收端的中间人窃听数据内容。

tor路由技术

以下步骤讲述了Alice在使用tor与Bob的服务器进行通讯时，tor是如何工作的。

• Alice开启tor客户端代理，获取来自tor 目录服务器（Dave）中的tor节点（或中继的列表）以及它们的公钥。

• Alice 选择三个节点建立通信链路。Alice 得到入口中继节点的 IP 地址和身份摘要，和入口节点协商一个只用于两者之间通信的短暂会话密钥。成功建立一跳的链路以后，Alice 使用同样地方法要求入口节点拓展链路到中间节点，得到了 Alice与中间节点的短暂会话密钥。Alice 重复此过程直至建立一条含有三跳的通信链路并且获得三个她与三个节点独一无二的短暂会话密钥。整个链路建立过程中的所有连接都是加密的。然后Alice 向 Bob 发送服务请求，并且将请求内容使用三个会话密钥按由远到近的顺序依次加密。入口节点接收到解密消息后会使用会话密钥将其解密一层，并将仍然加密的信息转发给中间节点。直至到达出口节点后，才将信息解密为明文。图中的虚线表示出口节点与 Bob 之间的连接是未加密的，出口节点将原始数据发送给 Bob。Bob 回复请求内容，并且每个节点会以相反的加密顺序加密一层,最终送还给 Alice。

• 如果 Alice 与 Bob 通信时间较长，Alice 每隔几分钟会重新选择三个节点建立新的通信链路以防攻击者窃听。如果 Alice 想要访问另一服务器 Jane，她也会重新选择中继节点建立新的通信链路。

tor匿名服务

  之前提到暗网中也存在很多网站，这些网站在提供相应的服务时（暗网中大部分网络服务都是违法的）也希望是匿名的，即用户无法追踪到关于该网站的相关信息。下面主要讲解用户Alice和匿名服务器Bob交互的具体过程。

• 服务器Bob与tor网络中的一些中继节点连接，请求这些中继节点作为匿名服务的接入点，并将Bob的公钥发送给这些中继节点。注意Bob和中继节点之间的连接也是匿名的，这些中继节点无法获取关于Bob的相关位置信息。

• Bob将之前建立的接入点的相关信息和自己的公钥组装成描述符，并用自己的私钥该描述符进行签名，然后将其发送到目录服务器。通过Bob的公钥可以生成一个16位的字符串，记为XYZ。当客户端请求XYZ.onion时就可以找到对应Bob的描述符。

• Alice通过某些渠道获得了tor域名XYZ.onion，Alice想要访问该服务器。她通过tor客户端访问XYZ.onion，此时可以从目录服务器中获取对应服务器的描述符，通过描述符可以知道Bob服务器的接入点和公钥。与此同时，Alice会提前建立另外一条私密临时会话点，用于下一步与Bob交互。

• 当确认描述符存在且临时通道准备好之后，Alice用描述符中的公钥加密一条信息，包括临时会话点和会话秘钥，将加密后的信息发送给描述符中的接入点，之后接入点会将加密信息发送到对应的服务器（即Bob的服务器）。

• Bob收到加密信息后将其解密，获取临时会话点和会话秘钥。然后和临时会话点建立匿名连接，连接成功后，临时会话点会通知Alice。之后Alice和Bob可以通过临时会话点进行通信，注意通信过程中建立的连接都是匿名的。

tor客户端代理

  如果只是希望匿名浏览web网页，我们可以通过tor浏览器来实现。tor浏览器是基于火狐浏览器改造而来，可以方便的帮助我们连接到tor，实现网络匿名。如果想要在更多应用中实现网络匿名，我们可以安装tor客户端代理。以下配置过程基于ubuntu，且默认已安装shadowsocks。

安装polipo

  polipo是轻量级的跨平台代理服务器，可以实现http和socks代理，polipo本地服务端口为8123。

1

sudo apt-get install polipo

安装完成后，修改配置文件/etc/polipo/config

1
2

socksParentProcy = "localhost:9050" #tor服务本地端口为9050
socksProxyType = socks5

安装tor

1

sudo apt-get install tor

安装完成后，修改配置文件/etc/tor/torrc，添加以下内容。

1

SOCKS5Proxy 127.0.0.1:1080 #shadowsocks本地服务端口为1080

测试

  完成上述操作后，开启polipo、tor和shadowsocks。如果我们希望在chrome浏览器中实现网络匿名，可以通过添加tor代理来实现。

1

代理协议：socks5    代理服务器：127.0.0.1    代理端口：9050

如果我们希望在命令行中实现网络匿名，可以通过polipo代理来

1

http_proxy=http://localhost:8123 "需要执行的操作“