video caption

在这篇论文和后续几篇论文中，谷歌的研究者们在超过 250 亿的句子对上训练了一个 NMT 模型，这些句子是 100 多种语言与英语的互译，参数量超过 500 亿。他们得到了一种大规模多语言、大规模神经机器翻译方法 M4，在数据丰富和匮乏的语言中都实现了显著的性能提升，可以轻松适应单个领域/语言，同时能够有效应用于跨语言下游迁移任务。

EMNLP2019上，Investigating Multilingual NMT Representations at Scale，谷歌的研究者比较了多语言模型在多种语言中的表征能力。他们发现，多语言模型无需外部限制就能学习在语言学上相似的语言的共享表征，验证了长期以来利用这些相似性的直觉和实验结果。

Evaluating the Cross-Lingual Effectiveness of Massively Multilingual Neural Machine Translation中，研究者进一步证明了这些学习到的表征在下游任务中跨语言迁移的有效性。

构建大规模神经网络

在增加数据匮乏的语种数量之后，数据丰富的语种翻译质量开始下降。这种下降在多任务设置中可以被观察到，由任务间的竞争和迁移的单向性引起（即从数据丰富的语言到数据匮乏的语言）。研究人员探索了能够更好地学习和实现能力控制的算法，以此来解决这种负迁移问题。在此过程中，他们还通过增加神经网络模型的参数量来提高其表征能力，以此来提高数据丰富语言的翻译质量。

提高神经网络的能力还有其他几种方法，包括添加层数、增加隐藏表征的宽度等。为了训练更深的翻译模型，研究者利用 GPipe 来训练 128 层、参数超过 60 亿的 Transformer。模型能力的提高使得所有语言的翻译质量都得到了显著提升，BLEU 分数平均提高了 5 分。他们还研究了深度网络的其他性质，包括深度-宽度权衡、可训练性难题以及将 transformer 扩展到 1500 多层、840 亿参数的设计选择等。

尽管扩展深度是提高模型能力的一种方法，探索能够利用问题多任务特性的架构也是一种非常可行的补充方法。研究者通过用稀疏门控专家混合层（sparsely-gated mixture of experts）替代原始的前馈层修改 transformer 的架构，显著提高了模型能力，使得我们可以成功地训练和传递 500 亿参数，从而进一步提高了翻译质量。

RSGAN

2019-10-12T00:00:00+00:00

节后收心困难？这15篇论文，让你迅速找回学习状态

Generating Reliable Friends via Adversarial Training to Improve Social Recommendation

http://github.com/Coder-Yu/RecQ

本文为发表在 ICDM 2019 的工作。论文提出了一种基于生成对抗训练框架的 social recommendation 模型，指出了现有社会化推荐模型中的关系缺失、噪声问题，并利用对抗训练改善了这些问题，提高了社会化推荐的效果。此外，以往基于 Policy Gradient 的离散 GAN 在训练时存在 reward 函数设计困难，收敛难等问题，本文利用重参数技巧，对模型进行了 End-to-End 的训练，绕开了 reward 函数，取得了很好的效果。

Animating Face using Disentangled Audio Representations

2019-10-11T00:00:00+00:00

微软AI：一张面部照片一段音频，完美生成头像演讲视频

Animating Face using Disentangled Audio Representations

flowseq

2019-10-11T00:00:00+00:00

参考节后收心困难？这15篇论文，让你迅速找回学习状态

FlowSeq: Non-Autoregressive Conditional Sequence Generation with Generative Flow

本文是 CMU 和 Facebook AI 联合发表于 EMNLP 2019 的工作。为了解决自自回归模型（auto regressive）在 Seq2Seq 问题上解码速度慢，只能利用一侧上下文信息等问题，提出了利用 generative flow 的非自回归模型（non-autoregressive）FlowSeq。在机器翻译任务上面的相比于之前的非自回归模型有显著提高，大大缩小了与自回归模型的差距。同时解码速度比自回归模型明显加快。

https://github.com/XuezheMax/flowseq

MixHop

2019-10-11T00:00:00+00:00

参考节后收心困难？这15篇论文，让你迅速找回学习状态

MixHop: Higher-Order Graph Convolutional Architectures via Sparsified Neighborhood Mixing

https://github.com/samihaija/mixhop

本文是图分析大牛 Bryan Perozzi 组发表于 ICML 2019 的工作。本文 argue 现有的 GNN 模型无法学习到一种很通用的邻居混合信息，然后提出了 MixHop 来混合不同阶邻居的信息并学习节点表示。

MixHop 非常的高效并且有很强的理论背景（MixHop 与 delta operators 之间的联系）。另外，通过混合各阶信息，MixHop 一定程度上避免了 GNN 过平滑问题。GNN 的过平滑问题：随着层数的增加，GNN 所学习到的节点表示变的没有区分度。最后作者通过大量的试验验证了 MixHop 的效果。

在 Citeseer，Cora 和 Pubmed 上，MixHop 都取得了大量提升。例如，虽然 MixHop 没有使用注意力机制来学习邻居的重要性，但其表现依然大幅超过 GAT。

avm

2019-10-11T00:00:00+00:00

平安首创AVM自动变奏模型，探秘全球首部AI交响变奏曲背后硬核技术

Arror数据集+tf

2019-10-10T00:00:00+00:00

TensorFlow 与 Apache Arrow 数据集搭配简介

Apache Arrow 本质上是一种基于内存的列式数据的标准格式，旨在提高系统之间的效率和互操作性。

首先，作为一种数据标准，无论数据来源为何，Apache Arrow 均能确保数据类型安全性和数据完整性。
其次，作为一种内存格式，Apache Arrow 允许系统之间进行数据交换，而无需为不同文件格式进行序列化或转换。
最后，Arrow 始终针对数据处理进行全面优化，无论是零拷贝中读取还是现代硬件上的加速操作支持均涵盖在内。

因此，这确保了您可以高效地处理数据，同时与不同规模的各类系统无缝集成。

Arrow 数据集是 tf.data.Dataset 的扩展，因此两者可利用相同的 API 与 tf.data 流水线集成，并可作为 tf.keras 的输入。TensorFlow I/O 目前提供 3 种 Arrow 数据集，按名称排序如下：ArrowDataset、ArrowFeatherDataset 和 ArrowStreamDataset。这三种数据集均由相同的底层 Arrow 数据馈送，且此类底层数据具有两个重要特征：结构化和批量化。

TensorFlow 与 Apache Arrow 数据集搭配最佳实践

情感计算

2019-10-10T00:00:00+00:00

情感计算：让机器更加智能

Recurrent Independent Mechanisms

2019-10-08T00:00:00+00:00

Bengio等人提出新型循环架构，大幅提升模型泛化性能

Recurrent Independent Mechanisms

deep image prior用于视频修复

2019-10-07T00:00:00+00:00

让视频里的你完全消失，Adobe最新SOTA模型实现无痕修图，无需先验知识

用各种修图技术 P 掉图片里的指定内容往往很难不着痕迹，抹掉视频里的流动内容就更难了。但近日，Adobe 提出了一种基于 Deep Image Prior 的新型视频修图算法，可以同时修复缺失图像和移动（光流）信息，增强视频的时间和空间连贯性，使得去掉某些内容之后的视频依然自然、流畅，毫无修图痕迹。而且，该方法无需外部数据库，仅通过视频内部学习即可实现。

An Internal Learning Approach to Video Inpainting

tsm

2019-10-05T00:00:00+00:00

TSM
加速

TSM

ICCV2019上，TSM: Temporal Shift Module for Efficient Video Understanding

加速

15分钟完成Kinetics视频识别训练，除了超级计算机你还需要TSM

Training Kinetics in 15 Minutes: Large-scale Distributed Training on Videos

https://github.com/mit-han-lab/temporal-shift-module

https://hanlab.mit.edu/projects/tsm/

深度视频识别的计算成本比图像识别更高，尤其是在 Kinetics 等大规模数据集上。因此，为了处理大量视频，可扩展性训练是至关重要的。这篇论文研究了影响视频网络的可扩展性的因素。研究者认定了三个瓶颈，包括数据加载（从磁盘向 GPU 移动数据）、通信（在网络中移动数据）和计算速度（FLOPs）。

针对这些瓶颈，研究者提出了三种可以提升可扩展性的设计原则：（1）使用 FLOPs 更低且对硬件友好的算子来提升计算效率；（2）降低输入帧数以减少数据移动和提升数据加载效率，（3）减少模型大小以降低网络流量和提升网络效率。

基于这些原则，研究者设计了一种新型的算子「时间位移模块（TSM：Temporal Shift Module）」，能够实现高效且可扩展的分布式训练。相比于之前的 I3D 模型，TSM 模型的吞吐量可以高出 1.8 倍。

研究者也通过实验测试了新提出的 TSM 模型。将 TSM 模型的训练扩展到了 1536 个 GPU 上，使用了包含 12288 个视频片段/ 98304 张图像的 minibatch，没有造成准确度损失。使用这样的硬件友好的模型设计，研究者成功地扩展了在 Summit 超级计算机上的训练，将在 Kinetics 数据集上的训练时间从 49 小时 55 分减少到了 14 分 13 秒，同时实现了 74.0% 的 top-1 准确度，这在准确度更高的同时还比之前的 I3D 视频模型快 1.6 和 2.9 倍。

在计算机视觉领域，视频识别是一个至关重要的分支。视频识别问题的难度更高，但得到的研究更少：（1）相比于 2D 图像模型，视频模型的计算成本通常高一个数量级。举个例子，很常见的 ResNet-50 模型的速度大约是 4G FLOPs，而 ResNet-50 I3D 则要消耗 33G FLOPs，多过 8 倍；（2）视频数据集比 2D 图像数据集大得多，而且数据 I/O 也比图像高很多。举个例子，ImageNet 有 128 万张训练图像，而视频数据集 Kinetics-400 有 6300 万训练帧，大约是前者的 50 倍；（3）视频模型的模型大小通常更大，因此需要更高的网络带宽来交换梯度。

gan-tts

2019-10-05T00:00:00+00:00

DeepMind推出GAN-TTS：用生成对抗网络实现高保真语音

High fidelity speech synthesis with adversarial networks

tensorflow 2.0

2019-10-01T00:00:00+00:00

tf2.0教程
- 基础
- 模型

谷歌重磅发布TensorFlow 2.0正式版，高度集成Keras，大量性能改进

安装：https://www.tensorflow.org/install

datasets：https://www.tensorflow.org/guide/data

autograph：https://www.tensorflow.org/guide/function

1.x->2.0迁移：https://www.tensorflow.org/guide/migrate

deeplearning.ai的教程：https://www.coursera.org/learn/introduction-tensorflow

tf2.0教程

基础

TensorFlow 2.0 基础：张量、自动求导与优化器

模型

TensorFlow 2.0 模型：Keras 训练流程及自定义组件

TensorFlow 2.0 模型：卷积神经网络

拷了一份过来：https://colab.research.google.com/drive/1GCWbk5pInyXSrJitM5dZfGxVT9ZWQsnM

InterpretML

2019-10-01T00:00:00+00:00

InterpretML
其他库
- LIME
- RSLIME
- H2O
- ACE(cv相关)

InterpretML

InterpretML: A Unified Framework for Machine Learning Interpretability

https://github.com/microsoft/interpret

InterpretML 是一个为实践者和研究者提供机器学习可解释性算法的开源 Python 软件包。InterpretML 能提供以下两种类型的可解释性：（1）明箱（glassbox），这是针对可解释性设计的机器学习模型（比如线性模型、规则列表、广义相加模型）；（2）黑箱（blackbox）可解释技术，用于解释已有的系统（比如部分依赖、LIME）。这个软件包可让实践者通过在一个统一的 API 下，借助内置的可扩展可视化平台，使用多种方法来轻松地比较可解释性算法。InterpretML 也包含了可解释 Boosting 机（Explanable Boosting Machine，EBM）的首个实现，这是一种强大的可解释明箱模型，可以做到与许多黑箱模型同等准确的性能。

其他库

参考吐血整理！绝不能错过的24个顶级Python库

LIME

“Why Should I Trust You?” Explaining the Predictions of Any Classifier

https://github.com/marcotcr/lime

LIME是一种算法（库），可以解释任何分类器或回归量的预测。LIME是如何做到的呢？通过可解释的模型在局部不断接近预测值，这个模型解释器可用于生成任何分类算法的解释。

在机器学习模型中建立信任（在Python中使用LIME）

RSLIME

RSLIME: An Efficient Feature Importance Analysis Approach for Industrial Recommendation Systems

为什么刷小视频停不下来？爱奇艺用这篇论文告诉你答案

相比于传统的视频推荐系统，爱奇艺的 UGC 推荐和小视频分发有四个极其困难的方面：

新鲜度：爱奇艺的小视频应用的语料库非常动态，用户每天都会上传数十万条新视频。推荐系统应具有足够的响应能力，以便建模新上传的视频和最新的用户行为。
冷启动：鉴于小视频有更高的及时性要求和更低的用户黏性，推荐系统面临着严重的用户和项目冷启动问题，这会有损基于协同过滤（CF）的方法的性能。
多样性：由于视频类型和用户人口统计分布的多样性，爱奇艺的视频标签系统以及用户兴趣画像都比传统的视频推荐复杂得多，这也使得相关特征极其分散。内容和用户的多样性也会使得小视频推荐系统的结果不能稳健地应对输入中的错误。
兴趣转移：历史用户行为并不总是可靠的。每位用户在一个小时内就可能浏览数十个小视频，他们感兴趣的内容也会发生巨大的变化。一旦用户对之前的视频感到厌烦，他们就会渴望探索新的类别。因此，把握短期和长期用户偏好之间的平衡是至关重要的。

针对这些难题，爱奇艺的研究者提出了一种遵循多阶段流程的模型，其由三个模块构成，即用户画像（User Profile）、召回（Recall）和排序 Ranking）。为了提升小视频推荐系统的表现，每个模块中都使用了广泛的模型集成方法。下面简要介绍了其系统结构：

用户画像：对用户的人口统计属性、历史行为、兴趣和偏好的多维度分析。用户画像可用作实现个性化推荐的基石。
召回：多种协同过滤（CF）算法（基于物品的 CF、基于用户的 CF、矩阵分解、Item2Vec 等）和多种基于内容的过滤（CBF）方法的组合。这些模型的结果会被聚合起来，为每个请求构建一个视频候选项语料库，其中通常包含数百条视频。
排序：一个用于评估视频候选项的分数的点击率预估模型，然后将少量最佳推荐的视频推送到用户界面。

为了监控排序模型的工作方式是否有如预期以及是否能加速模型的迭代过程，爱奇艺提出了一种与模型无关的推荐系统局部可解释方法 Recommendation System Boosted Local Interpretable Model-Agnostic Explanations Method（RSLIME，），可为其排序模型提供特征重要度分析。RSLIME 有望为推荐系统中的特征选取过程提供参照，并帮助推荐系统开发者不必太过麻烦就能调整他们的排序模型。RSLIME 具有以下特点：

对于单个输入样本，RSLIME 可以生成特征重要度的估计，而不管排序模块中所用的架构为何。然后可以基于这些特征重要度解释推荐结果。
对于多个输入样本，RSLIME 可以结合多个样本的预测结果进行整体分析，并给出准确的特征重要度估计。
RSLIME 可对稀疏特征的影响进行高效的分析，从而指导模型的优化和特征的选择

其中：

DNN：DNN 使用的是一个带有三个隐藏层的全连接网络，其维度分别为 1024、512 和 256。DNN 的输入是用户和视频的预训练的特征嵌入，这基于用户行为和视频语义内容。爱奇艺的模型使用了 DNN 来提升排序模块的准确度以及在线 A/B 测试中的泛化能力。
GBDT：GBDT 是指多个决策树的基于提升（boosting）的集成。GBDT 的叶节点自动表示所选择的重要特征，其可被用于提升 FM 的性能。GBDT 先要单独进行预训练，之后才会与 FM 和 DNN 进行联合训练。由于 GBDT 对非归一化的特征的存在而言是稳健的，所以其输入中归一化和非归一化的稠密特征都可以有。
FM：FM 可自动执行特征组合和二阶交叉特征计算。因此，FM 可以执行特征融合和在 GBDT 输出和稀疏特征上执行交叉，由此能在推荐点击率（CTR）预估方面取得当前最佳的结果。
Sigmoid：Sigmoid 能为 DNN 和 FM 的输出加权并在其结果上执行 sigmoid 变换。

这里使用 X 表示输入数据，x 表示单个输入样本。样本 x 的 n 维输入特征表示为 Zn 或 (z1…zn)。z 表示单个特征组合，推理模型表示为 f。线性回归模型 g ∈ G 等可解释的模型经过训练后用于执行单个案例的特征重要度分析。

RSLIME 是局部可解释的与模型无关的解释（LIME）方法的一种扩展。LIME 使用了一种可解释的模型来评估推理模型 f 在单个输入样本 x 上的特征重要度。设有 100 个特征 (z1…z100) 的一个输入样本 x，f(x) 是 x 的推理结果。

LIME 首先会自动生成数千个不同的特征组合（比如 z1…z99、z2…z100）。然后对于每个特征组合，LIME 根据这个组合内部的特征（同时掩盖其它所有特征）计算该推理模型 f 的预测结果。为了说明清楚，使用特征组合 z1…z99 时，表示 z100 被 0 掩码掩盖。

给定每个特征组合 z 和对应的预测结果 f(z)，LIME 会计算 z 和 x 的距离并将其作为 z 的权重，然后会训练一个可解释的模型（以线性回归模型为例）g 将 z 映射到 f(z) 和 f(x) 之间的绝对差值，然后用作单个案例特征重要度的直接指示。这个可解释模型中每个特征的最终权重都会被用作特征重要度。因此，LIME 的局部特征诊断算法可以表示为：

\[ \varepsilon(x)=\operatorname{argmin}_{g \in G} L\left(f, g, \pi_{x}(z)\right)+\Omega(g) \]

$\Omega(g)$表示模型复杂度，$\pi_{x}(z)$表示样本x的特征组合。

H2O

https://github.com/h2oai/mli-resources

H2O的无人驾驶AI，提供简单的数据可视化技术，用于表示高度特征交互和非线性模型行为，通过可视化提供机器学习可解释性（MLI），说明建模结果和模型中特征的影响。

机器学习可解释性

AI眼中的世界是什么样子？谷歌新研究找到了机器的视觉概念

https://github.com/amiratag/ACE

各种概率分布

2019-10-01T00:00:00+00:00

Distribution is all you need：这里有12种做ML不可不知的分布

https://github.com/graykode/distribution-is-all-you-need

量子计算相关

2019-10-01T00:00:00+00:00

简介
量子霸权
强化学习+量子计算

简介

量子计算介绍：An Introduction to Quantum Computing, Without the Physics

量子霸权

Quantum Supremacy Using a Programmable Superconducting Processor

谷歌实现量子霸权论文曝光，圈内人士：量子计算的里程碑事件

谷歌开启量子计算“hello world”时代！费曼预言将成真

量子霸权（quantum supremacy）是指量子计算在某些任务上拥有超越所有传统计算机的计算能力。

强化学习+量子计算

通往量子霸权之路：谷歌用强化学习优化量子门控制策略

Universal Quantum Control through Deep Reinforcement Learning

one-shot模仿学习

2019-10-01T00:00:00+00:00

让机器人看一眼就能模仿：One-Shot模仿学习发展情况

3篇：

Yu, Tianhe, et al. One-shot hierarchical imitation learning of compound visuomotor tasks，基于元学习的单样本模仿学习。
De-An Huang, et al. Continuous Relaxation of Symbolic Planner for One-Shot Imitation Learning (2019)，利用符号规划问题的单样本模仿学习。
Leo Pauly, et al.One-Shot Observation Learning Using Visual Activity Features，基于视觉活动特征的单样本观察学习。

gate decorator

2019-10-01T00:00:00+00:00

利用LSTM思想来做CNN剪枝，北大提出Gate Decorator

可解释性CNN

2019-10-01T00:00:00+00:00

CVPR 2019 | 基于可解释性以及细粒度的可视化解释卷积神经网络

Interpretable and Fine-Grained Visual Explanations for Convolutional Neural Networks

gan剪枝

2019-10-01T00:00:00+00:00

ICCV 2019：华为、北大等首创GAN剪枝算法，线上加速 3 倍以上

Co-Evolutionary Compression for Unpaired Image Translation

https://github.com/huawei-noah/GAN-pruning

语音生成评价

2019-10-01T00:00:00+00:00

语音生成效果评价不再逐句进行：谷歌提出长文本语音生成评价新系统

rl for recommendation

2019-09-20T00:00:00+00:00

drn
top-k off-policy
slateq
DEAR
- dear模型结构
- dear实验

drn

https://daiwk.github.io/posts/rl-drn.html

top-k off-policy

https://daiwk.github.io/posts/dl-topk-off-policy-correction.html

slateq

https://daiwk.github.io/posts/rl-slateq.html

DEAR

今日头条最新论文，首次改进DQN网络解决推荐中的在线广告投放问题

Deep Reinforcement Learning for Online Advertising in Recommender Systems

dear模型结构

在给定推荐列表前提下，本文提出了一种基于DQN的创新架构来同时解决三个任务：

是否插入广告
如果插入，插入哪一条广告
插入广告在推荐列表的哪个位置

DQN的两种经典结构：

输入state，输出是所有可能action对应的Q；
输入state以及某一个action，输出是对应的Q。

这两种经典架构的最主要的问题是只能将action定义为插入哪一条广告，或者插入广告在列表的哪个位置，无法同时解决上述提到的三个任务。

当然，插入位置与插入哪一条广告通过某种表示形式，如one-hot编码来建模action，那么action空间就是O(A*L)，其中A是广告数量，L是位置数量。要实际应用是不可能的。。

本文融合了上述提到了两种经典DQN结构的结合，会同时针对所有可能的插入位置的Q进行预估。

如下图的左边部分，输入层包含State以及Action（插入哪条广告），输出层则是广告插入推荐列表的L+1位置对应的Q-（假设推荐列表长度为L，则可以插入广告的位置为L+1种可能）。与此同时，使用一个特殊插入位置0用来表示不进行广告插入，因此输出层的长度扩展成为L+2。

然后看右边部分，参考dueling dqn，输出层Q函数被拆解成两部分：只由state决定的V(s)函数；以及由state和action同时决定的A(s,a)函数。其中，

state是把下面3部分concate到一起的一个向量：
- 使用GRU针对用户的推荐结果点击历史和广告点击历史进行用户序列偏好建模的$p^{rec}_t$和$p^{ad}_t$；
- 当前用户请求的上下文信息$c$，例如操作系统，app版本号，上下滑动等；
- 当前请求展示的推荐列表item的特征进行concat(当然也可以是cnn等)形成的低维稠密向量$rec_{t}$；
action包含两部分：
- 一部分是候选插入广告ad的特征$a_t^{ad}$，作为输入的一部分
- 另一部分则是广告插入的位置$a_t^{loc}$
reward函数。Reward函数也包含两部分：
- 一部分是广告的的收入$r^{ad}_t$；
- 另一部分则是用户是否继续往下刷的奖励$r^{ex}_t$，继续刷新是1，离开是-1。

最优的Q函数策略便可以通过Bellman等式求得：

\[ Q^{*}\left(s_{t}, a_{t}\right)=\mathbb{E}_{s_{t+1}}\left[r_{t}+\gamma \max _{a_{t+1}} Q^{*}\left(s_{t+1}, a_{t+1}\right) | s_{t}, a_{t}\right] \]

基于用户交互历史的离线日志，采用 Off-policy的方式进行训练得到最优的投放策略。

针对每一次迭代训练：

针对用户请求构建状态$s_t=concat(p^{rec}_t,p^{ad}_t,c_t,rec_t)$；
根据off-policy $b(s_t)$(即离线日志里的当前广告策略)执行action $a_t$，也就是选取特定ad；
更新状态为$s_{t+1}$
计算reward $r_t=r_t^{ad}+\alpha r_t^{ex}$；
将状态转移信息$(s_{t}，a_{t}，r_{t}，s_{t+1})$存储到replay buffer；
从replay buffer中取出mini-batch的状态转移信息$s,a,r,s'$，来最小化$(y-Q(s, a ; \theta))^{2}$训练得到最优的Q函数参数。
其中，

\[ y=\left\{\begin{array}{ll}{r} & {\text { terminal } s^{\prime}} \\ {r+\gamma \max _{a^{\prime}} Q\left(s^{\prime}, a^{\prime} ; \theta\right)} & {\text { non - terminal } s^{\prime}}\end{array}\right. \]

在线test：

得到状态$s_t=concat(p^{rec}_t,p^{ad}_t,c_t,rec_t)$；
通过最优策略$Q^*(s_t,a_t)$执行动作$a_t$
得到用户反馈的reward $r_t(s_t,a_t)$
将状态从$s_t$更新到$s_{t+1}$

dear实验

100w的session，涉及到18w的user，1700w的自然结果视频，1000w的广告。

平均每个session里有55个自然结果视频,55%的推荐列表里有广告，平均每个session的时长是17min。

The Lottery Ticket Hypothesis

2019-09-18T00:00:00+00:00

参考训练网络像是买彩票？神经网络剪枝最新进展之彩票假设解读

ICLR2019，The Lottery Ticket Hypothesis: Finding Sparse, Trainable Neural Networks

彩票假设的正式定义为：一个随机初始化的密集神经网络包含一个初始化的子网络，在单独训练时，最多经过相同的迭代次数，可以达到和原始网络一样的测试准确率。

我们将一个复杂网络的所有参数当做奖池，上述一组子参数对应的子网络就是中奖彩票。

作者提出了彩票假设并给出一种寻找中奖彩票的方法，通过迭代非结构化剪枝的方式可以找到一个子网络，用原始网络的初始化参数来初始化，可以在性能不下降的情况下更快的训练这个子网络，但是如果用随机初始化方法却达不到同样的性能。

作者也在文章中指出这项工作存在的一些问题。例如，迭代剪枝的计算量太大，需要对一个网络进行连续 15 次或 15 次以上的多次训练。未来可以探索更加高效的寻找中奖彩票的方法。

Deconstructing Lottery Tickets: Zeros, Signs, and the Supermask

SpeedTorch

2019-09-17T00:00:00+00:00

超原版速度110倍，针对PyTorch的CPU到GPU张量迁移工具开源

https://github.com/Santosh-Gupta/SpeedTorch

可视化工具

2019-09-17T00:00:00+00:00

netron

netron

官网：https://github.com/lutzroeder/netron

可以装个mac的app

也可以直接python装了，然后：

netron xxx.pb --host "aa.bbbbb.cc.com" --p 8999

接下来就可以在chrome里通过http://aa.bbbbb.cc.com:8999来看了

tf要生成pb的一个最简单的demo，紧跟着save加一句write_graph就行：

with tf.Session() as sess:
    saver = tf.train.Saver()
    ## ...
    ## save
    saver.save(sess, "models/")
    tf.train.write_graph(sess.graph_def, './', 'model.pb', False)

可以搜索的呢。。掉渣天

hypergraph相关

2019-09-17T00:00:00+00:00

IJCAI 2019 论文解读 | 基于超图网络模型的图网络进化算法

现实生活中很多的数据可以用图（graph）来建模，比如社交网络数据，paper 引用数据等。对于 AI 而言，一个常见的任务是半监督分类，即对图中的每一个点进行分类，在仅有部分点有标注的情况下。

处理理此类问题，比较经典的方法是 GCN，通过对相邻节点的特征聚合操作来对每个节点进行特征提取。GCN 等 GNN 模型对于节点之间的关系表征是二元的，即仅能表征两个节点 <e1,e2> 之间的关系，对于大于二元的关系组只能通过多个二元关系的方式去近似。

超图模型（Hypergraph）就是针对这种情况提出的一种网络结构。不同类型的数据中都存在着多元关系，超图模型的基本设定就是一个边可以包含大于 2 个点，去拟合多元关系。

Listener-Decoder-Speller(LDS)

2019-09-15T00:00:00+00:00

Interspeech 2019 | 阿里达摩院语音实验室：联合CTC和Transformer的自动中文纠错模型

Automatic Spelling Correction with Transformer for CTC-based End-to-End Speech Recognition

learn2learn

2019-09-14T00:00:00+00:00

三四行代码打造元学习核心，PyTorch元学习库L2L现已开源

文档：http://learn2learn.net/docs/learn2learn/

github: https://github.com/learnables/learn2learn

pip install learn2learn

neural style transfer相关

2019-09-14T00:00:00+00:00

参考10秒搞定建筑日夜景转换，还自带中秋月光

美图的MML

2019-09-09T00:00:00+00:00

概述
召回+排序
多目标

概述

当推荐遇到社交：美图的推荐算法设计优化实践

MML 机器学习平台包括三个主要模块：

Spark Feature：负责数据分析、特征工程，以及样本拼接。Spark Feature 基于 Spark SQL 进行开发，用户通过编写 SQL 以及配置样本拼接 JSON，即可实现特征以及样本生产的工作；
Bamboo：基于 tensorflow 开发，负责模型训练、离线效果评估。Bamboo 实现了推荐领域大量的 State of the Art 的模型，并且提供了丰富的 Layers，以简化算法同学的建模工作。在训练方面支持多种并行训练方式，同时通过对代码的优化实现了较高的训练效率；
MML Serving：负责模型的在线服务。底层通过 C++ 实现，在内存和并发上做了大量的优化，支持同时请求多个模型，以及在线热更。灵活的架构让我们能够很方便地接入各种机器学习框架训练的模型。

Bamboo 具有以下优点：

便捷：内置了近几年推荐领域的 SOTA 模型，以及建模常用的 Layers，并且内置了部分公共数据集的访问接口，能够支持从本地磁盘，以及 HDFS 读取训练数据。数据、训练、模型评估、模型导出通过配置化实现，算法同学可以专注于模型的设计；
高效：采用 tensorflow 底层 API 和 Estimator 来实现，并遵循 tensorflow 官方性能优化指南，最大限度提升模型训练效率，相比 Keras 以及内部未优化版本，单卡训练效率有数倍提升。同时，能够支持同步、异步等多种并行训练方案；
可扩展：Bamboo 的最初的设计目标是作为 tensorflow 的补充，因此在整个设计过程充分考虑了扩展性，能够支持采用 Bamboo 提供的 API 或者使用 tensorflow 原生 API。良好的分层设计，方便使用方进行模块的复用和重构。

MML Serving 决定了模型能否上线提供服务以及在线服务的效率。去年下半年，我们上线了采用 C++ 开发的新版 MML Serving，通过内存和并发的优化，让我们整体预估耗时减少了 50%，服务初始化耗时减少了 50%，内存使用量降低了 77%。通过压测发现，服务在高并发下，整体表现稳定。另外良好的架构设计，可以很方便接入各种第三方机器学习库，目前已经内置了对 tensorflow 和 xgboost 模型的支持。

2018 年，我们上线了第一个基于何向南在 SIGIR 2017 发表的《Neural Factorization Machines for Sparse Predictive Analytics》改进的模型——NFM-v4。相比原论文，我们的主要改进点是通过一个线性变换，将变长稀疏的原始高维特征压缩到一个定长稠密的低维实数空间，从而屏蔽了模型在输入特征处理上的差异，可以将精力更多放在特征的挖掘上。

但是，将几十万维的高维空间直接压缩到几百维，存在一定的信息损失，因此，在 NFM-v4 的基础上，我们通过将部分高维 id 特征单独建模，比较好的解决了这个问题，在业务指标上，也有不错的效果提升，美拍的人均播放时长增加了 4.75%，人均有效行为数增加了 3.45%。

不过，NFM 存在的一个问题是，bi-interaction pooling 认为特征二阶交叉的权重是相等的，这种假设在多数场景下并不符合数据的真实分布。因此，在 NFM 的基础上，我们提出了 Neural Field weighted Factorization Machines（NFwFM）模型，通过引入一个权重向量，来建模二阶交叉特征的权重。通过二阶向量不等权相加，业务指标整体提升较为明显。其中美拍人均播放时长增加 3.78%，播放用户数增加 1.74%，美图秀秀点击率提升了 5.689%，人均使用时长增加 2.53%，新用户点击率增加 2.701%。

目前，我们主要尝试了三种用户行为序列建模的方法，包括 Sum/Mean Pooling 、 RNN 、 Attention 等。在我们的业务场景下，

RNN 的离线效果并不理想，原因推测是用户点击 feed 的先后顺序并不存在某种固定的模式，而主要取决于用户对所推荐 feed 的偏好，此外，RNN 的训练耗时也增加比较明显。
Sum/Mean Pooling 的方式虽然简单，但是在长行为序列建模上，效果相比其它两种方式表现得更加优异，因此是我们目前线上建模用户长序列特征的主要手段。
我们也对比了基于 Attention 的方法，离线效果相比 Sum/Mean Pooling 有略微提升，但是考虑到计算复杂度，Attention 只适合于序列长度较短的场景。

在美拍，美图秀秀社区，以及 push 业务都尝试了用户行为序列特征建模，各项业务指标均有较大幅度的提升，美拍人均时长提升了 12%，秀秀的点击率提升了 5%，push 的到达点击率提升了 10%。

召回+排序

深度学习技术在美图个性化推荐的应用实践

多目标

整个多目标优化的路线，大概经历了四个阶段：样本 reweight，多目标模型，多模型，多个多目标模型。

样本reweight

样本 reweight 是一种简单轻量的可用于解决多目标问题的做法，它借鉴了 imbalanced data 的典型做法，在保持模型优化的主目标不变的情况下，通过提高次要目标的正样本占比，来模拟多目标的联合概率分布。

我们在美拍和美图秀秀社区上，对增加关注目标进行了尝试。美拍在播放时长略微上涨的情况下，实现了人均关注 10.06% 的提升。美图秀秀社区关注转化率提升了 12.03%，不过点击率也有略微的下降。

样本 reweight 的方式改变了样本的原始分布，导致主目标存在比较大的预估偏差。同时，因为次要目标是通过主目标的网络结构来实现，无法对各个目标的模型分别进行调优，模型结构优化存在比较大的局限性。

多目标模型

多目标模型通过共享底层的网络输入，实现信息共享，再根据每个目标的数据特点，分别构建各个目标的输出网络，得到每个目标的输出。

在美图的多个社交场景中，我们进行了尝试，并取得了比较大的在线提升。其中，在美拍双列 feed 流场景下，人均关注提升 11.43%，人均播放时长提升 12.45%。美图秀秀首页 feed 流，点击率提升 1.93%，关注率提升 2.9%。美图秀秀下滑 feed 流，关注率提升 9.3%，人均时长提升 10.33%。

多模型

虽然多目标模型在业务上取得了比较大的提升，但是仍然存在一些问题。典型的问题包括：

当不同任务的目标相关性较弱，或者损失函数的输出值范围差异较大时，多目标模型的调优存在比较大的困难；
使用多目标模型，会导致不同目标的优化存在比较大的耦合，延迟整体优化进度，在产品要求快速迭代的场景下，这种技术手段不一定能够很好的满足业务需求。

为了解决多目标模型存在的一些问题，我们通过拆分多目标模型的各个目标，得到多个单目标模型，并对每个单目标模型分别进行优化。在美拍双列 feed 流场景下，我们进行了相应的尝试，在人均时长不变的情况下，人均关注提升了 2.98%。通过进一步调整模型的优化目标，人均时长再次提升了 19.37%，人均关注提升了 14.1%。

多个多目标模型

当推荐场景的优化目标增加，多模型的方案会存在维护成本高，线上资源开销大，各个任务的模型无法利用其它任务的数据等问题。

综合多模型和多目标模型的优点，采用多个多目标模型是解决多目标任务的有效手段。在美拍场景下，通过同时优化关注、时长、播放等目标，人均关注提升 12.18%，活跃留存提升 25.67%。

非独立同分布的机器学习方法

2019-09-08T00:00:00+00:00

联邦学习相关可以看：https://daiwk.github.io/posts/dl-federated-learning.html

若DL没了独立同分布假设，样本不独立的机器学习方法综述

Learning Classifiers When The Training Data Is Not IID，ijcai，主要解决经典统计分析进行分类器预测过程中针对 Non-IID 数据的处理方法
Communication-Efficient Learning of Deep Networks from Decentralized Data 为解决联邦学习中 Non-IID 数据问题，提出一种基于迭代模型平均的深层网络联合学习方法（Federated Averaging，FedAvg）
Federated Learning with Non-IID Data是针对（2）的分析和改进，使用客户端数据分布和中央服务器数据总体分布之间的土方运距 (earth mover』s distance, EMD) 计算权重散度，同时提出了一种数据共享（Data-Sharing）策略改进 FedAvg 的性能
On the Convergence of FedAvg on Non-IID Data重点讨论联邦学习问题中 FedAvg 在处理 Non-IID 数据时的收敛性问题，从理论角度证明了 FedAvg 的有效性
LoAdaBoost:Loss-Based AdaBoost Federated Machine Learning on medical data基于 FedAvg 和数据共享策略提出了一种针对医学数据的提高联邦学习效率的自适应增强方法

neural structured learning(NSL)

2019-09-04T00:00:00+00:00

五行代码用图提升模型表现，TensorFlow开源NSL神经结构学习框架

https://github.com/tensorflow/neural-structured-learning

tf-gan

2019-08-31T00:00:00+00:00

参考谷歌TF-GAN大升级！云TPU支持，兼容TF 2.0，全新免费教程！

https://github.com/tensorflow/gan/tree/master/tensorflow_gan/examples/self_attention_estimator

参考TF - GAN入门：TensorFlow 2.0 的轻量级 GAN 库【这个东西不少，可以去看看。。】

使用tf-gan的论文：

https://github.com/tensorflow/gan#who-uses-tf-gan

多gpu并行

2019-08-31T00:00:00+00:00

Optimizing Multi-GPU Parallelization Strategies for Deep Learning Training

参考分布式训练中数据并行远远不够，「模型并行+数据并行」才是王道

数据并行化（Data parallelism，DP）是应用最为广泛的并行策略，但随着数据并行训练设备数量的增加，设备之间的通信开销也在增长。

此外，每一个训练步中批大小规模的增加，使得模型统计效率（statistical efficiency）出现损失，即获得期望准确率所需的训练 epoch 增加。这些因素会影响整体的训练时间，而且当设备数超出一定量后，利用 DP 获得的加速无法实现很好的扩展。除 DP 以外，训练加速还可以通过模型并行化（model parallelism，MP）实现。

来自加州大学洛杉矶分校和英伟达的研究人员探索了混合并行化方法，即每一个数据并行化 worker 包含多个设备，利用模型并行化分割模型数据流图（model dataflow graph，DFG）并分配至多个设备上。

autogan

2019-08-25T00:00:00+00:00

华人团队打造：AutoML + GAN = AutoGAN！AI设计GAN模型比人类更好

AutoGAN: Neural Architecture Search for Generative Adversarial Networks

github：https://github.com/TAMU-VITA/AutoGAN

利用NAS寻找最佳GAN：AutoGAN架构搜索方案专为GAN打造

mrqa

2019-08-19T00:00:00+00:00

百度夺冠MRQA 2019，包揽测试集10项第一，飞桨加持

说话人分类模型

2019-08-17T00:00:00+00:00

是谁在说话？谷歌多人语音识别新系统错误率降至2%

Joint Speech Recognition and Speaker Diarization via Sequence Transductio

HSIC-bottleneck

2019-08-16T00:00:00+00:00

参考彻底解决梯度爆炸问题，新方法不用反向传播也能训练ResNet

The HSIC bottleneck: deep learning without back-propagation

CorrNet

2019-08-11T00:00:00+00:00

基于Keras的关联神经网络CorrNet综合指南

在机器学习中，这些来自不同异构源的数据类型称为多模态数据，如语音识别中的音频和视觉信息。由于多模态数据可能由不同维度和类型的数据构成，往往难以在训练中直接使用。因此许多研究致力于解决多模态数据的通用表示。

学习多视图数据的通用表示有助于若干下游应用，如对视频及其对应的音频的通用表示进行学习，相比于单纯使用音频而言可以生成更加精确的字幕。

尝试学习两种数据视图的共同表示，并且从该编码表示重构两种视图。

相关神经网络（CorrNet）是学习通用表示的一种方法。它的架构与传统的单视图深度自动编码器几乎相同。但它为每种数据模态都构建了编解码对。

concept activation vector(概念激活向量)

2019-08-10T00:00:00+00:00

谷歌大脑提出概念激活向量，助力神经网络可解释性研究

https://github.com/tensorflow/tcav

Interpretability Beyond Feature Attribution: Quantitative Testing with Concept Activation Vectors

pytorch-kaldi

2019-08-01T00:00:00+00:00

参考语音识别开源工具PyTorch-Kaldi：兼顾Kaldi效率与PyTorch灵活性

github：https://github.com/mravanelli/pytorch-kaldi

论文：The PyTorch-Kaldi Speech Recognition Toolkit

生成模型小结

2019-07-29T00:00:00+00:00

O’Reilly新书：《生成式深度学习》，近5年最先进GAN一网打全！

电子书：https://www.oreilly.com/library/view/generative-deep-learning/9781492041931/

代码：https://github.com/davidADSP/GDL_code

生成式模型入门：训练似然模型的技巧

原文：https://blog.evjang.com/2019/07/likelihood-model-tips.html

SLATEQ

2019-07-24T00:00:00+00:00

背景
结合top-k off-policy一起看

Reinforcement Learning for Slate-based Recommender Systems: A Tractable Decomposition and Practical Methodology

这个比较长。。38页

SLATEQ: A Tractable Decomposition for Reinforcement Learning with Recommendation Sets

这个比较短。。

背景

xxx

结合top-k off-policy一起看

以 YouTube 论文学习如何在推荐场景应用强化学习

一个是 off-policy，一个是 value-base，用 on-policy。

好在推荐场景的样本收集成本低，量级比较大，但问题是存在较为严重的Bias。即只有被系统展示过的物料才有反馈，而且，还会有源源不断的新物料和用户加入。

off-policy的特点是，使用了两个policy，一个是用户behavior的$\beta$，代表产生用户行为Trajectory：$(s_0,A_0,s_1, ..., )$的策略，另一个是系统决策的$\pi$，代表系统是如何在面对用户a在状态s下选择某个action的。

off-policy的好处是一定程度上带了exploration，但也带来了问题。因此，常见的是引入importance weighting来解决。

和标准的objective比，多了一个因子，因为这个因子是连乘和rnn的问题类似，梯度容易爆炸或消失。论文中用了一个近似解，并有人证明了是ok的。

value-base虽然直观容易理解，但一直被质疑不能稳定的收敛。

而policy-base则有较好的收敛性质，所以在很多推荐场景的RL应用，大部分会选择policy-base。当然现在也很有很多二者融合的策略，比如A3C、DDPG这种，也是比较流行的。

$\pi$的训练是比较常规的，有意思的是$\beta$的学习。用户的behavior是很难建模的，我们还是用nn的方式去学一个出来，这里有一个单独的分支去预估$\beta$，和$\pi$是一个网络，但是它的梯度不回传。

listwise的loss并不容易优化，复杂度较高。RL在推荐场景，也会遇到相同的问题。但直接做list推荐是不现实的，假设我们一次推荐K个物料，总共有N个物料，那么我们能选择的action就是一个排列组合问题，$C_N^K * K!$个，当N是百万级时，量级非常夸张。

youtube的两篇论文，都将问题从listwise（他们叫slatewise）转化成了itemwise。但这个itemwise和我们常规理解的pointwise的个性化技术还是有区别的。在于这个wise是reward上的表达，同时要引申出user choice model。

pointwise的方法只考虑单个item的概率，论文中提出的itemwise，虽然也是认为最后的reward只和每个被选中的item有关，且item直接不互相影响，但它有对user choice做假设。比如论文[2]还做了更详细的假设，将目标函数的优化变成一个多项式内可解的问题

SC是指用户一次指选择一个item，RTDS是指reward只和当前选择的item有关。

有不少研究是专门针对user choice model的，一般在经济学中比较多。推荐中常见的有cascade model和mutilnomial logit model，比如cascade model，会认为用户选择某个item的概率是p，那么在一个list下滑的过程中，点击了第j个item的概率是$(1-p(i))^j * p(j)$.

论文1中最后的objective中有一个因子，表达了user choice的假设：

\[ \lambda_{K}\left(s_{t}, a_{t}\right)=\frac{\partial \alpha\left(a_{t} | s_{t}\right)}{\partial \pi\left(a_{t} | s_{t}\right)}=K\left(1-\pi_{\theta}\left(a_{t} | s_{t}\right)\right)^{K-1} \]

简单理解就是，用$\pi$当做用户每次选择的概率，那上面就是K-1不选择a概率的连乘。而论文2中，RL模型和现有的监督模型是融合在一起的，直接用pCTR模型预估的pctr来当这个user choice的概率。

Large Memory Layers with Product Keys

2019-07-13T00:00:00+00:00

参考LeCun力荐：Facebook推出十亿参数超大容量存储器

Large Memory Layers with Product Keys

label smoothing

2019-07-13T00:00:00+00:00

参考Hinton等人最新研究：大幅提升模型准确率，标签平滑技术到底怎么用?

When Does Label Smoothing Help?

layer rotation

2019-07-12T00:00:00+00:00

参考层旋转：超强的深度网络泛化评价标准？

dlrm

2019-07-04T00:00:00+00:00

参考想知道Facebook怎样做推荐？FB开源深度学习推荐模型

参考Facebook 面向个性化推荐系统的深度学习推荐模型

https://github.com/facebookresearch/dlrm

Deep Learning Recommendation Model for Personalization and Recommendation Systems

原始博客：https://ai.facebook.com/blog/dlrm-an-advanced-open-source-deep-learning-recommendation-model/

DLRM模型有两大类特征：连续（dense）特征和类别（sparse）特征。使用emb处理类别特征，使用下方的多层感知机（MLP）处理连续特征。然后显式地计算不同特征的二阶交互（second-order interaction）。最后，使用顶部的多层感知机处理结果，并输入sigmoid函数中，得出点击的概率。

multi-sample dropout

2019-06-07T00:00:00+00:00

Multi-Sample Dropout for Accelerated Training and Better Generalization

大幅减少训练迭代次数，提高泛化能力：IBM提出「新版Dropout」

简单地说，假设dropout的比例是0.5，那么dropout会在每轮训练中随机忽略（即 drop）50%的神经元，以避免过拟合的发生。如此一来，神经元之间无法相互依赖，从而保证了神经网络的泛化能力。在infer时，会用到所有的神经元，因此所有的信息都被保留；但输出值会乘0.5，使平均值与训练时间一致。这种推理网络可以看作是训练过程中随机生成的多个子网络的集合。后来有一些变形，例如DropConnect，也就是Regularization of Neural Networks using DropConnect，随机忽略的是神经元之间的部分连接，而不是神经元。

本文阐述的也是一种 dropout 技术的变形——multi-sample dropout。传统 dropout 在每轮训练时会从输入中随机选择一组样本（称之为 dropout 样本），而 multi-sample dropout 会创建多个 dropout 样本，然后平均所有样本的损失，从而得到最终的损失。这种方法只要在 dropout 层后复制部分训练网络，并在这些复制的全连接层之间共享权重就可以了，无需新运算符。

通过综合 M 个 dropout 样本的损失来更新网络参数，使得最终损失比任何一个 dropout 样本的损失都低。这样做的效果类似于对一个 minibatch 中的每个输入重复训练 M 次。因此，它大大减少了训练迭代次数。

GAN-CDQN

2019-06-05T00:00:00+00:00

简介
Setting和RL Formulation
Generative Adversarial User Model
Cascading RL Policy for Recommendation
- Cascading Q-Networks
- Parameterization and Estimation

参考ICML 2019 | 强化学习用于推荐系统，蚂蚁金服提出生成对抗用户模型

Generative Adversarial User Model for Reinforcement Learning Based Recommendation System

代码：https://github.com/xinshi-chen/GenerativeAdversarialUserModel

ppt：https://icml.cc/media/Slides/icml/2019/201(11-14-00)-11-14-25-4831-generative_adve.pdf

简介

本文提出利用生成对抗网络同时学习用户行为模型transition以及奖励函数reward。将该用户模型作为强化学习的模拟环境，研究者开发了全新的Cascading-DQN算法，从而得到了可以高效处理大量候选物品的组合推荐策略。

本文用真实数据进行了实验，发现和其它相似的模型相比，这一生成对抗用户模型可以更好地解释用户行为，而基于该模型的RL策略可以给用户带来更好的长期收益，并给系统提供更高的点击率。

RL在推荐场景中有以下问题：

首先，驱动用户行为的兴趣点（奖励函数）一般是未知的，但它对于 RL 算法的使用来说至关重要。在用于推荐系统的现有RL算法中，奖励函数一般是手动设计的（例如用 ±1 表示点击或不点击），这可能无法反映出用户对不同项目的偏好如何(如Deep Reinforcement Learning for Page-wise Recommendations)。
其次，无模型RL一般都需要和环境（在线用户）进行大量的交互才能学到良好的策略。但这在推荐系统设置中是不切实际的。如果推荐看起来比较随机或者推荐结果不符合在线用户兴趣，他会很快放弃!!这一服务。

为了解决无模型方法样本复杂度大的问题，基于模型的RL方法更为可取。近期有一些研究，在robotics applications中，在相关但不相同的环境设置中训练机器人策略，结果表明基于模型的RL采样效率更高。如Neural Network Dynamics for Model-Based Deep Reinforcement Learning with Model-Free Fine-Tuning，还有Gaussian Processes for Data-Efficient Learning in Robotics and Control，还有 Learning to adapt: Meta-learning for model-based control。

基于模型的方法的优势在于可以池化大量的off-policy数据，而且可以用这些数据学习良好的环境动态模型，而无模型方法只能用昂贵的on-policy数据学习。但之前基于模型的方法一般都是根据物理或高斯过程设计的，而不是根据用户行为的复杂序列定制的。

本文的框架用统一的minimax框架学习用户行为模型和相关的奖励函数，然后再用这个模型学习RL策略。

主要贡献如下：

开发了生成对抗学习（GAN）方法来对用户行为动态性(dynamics)建模，并recover奖励函数。可以通过联合的minimax优化算法同时评估这两个组件。该方法的优势在于：
- 可以得到更predictive(可预测的？)的用户模型，而且可以用与用户模型一致的方法学习奖励函数；
- 相较于手动设计的简单奖励函数，从用户行为中学习到的奖励函数更有利于后面的强化学习；
- 学习到的用户模型使研究者能够为新用户执行基于模型的RL和在线适应从而实现更好的结果。
用这一模型作为模拟环境，研究者还开发了级联DQN(cascade dqn)算法来获得组合推荐策略。动作-值函数的级联设计允许其在大量候选物品中找到要展示的物品的最佳子集，其时间复杂度和候选物品的数量呈线性关系，大大减少了计算难度。

用真实数据进行实验得到的结果表明，从保留似然性和点击预测的角度来说，这种生成对抗模型可以更好地拟合用户行为。根据学习到的用户模型和奖励，研究者发现评估推荐策略可以给用户带来更好的长期累积奖励。此外，在模型不匹配的情况下，基于模型的策略也能够很快地适应新动态（和无模型方法相比，和用户交互的次数要少得多）。

图中绿线是推荐的信息流，黄线是用户的信息流。

Setting和RL Formulation

setting：给用户展示了$k$个item，然后他点了1个或者0个，然后展示后$k$个item。

简单来讲，RL框架就是，推荐系统会在用户状态$\mathcal{s}$下，采用策略$\pi(\boldsymbol{s}, \mathcal{I})$来从集合$\mathcal{I}$中进行选择，使得如下的用户长期累积reward最大：

\[ \pi^{*}=\underset{\pi\left(\boldsymbol{s}^{t}, \mathcal{I}^{t}\right)}{\arg \max } \mathbb{E}\left[\sum_{t=0}^{\infty} \gamma^{t} r\left(\boldsymbol{s}^{t}, a^{t}\right)\right] \]

其中，$s^{0} \sim p^{0}$，$\mathcal{A}^{t} \sim \pi\left(s^{t}, \mathcal{I}^{t}\right)$，$\boldsymbol{s}^{t+1} \sim P\left(\cdot | \boldsymbol{s}^{t}, \mathcal{A}^{t}\right)$，$a^{t} \in \mathcal{A}^{t}$。

环境：在推荐的每一页的$k$个item中可以点击其中一个的用户
状态$\boldsymbol{s}^{t} \in \mathcal{S}$：用户历史点击的一个有序序列
动作$\mathcal{A}^{t} \in\left(\begin{array}{c}{\mathcal{I}^{t}} \\ {k}\end{array}\right)$：推荐系统从$\mathcal{I}^{t}$个候选中选择$k$个候选的子集。其中，$\left(\begin{array}{c}{\mathcal{I}^{t}} \\ {k}\end{array}\right)$表示$\mathcal{I}^{t}$中的所有的$k$元素子集。而$\mathcal{I}^{t} \subset \mathcal{I}$是所有候选$\mathcal{I}$在时间步$t$的候选子集。
状态转移$P\left(\cdot | s^{t}, \mathcal{A}^{t}\right) : \mathcal{S} \times\left(\begin{array}{l}{\mathcal{I}} \\ {k}\end{array}\right) \mapsto \mathcal{P}(\mathcal{S})$：给定状态$\mathcal{s}^{t}$，以及展示的集合$\mathcal{A}^{t}$的情况下，转移到状态$\boldsymbol{s}^{t+1}$的转移概率。等价于下文提到的在用户行为上的分布$\phi\left(s^{t}, \mathcal{A}^{t}\right)$
奖励函数$r\left(\boldsymbol{s}^{t}, \mathcal{A}^{t}, a^{t}\right) : \mathcal{S} \times\left(\begin{array}{l}{\mathcal{I}} \\ {k}\end{array}\right) \times \mathcal{I} \mapsto \mathbb{R}$：用户在状态$\boldsymbol{s}^{t}$下，采用动作$a^{t} \in \mathcal{A}^{t}$得到的回报。在这里假设推荐系统得到的回报和用户得到的回报一样，所以长期回报也是一样。
策略$\mathcal{A}^{t} \sim \pi\left(s^{t}, \mathcal{I}^{t}\right) : \mathcal{S} \times 2^{\mathcal{I}} \mapsto \mathcal{P}\left(\left(\begin{array}{c}{\mathcal{I}_{k}} \\ {k}\end{array}\right)\right)$：在用户状态$\mathcal{s}^{t}$下，从集合$\mathcal{I}^{t}$中选择子集$\mathcal{A}^{t}$进行展示的概率。

可见，

环境、状态、状态转移与用户有关，
行为、策略与推荐系统有关。
回报与推荐系统和用户均有关。

使用$r\left(\boldsymbol{s}^{t}, \mathcal{A}^{t}, a^{t}\right)$来强调回报对推荐的action的依赖，也就是说，用户只能从展示的结果集中进行选择。其实，$r\left(\boldsymbol{s}^{t}, \mathcal{A}^{t}, a^{t}\right)=r\left(\boldsymbol{s}^{t}, a^{t}\right) \cdot \mathbf{1}\left(a^{t} \in \mathcal{A}^{t}\right)$。所以下文在讲用户模型的时候，就使用$r\left(\boldsymbol{s}^{t}, a^{t}\right)=r\left(\boldsymbol{s}^{t}, \mathcal{A}^{t}, a^{t}\right)$来表示了，假设$a^{t} \in \mathcal{A}^{t}$是true。

reward函数和transition都是未知的，可以从数据中学习。只要这两个学好了，那么就可以通过使用例如Q-learrning等算法，不断地对模型进行query，来估计上文提到的最优的策略$ \pi^{*}=\underset{\pi\left(\boldsymbol{s}^{t}, \mathcal{I}^{t}\right)}{\arg \max } \mathbb{E}\left[\sum_{t=0}^{\infty} \gamma^{t} r\left(\boldsymbol{s}^{t}, a^{t}\right)\right]$。

Generative Adversarial User Model

找reward的过程，其实是一个逆向强化学习的过程，可以参考漫谈逆向强化学习 - A Brief Review to Inverse Reinforcement Learning：

什么是逆向强化学习呢？当完成复杂的任务时，强化学习的回报函数很难指定，我们希望有一种方法找到一种高效可靠的回报函数，这种方法就是逆向强化学习。我们假设专家在完成某项任务时，其决策往往是最优的或接近最优的，当所有的策略产生的累积汇报函数期望都不比专家策略产生的累积回报期望大时，强化学习所对应的回报函数就是根据示例学到的回报函数。即逆向强化学习就是从专家示例中学习回报函数。当需要基于最优序列样本学习策略时，我们可以结合逆向强化学习和强化学习共同提高回报函数的精确度和策略的效果。

而paper的话，可以看吴恩达的Algorithms for Inverse Reinforcement Learning。

受imitation learning的启发，通过expert demonstration来学习序列决策策略(sequential decision-making policies)，参考Abbeel和吴恩达的Apprenticeship learning via inverse reinforcement learning【其中的”Apprenticeship”的意思就是学徒】，还有Model-free imitation learning with policy optimization，还有Generative adversarial imitation learning，还有Behavioral Cloning from Observation。因此，本文提出了一个unified mini-max optimization来基于sample trajectories(轨迹)来同时学习用户行为模型和回报函数。

User Behavior As Reward Maximization

基于如下两个现实(realistic)的假设来对用户行为建模：

用户不是消极的(passive)。当用户看到展现的$k$个item时，会做出令他自己的回报最大的决定。回报$r$意味着这个用户对这个item有多感兴趣或者多满意。而如果他都不感兴趣，可以选择都不点。
reward不仅和当前这个被选择的item有关，也和用户的历史有关。例如，一个用户听了a的某一首歌，可能他会对a的其他歌也感兴趣；而如果他听了很多a的歌，可能他也会感到厌倦了。这些都是和personal experience有关的。

把点击的item(视为用户的action $a^{t}$)还有用户的历史(视为状态$\mathcal{s}^{t}$)都作为reward函数的输入：$r\left(s^{t}, a^{t}\right)$。而没有点击的item会被视为special item或者action。

假设在session $t$，展示给用户$k$个item $\mathcal{A}^{t}=\left\{a_{1}, \cdots, a_{k}\right\}$，而他们对应的特征是$\left\{\boldsymbol{f}_{1}^{t}, \cdots, \boldsymbol{f}_{k}^{t}\right\}$。然后他采用可以使自己的期望reward最大的策略$\phi^{*}$来做出action $a^{t} \in \mathcal{A}^{t}$。这个策略可以看成是在一个候选action集合$\mathcal{A}^{t}$上的概率分布：

\[ \phi^{*}\left(\boldsymbol{s}^{t}, \mathcal{A}^{t}\right)=\arg \max _{\phi \in \Delta^{k-1}} \mathbb{E}_{\phi}\left[r\left(\boldsymbol{s}^{t}, a^{t}\right)\right]-R(\phi) / \eta \]

其中，

$\Delta^{k-1}$是probability simplex，也就是概率单纯形，参考https://juejin.im/entry/58e09c2cda2f60005fcd5573，简单理解好像。。就是$k$个元素，和为1，所以可以看成是一个概率分布。
$R(\phi)$是一个凸的正则函数。
$\eta$能控制正则化的强度

引理1：假设正则项是$R(\phi)=\sum_{i=1}^{k} \phi_{i} \log \phi_{i}$，也就是negative Shannon entropy，而且$\phi \in \Delta^{k-1}$是任意一种mapping。然后这个最优策略有如下逼近形式：

\[ \phi^{*}\left(\boldsymbol{s}^{t}, \mathcal{A}^{t}\right)_{i}=\exp \left(\eta r\left(\boldsymbol{s}^{t}, a_{i}\right)\right) / \sum_{a_{j} \in \mathcal{A}^{t}} \exp \left(\eta r\left(\boldsymbol{s}^{t}, a_{j}\right)\right) \]

进一步地，在每一个session $t$中，用户的最优策略$\phi^{*}$与如下离散的choice model是等价的，其中，$\varepsilon^{t}$服从Gumbel分布（参考【Learning Notes】Gumbel 分布及应用浅析），wikipedia的解释https://en.wikipedia.org/wiki/Gumbel_distribution，简单来说是一个极值分布，比如每个点是周围若干个点的max或者min这种。。

\[ a^{t}=\arg \max _{a \in \mathcal{A}^{t}} \eta r\left(\boldsymbol{s}^{t}, a\right)+\varepsilon^{t} \]

如上引理说明了，用户根据reward function去greedily地选择一个item(exploitation)，而其中的Gumbel noise $\varepsilon^{t}$使得用户可以去deviate(偏差)和explore其他reward相对小一点的item。在经济学模型中，已经有类似的方法了，例如Maximum score estimation of the stochastic utility model of choice，还有Conditional logit analysis of qualitative choice behaviour，但之前的经济学模型并没有把多样的特征还有用户状态的演变考虑进去。可见，$\eta$越小，越偏向explore。不过，因为每个人的reward也不一样，所以实际应用的时候，简单地设置$\eta=1$。

注意：

其他的正则$R(\phi)$也可以用，这样$\phi^{*}$和$r$的关系也会变，也就不一定会有那个逼近的形式了
对于用户没有点击任意一个item这种情况，可以看成一直在展现集合$\mathcal{A}^{t}$中的一个特殊的item。这个item的feature vector可以都搞成0，或者可以把reward定义成一个常量。

Model Parameterization

使用用户在session $t$之前历史点击的embedding来表示状态$\boldsymbol{s}^{t}$，然后基于状态和当前action $a^{t}$的embedding来定义reward函数$r\left(\boldsymbol{s}^{t}, a^{t}\right)$。

定义用户的状态$\boldsymbol{s}^{t} :=h\left(\boldsymbol{F}_{*}^{1 : t-1} :=\left[\boldsymbol{f}_{*}^{1}, \cdots, \boldsymbol{f}_{*}^{t-1}\right]\right)$，其中每一个$\boldsymbol{f}_{*}^{\tau} \in \mathbb{R}^{d}$是session $\tau$的点击item的特征向量，$h(\cdot)$是一个embedding函数，本文提出了一种简单且有效的position weighting scheme。$\boldsymbol{W} \in \mathbb{R}^{m \times n}$是一个行数$m$是一个固定的历史的时间步数，而$n$列里每一列与positions上的importance weights的集合有关。所以embedding函数$h \in \mathbb{R}^{d n \times 1}$可以设计成如下形式：

\[ \boldsymbol{s}^{t}=h\left(\boldsymbol{F}_{*}^{t-m : t-1}\right) :=\operatorname{vec}\left[\sigma\left(\boldsymbol{F}_{*}^{t-m : t-1} \boldsymbol{W}+\boldsymbol{B}\right)\right] \]

其中，$\boldsymbol{B} \in \mathbb{R}^{d \times n}$是一个bias矩阵。$\sigma(\cdot)$是非线性变换。$\operatorname{vec}[\cdot]$把输入矩阵的列concate到一起，形成一个长向量。当然，也可以使用LSTM来对历史进行建模。但position weighting scheme是浅层网络，比RNN在前向计算和反向传播上都更加高效。

接下来，定义reward函数还有用户行为模型。

用户的选择$a^{t} \in \mathcal{A}^{t}$和特征是$\boldsymbol{f}_{a^{t}}^{t}$的item有关，所以，reward定义如下：

\[ r\left(\boldsymbol{s}^{t}, a^{t}\right) :=\boldsymbol{v}^{\top} \sigma\left(\boldsymbol{V}\left[\begin{array}{c}{\boldsymbol{s}^{t}} \\ {\boldsymbol{f}_{a^{t}}^{t}}\end{array}\right]+\boldsymbol{b}\right) \]

用户行为模型如下：

\[ \phi\left(s, \mathcal{A}^{t}\right) \propto \exp \left(\boldsymbol{v}^{\prime \top} \sigma\left(\boldsymbol{V}^{\prime}\left[\begin{array}{c}{\boldsymbol{s}^{t}} \\ {\boldsymbol{f}_{a^{t}}^{t}}\end{array}\right]+\boldsymbol{b}^{\prime}\right)\right) \]

其中，$\boldsymbol{V}, \boldsymbol{V}^{\prime} \in \mathbb{R}^{\ell \times(d n+d)}$是权重矩阵，而$\boldsymbol{b}, \boldsymbol{b}^{\prime} \in \mathbb{R}^{\ell \times 1}$是bias向量(原文写错了，和作者邮件确认了应该是这个维数)，$\boldsymbol{v}, \boldsymbol{v}^{\prime} \in \mathbb{R}^{\ell}$是最终的regression参数。

为了简化一点，把reward的所有参数定义为$\theta$，而用户模型的所有参数定义为$\alpha$，因此，reward就是$r_{\theta}$，而用户模型就是$\phi_{\alpha}$。

自己来梳理一下。。有m个时间步，每个时间步的f是dx1维的，所以F是dxm，而w是mxn，所以乘完后是个dxn，然后这个vec的操作就是把n列竖着叠到一起，变成一个dnx1的向量。这就是s。然后那个s,f呢，f只是一个item，所以是dx1维，而s是dnx1，把这两个竖着叠在一起就是(n+1)xd=dn+d这么多行，所以V就是lx(dn+d)。V乘以s和f的那个，出来就是一个lx1的。最后的r是一个标量吧。

Generative Adversarial Training

上面提到的reward函数$r\left(s^{t}, a^{t}\right)$和用户行为模型$\phi\left(s^{t}, \mathcal{A}^{t}\right)$均是未知的，需要从数据中学习。用户行为模型$\phi$试图模仿真实用户最大化其reward $r$的真实action序列。根据gan的术语，

$\phi$可以看做是一个generator。基于用户的历史，产生用户的下一个行为。参数是$\alpha$，要让把假的当成真实最大，所以在下面的式子里，需要$\alpha$最大！
$r$可以看做是一个discriminator，试图分辨出用户的真实行为与generator产生的用户行为。参数是$\theta$，要让把真实的当成真实最大，而下面的式子第二项前有个负号，所以要$\theta$最小。。

给定一个有$T$个已观测action的轨迹(trajectory)$\left\{a_{\text {true}}^{1}, a_{\text {true}}^{2}, \ldots, a_{\text {true}}^{T}\right\}$，以及对应的点击item的特征$\left\{\boldsymbol{f}_{*}^{1}, \boldsymbol{f}_{*}^{2}, \ldots, \boldsymbol{f}_{*}^{T}\right\}$，解决如下mini-max的优化问题：

\[ \begin{aligned} \min _{\theta} \max _{\alpha}\left(\mathbb{E}_{\phi_{\alpha}}\right.&\left[\sum_{t=1}^{T} r_{\theta}\left(\boldsymbol{s}_{\text {true}}^{t}, a^{t}\right)\right]-R\left(\phi_{\alpha}\right) / \eta ) -\sum_{t=1}^{T} r_{\theta}\left(\boldsymbol{s}_{\text {true}}^{t}, a_{\text {true}}^{t}\right) \end{aligned} \]

其中，$\boldsymbol{s}_{\text {true}}^{t}$用来强调这是观测到的数据。上式前面那项是基于真实state使用用户模型产出的action得到的reward，也就是正常gan里的D(G(z))，后面一项是真实的state下真实action的reward，也就是正常gan里的D(x)。

对于一般化的正则项$R\left(\phi_{\alpha}\right)$，mini-max的优化问题并没有一个逼近形式，所以需要通过交替更新$\phi_{\alpha}$和$r_{\theta}$：

\[ \left\{\begin{array}{l}{\alpha \leftarrow \alpha+\gamma_{1} \nabla_{\alpha} \mathbb{E}_{\phi_{\alpha}}\left[\sum_{t=1}^{T} r_{\theta}\right]-\gamma_{1} \nabla_{\alpha} R\left(\phi_{\alpha}\right) / \eta} \\ {\theta \leftarrow \theta-\gamma_{2} \mathbb{E}_{\phi_{\alpha}}\left[\sum_{t=1}^{T} \nabla_{\theta} r_{\theta}\right]+\gamma_{2} \sum_{t=1}^{T} \nabla_{\theta} r_{\theta}}\end{array}\right. \]

这个更新过程可能不一定会stable，因为这本身可能是一个非凸问题。所以可以在初始化的时候加个特殊的正则。对于entropy的正则，有个如下引理2的逼近形式：

引理2：假设正则项是$R(\phi)=\sum_{i=1}^{k} \phi_{i} \log \phi_{i}$，而$\Phi$包含了所有的从$\mathcal{S} \times\left(\begin{array}{l}{\mathcal{I}} \\ {k}\end{array}\right)$映射到$\Delta^{k-1}$的mapping。那么如上的优化问题可以等价为如下最大化likelihood的估计：

\[ \max _{\theta \in \Theta} \prod_{t=1}^{T} \frac{\exp \left(\eta r_{\theta}\left(s_{t r u e}^{t}, a_{t r u e}^{t}\right)\right)}{\sum_{a^{t} \in \mathcal{A}^{t}} \exp \left(\eta r_{\theta}\left(s_{t r u e}^{t}, a^{t}\right)\right)} \]

当entropy正则的reward函数学习完了之后，能用来对其他形式的正则进行初始化。

Cascading RL Policy for Recommendation

推荐策略需要处理$\left(\begin{array}{l}{\mathcal{I}} \\ {k}\end{array}\right)$（组合数）这么一个combinatorial action space，其中每个action是从有$K$个候选的大集合$\mathcal{I}$中挑选出$k$个item的子集。有两个挑战：

在combinatorial action space这个空间上的可能的很高的计算复杂度
对某种item组合的长期reward(Q)的预估也需要一个复杂度较高的框架

Cascading Q-Networks

用户的一次请求，系统需要从有$K$个候选的大集合$\mathcal{I}$中挑选出$k$个item的子集$\mathcal{A}$。

最优的Q如下：

\[ Q^{*}\left(s^{t}, \mathcal{A}^{t}\right)=\mathbb{E}\left[r\left(s^{t}, \mathcal{A}^{t}, a^{t}\right)+\gamma \max _{\mathcal{A}^{\prime} \subset \mathcal{I}} Q^{*}\left(s^{t+1}, \mathcal{A}^{\prime}\right)\right], a^{t} \in \mathcal{A}^{t} \]

而学到了这个最优的Q之后，最优的推荐策略就是：

\[ \pi^{*}\left(\boldsymbol{s}^{t}, \mathcal{I}^{t}\right)=\arg \max _{\mathcal{A}^{t} \subset \mathcal{I}^{t}} Q^{*}\left(\boldsymbol{s}^{t}, \mathcal{A}^{t}\right) \]

其中，$\mathcal{I}^{t} \subset \mathcal{I}$是在$t$时候的item候选集合。挑战就是，组合数$\left(\begin{array}{l}{K} \\ {k}\end{array}\right)$是非常巨大的，即使是不大的K=1000, k=5，组合数也有1.6亿！。。而且，同一个item，在不同的组合里，被点击的概率也会因不同用户在不同时刻而不同。

因此，本文用不止一个Q函数，而是使用k个相关的Q函数来进行建模。

定义推荐的action为$\mathcal{A}=\left\{a_{1: k}\right\} \subset \mathcal{I}$，最优的action为$\mathcal{A}^{*}=\left\{a_{1: k}^{*}\right\}=\arg \max _{\mathcal{A}} Q^{*}(s, \mathcal{A})$。

也就是说，给定一组当前推荐系统推荐的$a_1,...,a_k$，需要得到一组使得$Q^*(s,a_{1:k})$最大的最优的$a^*_1,...,a^*_k$。

可以这么拆解，

输入$s$和$a_1$，找到使得$Q^{1*}(s,a_1)$最大的动作$a_1^*$
输入$s$和$a_1^*$还有$a_2$，找到使得$Q^{2*}(s,a_1^*,a_2)$最大的动作$a_2^*$
…
输入$s$和$a_{1:k-1}^*$还有$a_k$，找到使得$Q^{k*}(s,a_{1:k-1}^*,a_k)$最大的动作$a_k^*$

其中，

第一步的$Q^{1*}(s,a_1)$可以看成是$Q^*(s,a_{1:k})$当动作取$a_{2:k}$的时候取得最大值
第二步的$Q^{2*}(s,a_1^*,a_2)$可以看成是$Q^*(s,a_{1:k})$当动作取$a_{3:k}$的时候取得最大值
…
第k步的$Q^{k*}(s,a_{1:k-1}^*,a_1)$可以看成是$Q^*(s,a_{1:k})$

于是：

\[ \begin{array}{l}{\text { Cascading Q-Networks: }} \\ {\qquad \begin{aligned} a_{1}^{*} &=\arg \max _{a_{1}}\left\{Q^{1 *}\left(s, a_{1}\right):=\max _{a_{2: k}} Q^{*}\left(s, a_{1: k}\right)\right\} \\ a_{2}^{*} &=\arg \max _{a_{2}}\left\{Q^{2 *}\left(s, a_{1}^{*}, a_{2}\right):=\max _{a_{3: k}} Q^{*}\left(s, a_{1: k}\right)\right\} \\ \cdots & \\ a_{k}^{*} &=\arg \max _{a_{k}}\left\{Q^{k *}\left(s, a_{1: k-1}^{*}, a_{k}\right):=Q^{*}\left(s, a_{1: k}\right)\right\} \end{aligned}}\end{array} \]

看ppt。。。

画成网络图就是：

Parameterization and Estimation

每一个$Q^{j*}$通过神经网络来定义：

\[ \boldsymbol{q}_{j}^{\top} \sigma\left(\boldsymbol{L}_{j}\left[\boldsymbol{s}^{\top}, \boldsymbol{f}_{a_{i}}^{\top}, \ldots, \boldsymbol{f}_{a_{j-1}^{\prime}}^{\top}, \boldsymbol{f}_{a_{j}}^{\top}\right]^{\top}+\boldsymbol{c}_{j}\right), \forall j \]

其中，参数$\Theta_{j}$包括了$\boldsymbol{L}_{j} \in \mathbb{R}^{\ell \times(d n+d j)}$，$\boldsymbol{c}_{j} \in \mathbb{R}^{\ell}$，$\boldsymbol{q}_{j} \in \mathbb{R}^{\ell}$。

这里的state和前面用户模型的是共享的，即

\[\boldsymbol{s}^{t}:=h\left(\boldsymbol{F}_{*}^{1: t-1}:=\left[\boldsymbol{f}_{*}^{1}, \cdots, \boldsymbol{f}_{*}^{t-1}\right]\right)\]

还有

\[ \boldsymbol{s}^{t}=h\left(\boldsymbol{F}_{*}^{t-m: t-1}\right):=\operatorname{vec}\left[\sigma\left(\boldsymbol{F}_{*}^{t-m: t-1} \boldsymbol{W}+\boldsymbol{B}\right)\right] \]

理论上，结果要是最优的话，那么要求$Q^{j*}$恰好就是$Q^*$

\[ Q^{j *}\left(s, a_{1}^{*}, \cdots, a_{j}^{*}\right)=Q^{*}\left(s, a_{1}^{*}, \cdots, a_{k}^{*}\right), \quad \forall j \]

但严格要求相等是很难的，作者做了如下近似。

定义loss为：

\[ \begin{array}{l}{\left(y-Q^{j}\right)^{2}, \text { where }} \\ {y=r\left(s^{t}, \mathcal{A}^{t}, a^{t}\right)+\gamma Q^{k}\left(s^{t+1}, a_{1: k}^{*} ; \Theta_{k}\right), \forall j}\end{array} \]

也就是说，所有的$Q^j$个网络都拟合同一个目标y。这样，参数$\Theta_{k}$就可以通过对上述loss进行梯度下降来更新了。

整体的训练方法：

VQ-VAE

2019-06-05T00:00:00+00:00

参考超越BigGAN，DeepMind提出「史上最强非GAN生成器」VQ-VAE-2

Generating Diverse High-Fidelity Images with VQ-VAE-2

EfficientNet

2019-06-01T00:00:00+00:00

efficientnet
改进版

efficientnet

参考谷歌出品EfficientNet：比现有卷积网络小84倍，比GPipe快6.1倍

EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks

https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet

目前提高CNN精度的方法，主要是通过任意增加CNN深度或宽度，或使用更大的输入图像分辨率进行训练和评估。

以固定的资源成本开发，然后按比例放大，以便在获得更多资源时实现更好的准确性。例如ResNet可以通过增加层数从ResNet-18扩展到ResNet-200。

劣势就是，往往需要进行繁琐的微调。一点点的摸黑去试、还经常的徒劳无功

作者发现只要对网络的深度、宽度和分辨率进行合理地平衡，就能带来更好的性能。基于这一观察，科学家提出了一种新的缩放方法，使用简单但高效的复合系数均匀地缩放深度、宽度和分辨率的所有尺寸。

第一步是执行网格搜索，在固定资源约束下找到基线网络的不同缩放维度之间的关系（例如，2倍FLOPS），这样做的目的是为了找出每个维度的适当缩放系数。
然后应用这些系数，将基线网络扩展到所需的目标模型大小或算力预算。

与传统的缩放方法相比，这种复合缩放方法可以持续提高扩展模型的准确性和效率，和传统方法对比结果：MobileNet（+ 1.4％ imagenet精度），ResNet（+ 0.7％）。

新模型缩放的有效性，很大程度上也依赖基线网络。

为了进一步提高性能，研究团队还通过使用AutoML MNAS框架执行神经架构搜索来开发新的基线网络，该框架优化了准确性和效率（FLOPS）。

由此产生的架构使用移动倒置瓶颈卷积（MBConv），类似于MobileNetV2和MnasNet，但由于FLOP预算增加而略大。然后，通过扩展基线网络以获得一系列模型，被称为EfficientNets。

改进版

AutoML构建加速器优化模型首尝试，谷歌发布EfficientNet-EdgeTPU

https://github.com/tensorflow/tpu/tree/master/models/official/efficientnet/edgetpu

https://coral.withgoogle.com/docs/

原文：https://ai.googleblog.com/2019/08/efficientnet-edgetpu-creating.html

fastspeech

2019-06-01T00:00:00+00:00

FastSpeech: Fast, Robust and Controllable Text to Speech

将文本转语音速度提高38倍，这个FastSpeech真的很fast

基于神经网络的端到端文本语音转换（TTS）显著改善了合成语音的质量。一些主要方法（如 Tacotron 2）通常首先从文本生成梅尔频谱（mel-spectrogram），然后使用诸如 WaveNet 的声码器从梅尔频谱合成语音。

与基于连接和统计参数的传统方法相比，基于神经网络的端到端模型有一些不足之处，包括推理速度较慢，合成语音不稳健（即某些词被跳过或重复），且缺乏可控性（语音速度或韵律控制）。

本文提出了一种基于 Transformer 的新型前馈网络，用于为 TTS 并行生成梅尔频谱。具体来说就是，从基于编码器-解码器的教师模型中提取注意力对齐（attention alignments），用于做音素（phoneme）持续时间预测。长度调节器利用这一预测来扩展源音素序列，以匹配目标梅尔频谱序列的长度，从而并行生成梅尔频谱。

对抗学习进展

2019-05-31T00:00:00+00:00

https://pan.baidu.com/s/1S3g77xA2qtRFHZ9zFqRWsg

提取码: 51j1

另外，参考一文读懂文本处理中的对抗训练

Top-K Off-Policy Correction for a REINFORCE Recommender System

2019-05-28T00:00:00+00:00

Top-K Off-Policy Correction for a REINFORCE Recommender System

视频链接：Reinforcement Learning for Recommender Systems: A Case Study on Youtube

google的ai blog也说到了off-policy的分类方法，可以预测出哪种机器学习模型会产生最好结果。参考https://ai.googleblog.com/2019/06/off-policy-classification-new.html

Youtube推荐系统架构主要分为两层：召回和排序。本文中的算法应用在召回侧。

建模思路是给定用户的行为历史，预测用户下一次的点击item。

受限于On-Policy方法对系统训练架构要求复杂，所以本文采用Off-Policy的训练策略，即，并不是根据用户的交互进行实时的策略更新，而是根据收集到日志中用户反馈进行模型训练。

假设同时展示K个不重复item的reward奖励等于每个item的reward的之和，

而offpolicy的训练方式，对policy gradient类的模型训练会带来如下问题：

策略梯度是由不同的policy计算出来的
同一个用户的行为历史也收集了其他召回策略的数据。（没看懂。。）

然后作者就提出了基于importance weighting的Off-Policy修正方案，对pg的计算进行一阶逼近：

\[ \prod_{t^{\prime}=0}^{|\tau|} \frac{\pi\left(a_{t^{\prime}} | s_{t^{\prime}}\right)}{\beta\left(a_{t^{\prime}} | s_{t^{\prime}}\right)} \approx \prod_{t^{\prime}=0}^{t} \frac{\pi\left(a_{t^{\prime}} | s_{t^{\prime}}\right)}{\beta\left(a_{t^{\prime}} | s_{t^{\prime}}\right)}=\frac{P_{\pi_{\theta}}\left(s_{t}\right)}{P_{\beta}\left(s_{t}\right)} \frac{\pi\left(a_{t} | s_{t}\right)}{\beta\left(a_{t} | s_{t}\right)} \approx \frac{\pi\left(a_{t} | s_{t}\right)}{\beta\left(a_{t} | s_{t}\right)} \]

最终可以得到一个低variance的策略梯度的biased estimator：

\[ \sum_{\tau \sim \beta}\left[\sum_{t=0}^{|\tau|} \frac{\pi_{\theta}\left(a_{t} | s_{t}\right)}{\beta\left(a_{t} | s_{t}\right)} R_{t} \nabla_{\theta} \log \pi_{\theta}\left(a_{t} | s_{t}\right)\right] \]

注：随机策略梯度就有这么个重要性权重，应该是类似的思路吧。。https://daiwk.github.io/posts/rl-stepbystep-chap9.html#31-%E9%9A%8F%E6%9C%BA%E7%AD%96%E7%95%A5ac%E6%96%B9%E6%B3%95

因为是基于用户的交互历史预测下一个用户点击的item，所以文中也采用RNN针对用户State的转换进行建模。文中提到实验了包括LSTM、GRU等RNN单元，发现Chaos Free的RNN单元(A recurrent neural network without chaos)因为稳定高效而使用起来效果最好。

上面那个公式里，最难获取到的是用户的行为策略，理想情况下是收集日志的时候同时把用户相应的用户策略也就是点击概率给收集下来，但由于策略不同等客观原因文中针对用户的行为策略使用另外一组$\theta '$参数进行预估，而且防止它的梯度回传影响主RNN网络的训练。

在推荐系统中，用户可以同时看到k个展示给用户的候选item，用户可能同时与一次展示出来的多个item进行交互。因此需要扩展策略根据用户的行为历史预测下一次用户可能点击的top-K个item。

假设同时展示K个不重复item的reward奖励等于每个item的reward的之和，这样，Top-K的Off-Policy修正的策略梯度如下：

\[ \begin{aligned} & \sum_{\tau \sim \beta}\left[\sum_{t=0}^{|\tau|} \frac{\alpha_{\theta}\left(a_{t} | s_{t}\right)}{\beta\left(a_{t} | s_{t}\right)} R_{t} \nabla_{\theta} \log \alpha_{\theta}\left(a_{t} | s_{t}\right)\right] \\=& \sum_{\tau \sim \beta}\left[\sum_{t=0}^{|\tau|} \frac{\pi_{\theta}\left(a_{t} | s_{t}\right)}{\beta\left(a_{t} | s_{t}\right)} \frac{\partial \alpha\left(a_{t} | s_{t}\right)}{\partial \pi\left(a_{t} | s_{t}\right)} R_{t} \nabla_{\theta} \log \pi_{\theta}\left(a_{t} | s_{t}\right)\right] \end{aligned} \]

与上面Top 1的修正公式相比主要是多了一个包含K的系数。也就是说，随着K的增长，策略梯度会比原来的公式更快地降到0。

mixmatch

2019-05-21T00:00:00+00:00

MixMatch: A Holistic Approach to Semi-Supervised Learning

本文来自 Google Research，这一方法综合了自洽正则化（Consistency Regularization），最小化熵（Entropy Minimization）以及传统正则化（Traditional Regularization），取三者之长，并补三者之短，提出了 MixMatch 这一方法。在 CIFAR10 上，仅仅使用 250 个标签数据就达到 11% 的错误率，远超其他主流方法。

参考https://zhuanlan.zhihu.com/p/66281890

参考谷歌首席科学家：半监督学习的悄然革命

原始blog：https://towardsdatascience.com/the-quiet-semi-supervised-revolution-edec1e9ad8c

https://github.com/google-research/mixmatch

强化学习进展（持续更新）

2019-05-11T00:00:00+00:00

Beyond DQN/A3C: A Survey in Advanced Reinforcement Learning(2018)
Modern Deep Reinforcement Learning Algorithms(2019)
Evolution Strategies as a Scalable Alternative to Reinforcement Learning
模拟器相关
代码库
迁移学习+强化学习

梳理rl的一些新进展

Beyond DQN/A3C: A Survey in Advanced Reinforcement Learning(2018)

参考深度 | 超越DQN和A3C：深度强化学习领域近期新进展概览

原blog：https://towardsdatascience.com/advanced-reinforcement-learning-6d769f529eb3

DQN

\[ Q\left(s_{t}, a_{t} ; \theta\right) \leftarrow Q\left(s_{t}, a_{t} ; \theta\right)+\alpha[\underbrace{\underbrace{(r_{t}+\max _{a} \hat{Q}\left(s_{t+1}, a ; \theta^{\prime}\right))}_{\text { target }}-Q\left(s_{t}, a_{t} ; \theta\right) )}_{\text {TD-error}}] \]

\[ d \theta_{v} \leftarrow d \theta_{v}+\partial{\underbrace{\left(R-V\left(s_{i} ; \theta_{v}\right)\right)}_{\text{advantage}}}^{2} / \partial \theta_{v} \]

Modern Deep Reinforcement Learning Algorithms(2019)

Modern Deep Reinforcement Learning Algorithms

原论文有点大。。打开太慢。。转存一份：https://daiwk.github.io/assets/Modern%20Deep%20Reinforcement%20Learning%20Algorithms.pdf

Evolution Strategies as a Scalable Alternative to Reinforcement Learning

blog：https://openai.com/blog/evolution-strategies/

代码：https://github.com/openai/evolution-strategies-starter

Simulating User Feedback for Reinforcement Learning Based Recommendations

代码库

https://github.com/p-christ/Deep-Reinforcement-Learning-Algorithms-with-PyTorch

参考17种深度强化学习算法用Pytorch实现

迁移学习+强化学习

八千字长文深度解读，迁移学习在强化学习中的应用及最新进展

tensorlayer

2019-05-11T00:00:00+00:00

参考TensorLayer 2.0：保有最多官方神经网络层的通用Python库

图神经网络+推荐

2019-05-07T00:00:00+00:00

DiffNet
DGRec
IGPL
GraphRec
DANSER
NGCF
MEIrec

参考CIKM 2019 EComm AI：用户行为预测赛题解读与阿里GNN推荐结合实践分享

DiffNet

SIGIR ’19，

A Neural Influence Diffusion Model for Social Recommendation

社交推荐系统利用每个用户的局部邻居偏好(local neighbors’ preferences)来缓解数据稀疏性，从而更好地进行用户emb建模。对于每一个社交平台的用户，其潜在的嵌入是受他信任的用户影响的，而这些他信任的用户也被他们自己的社交联系所影响。随着社交影响在社交网络中递归传播和扩散（diffuse），每个用户的兴趣在递归过程中发生变化。然而，目前的社交推荐模型只是利用每个用户的局部邻居来构建静态模型，没有模拟全局社交网络中的递归扩散，导致推荐性能不理想。

本文提出了一个deep influence propagation model。对于每个用户，扩散过程（diffusion）用融合了相关特征和一个caputure了latent behavior preference的free的用户隐向量。本文的key idea是，设计了一个layer-wise的influence propagation结构，可以随着social diffusion process的进行，对用户emb进行演化。

DGRec

WSDM ’19，

Session-based Social Recommendation via Dynamic Graph Attention Networks

代码：https://github.com/DeepGraphLearning/RecommenderSystems/tree/master/socialRec

IGPL

Inductive Graph Pattern Learning for Recommender Systems Based on a Graph Neural Network

GraphRec

WWW’19，

Graph Neural Networks for Social Recommendation

DANSER

WWW’19 Oral

Dual Graph Attention Networks for Deep Latent Representation of Multifaceted Social Effects in Recommender Systems

NGCF

SIGIR’19

Neural Graph Collaborative Filtering

参考https://www.jianshu.com/p/16c8973ef8ff

MEIrec

节后收心困难？这15篇论文，让你迅速找回学习状态

Metapath-guided Heterogeneous Graph Neural Network for Intent Recommendation

本文是北京邮电大学和阿里巴巴发表于 KDD 2019 的工作。针对手机淘宝的用户意图推荐，本文设计了基于异质图神经网络的意图推荐模型 MEIRec。

传统商品推荐为用户推荐商品，而意图推荐则关注于预测用户的意图。本文将意图推荐的业务场景建模为异质图（包含多种类型节点和关系的图），然后设计了 metapath-guided heterogeneous Graph Neural Network 来学习该业务场景下多种不同目标的表示。同时，本文也提出一种 term embedding mechanism 来降低大规模异质图场景下的参数量。最后，在淘宝真实场景下的 AB test 证明了 MEIRec 算法的优越性。

https://github.com/googlebaba/KDD2019-MEIRec

chatbot

2019-04-29T00:00:00+00:00

小冰
space fusion
style fusion

专栏 | 聊天机器人：困境和破局

最新综述：对话系统之用户模拟器

AI更懂人话：谷歌发布全新对话数据集，模仿智能助理

谷歌发布了Coached Conversational Preference Elicitation（CCPE）和Taskmaster-1 对话数据集，在设计中独特地模仿当今基于语音的数字助理，在自动化系统的环境中保留口语对话的特征。

小冰

第七代微软小冰现身：史上最大升级，订制私人AI不是梦

DIY自己的AI助理，萝莉御姐暖男霸道总裁全凭你定义，微软小冰团队发布新框架

开放框架，进驻OV手机，五岁的微软小冰已经学会了养活自己

space fusion

Jointly optimizing diversity and relevance in neural response generation

NACCL 2019

style fusion

节后收心困难？这15篇论文，让你迅速找回学习状态

Structuring Latent Spaces for Stylized Response Generation

https://github.com/golsun/StyleFusion

本文是微软发表于 EMNLP 2019 的工作，这是 SpaceFusion 的后续之作。SpaceFusion 尝试将对话系统中的 source 和 target 映射到同一隐空间上，从而转换生成对话的问题成为生成隐空间向量的问题。本文（StyleFusion）进一步将额外的风格化文本的特征迁移到生成回复中，从而达到对话个性化和风格化的效果。在若干标准数据集上取得了很好的效果。

bert加速

2019-04-03T00:00:00+00:00

LAMB
cuBERT
distill
土豪版：Megatron

LAMB

参考76分钟训练BERT！谷歌大脑新型优化器LAMB加速大批量训练

论文：Reducing BERT Pre-Training Time from 3 Days to 76 Minutes

cuBERT

https://github.com/zhihu/cuBERT

distill

Distilling Task-Specific Knowledge from BERT into Simple Neural Networks

首先，distill相关的可以参考https://daiwk.github.io/posts/dl-knowledge-distill.html

背景与相关工作

要进行distill就需要大量的无标签数据，然后让大模型给出logits，但nlp领域不像图像，可以简单地data augmentation。传统的nlp的data augmentation通常是task-specific的（例如GLUE: A multi-task benchmark and analysis platform for natural language understanding，或者Generating factoid questions with recurrent neural networks: The 30m factoid question-answer corpus），本文提出了一个rule-based的用来构建transfer set的data augmentation方法。

模型压缩

开山之作是lecun在1990年的Optimal brain damage，提出了一个local error-based的方法来剪枝不重要的weight。

2015年的Compressing deep neural networks with pruning, trained quantization and Huffman coding提出了一个简单的压缩pipeline，可以把模型大小缩小40倍，且不对准确率造成损伤。

但上面的这些方法会引入高度不规则的稀疏性（highly irregular sparsity），阻止了高度优化的计算routines。

所以其他人会使用一些以设备为中心的指标（ targeting device-centric metrics），例如浮点数运算（FLOPs as a direct optimization objective for learning sparse neural networks），或者响应时间（Constraint-aware deep neural network compression），来直接把整个filters剪枝掉（如Pruning filters for efficient convnets，或者Learning efficient convolutional networks through network slimming）。

还有些人直接研究量子神经网络（如Training and inference with integers in deep neural networks）。甚至还有提出用二进制权重和激活的二进制网络来搞，Binarized neural networks: Training deep neural networks with weights and activations constrained to +1 or -1

而distill的方法能将大模型(teacher)的知识transfer到一个完全不同结构的小模型(student)中，在nlp领域已经有两个例子了：机器翻译的Sequence level knowledge distillation，还有语言模型的On-device neural language model based word prediction。

网络结构与方法

拆成两大步：

加上logits-regression objective
建立transfer set，对训练集做augmentation从而可以让knowledge transfer更有效

bert模型对一个句子或者pair，会产出一个特征向量$\boldsymbol{h} \in \mathbb{R}^{d}$，我们基于这个向量来构建分类器：

单个句子的分类：直接加一个softmax层，$\boldsymbol{y}^{(B)}=\operatorname{softmax}(W \boldsymbol{h})$，其中$W \in \mathbb{R}^{k \times d}$是softmax层的权重矩阵，$k$是label数
句子pair的任务：将两句话的feature进行concat，然后扔给一个softmax层

训练阶段，同时finetune bert的参数和softmax层的参数，目标是label的cross-entropy loss。

student模型

单个句子的分类：如下图，word emb之后接一个双向lstm，两个方向的输出concat到一起，然后接全连接(用的Relu)，然后再接softmax。

句子pair的任务：如下图，对两个sentence encoder使用siamese结构我双向lstm，分别产生$\boldsymbol{h}_{s_1}$和$\boldsymbol{h}_{s_2}$，然后做一个标准的concatenate–compare操作（参考GLUE: A multi-task benchmark and analysis platform for natural language understanding），即$f\left(\boldsymbol{h}_{s 1}, \boldsymbol{h}_{s 2}\right)=\left[\boldsymbol{h}_{s 1}, \boldsymbol{h}_{s 2}, \boldsymbol{h}_{s 1} \odot\right. \boldsymbol{h}_{s 2},\left|\boldsymbol{h}_{s 1}-\boldsymbol{h}_{s 2}\right| ]$，其中$\odot$是element wise乘积，然后把这个结果给一个relu的分类器。

distill目标

softmax的输入也就是logits是$z=w^Th$，输出是：

\[ \widetilde{y}_{i}=\operatorname{softmax}(\boldsymbol{z})=\frac{\exp \left\{\boldsymbol{w}_{i}^{\top} \boldsymbol{h}\right\}}{\sum_{j} \exp \left\{\boldsymbol{w}_{j}^{\top} \boldsymbol{h}\right\}} \]

本文使用Caruana等人的Do deep nets really need to be deep?方法，distillation objective是student和teacher的logits的mse：

\[ \mathcal{L}_{\text { distill }}=\left\|\boldsymbol{z}^{(B)}-\boldsymbol{z}^{(S)}\right\|_{2}^{2} \]

其中，$\boldsymbol{z}^{(B)}$是teacher的logit，$\boldsymbol{z}^{(S)}$是student的logit。其他方法比如hinton在2015年的Distilling the knowledge in a neural network使用soft target的cross entropy也是可行的，但在这个任务上效果还是mse稍好一点。

训练的时候，这个distillation objective可以和传统的针对one-hot的label的cross-entropy一起用：

\[ \begin{aligned} \mathcal{L} &=\alpha \cdot \mathcal{L}_{\mathrm{CE}}+(1-\alpha) \cdot \mathcal{L}_{\mathrm{distill}} \\=&-\alpha \sum_{i} \log y_{i}^{(S)}-(1-\alpha)\left\|z^{(B)}-z^{(S)}\right\|_{2}^{2} \end{aligned} \]

实验结果显示，$\alpha$设成0的时候，也就是只使用distill的loss，效果最好。

对于有label的数据集，one-hot target $t$直接用ground-truth的label
对于无label的数据集，可以直接用teacher的预估label：$t_{i}=1\ if\ i=\operatorname{argmax} y^{(B)}$，否则就是0

用于distill的augmentation

随机使用以下几个操作之一：

Masking

以$p_{\text { mask }}$的概率，随机地将一个词替换为[MASK]，在student模型里就是[UNK]，而在bert中就是mask。这个规则能够clarify每个词对label的贡献，例如，teacher网络对于I [MASK] the comedy产生的logits比“I loved the comedy产出的logits要低。

POS-guided word replacement

以$p_{\text { pos }}$的概率，随机地把一个词替换成相同POS(part-of-speech) tag的另一个词（如，把how替换成what）。为了保持原始的训练集的分布，新词从使用POS tag进行re-normalize的unigram的分布中采样出来。

n-gram sampling

以$p_{\text { ng }}$的概率，从$\{1,2, \dots, 5\}$中随机选一个$n$，然后随机采样出一个ngram。这种方法相当于随机扔掉句子的其他部分，是一种更aggressive的masking。

整个augmentation的流程

给定一个训练样本$\left\{w_{1}, \dots w_{n}\right\}$，整个augmentation的过程如下：

对每个词$w_i$从uniform distribution $X_{i} \sim \mathrm{UNIFORM}[0,1]$中采样出一个$X_i$如下操作
- 如果$X_{i}<p_{\mathrm{mask}}$，对$w_i$进行masking
- 如果$p_{\text { mask }} \leq X_{i}<p_{\mathrm{mask}}+p_{\mathrm{pos}}$，那么对$w_i$使用POS-guided word replacement
对这个样本的每个词处理完之后，以$p_{\text { ng }}$的概率，使用n-gram sampling，然后把结果加到augmented数据集中（无标签）

然后使用$n_{\text { iter }}$次如上操作，得到$n_{\text { iter }}$个augmented的sample。

土豪版：Megatron

https://github.com/NVIDIA/Megatron-LM

有钱任性：英伟达训练80亿参数量GPT-2，1475块V100 53分钟训练BERT

将BERT的训练时间缩短到了53分钟；
将BERT的推理时间缩短到了2.2毫秒（10 毫秒已经是业界公认的高水平）；
将GPT-2的参数量推向80亿（以前OpenAI GPT-2最大为15亿参数量）。

最大配置：72层、每层隐藏单元都是3072

想效仿英伟达50分钟训练 BERT？只有GPU还不够……

论文：Megatron-LM: Training Multi-Billion Parameter Language Models Using GPU Model Parallelism

该方法无需新的编译器或库更改，它与 pipeline 模型并行正交且互补，只需在 PyTorch 中嵌入几个通信操作即可完整实现。利用该方法，研究者使用 512 个 GPU 收敛了一个具备 83 亿参数的 transformer 语言模型，该模型是目前最大的 transformer 模型，其规模是 BERT 的 24 倍，GPT-2 的 5.6 倍。

为了展示该方法的可扩展性，研究者建立了一个基线：他们在单个 NVIDIA V100 32GB GPU 上训练了一个具备 12 亿参数的模型，整个训练应用维持 39 TeraFLOPs/秒的性能，是单个 GPU 在 DGX-2H 服务器上运行的理论峰值 FLOPS 的 30%，因此这是一个非常强大的基线模型。将该模型扩展至 83 亿参数，并使用 8-way 模型并行化在 512 个 GPU 上进行训练，达到了 15.1 PetaFLOPs/秒的性能。与单个 GPU 的情况相比，它实现了 76% 的扩展效率。在 174 GB 文本数据上收敛该模型需要以 12 ZettaFLOPs 训练 9.2 天。

研究者利用 transformer 网络的结构，仅添加几个同步基元（synchronization primitives）即创建出一个简单的模型并行化实现。他们对 transformer 中的自注意力模块和多层感知机（MLP）模块均采用了模型并行化。

模型并行与数据并行是正交的，因此我们可以同时使用二者在合理时间内训练大型模型。

paddle的LARK(ERNIE/BERT等)+bert的各种变种

2019-03-20T00:00:00+00:00

小结

预训练语言模型关系图+必读论文列表，清华荣誉出品

https://github.com/thunlp/PLMpapers

paddle的LARK里包含了一些nlp模型

强力推荐！飞桨产业级PaddleNLP最新全景图发布

bert

finetune和跑预测并save模型

BERT_BASE_PATH=./pretrained_model/chinese_L-12_H-768_A-12/
TASK_NAME="XNLI"
#DATA_PATH=./data/XNLI-1.0-demo/
DATA_PATH=./data/XNLI-MT-1.0-dwk/
INIT_CKPT_PATH=./output/step_50
SAVE_INFERENCE_PATH=./output/infer_step_50 ## 这个目录下会有个__model__文件，给在线infer用的，注意paddle的版本要用1.3.1以上的，1.3.0生成的这个目录有bug
python=../../python-2.7.14-paddle-1.3.1/bin/python


export FLAGS_enable_parallel_graph=1
export FLAGS_sync_nccl_allreduce=1
export CUDA_VISIBLE_DEVICES=0,1,2,3,4,5,6,7
export CPU_NUM=3 ## 设置跑的cpu核数

TASK_NAME='XNLI'
CKPT_PATH=./output/

function finetune_xnli()
{

### 如果有56核的cpu，会占114g。。；而如果是12核的cpu，只会占25g内存
DATA_PATH=./data/XNLI-MT-1.0-dwk/
$python -u run_classifier.py --task_name ${TASK_NAME} \
           --use_cuda false \
           --do_train true \
           --do_val true \
           --do_test true \
           --batch_size 1 \
           --in_tokens false \
           --init_pretraining_params ${BERT_BASE_PATH}/params \
           --data_dir ${DATA_PATH} \
           --vocab_path ${BERT_BASE_PATH}/vocab.txt \
           --checkpoints ${CKPT_PATH} \
           --save_steps 50 \
           --weight_decay  0.01 \
           --warmup_proportion 0.0 \
           --validation_steps 2500 \
           --epoch 1 \
           --max_seq_len 8 \
           --bert_config_path ${BERT_BASE_PATH}/bert_config.json \
           --learning_rate 1e-4 \
           --skip_steps 1 \
           --random_seed 1
}

function save_inference_model() 
{

### 如果是56核cpu，会占22g内存..
DATA_PATH=./data/XNLI-1.0-demo/
$python -u predict_classifier.py --task_name ${TASK_NAME} \
           --use_cuda false \
           --batch_size 1 \
           --data_dir ${DATA_PATH} \
           --vocab_path ${BERT_BASE_PATH}/vocab.txt \
           --do_lower_case true \
           --init_checkpoint ${INIT_CKPT_PATH} \
           --max_seq_len 8 \
           --bert_config_path ${BERT_BASE_PATH}/bert_config.json \
           --do_predict true \
           --save_inference_model_path ${SAVE_INFERENCE_PATH}

}

function main()
{
    finetune_xnli
    [[ $? -ne 0 ]] && exit 1
    save_inference_model
    [[ $? -ne 0 ]] && exit 1
    return 0
}

main 2>&1 

线上infer部分

参考这个readme:

https://github.com/PaddlePaddle/models/tree/develop/PaddleNLP/language_representations_kit/BERT/inference

生成demo文件可以参考

TASK_NAME="xnli"
DATA_PATH=../data/XNLI-1.0/
BERT_BASE_PATH=../pretrained_model/chinese_L-12_H-768_A-12/
python=../../../python-2.7.14-paddle-1.3.1/bin/python
$python gen_demo_data.py \
           --task_name ${TASK_NAME} \
           --data_path ${DATA_PATH} \
           --vocab_path "${BERT_BASE_PATH}/vocab.txt" \
           --batch_size 1 \
           > bert_data.demo

#           --in_tokens \

运行示例：

INFERENCE_MODEL_PATH=./output/infer_step_50
DATA_PATH=./bert_data.demo
REPEAT_TIMES=1
./bin/bert_demo --logtostderr \
        --model_dir $INFERENCE_MODEL_PATH \
        --data $DATA_PATH \
        --repeat $REPEAT_TIMES \
        --output_prediction

BAM

2019-03-19T00:00:00+00:00

概述
模型结构
方法
- 多任务训练
- 知识蒸馏

参考BAM！利用知识蒸馏和多任务学习构建的通用语言模型

论文地址：BAM! Born-Again Multi-Task Networks for Natural Language Understanding

概述

构建能够执行多个任务的单个模型一直是NLP领域的难题。多任务NLP对很多应用而言是无效的，多任务模型通常比单任务模型性能差。但是该研究提出利用知识蒸馏方法，让单任务模型高效教导多任务模型，从而在不同单任务上都有很好的表现。

知识蒸馏即将知识从「教师」模型迁移到「学生」模型，执行方式为训练学生模型模仿教师模型的预测。在Born-Again Neural Networks中，教师和学生具备同样的神经网络架构和模型大小，然而令人惊讶的是，学生网络的性能超越了教师网络。该研究将这一想法扩展到多任务模型训练环境中。

研究者使用多个变体对比Single->Multi born-again知识蒸馏，这些变体包括single->single的知识蒸馏和multi->multi的知识蒸馏，还有single->multi->single->multi。此外，该研究还提出了一个简单的教师退火（teacher annealing）方法，帮助学生模型超越教师模型，大幅改善预测结果。

模型结构

上面是整体模型的结构，其采用多个任务的单模型与对应标签作为输入。其中多任务模型主要基于BERT，因此该多任务模型能通过知识蒸馏学习到各单任务模型的语言知识。模型会有一个教师退火的过程，即最开始由多个单任务模型教多任务模型学习，而随着训练的进行，多任务模型将更多使用真实任务标签进行训练(即图中的$\lambda$从0慢慢变到1)。

方法

多任务训练

模型：该研究所有模型均基于BERT构建。该模型将byte-pair-tokenized的输入句子传输到Transformer网络，为每个token生成语境化的表征。最后一层的特征向量用token CLS的向量$c$来表示。对于分类任务，研究者使用标准softmax层直接分类，$softmax(Wc)$。对于回归任务，接一个size是1的nn并使用sigmoid激活函数，$sigmoid(w^Tc)$。在该研究开发的多任务模型中，除了基于BERT的分类器，所有模型参数在所有任务上共享，这意味着不到 0.01% 的参数是task-specific的。和BERT一样，字符级词嵌入和Transformer使用「masked LM」预训练阶段的权重进行初始化。

训练：单任务训练按照BERT原文的研究来执行。至于多任务训练，研究者将打乱不同任务的顺序，即使在小批量内也会进行shuffle。最后模型的训练为最小化所有任务上的（未加权）损失和。

知识蒸馏

使用知识蒸馏方法，让单任务模型来教多任务模型。这里学生网络和教师网络具备同样的模型架构。

知识蒸馏中学生网络要模仿教师网络，这有可能导致学生网络受限于教师网络的性能，无法超过教师网络。为了解决该问题，该研究提出teacher annealing，在训练过程中混合教师预测和gold label。

SimPLe

2019-03-12T00:00:00+00:00

概述

概述

参考仅需2小时学习，基于模型的强化学习方法可以在Atari上实现人类水平

论文地址：Model Based Reinforcement Learning for Atari

无模型强化学习能够用于在复杂任务（如雅达利游戏，甚至基于图像观测）中学习非常有效的策略。但是，这通常需要非常大量的交互——事实上，比人类掌握相同游戏需要的次数更多。为什么人类可以学习如此之快？部分原因可能是，人类能够学习游戏原理，并预测出哪个动作会带来想要的结果。在本文中，我们探索了如何基于视频预测模型来达到类似效果，让智能体能够通过更少的交互（相较于无模型方法而言，次数降低了几个数量级），通过雅达利游戏。本文讨论了模拟策略学习（SimPLe），一个基于视频预测模型的完全基于模型的深度强化学习算法，并比较了几种模型架构，包括一个在本文设定下得出最优结果的全新架构。我们在一系列雅达利游戏上测试评估了SimPLe，实验结果显示，仅通过10万次智能体和环境之间的交互（40万帧），约2小时的实时学习，SimPLe 就可获得有竞争力的结果。

效果最好的模型是前馈卷积神经网络。它利用一组卷积对一系列输入帧进行编码，并给定智能体采取的行动，然后利用一组反卷积对下一帧进行解码。奖励是基于瓶颈表征（bottleneck representation）预测的。

将随机性引入模型会带来不错的效果，可以让策略在训练阶段尝试更多不同的场景。为此，研究人员添加了一个隐变量，而来自隐变量的样本被添加至瓶颈表征。在离散变量该设定下效果最优，被编码为比特序列。模型的整体架构类似于变分自编码器，其中隐变量上的后验是基于整个序列（输入帧+目标帧）近似得到，从该后验中抽取一个值，并将该值与输入帧和action一起用于预测下一帧。在推断阶段，latent code由自回归 LSTM网络生成。

网络结构如下：

模型输入是 4 个堆叠的帧（以及智能体选择的策略），输出则是预测的下一帧及预期奖励。

用全连接层嵌入输入像素和action，在输出中有像素级的softmax（256 色）函数。

该模型有两个主要组成部分。

首先，网络底部由带有残差连接的卷积编码器和解码器(反卷积)组成。为了根据智能体的行动调节输出，解码器中每一层的输出都乘以learned embedded action。
模型的第二部分是卷积推断网络，类似于 Babaeizadeh 等人 (2017) Stochastic variational video prediction的观点，它在给定下一帧的条件下近似估计后验。
- 在训练阶段(左上角的@training)，从近似后验抽样得到的隐变量值将离散化为比特。为使模型可微，反向传播根据 Kaiser & Bengio (2018) Discrete autoencoders for sequence models的方法避开离散化，并训练第三个基于LSTM的网络，以在给定先前比特时近似估计当前比特。
- 在推断阶段(右上角的@inference)，利用该网络自回归地(auto-regressively)预测latent bits。

确定性模型（deterministic model）与上图架构相同，但不包含推断网络。

代码：https://github.com/tensorflow/tensor2tensor/tree/master/tensor2tensor/rl

包含视频的url：https://sites.google.com/view/modelbasedrlatari/home

parl

2019-03-01T00:00:00+00:00

简单使用
PARL框架
quickstart代码解析

简单使用

代码https://github.com/PaddlePaddle/PARL

安装：

pip install parl

也可以从源码安装：

pip install paddlepaddle

pip install gym
git clone https://github.com/PaddlePaddle/PARL.git
cd PARL
pip install .

然后跑quickstart：

cd examples/QuickStart/
python train.py
# 

或者将评估过程可视化：

python train.py --eval_vis

这样就可以得到下图的结果

PARL框架

主要抽象为Model、Algorithm、Agent三大模块：

Model：定义policy network或者critic network，使用state作为输入，建立一个前向网络
Algorithm：定义更新Model中的参数的机制，经常有不止一个model
Agent：是环境和Algorithm间的桥梁。负责与外界的数据I/O，并在把数据feed给训练process之前进行数据预处理

quickstart代码解析

我们看一下quickstart的例子，这是一个policygradient：

Model如下：

import parl.layers as layers
from parl.framework.model_base import Model
class CartpoleModel(Model):
    def __init__(self, act_dim):
        act_dim = act_dim
        hid1_size = act_dim * 10

        self.fc1 = layers.fc(size=hid1_size, act='tanh')
        self.fc2 = layers.fc(size=act_dim, act='softmax')

    def policy(self, obs):
        out = self.fc1(obs)
        out = self.fc2(out)
        return out

Algorithm如下，直接用的pg：

from parl.algorithms import PolicyGradient
alg = PolicyGradient(model, hyperparas={'lr': LEARNING_RATE})

Agent就有点复杂啦：

import parl.layers as layers
from parl.framework.agent_base import Agent
class CartpoleAgent(Agent):
    def __init__(self, algorithm, obs_dim, act_dim, seed=1):
        self.obs_dim = obs_dim
        self.act_dim = act_dim
        self.seed = seed
        super(CartpoleAgent, self).__init__(algorithm)

    def build_program(self):
        self.pred_program = fluid.Program()
        self.train_program = fluid.Program()

        fluid.default_startup_program().random_seed = self.seed
        self.train_program.random_seed = self.seed

        with fluid.program_guard(self.pred_program):
            # obs相当于是state
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            self.act_prob = self.alg.define_predict(obs)

        with fluid.program_guard(self.train_program):
            # obs相当于是state
            obs = layers.data(
                name='obs', shape=[self.obs_dim], dtype='float32')
            act = layers.data(name='act', shape=[1], dtype='int64')
            reward = layers.data(name='reward', shape=[], dtype='float32')
            self.cost = self.alg.define_learn(obs, act, reward)

    def sample(self, obs):
        obs = np.expand_dims(obs, axis=0)
        act_prob = self.fluid_executor.run(
            self.pred_program,
            feed={'obs': obs.astype('float32')},
            fetch_list=[self.act_prob])[0]
        # 从数组的形状中删除单维度条目，即把shape中为1的维度去掉，参考https://daiwk.github.io/posts/knowledge-numpy-usage.html#npsqueeze
        act_prob = np.squeeze(act_prob, axis=0)
        act = np.random.choice(range(self.act_dim), p=act_prob)
        return act

    def predict(self, obs):
        obs = np.expand_dims(obs, axis=0)
        act_prob = self.fluid_executor.run(
            self.pred_program,
            feed={'obs': obs.astype('float32')},
            fetch_list=[self.act_prob])[0]
        # 从数组的形状中删除单维度条目，即把shape中为1的维度去掉，参考https://daiwk.github.io/posts/knowledge-numpy-usage.html#npsqueeze
        act_prob = np.squeeze(act_prob, axis=0)
        # 取出概率最大的那个动作
        act = np.argmax(act_prob)
        return act

    def learn(self, obs, act, reward):
        # 在act的最后面加多一维，why?...
        act = np.expand_dims(act, axis=-1)
        feed = {
            'obs': obs.astype('float32'),
            'act': act.astype('int64'),
            'reward': reward.astype('float32')
        }
        cost = self.fluid_executor.run(
            self.train_program, feed=feed, fetch_list=[self.cost])[0]
        return cost

使用时，先定义训练方法（reset环境，然后根据当前state采样出一个action，然后在环境中执行这个action，得到reward，这些(s,a,r)都存起来，如果done了，就返回这些(s,a,r)）：

def run_train_episode(env, agent):
    obs_list, action_list, reward_list = [], [], []
    obs = env.reset()
    while True:
        obs_list.append(obs)
        action = agent.sample(obs)
        action_list.append(action)

        obs, reward, done, info = env.step(action)
        reward_list.append(reward)

        if done:
            break
    return obs_list, action_list, reward_list

然后定义计算discounted reward的函数，不断地乘gamma，再做个归一化

def calc_discount_norm_reward(reward_list, gamma):
    discount_norm_reward = np.zeros_like(reward_list)

    discount_cumulative_reward = 0
    for i in reversed(range(0, len(reward_list))):
        discount_cumulative_reward = (
            gamma * discount_cumulative_reward + reward_list[i])
        discount_norm_reward[i] = discount_cumulative_reward
    discount_norm_reward = discount_norm_reward - np.mean(discount_norm_reward)
    discount_norm_reward = discount_norm_reward / np.std(discount_norm_reward)
    return discount_norm_reward

然后定义evaluate的方法，其实就是先reset环境，然后根据s，通过agent的predict得到一个a，然后执行这个a，得到reward，累加这个reward（注意！！！这里没有gamma了！！！），直到done，返回当前的累积reward：

def run_evaluate_episode(env, agent):
    obs = env.reset()
    all_reward = 0
    while True:
        if args.eval_vis:
            env.render()
        action = agent.predict(obs)
        obs, reward, done, info = env.step(action)
        all_reward += reward
        if done:
            break
    return all_reward

然后就是整体流程啦：

env = gym.make("CartPole-v0")
env.seed(SEED)
np.random.seed(SEED)
model = CartpoleModel(act_dim=ACT_DIM)
alg = PolicyGradient(model, hyperparas={'lr': LEARNING_RATE})
agent = CartpoleAgent(alg, obs_dim=OBS_DIM, act_dim=ACT_DIM, seed=SEED)
for i in range(1000):
    obs_list, action_list, reward_list = run_train_episode(env, agent)
    logger.info("Episode {}, Reward Sum {}.".format(i, sum(reward_list)))

    batch_obs = np.array(obs_list)
    batch_action = np.array(action_list)
    batch_reward = calc_discount_norm_reward(reward_list, GAMMA)

    agent.learn(batch_obs, batch_action, batch_reward)
    if (i + 1) % 100 == 0:
        all_reward = run_evaluate_episode(env, agent)
        logger.info('Test reward: {}'.format(all_reward))

lingvo

2019-02-26T00:00:00+00:00

安装及基本使用
自定义参数和模型
- 自定义参数
现有模型

代码：https://github.com/tensorflow/lingvo

论文：Lingvo: a Modular and Scalable Framework for Sequence-to-Sequence Modeling

Lingvo 是一个能够为协作式深度学习研究提供完整解决方案的 Tensorflow 框架，尤其关注序列到序列模型。Lingvo 模型由模块化构件组成，这些构件灵活且易于扩展，实验配置集中且可定制。分布式训练和量化推理直接在框架内得到支持，框架内包含大量 utilities、辅助函数和最新研究思想的现有实现。

设计原则如下：

单个代码块应该精细且模块化，它们会使用相同的接口，同时也容易扩展；
实验应该是共享的、可比较的、可复现的、可理解的和正确的；
性能应该可以高效地扩展到生产规模的数据集，或拥有数百个加速器的分布式训练系统；
当模型从研究转向产品时应该尽可能共享代码。

我们可以发现好多paper都是基于lingvo跑的呢：https://github.com/tensorflow/lingvo/blob/master/PUBLICATIONS.md

api文档：https://tensorflow.github.io/lingvo/

安装及基本使用

安装

首先的首先，需要安装：

pip install tf-nightly
pip install tensorflow -U # 至少要是2.0的哦，后面会讲原因，可以自己编个whl出来，再pip本地安装

首先下载数据集(如果遇到下载的ssl问题，可以参考https://daiwk.github.io/posts/knowledge-tf-usage.html#%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98)

mkdir -p /tmp/mnist
bazel run -c opt //lingvo/tools:keras2ckpt -- --dataset=mnist --out=/tmp/mnist/mnist

然后build一个trainer，如果出现如下错误。。把装了tf的py扔到PATH里就行。

bazel build -c opt //lingvo:trainer
ERROR: /home/disk2/daiwenkai/workspaces/tf/lingvo/lingvo/core/ops/BUILD:24:1: no such package '@tensorflow_solib//': Traceback (most recent call last):
        File "/home/disk2/daiwenkai/workspaces/tf/lingvo/lingvo/repo.bzl", line 88
                _find_tf_lib_path(repo_ctx)
        File "/home/disk2/daiwenkai/workspaces/tf/lingvo/lingvo/repo.bzl", line 30, in _find_tf_lib_path
                fail("Could not locate tensorflow ins...")
Could not locate tensorflow installation path. and referenced by '//lingvo/core/ops:x_ops'
ERROR: Analysis of target '//lingvo:trainer' failed; build aborted: no such package '@tensorflow_solib//': Traceback (most recent call last):
        File "/home/disk2/daiwenkai/workspaces/tf/lingvo/lingvo/repo.bzl", line 88
                _find_tf_lib_path(repo_ctx)
        File "/home/disk2/daiwenkai/workspaces/tf/lingvo/lingvo/repo.bzl", line 30, in _find_tf_lib_path
                fail("Could not locate tensorflow ins...")
Could not locate tensorflow installation path.
INFO: Elapsed time: 5.916s
INFO: 0 processes.

想看详细日志，可以：

bazel build -c opt //lingvo:trainer --sandbox_debug

想把当前的PATH加进去，可以：

bazel build -c opt //lingvo:trainer --sandbox_debug --action_env=PATH

这样，就会显示：

ERROR: /home/disk2/daiwenkai/workspaces/tf/lingvo/lingvo/core/ops/BUILD:304:1: Executing genrule //lingvo/core/ops:hyps_proto_gencc failed (Exit 1) process-wrapper failed: error executing command 
  (cd /home/work/.cache/bazel/_bazel_work/6019387a2835fd5f247d5cbc29b5ee5a/execroot/__main__ && \
  exec env - \
    PATH=/opt/compiler/gcc-4.8.2/bin/:/home/disk2/daiwenkai/tools/python-2.7.14/bin/:/home/disk2/daiwenkai/workspaces/tf/prepare/:/home/disk2/daiwenkai/workspaces/tf/prepare/jdk1.8.0_152/bin:/home/work/.hmpclient/bin:/home/work/.BCloud/bin:/home/work/.hmpclient/bin:/home/work/.jumbo/opt/sun-java6/bin:/home/work/.jumbo/opt/sun-java6/jre/bin:/home/work/.jumbo/opt/sun-java6/db/bin:/home/work/.jumbo/bin/core_perl:/home/work/.jumbo/bin:/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin:/usr/X11R6/bin:/opt/bin:/home/opt/bin \
    TMPDIR=/tmp \
  /home/work/.cache/bazel/_bazel_work/install/8e122cdaf21df7dee88c59e8c0fa6061/_embedded_binaries/process-wrapper '--timeout=0' '--kill_delay=15' /bin/bash -c 'source external/bazel_tools/tools/genrule/genrule-setup.sh; 
          mkdir -p bazel-out/k8-opt/genfiles/lingvo/core/ops/tf_proto.$$;
          tar -C bazel-out/k8-opt/genfiles/lingvo/core/ops/tf_proto.$$ -xf bazel-out/host/genfiles/lingvo/tf_protos.tar;
          external/protobuf_protoc/bin/protoc --proto_path=bazel-out/k8-opt/genfiles/lingvo/core/ops/tf_proto.$$  --proto_path=. --cpp_out=bazel-out/k8-opt/genfiles lingvo/core/ops/hyps.proto;
          rm -rf bazel-out/k8-opt/genfiles/lingvo/core/ops/tf_proto.$$
        ')
external/protobuf_protoc/bin/protoc: /lib64/tls/libc.so.6: version `GLIBC_2.4' not found (required by external/protobuf_protoc/bin/protoc)
Target //lingvo:trainer failed to build
Use --verbose_failures to see the command lines of failed build steps.

这个时候我们会发现，，因为依赖的是用gcc4.8编译好的protoc，而下下来本地跑bazel的时候，会用本地默认的lib64，所以不行，所以我们用trick来搞，对lingvo/lingvo.bzl进行如下修改，也就是

一方面把/opt/compiler/gcc-4.8.2/lib/ld-linux-x86-64.so.2 --library-path /opt/compiler/gcc-4.8.2/lib加到protoc前面，
另一方面，手动把protc的zip下载下来，例如lingvo/repos.bzl里要求的是3.6.1版本，然后解压到./protobuf3.6.1_dir目录，所以咱们把里面的include目录(里面有一堆.proto文件)加进来『-I/home/disk2/daiwenkai/workspaces/tf/lingvo/protobuf3.6.1_dir/include』

def _proto_gen_cc_src(name, basename):
    native.genrule(
        name = name,
        srcs = [basename + ".proto"],
        outs = [basename + ".pb.cc", basename + ".pb.h"],
        tools = [
            "@protobuf_protoc//:protoc_bin",
            "//lingvo:tf_dot_protos",
        ],      
        # TODO(drpng): only unpack if tf_proto dependency is requested.
        cmd = """
          mkdir -p $(@D)/tf_proto.$$$$;
          tar -C $(@D)/tf_proto.$$$$ -xf $(location //lingvo:tf_dot_protos);
          /opt/compiler/gcc-4.8.2/lib/ld-linux-x86-64.so.2 --library-path /opt/compiler/gcc-4.8.2/lib $(location @protobuf_protoc//:protoc_bin) --proto_path=$(@D)/tf_proto.$$$$ -I/home/disk2/daiwenkai/workspaces/tf/lingvo/protobuf3.6.1_dir/include --proto_path=. --cpp_out=$(GENDIR) $(<);
          rm -rf $(@D)/tf_proto.$$$$
        """,
    )

def _proto_gen_py_src(name, basename):
    native.genrule(
        name = name, 
        srcs = [basename + ".proto"],
        outs = [basename + "_pb2.py"],
        tools = [
            "@protobuf_protoc//:protoc_bin",
            "//lingvo:tf_dot_protos",
        ],      
        # TODO(drpng): only unpack if tf_proto dependency is requested.
        cmd = """
          mkdir -p $(@D)/tf_proto.$$$$;
          tar -C $(@D)/tf_proto.$$$$ -xf $(location //lingvo:tf_dot_protos);
          /opt/compiler/gcc-4.8.2/lib/ld-linux-x86-64.so.2 --library-path /opt/compiler/gcc-4.8.2/lib $(location @protobuf_protoc//:protoc_bin) --proto_path=$(@D)/tf_proto.$$$$ -I/home/disk2/daiwenkai/workspaces/tf/lingvo/protobuf3.6.1_dir/include --proto_path=. --python_out=$(GENDIR) $(<);
          rm -rf $(@D)/tf_proto.$$$$
        """,
    )

注意！！！这里的protobuf版本要求是3.6.1！！！

为什么呢。。。发现我们从tf1.3源码build出来的include里会出现这种问题https://github.com/tensorflow/lingvo/issues/39，于是。。从源码编个tf2.0就行啦！！！！！

因为你的tf1.3的，那么protobuf是3.6.0的，所以是不行的呢！！

也就是说，把lingvo/repo.bzl必须是原来的3.6.1！！不要乱改成3.6.0。。。：

def lingvo_protoc_deps():
    http_archive(
        name = "protobuf_protoc",
        build_file_content = """
filegroup(
    name = "protoc_bin",
    srcs = ["bin/protoc"],
    visibility = ["//visibility:public"],
)
""",
        urls = [
            #"https://github.com/google/protobuf/releases/download/v3.6.0/protoc-3.6.0-linux-x86_64.zip",
            "https://github.com/google/protobuf/releases/download/v3.6.1/protoc-3.6.1-linux-x86_64.zip",
        ],      
        sha256 = "6003de742ea3fcf703cfec1cd4a3380fd143081a2eb0e559065563496af27807",
        #sha256 = "84e29b25de6896c6c4b22067fb79472dac13cf54240a7a210ef1cac623f5231d",
    )

跑lenet5

然后就可以跑啦

bazel-bin/lingvo/trainer --run_locally=cpu --mode=sync --model=image.mnist.LeNet5 --logdir=/tmp/mnist/log --logtostderr

如果出现：『locale.Error: unsupported locale setting』这种报错！！

那么！！https://stackoverflow.com/questions/14547631/python-locale-error-unsupported-locale-setting这个解答是完美的！！

export LC_ALL=C

注意，跑的时候要装matplotlib，而且要用tk的东西（记得把libtk*，还有libtcl*拷到python的lib-dynload目录下去）~

当然，我们可以看tensorboard，使用

tensorboard --logdir=/tmp/mnist/log/ --port 8023

如果提示

E0309 04:14:00.829349 139808152127232 program.py:232] Tensorboard could not bind to unsupported address family ::
ERROR: Tensorboard could not bind to unsupported address family ::

那么，我们可以加上host参数：

tensorboard --logdir=/tmp/mnist/log/ --port 8023 --host bj01-aaa.bbb.bj01

可以看到：

这样，在/tmp/mnist/log/control目录下，就有：

params.txt: hyper-parameters.

例如：

add_summary : True
allow_implicit_capture : NoneType
cls : type/lingvo.core.base_model/SingleTaskModel
cluster.add_summary : NoneType
cluster.cls : type/lingvo.core.cluster/_Cluster
cluster.controller.devices_per_split : 1
cluster.controller.gpus_per_replica : 0
cluster.controller.name : '/job:local'
cluster.controller.num_tpu_hosts : 0
cluster.controller.replicas : 1
cluster.controller.tpus_per_replica : 0
cluster.decoder.devices_per_split : 1
cluster.decoder.gpus_per_replica : 0
cluster.decoder.name : '/job:local'

...

task.train.max_steps : 4000000
task.train.optimizer.add_summary : True
task.train.optimizer.allow_implicit_capture : NoneType
task.train.optimizer.beta1 : 0.9
task.train.optimizer.beta2 : 0.999
task.train.optimizer.cls : type/lingvo.core.optimizer/Adam
task.train.optimizer.dtype : float32
task.train.optimizer.epsilon : 1e-06
task.train.optimizer.fprop_dtype : NoneType
task.train.optimizer.inference_driver_name : NoneType
task.train.optimizer.is_eval : NoneType
task.train.optimizer.is_inference : NoneType
task.train.optimizer.name : 'Adam'
task.train.optimizer.params_init.method : 'xavier'

model_analysis.txt: model sizes for each layer.

例如：

_task.conv[0].w           (5, 5, 1, 20)               500 lenet5/conv0/w/var
_task.conv[1].w           (5, 5, 20, 50)            25000 lenet5/conv1/w/var
_task.fc.b                (300,)                      300 lenet5/fc/b/var
_task.fc.w                (2450, 300)              735000 lenet5/fc/w/var
_task.softmax.bias_0      (10,)                        10 lenet5/softmax/bias_0/var
_task.softmax.weight_0    (300, 10)                  3000 lenet5/softmax/weight_0/var
====================================================================================================
total #params:     763810

train.pbtxt: the training tf.GraphDef.

例如：

node {
  name: "global_step/Initializer/zeros"
  op: "Const" 
  attr {  
    key: "_class"
    value { 
      list {  
        s: "loc:@global_step"
      }
    }
  }
  attr {  
    key: "dtype" 
    value { 
      type: DT_INT64
    }
  }
  attr {  
    key: "value" 
    value { 
      tensor {
        dtype: DT_INT64
        tensor_shape {
        }       
        int64_val: 0
      }
    }
  }
}
node {
  name: "global_step"
...

events.*: a tensorboard events file.

而在/tmp/mnist/log/train目录下，有

ckpt-*: the checkpoint files.
checkpoint: a text file containing information about the checkpoint files.

例如：

model_checkpoint_path: "/tmp/mnist/log/train/ckpt-00397115"
all_model_checkpoint_paths: "/tmp/mnist/log/train/ckpt-00391858"
all_model_checkpoint_paths: "/tmp/mnist/log/train/ckpt-00391915"
all_model_checkpoint_paths: "/tmp/mnist/log/train/ckpt-00391973"
all_model_checkpoint_paths: "/tmp/mnist/log/train/ckpt-00392030"

跑机器翻译

参考https://github.com/tensorflow/lingvo/tree/master/lingvo/tasks/mt

自定义参数和模型

自定义参数

例如，我们想基于lenet5的模型，改一下训练时间，那么需要参考https://github.com/tensorflow/lingvo/issues/40

自己写一个：

@model_registry.RegisterSingleTaskModel
class LeNet5Custom(LeNet5):
  """LeNet params for MNIST classification custom."""

  @classmethod
  def Task(cls):
    p = super(LeNet5Custom, cls).Task()
    p.train.max_steps = 100
    return p

然后跑一遍全流程：

ps aux| grep tensorboard| awk '{print $2}'| xargs kill -9
nohup tensorboard --logdir=/tmp/mnist/log/ --port 8023 --host xxx-xx-xx &

bazel build -c opt //lingvo:trainer --sandbox_debug --action_env=PATH
bazel-bin/lingvo/trainer --run_locally=cpu --mode=sync --model=image.mnist.LeNet5Custom --logdir=/tmp/mnist/log --logtostderr

现有模型

deepgan

2019-02-24T00:00:00+00:00

参考史上最强图像生成器BigGAN变身DeepGAN？四倍深度实现更强效果

multitask nlu

2019-02-13T00:00:00+00:00

参考GLUE排行榜上全面超越BERT的模型近日公布了！

Multi-Task Deep Neural Networks for Natural Language Understanding

较低层（即文本编码层）在所有任务中共享，而顶层是任务特定的，组合不同类型的 NLU 任务，如单句分类、pair文本分类、文本相似性和相关性排序。与BERT模型类似，MT-DNN分两个阶段进行训练：预训练和微调。与BERT不同的是，MT-DNN在微调阶段使用MTL，在其模型架构中具有多个任务特定层。

单词序列（可以是一句话或者打包在一起的句子对）作为输入X，先表示为一个嵌入向量序列，其中$l_1$中一个向量对应一个单词。然后 Transformer编码器通过自注意机制捕捉每个单词的语境信息，在$l_2$中生成语境嵌入序列。这就是多任务目标函数训练得到的共享语义表征。

meta learning& auto-ml

2019-02-02T00:00:00+00:00

meta-learning
auto-ml
once for all
应用

meta-learning

参考https://lilianweng.github.io/lil-log/2018/11/30/meta-learning.html

auto-ml

参考https://www.automl.org/wp-content/uploads/2018/12/AutoML-Tutorial-NeurIPS2018-MetaLearning.pdf

参考AutoML研究综述：让AI学习设计AI

参考专栏 | 神经网络架构搜索（NAS）综述（附AutoML资料推荐）

参考KDD Cup 2019 AutoML Track冠军深兰科技DeepBlueAI团队技术分享 | 开源代码

参考AutoML: A Survey of the State-of-the-Art

在特定领域构建高质量的深度学习系统不仅耗时，而且需要大量的资源和人类的专业知识。为了缓解这个问题，许多研究正转向自动机器学习。本文是一个全面的 AutoML 论文综述文章，介绍了最新的 SOTA 成果。首先，文章根据机器学习构建管道的流程，介绍了相应的自动机器学习技术。然后总结了现有的神经架构搜索（NAS）研究。论文作者同时对比了 NAS 算法生成的模型和人工构建的模型。最后，论文作者介绍了几个未来研究中的开放问题。

fairnas

参考超越MnasNet、Proxyless：小米开源全新神经架构搜索算法FairNAS

FairNAS: Rethinking Evaluation Fairness of Weight Sharing Neural Architecture Search

源码：https://github.com/fairnas/FairNAS

efficientnet

参考https://daiwk.github.io/posts/cv-efficientnet.html

adanet

参考https://daiwk.github.io/posts/platform-adanet.html

mdenas

参考ICCV 2019 | 四小时搜索NN结构，厦大提出快速NAS检索方法

Multinomial Distribution Learning for Effective Neural Architecture Search

https://github.com/tanglang96/MDENAS

近年来，通过神经架构搜索（NAS）算法生成的架构在各种计算机视觉任务中获得了极强的的性能。然而，现有的 NAS 算法需要再上百个 GPU 上运行 30 多天。在本文中，我们提出了一种基于多项式分布估计快速 NAS 算法，它将搜索空间视为一个多项式分布，我们可以通过采样-分布估计来优化该分布，从而将 NAS 可以转换为分布估计/学习。

除此之外，本文还提出并证明了一种保序精度排序假设，进一步加速学习过程。在 CIFAR-10 上，通过我们的方法搜索的结构实现了 2.55％的测试误差，GTX1080Ti 上仅 4 个 GPU 小时。在 ImageNet 上，我们实现了 75.2％的 top1 准确度。

ProxylessNAS & HAQ

寻找最佳的神经网络架构，韩松组两篇论文解读

ProxylessNAS: Direct Neural Architecture Search on Target Task and Hardware, ICLR2019

github: https://github.com/MIT-HAN-LAB/ProxylessNAS

HAQ: Hardware-Aware Automated Quantization with Mixed Precision, CVPR2019

进化论方法

亚马逊：自动选择AI模型，进化论方法效率更高！

来自亚马逊的研究人员探索出了一种可适用于任何计算模型的技术，条件是该模型可以计算出与图灵机相同的功能。（这里的“图灵机”是指定义抽象机的模型，可以根据规则来操纵符号。）

“无论使用哪种学习算法，选择哪种体系结构或调整训练参数（例如批规模或学习率），选择神经体系结构都不可能为给定的机器学习问题提供最佳解决方案，”Alexa AI机器学习平台服务组织的研究工程师，论文的主要作者温特表示。“只有考虑到尽可能多的可能性，才能确定一种在理论上保证计算准确性的体系结构。”

为此，研究团队评估了函数逼近问题的解决方案，这是AI算法搜索参数以逼近目标函数输出的方式的数学抽象方法。研究人员将其重新制定为发现一个估计目标函数输出的已知函数序列的问题，以获取更大的系统建模优势。

研究人员的研究表明，应该选择AI模型的组成部分，以确保它们具有“图灵等效性”。研究人员认为，最好通过自动搜索来识别模型，使用程序来设计特定任务的AI模型架构。这种搜索中的算法会首先生成用于解决问题的其他候选算法，然后将性能最佳的候选者彼此组合并再次进行测试。

“本文中……可立即应用的结果是鉴定遗传算法，更具体地说，是协同进化算法，其性能指标取决于彼此之间的相互作用，这是寻找最佳（或接近最佳）架构的最实用方法，”论文作者写道。“基于经验，许多研究人员得出的结论是，协同进化算法提供了构建机器学习系统的最佳方法。但是本文中的函数逼近框架有助于为他们的直觉提供更安全的理论基础。”

亚马逊并不是唯一一个倡导采用进化方法进行AI架构搜索的机构。今年7月，Uber为名为EvoGrad的进化算法开源了开发资源库。去年10月，Google推出了AdaNet，这是一种用于组合机器学习算法以获得更好的预测观点的工具。

On the Bounds of Function Approximations

autogan

[[https://daiwk.github.io/posts/cv-autogan.html](https://daiwk.github.io/posts/cv-autogan.html](https://daiwk.github.io/posts/cv-autogan.html

once for all

参考韩松等人提出NN设计新思路：训练一次，全平台应用

Once for All: Train One Network and Specialize it for Efficient Deployment

如要有效地部署深度学习模型，需要专门的神经网络架构，以便最好地适应不同的硬件平台和效率限制条件（定义为部署场景（deployment scenario））。传统的方法要么是人工设计，要么就是使用 AutoML（自动机器学习）来搜索特定的神经网络，再针对每个案例从头开始训练。这些方法的成本高昂，而且难以扩展，因为它们的训练成本与部署场景的数量有关。

本研究为高效神经网络设计引入了一种 Once for All（OFA/一劳永逸）方法，可处理很多部署场景。这种新方法的特点是分离了模型训练与架构搜索过程。这种方法不会针对每种案例都训练一个专用模型，而是训练一个支持多种不同架构设置（深度、宽度、核大小和分辨率）的 OFA 网络。

然后给定一个部署场景，再通过选择 OFA 网络中特定的子网络来搜索合适的结果，这个过程无需训练。因此，专用模型的训练成本就从 O(N) 降到了 O(1)。但是，我们却难以防止许多不同子网络之间的干扰。针对这一问题，MIT 的这些研究者提出了渐进式收束算法（progressive shrinking algorithm）。该算法能够训练支持超过 10^19 个子网络的 OFA 网络，同时还能保持与独立训练的网络一样的准确度，从而节省非重复性工程开发（non-recurring engineering/NRE）成本。

研究者在多种不同的硬件平台（移动平台/CPU/GPU）和效率限制条件上进行了广泛的实验，结果表明：相比于当前最佳（SOTA）的神经架构搜索（NAS）方法，OFA 能稳定地取得同等水平（或更好）的 ImageNet 准确度。值得注意的是，OFA 在处理多部署场景（N）时的速度比 NAS 快几个数量级。当 N=40 时，OFA 所需的 GPU 工作小时数比 ProxylessNAS 少 14 倍、比 FBNet 少 16 倍、比 MnasNet 少 1142 倍。部署场景越多，则相比于 NAS 就节省越多。

应用

AutoTiKV：基于机器学习的数据库调优

graph representation

2019-02-02T00:00:00+00:00

Introduction
part1-Node Representation Learning
part2-Graph Neural Networks
part3-Deep Generative Models for Graph Generation
未来方向
自己的小结
其他
- Google的一些进展
- 理解gat

入门可以看看从数据结构到算法：图网络方法初探

再来另一个KDD2019的图相关的turorial：“Learning From Networks——Algorithms, Theory, & Applications”：

链接:https://pan.baidu.com/s/1uLXThmqVgS3P18i2PPBI9g 密码:9ls2

以下主要参考自AAAI2019的tutorial：AAAI2019《图表示学习》Tutorial, 180 页 PPT 带你从入门到精通（下载）

ppt下载：https://pan.baidu.com/s/1hRjm1nbMcj4_ynZ0niE2JA

传统的机器学习方法依赖于用户定义的启发式模型来提取关于图的结构信息的特征编码 (例如，degree statistics或核函数)。然而，近年来，使用基于深度学习和非线性降维的技术，自动学习将图结构编码为低维embedding的方法激增。

Introduction

graph的几大传统ml任务：

Node classification：预测给定的结点的type
Link prediction：预测两个结点是否有边相连
Community detection：发现联系紧密的nodes的clusters
Network similarity：两个（子）网是否相似

目前的深度学习：

cnn：固定大小的图片/网格
rnn/w2v：文本/序列

图更加复杂：

复杂的拓扑结构（例如，不像网格那样有spatial locality(空间局部性，在最近的将来将用到的信息很可能与现在正在使用的信息在空间地址上是临近的。)）
没有固定的结点顺序或者参考点（reference point）(例如，isomorphism（同构）问题)
经常是动态的并且有multimodal（多模态）的features

part1-Node Representation Learning

Node Representation Methods

问题定义：给定$G=(V,E,W)$，其中，$V$是结点集合，$E$是边的集合，$W$是边的权重集合。所谓的node embedding就是对结点$i$学习一个向量$u_i\in R^d$。

LINE

WWW2015上的LINE: Large-scale Information Network Embedding

LINE代码（c++）：https://github.com/tangjianpku/LINE

特点：

任意类型的网络（有向图、无向图、有/无权重）
明确的目标函数（一阶和二阶相似性（first/second proximity））
可扩展性
- 异步sgd
- 百万级的结点和十亿级别的边：单机数小时

一阶相似度

First-order Proximity（一阶相似度）：两个顶点之间的自身相似（不考虑其他顶点）。因为有些结点的link并没有被观测到，所以一阶相似度不足以保存网络结构。

分布：(定义在无向边$i-j$上)

一阶相似度的经验分布：

\[ \hat{p}_1(v_i,v_j)=\frac{w_{ij}}{\sum_{(m,n)\in E}w_{mn}} \]

一阶相似度的模型分布：

\[ p_1(v_i,v_j)=\frac{\exp(\vec{u_i}^T\vec{u_j})}{\sum_{(m,n)\in V\times V}\exp(\vec{u_m}^T\vec{u_n})} \]

其中，$\vec{u_i}$是节点$i$的embedding，其实就是sigmoid：

\[ p_1(v_i,v_j)=\frac{1}{1+\exp(-\vec{u_i}^T\vec{u_j})} \]

目标函数是KL散度：

\[ O_1=KL(\hat{p}_1,p_1) \]

干掉常量$\sum_{(m,n)\in E}w_{mn}$，还有$\sum _{(i,j)\in E}w_{ij}\log w_{ij}$之后：

\[ O_1=\sum _{(i,j)\in E}w_{ij}\log w_{ij}-\sum _{(i,j)\in E}w_{ij}\log p_1(v_i,v_j)\approx -\sum _{(i,j)\in E}w_{ij}\log p_1(v_i,v_j) \]

只考虑一阶相似度的情况下，改变同一条边的方向对于最终结果没有什么影响。因此一阶相似度只能用于无向图，不能用于有向图。

二阶相似度

Second-order Proximity（二阶相似度）：网络中一对顶点$(u,v)$之间的二阶相似度是它们邻近网络结构之间的相似性。

分布：(定义在有向边$i\rightarrow j$上)

邻近网络的经验分布：

\[ \hat{p}_2(v_j|v_i)=\frac{w_{ij}}{\sum_{k\in V}w_{ik}} \]

邻近网络的模型分布，其中，$u_i$是$v_i$被视为顶点时的表示，$u'_i$是$v_i$被视为”context”时的表示：

\[ p_2(v_j|v_i)=\frac{\exp(\vec{u'_j}^T\vec{u_i})}{\sum_{k\in V}\exp(\vec{u'_k}^T\vec{u_i})} \]

目标函数是KL散度：

\[ O_2=\sum_i KL(\hat{p}_2(\cdot |v_i),p_2(\cdot|v_i))=-\sum _{(i,j)\in E}w_{ij}\log p_2(v_j|v_i) \]

优化trick

sgd+negative sampling：随机sample一条边，以及多个negative的边

例如针对二阶的，对每条边$(i,j)$来说，它的目标函数就是：

\[ \log \sigma(\vec{u'_j}^T\vec{u'_i})+\sum ^K_{i=1}E_{v_n\sim P_n(v)}[\log \sigma (-\vec{u'_n}^T\vec{u_i})] \]

其中$\sigma(x)=1/(1+\exp(-x))$，设置$P_n(v)\propto d_v^{3/4}$，其中$d_v$是节点的出度（即$d_i=\sum _{k\in N(i)}w_{ik}$，其中$N(i)$是$v_i$的为起点的邻居的集合）。

针对一阶的，把上面式子里的第一项里的$\vec{u'_j}^T$换成$\vec{u_j}^T$就行啦~

边$(i,j)$的embedding的梯度：

\[ \frac{\partial O_2}{\partial \vec{u_i}}=w_{ij}\frac{\partial \log \hat{p}_2(v_j|v_i)}{\partial \vec{u_i}} \]

当边的权重方差很大的时候，从上式可知，目标函数的梯度是$p_2$的梯度再乘以边权重，所以目标函数的梯度的方差也会很大，这样会有问题。
解决方法：edge sampling：根据边的权重来采样边，然后把采样到的边当成binary的，也就是把每条边的权重看成一样的！(例如一个边的权重是$w$，那么拆成$w$条binary的边)
复杂度：$O(d\times K \times |E|)$：$d$是embedding的维数，$K$是负样本的个数，$|E|$是边的总数

讨论

对只有少量邻居的节点（low degree vertices）进行embed：
- 通过增加高阶邻居来扩展邻居
- BFS(breadth-first search)，使用广度优先搜索策略扩展每个顶点的邻域，即递归地添加邻居的邻居
- 在大部分场景下，只增加二阶邻居就足够了
对新节点进行emb（如果新节点和已有节点有边相连，可以如下方式来搞；否则，future work…）:
- 保持现有节点的embedding不变
- 根据新节点的embedding求经验分布和模型分布，从而优化目标函数 w.r.t. 新node的embedding

所以，对于新节点$i$，直接最小化如下目标函数：

\[ -\sum_{j\in N(i)}w_{ji}\log p_1(v_j,v_i) \]

或者

\[ -\sum _{j\in N(i)}w_{ji}\log p_2(v_j|v_i) \]

实验

LINE(1st)只适用于无向图，LINE(2nd)适用于各种图。

LINE (1st+2nd)：同时考虑一阶相似度和二阶相似度。将由LINE（1st）和LINE（2nd）学习得到的两个向量表示，连接成一个更长的向量。在连接之后，对维度重新加权以平衡两个表示。因为在无监督的任务中，设定权重很困难，所以只应用于监督学习的场景。

更适合的方法是共同训练一阶相似度和二阶相似度的目标函数，比较复杂，文章中没有实现。

DeepWalk

KDD14上的DeepWalk: Online Learning of Social Representations

使用学习word representation的方法来学习node representation（例如skip gram）

将网络上的随机游走视为句子。

分成两步：

通过随机游走生成结点的context
预测周围的节点:

\[ p(v_j|v_i)=\frac{\exp(\vec{u'_i}^T \vec{u_j})}{\sum _{k\in V}\exp(\vec{u'_k}^T\vec{u_i})} \]

Node2vec

KDD16上的node2vec: Scalable Feature Learning for Networks

通过如下混合策略去寻找一个node的context：

Breadth-firstSampling(BFS): homophily（同质性）
Depth-firstSampling(DFS): structuralequivalence（结构等价）

使用带有参数$p$和$q$的Biased Random Walk来进行context的扩展，在BFS和DFS中达到一个平衡，同时考虑到微观局部(BFS)和宏观全局(DFS)的信息，并且具有很高的适应性：

$p$：Return parameter，控制在walk的过程中，revisit一个节点的概率，对应BFS
$q$：In-out parameter，控制探索”outward“节点的概率，对应DFS
在有标签的数据上，用cross validation来寻找最优的$p$和$q$

刚从edge$(t,v)$过来，现在在节点$v$上，要决定下一步$(v,x)$怎么走：

\[ \alpha _{pq}(t,x)=\left\{\begin{matrix} \frac{1}{p}&if\ d_{tx}=0\\ 1 &if\ d_{tx}=1\\ \frac{1}{q}&if\ d_{tx}=2 \end{matrix}\right. \]

其中的$d_{tx}$表示节点$t$到节点$x$间的最短路径：

为0表示回到节点$t$本身
为1表示节点$t$和节点$x$直接相连，但上一步却选择了节点$v$
为2表示节点$t$和$x$不直接相连，但节点$v$和节点$x$直接相连

最简单的给random walk加上bias的方法就是转移概率$\pi _{vx}=w_{vx}$，而我们的方法就是$\pi _{vx}=\alpha _{pq}(t,x)w_{vx}$，相当于还考虑了跳到$v$之前的节点$t$。

优化目标和LINE的一阶相似度类似

LINE、DeepWalk、Node2vec的对比：

node representation的应用：

Node classification (Perozzi et al. 2014, Tang et al. 2015a, Grover et al. 2015 )
Node visualization (Tang et al. 2015a)
Link prediction (Grover et al. 2015)
Recommendation (Zhao et al. 2016)
Text representation (Tang et al. 2015a, Tang et al. 2015b)

node representation的扩展：

Leverage global structural information (Cao et al. 2015)
Non-linear methods based on autoencoders (Wang et al. 2016) • Matrix-factorization based approaches (Qiu et al. 2018)
Directed network embedding (Ou et al. 2016)
Signed network embedding (Wang et al. 2017)
Multi-view networks ( Qu and Tang et al. 2017)
Networks with node attributes (Yang et al. 2015)
Heterogeneous(异构) networks (Chang et al. 2015)
Task-specific network embedding (Chen et al. 2017)

Graph and High-dimensional Data Visualization

t-SNE

高维数据可视化的一个state-of-the-art的方法，tensorboard就用的这个。

缺点：

K-NNG(K-Nearest Neighbor Graph) construction: 复杂度是$O(NlogN)$，假设图中有$N$个数据点
Graph layout: 复杂度是$O(NlogN)$
对参数非常敏感（Very sensitive parameters）

Visualizing Large-scale and High-dimensional Data

www16的best paper提名Visualizing Large-scale and High-dimensional Data

largevis代码（c++&python）：https://github.com/lferry007/LargeVis

特点：

K-NNG construction的高效近似：
- 比t-SNE的速度快30倍（300w的数据点）
- 更好的time-accuracy tradeoff
graph layout的高效的probabilistic model
- 从$O(NlogN)$到$O(N)$
- 比t-SNE快7倍（300w的数据点）
- 更好的visualization layouts
- 在不同数据集间有更stable的参数

Learning the Layout of KNN Graph

保持2D/3D空间的节点的相似度
- 对每个节点使用一个2D/3D的向量来表示
- 保持相似的数据距离近而不相似的距离远
观测节点$(i,j)$间的一条binary的边的概率：

\[ p(e_{ij}=1)=\frac{1}{1+\left \|\vec{y_i}-\vec{y_j}\right \|^2} \]

观测节点$(i,j)$间的一条有权重的边的likelihood：

\[ p(e_{ij}=w_{ij})=p(e_{ij}=1)^{w_{ij}} \]

A Probabilistic Model for Graph Layout

目标函数：

\[ O=\prod _{(i,j)\in E}p(e_{ij}=w_{ij})\prod _{(i,j)\in \bar{E}}(1-p(e_{ij}=w_{ij})^{\gamma } \]

其中$\gamma$是给negative edge赋值的unified weight

随机sample一些negative edges
使用异步sgd来优化
时间复杂度：与数据点数是线性关系

Knowledge Graph Embedding

知识图谱是异构图，有多种类型的relations

用(head entity, relation, tail entity)的三元组来表示facts的集合。

related works：

将entities用embeddings来表示
将relations用embeddings或者matrices来表示

kg的核心任务：预测missing links

kg的核心idea：根据观测到的knowledge facts，对kg中的relation patterns进行建模和infer。也就是学习relations的relations。

relation patterns

对称和反对称：
- 对称(Symmetric)：例如，marriage
- 反对称(Antisymmetric)：例如，Filiation(父子关系)

形式化定义：

\[ \begin{matrix} r\ is\ Symmetric & r(x,y)\Rightarrow r(y,x)\ if\ \forall x,y\\ r\ is\ Antisymmetric & r(x,y)\Rightarrow \neg r(y,x)\ if\ \forall x,y\\ \end{matrix} \]

Inverse relations:
- Hypernym(上位词) and hyponym(下位词)：花是鲜花的上位词，鲜花是花的下位词
- 丈夫和妻子

形式化定义：

\[ r_1\ is\ inverse\ to\ relation\ r_2:\ r_2(x,y)\Rightarrow r_1(y,x)\ if\ \forall x,y \]

Composition Relations
- My mother’s husband is my father

形式化定义：

\[ \begin{matrix} r_1\ is\ a\ composition\ of\ relation\ r_2\ and\ relation\ r_3: & \ r_2(x,y)\wedge r_3(y,z) \Rightarrow r_1(x,z)\ if\ \forall x,y,z \end{matrix} \]

目前的方法没有一种能同时infer上面这所有3种relation patterns，只有RotatE可以！！

RotatE

ICLR19 RotatE: Knowledge Graph Embedding by Relational Rotation in Complex Space.

RotatE代码（pytorch）:https://github.com/DeepGraphLearning/KnowledgeGraphEmbedding

每一个relation可以看成是从source entity到target entity在complex(复数)向量空间上的elementwise rotation

RotatE可以同时建模和infer上面这所有3种relation patterns

优化RotatE可以用高效的negative sampling

在kg的link prediction的benchmarks中能达到state-of-the-art的效果

Relation as Elementwise Rotation in Complex Space

head entity：$h\in \mathbb{C}^k$；tail entity：$t\in \mathbb{C}^k$

relation $r$：是一个从$h$到$t$的elementwise rotation：

\[ t=h\circ r,\ where\ |r_i|=1 \]

其中，$\circ$是element-wise product，所以$t_i=h_ir_i$，其中

\[ r_i=e^{\mathbf{i}\theta _{r,i}} \]

里面的$\theta _{r,i}$是$r$的第$i$维的phase angle，e的$\mathbf{i}\theta_{r,i}$的第一个$\mathbf{i}$是虚数单位，第二个$i$是第i维。

定义distance function：

\[ d_r(h,t)=\left \| h\circ r-t \right \| \]

如左图，transE建模的是$h+r$和$t$的距离，也就是在实数直线上以translation的方式建模$r$；
如右图，RotatE建模的是$h\circ r$和$t$的距离，也就是在复平面上以rotation的方式建模$r$。

先科普一下，在复变函数中，自变量$z$可以写成$z=r\times (\cos \theta + \mathbf{i}\sin \theta)$，$r$是$z$的模，即$r=|z|$；$\theta$是$z$的辐角，记作$Arg(z)$。在$-\pi$到$\pi$间的辐角称为辐角主值，记作$arg(z)$。指数形式$z=r(\cos \theta + i\sin \theta)=re^{\mathbf{i}\theta}$。

relation $r$是对称的，当且仅当，$r_i=\pm 1$，也就是$\theta_{r,i}=0\ or\ \pi$，例如下图，$r_i=-1$也就是$\theta _{r,i}=\pi$

relation $r$是反对称的，当且仅当，$r\circ r\neq 1$
relation $r_1$和$r_2$是inverse，当且仅当，$r_2=r^{-1}_1$，也就是$\theta _{2,i}=-\theta _{1,i}$
relation $r_3=e^{\mathbf{i}\theta_3}$是两个relation $r_1=e^{\mathbf{i}\theta_1}$和$r_2=e^{\mathbf{i}\theta_2}$的composition，当且仅当，$r_3=r_1\circ r_2$，也就是$\theta _3=\theta _1 + \theta _2$

RoteE的优化

Negative sampling loss如下：

\[ L=-\log\sigma (\gamma -d_r(h,t))-\sum ^k_{i=1}\frac{1}{k}\log \sigma (d_r(h'_i,t'_i)-\gamma) \]

其中的$\gamma$是一个fixed margin，$\sigma$是sigmoid，$(h'_i,r,t'_i)$是第$i$个negative三元组。

然后我们要变成self-adversarial negative sampling：

传统地，负样本通过uniform的方式（均匀分布，即等概率）来采样
- 随着训练的继续，因为很多样本是obviously false了，所以这种采样是inefficient的
- 没有提供有用的信息
self-adversarial negative sampling：
- 根据当前的embedding model来进行negative三元组的采样
- 从更简单的samples开始，逐步变难
- Curriculum Learning（递进学习，课程学习，可以参考https://blog.csdn.net/qq_25011449/article/details/82914803），从如下分布中进行采样：

\[ p(h'_j,r,t'_j|\{(h_i,r_i,t_i)\})=\frac{\exp \alpha f_r(h'_j,t'_j)}{\sum _i \exp \alpha f_r(h'_i,t'_i)} \]

其中，$\alpha$是sampling的temperature，$f_r(h'_j,t'_j)$衡量三元组的salience(突出程度)

但在实际应用中，从上面这个分布去sample的代价是很大的，所以我们把这个概率直接作为负样本的权重，所以最终的loss如下：

\[ L=-\log\sigma (\gamma -d_r(h,t))-\sum ^k_{i=1}p(h'_i,r,t'_i)\log \sigma (d_r(h'_i,t'_i)-\gamma) \]

A High-performance Node Representation System

A High-Performance CPU-GPU Hybrid System for Node Embedding，投稿www19

algorithm and system co-design的一个node embeddings的系统

CPUs: online random walk generation
GPUs: training node embeddings
Efficient and effective collaboration strategies between CPUs and GPUs

比现有的系统快50倍，一个有100w节点的网络只要1min

part2-Graph Neural Networks

基础知识

通过一个encoder函数$ENC$，把原始网络的结点$u$和结点$v$映射到embedding space的$d$维向量$z_u$和$z_v$，然后希望原空间的相似度和embedding space的相似度（例如内积）接近：

\[ similarity(u,v)\approx z_v^Tz_u \]

之前的encoder是shallow的，也就是一个$Z$矩阵，使用embedding lookup，矩阵大小是node_num * emb_dim。缺点如下：

需要$O(|V|)$的参数：每个node有自己的unique的embedding vector，没有参数共享！！
Inherently “transductive”：固有的『直推式』。也就是说，对于训练中没有见过的结点，不可能生成一个embedding
没有包含节点feature：很多图有一些我们必须要考虑和利用好的feature。

因此需要使用deeper的encoder，而这些更复杂的encoder也自带了similarity函数。

参考2017年的综述Representation Learning on Graphs: Methods and Applications

还有2005年的The Graph Neural Network Model

定义：

$G$：图
$V$：节点集合
$A$：邻接矩阵(假设是binary的)
$X\in R ^{m\times |V|}$：节点features的矩阵
- 类别型的特征、文本、图像数据等
- 节点度数、clustering coefficients(聚集系数，参考https://blog.csdn.net/pennyliang/article/details/6838956)等
- Indicator vectors(例如，每个节点的one-hot vector)

Neighborhood Aggregation

核心思想：使用nn对节点的邻居的信息进行汇聚，生成这个节点的embedding

如下图：

node在每一层都有embedding
模型的depth可以任意
节点$u$在第0层的embedding是它的input-feature $x_u$

neighborhood aggregateion其实数学上和spectral graph convolutions(参考Geometric deep learning: going beyond Euclidean data)很像，可以看成是一种center-surround filter。

关键在于上图的layer1和layer2用什么样的网络结构，一种basic的方法就是，layer2先average，然后再接一个神经网络：

\[ \begin{align*} h^0_v &=x_v \\ h^k_v &=\sigma (W_k\sum _{u\in N(v)}\frac{h^{k-1}_u}{|N(v)|}+B_kh^{k-1}_v) ,\forall k>0\\ z_v&=h^K_v\\ \end{align*} \]

$h^0_v$：第0层的embedding就是node的特征
$h^k_v$：第$k$层的embedding，包括的两项分别是邻居节点的前一层的emb的平均，还有当前节点的前一层的emb
$\sigma$：非线性，可以是relu/tanh等
$W_k$和$B_k$是两个待训练的矩阵
$z_v$：最终的输出结果，也就是第$K$层的输出

训练可以使用无监督的方法，loss可以是前面讲到的任意的node embedding的方法：

Random walks (node2vec, DeepWalk)
Graph factorization
或者直接训练保证相似的node有相似的embedding

也可以直接用监督学习的方法来训（例如是一个node的分类问题），其中的$\theta$是classification weights：

\[ L=\sum _{v\in V}y_v\log (\sigma (z^T_v\theta )+(1-y_v)\log(1-\sigma (z^T_v\theta))) \]

归纳能力（inductive capability）：

所有节点共享相同的aggregation parameters
模型参数是$|V|$的sublinear，而且可以对没见过的node生成embed

Graph Convolutional Networks(GCN)

参考ICLR17的Semi-Supervised Classification with Graph Convolutional Networks

在neighborhood aggregation上有一些小改动：

\[ h^k_v=\sigma(W_k\sum_{u\in N(v)\cup v}\frac{h^{k-1}_u}{\sqrt{|N(u)||N(v)|}}) \]

和普通gnn的区别：

self和neighbor的embedding共用同一个权重$W_k$，而普通的gnn是两个权重$B_k$和$W_k$，好处就是有更多的参数共享
每一个neighbor都有normalization(即$\sqrt{|N(u)||N(v)|}$)，好处就是可以减小度数多的邻居的权重

GraphSAGE

参考NIPS17的Inductive Representation Learning on Large Graphs

出发点：把上面在aggregate之后使用的神经网络换成任意一个可以把一堆vectors映射成一个单独的vector的可微函数（也就是下面的$AGG(\{h^{k-1}_u,\forall u\in N(v)\})$）：

\[ h^k_v=\sigma ([A_k\cdot AGG(\{h^{k-1}_u,\forall u\in N(v)\}),B_kh^{k-1}_v]) \]

上面的$[A_k\cdot AGG(\{h^{k-1}_u,\forall u\in N(v)\}),B_kh^{k-1}_v]$是把这self embedding和neighbor embedding这两个向量concate到一起。

AGG的变种：

mean：

\[ AGG=\sum _{u\in N(v)}\frac{h^{k-1}_u}{|N(v)|} \]

pool：对neighbor vectors进行转换（例如下面的$Q$），并进行symmetric vector函数变换（例如下面的$\gamma$就是element-wise mean/max）

\[ AGG=\gamma (\{Qh^{k-1}_u,\forall u \in N(v)\}) \]

lstm：对neighbor的一个随机排列（random permutation）使用lstm

\[ AGG=LSTM([h^{k-1}_u, \forall u\in \pi(N(v))]) \]

Gated Graph Neural Networks

参考ICLR16的Gated Graph Sequence Neural Networks

参考ICML17的Neural Message Passing for Quantum Chemistry

GCNs和GraphSAGE大部分情况下只有2-3层深，层数加深有如下挑战：

参数太多导致过拟合
bp的过程中出现梯度消失/爆炸

思路：

层间参数共享
Recurrent state update：各层的神经网络使用RNN。

Gated Graph Neural Networks介绍

Recurrent state update这种方法分成两步：

在step $k$从neighbors获取”message”，这个聚合函数与$k$无关：

\[ m^k_v=W\sum _{u\in N(v)}h^{k-1}_u \]

通过gru来更新节点的”state”。新节点的state依赖old state以及neighbors的”message”：

\[ h^k_v=GRU(h^{k-1}_v,m^k_v) \]

优点：

可以处理20+的层数
绝大部分真实世界的网络有比较小的diameters（直径，放大倍率），大部分小于等于7
能够将global的图结构的复杂信息传播给所有结点
对复杂网络的表示很有用（例如Logical formulas，或者程序）

Message-Passing Neural Networks介绍

从以下两个方面来对gated graph neural networks进行泛化：

在step $k$从neighbors获取”message”：

其中的$M$可以是一个一般(generic)的”message”函数，例如sum或者MLP。$e_{u,v}$把边的信息考虑进来了！

\[ m^k_v=\sum _{u\in N(v)}M(h^{k-1}_u,h^{k-1}_v,e_{u,v}) \]

更新node的”state”：

其中的$U$可以是一个一般(generic)的”update”函数，例如LSTM或者GRU

\[ h^k_v=U(h^{k-1}_v,m^k_v) \]

所以，其实这是一个通用的conceptual（概念性的） framework，可以归纳大部分GNNs。

Graph Attention Networks(GAT)

参考ICLR18的Graph Attention Networks

key idea：某些neighbor更重要，所以可以使用attention机制来搞

\[ h^k_v=\sigma (\sum _{u\in N(v)\cup \{v\}}\alpha _{v,u}W^kh^{k-1}_u) \]

其中：

$\sigma$是非线性；
$\sum _{u\in N(v)\cup \{v\}}$意味着把所有neighbor(包括节点自己！！)都加起来
$\alpha _{v,u}$是学习到的attention权重

各种attention都是可以的，原始GAT用的是如下attention权重：

\[ \alpha _{v,u}=\frac{\exp(LeakyReLU(a^T[Qh_v,Qh_u]))}{\sum _{u'\in N(v)\cup \{v\}}\exp(LeakyReLU(a^T[Qh_v,Qh_{u'}]))} \]

对照上面讲到的通用的conceptual（概念性的） framework，其实就是把attention加到获取”message”那步里去。

其他新的东西：

Generalizations based on spectral convolutions:
- Geometric Deep Learning (Bronstein et al., 2017, Geometric deep learning: going beyond Euclidean data)
- Mixture Model CNNs (Monti et al., 2017, Geometric deep learning on graphs and manifolds using mixture model CNNs)
Speed improvements via subsampling:
- FastGCNs (Chen et al., 2018, FastGCN: Fast Learning with Graph Convolutional Networks via Importance Sampling)
- Stochastic GCNs (Chen et al., 2017, Stochastic Training of Graph Convolutional Networks with Variance Reduction)

还可以参考专栏 | 深入理解图注意力机制

Subgraph Embeddings

方法一：直接把子图中的node的emb进行sum或者avg

\[ z_S=\sum _{v\in S}z_v \]

见2016年的Convolutional Networks on Graphs for Learning Molecular Fingerprints

方法二：引入”virtual node”来表示子图，并走一个完整的gnn

如下图

见2016年的Gated Graph Sequence Neural Networks

方法三：对节点进行层次聚类

见2018年的Hierarchical Graph Representation Learning with Differentiable Pooling

大致流程如下：

在图上跑GNN，得到node的embeddings
对node embeddings进行聚类，得到一个“coarsened” graph（粗糙的）
在“coarsened” graph上跑GNN
重复

学习clustering的不同方式：

使用softmax weight的soft clustering（2018年的Hierarchical Graph Representation Learning with Differentiable Pooling）
使用hard clustering（2018年的Towards Sparse Hierarchical Graph Classifiers和2018年的GRAPH U-NET）

其他GNN

更深的GCN

参考ICCV 2019 Oral论文：KAUST提出大幅加深图卷积网络的新方法

Can GCNs Go as Deep as CNNs?

part3-Deep Generative Models for Graph Generation

深度生成模型

深度生成模型的目标：为数据分布$p(x)$隐式或者显式地建模，$x$是一个高维随机变量

Variational Autoencoders (VAEs)

原始论文：2014年Kingma et al.的Auto-Encoding Variational Bayes

Latent variable model:

一个encoder $q_{\phi}(z|x)$
一个decoder $q_{\theta}(x|z)$

最大化log likelihood $\log p(x)$：inference是intractable（棘手）的，因为$z$是连续的

最大化variational的下界$L(\phi, \theta;x)$

通过reparametrization trick来jointly优化encoder和decoder：

\[ L(\phi, \theta;x)=E_{q_{\phi}(z|x)}\log p_{\theta }(x|z)-KL[q_{\phi}(z|x)||p(z)] \]

其中的$E_{q_{\phi}(z|x)}\log p_{\theta }(x|z)$是reconstruction，$KL[q_{\phi}(z|x)||p(z)]$是regularization

小结一下，encoder是$q_{\phi}$，decoder是$p_{\theta}$，encoder根据$x$生成$z$，decoder根据$z$生成$x$。

可以参考https://blog.csdn.net/antkillerfarm/article/details/80648805

重构的过程是希望没噪声的，而KL loss则希望有高斯噪声的，两者是对立的。所以，VAE跟GAN一样，内部其实是包含了一个对抗的过程，只不过它们两者是混合起来，共同进化的。

公式推导可以看https://blog.csdn.net/weixin_40955254/article/details/82315909

Generative Adversarial Networks (GANs)

原始论文：2014年Goodfellow et al.的Generative Adversarial Networks

一个两个玩家的Minimax游戏：

Generator $G: z\rightarrow x$。目标是迷惑discriminator
Discriminator $D: x\rightarrow \{0,1\}$。目标是区分真实数据和生成的数据

\[ \underset{G}{\min}\underset{D}{\max}V(D,G)=E_{x\sim p_{data}(x)}[\log D(x)]+E_{z\sim p_z(z)}[\log (1-D(G(z)))] \]

直观地理解，这个式子包括两部分，一部分是判别真实数据是正例的概率，另一部分是判别生成的数据是负例的的概率，对于$G$来讲，期望这个式子min，而对于$D$来讲，期望这个式子max

Deep Auto-regressive Models

深度自回归模型：例如RNN

例如，PixelRNN（2016年Oort et al.的Pixel Recurrent Neural Networks）和PixelCNN（2016年也是Oort et al.的Conditional Image Generation with PixelCNN Decoders）：

一个pixel一个pixel地生成图像
通过一个神经网络来对条件概率分布建模

WaveNet（2017年Oort et al.的WaveNet: A Generative Model for Raw Audio）

\[ p(x)=\prod ^{n^2}_{i=1}p(x_i|x_1,...,x_{i-1}) \]

但如果要用在图上，有以下几个挑战：

图的structures和size是不一样的
node之间并没有顺序
离散

GraphVAE

2018年Simonovsky和Komodakis的GraphVAE: Towards Generation of Small Graphs Using Variational Autoencoders

提出了生成图的VAE的框架：

输入graph
encoder：gnn+gated pooling=>graph representation，参考Li et al.在2015的
decoder：输出一个预先定义好max size的probalistic fully-connected graph
- 对节点、边、节点和边的属性的存在性单独建模
- graph matching是必须的

输入的graph是$G=(A,E,F)$：$A$是邻接矩阵；$E$是边的属性的tensor；$F$是节点的属性的矩阵

decoder的输出：

限制domain在最多max k个节点的所有graphs的集合中（k一般是10左右）
一次输出一个k个节点的probalistic fully-connected graph $\tilde{G}=(\tilde{A},\tilde{E},\tilde{F})$
- 以bernoulli variables建模nodes和edges的existence
- 以multinomial variables建模nodes和edges的attributes
- $\tilde{A}\in [0,1]^{k\times k}$：同时包括node probabilities $\tilde{A}_{aa}$和edge probabilities $\tilde{A}_{ab}$，其中$a\neq b$
- $\tilde{E}\in [0,1]^{k\times k\times d_e}$：表示edge attributes的probabilities
- $\tilde{F}\in [0,1]^{k\times d_e}$：表示node attributes的probabilities
inference：在$\tilde{A}$，$\tilde{E}$，$\tilde{F}$中使用edge-wise和node-wise的argmax
计算reconstruction loss的时候，需要使用graph matching

缺点：

graph的max size必须是预先定义好的
graph matching是必须的

JTVAE

Junction Tree Variational Autoencoder for Molecular Graph Generation

利用了化学领域的知识
- 每个molecule(分子)可以表示为化学substructures(如环、键(bond))的树状的scaffold(骨架、支架)
生成一个树状结构的object
- 用来表示subgraph components的scaffold
将substructure组装成一个coherent(连贯的) molecular graph

MolGAN

MolGAN: An implicit generative model for small molecular graphs

一个implicit, likelihood-free的生成模型：用于分子生成
结合了强化学习来encourage生成的带有化学属性的分子
Generator：从先验分布中生成分子
Discriminator：区分生成的sample和真实的sample
Reward network：
- 学习给每个分子赋值一个reward，这个reward要和external software提供的score进行match
- invalid的分子通常得到的reward是0

整体架构图如下：

Generator：

生成一个probabilistic fully-connected graph：
- $X\in R^{N\times T}$：atom types
- $A\in R^{N\times N\times Y}$：bond types
目标函数：

\[ L(\theta)=\lambda L_{WGAN}+(1-\lambda)L_RL \]

Discriminator & Reward network：

通过neural message passing algorithm的一个变种-Relational-GCN，Schlichtkrull et al. 2017的Modeling relational data with graph convolutional networks来学习分子/graph的表示
discriminator和reward network用相同的网络结构（但参数不共享）
reward network用来近似external software的打分(使用真实的samples和生成的samples进行训练)

优缺点：

不需要graph matching
graphs/分子的max size仍然需要预先定义

GCPN

You et al.在2018的Graph Convolutional Policy Network for Goal-Directed Molecular Graph Generation

将分子的生成看成序列决策问题
- 增加节点和边
- 一个马尔可夫决策过程
目标：发现分子式，能优化融入了chemical rules的特定的properties
GCPN：一个结合了RL的面向目标（goal-directed）的通用的model
- 使用policy gradients来优化adversarial loss和domain-specific rewards
- 能够在一个融入了domain-specific rules的environment中生效

整体架构图如下：

$M=(S,A,P,R,\gamma)$：
- states $S=\{s_i\}$：包括所有intermediat和final graphs
- actions $A=\{a_i\}$：每一个step对当前graph进行的修改
- 状态转移概率$P$
- reward函数$R$
- discount factor $\gamma$
状态空间：
- $s_t$是中间生成的图$G_t$
- $G_0$包括一个single node，表示一个carbon atom(碳原子)
动作空间：
- 每个step将要添加的一个atoms的集合：$C=\cup ^S_{i=1}C_i$
- 具体的actions:
  - 把一个新的atom $C_i$连接到现有的$G_t$中的一个节点上去
  - 连接$G_t$内退出(exiting)的节点
state transition dynamics:
- 在state transition dynamics中融入了domain-specific rules，只执行遵守规则的actions
- policy network产生的infeasible(不可实行的)动作会被rejected，而state保持不变
Reward设计
- final rewards：domain-specific rewards之和（例如，最终的property scores，对不真实的分子的惩罚，adversirial rewards）
- intermediate rewards：step-wise validity(有效性) rewards和adversirial rewards
GCPN
- 使用neural message passing算法计算节点的embeddings
- 预测action：
  - 挑选两个节点
  - 预测边的类型
  - 预测是否结束（termination）

整体公式如下：

\[ a_t=CONCAT(a_{first},a_{second},a_{edge},a_{stop}) \]

其中

\[ \begin{matrix} f_{first}(s_t)=SOFTMAX(m_f(X)), & a_{first}\sim f_{first}(s_t)\in \{0,1\}^n \\ f_{second}(s_t)=SOFTMAX(m_s(X_{a_{first}},X)), & a_{second}\sim f_{second}(s_t)\in \{0,1\}^{n+c} \\ f_{edge}(s_t)=SOFTMAX(m_e(X_{a_{first}},X_{a_{second}})), & a_{edge}\sim f_{edge}(s_t)\in \{0,1\}^b \\ f_{stop}(s_t)=SOFTMAX(m_t(AGG(X))), & a_{stop}\sim f_{stop}(s_t)\in \{0,1\} \\ \end{matrix} \]

未来方向

参考https://zhuanlan.zhihu.com/p/38142339

主要想法：将relational的关系转化成attention，利用attention来代表两个entity的关系。隐式地将relational引入NN结构中

Zambaldi et al.在2018的Relational deep reinforcement learning

自己的小结

某个时候整理了个ppt：

其他

Google的一些进展

https://ai.googleblog.com/2019/06/innovations-in-graph-representation.html

谷歌图表征学习创新：学习单个节点多个嵌入&自动学习最优超参数

代码地址：https://github.com/google-research/google-research/tree/master/graph_embedding

理解gat

节后收心困难？这15篇论文，让你迅速找回学习状态

Understanding Attention and Generalization in Graph Neural Networks

https://github.com/bknyaz/graph_attention_pool

本文是圭尔夫大学发表于 NeurIPS 2019 的工作。本文的目标是更好地理解图神经网络（GNN）中节点的注意力，并确定影响其有效性的因素。本文特别关注将注意力 GNN 泛化到更大，更复杂或更嘈杂的图的能力。受图同构网络工作的启发，本文设计了简单的图推理任务，使本文能够在受控环境中研究注意力机制。本文发现在典型条件下，注意力的影响可以忽略甚至是有害的，但在某些条件下，它在一些分类任务中提供超过 60％的特殊性能提升。在实践中满足这些条件是具有挑战性的，并且通常需要对注意力机制进行监督训练。本文提出了一种替代方法，并以弱监督的方式训练注意力，以接近监督模型的性能，并且与无监督模型相比，改进了几个合成数据集和真实数据集的结果。

txt2img gan

2019-02-01T00:00:00+00:00

paper：An Introduction to Image Synthesis with Generative Adversarial Nets

GAN在图像生成应用综述（论文解读）

smlta

2019-01-19T00:00:00+00:00

参考超越整句的流式多级Attention：解密百度输入法背后的语音识别模型

序列生成学习算法通用框架(ERPO)

2019-01-14T00:00:00+00:00

参考Petuum提出序列生成学习算法通用框架

资源 | Petuum&CMU开源Texar：一个模块化、多功能、可扩展的文本生成工具包

transformer-xl

2019-01-12T00:00:00+00:00

对比论文
模型架构
- 原始transformer
- transformer-xl

参考谷歌、CMU重磅论文：Transformer升级版，评估速度提升超1800倍！

Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context

github：https://github.com/kimiyoung/transformer-xl

Transformer网络具有学习较长期依赖关系的潜力，但是在语言建模的设置中受到固定长度上下文(fixed-length context)的限制。

Transformer-XL使Transformer能够在不破坏时间一致性的情况下学习固定长度以外的依赖性。它由一个segment-level的递归机制和一种新的位置编码方案组成。这一方法不仅能够捕获长期依赖关系，而且解决了上下文碎片的问题。

Transformer-XL学习的依赖关系比RNN长80%，比vanilla Transformer长450%，在短序列和长序列上都获得了更好的性能，并且在评估中比vanilla Transformer快1800+倍。

Transformer-XL在5个数据集上都获得了强大的结果。研究人员在enwiki8上将bpc/perplexity的最新 state-of-the-art(SoTA)结果从1.06提高到0.99，在text8上从1.13提高到1.08，在WikiText-103上从20.5提高到18.3，在One Billion Word, 上从23.7提高到21.8，在Penn Treebank上从55.3提高到54.5。

对比论文

Character-level language modeling with deeper self-attention

这篇论文在char-level的语言模型中，用了很深的transformer(64层)…

模型架构

不再从头开始计算每个新的段(segment)的隐藏状态，而是重用(reuse)在前一段中获得的隐藏状态。被重用的隐藏状态用作当前段的memory，这就在段之间建立一个循环连接。提出了一个简单但更有效的相对位置编码公式，该公式可以推广到比训练中观察到的更长的attention lengths。

因此：

建模非常长期的依赖关系成为可能，因为信息可以通过循环连接传播
从上一段传递信息也可以解决上下文碎片(context fragmentation)的问题。
展示了使用相对位置编码而不是绝对位置编码的必要性，以便在不造成时间混乱的情况下实现状态重用。

原始transformer

为了将Transformer或self-attention应用到语言建模中，核心问题是如何训练Transformer有效地将任意长的上下文编码为固定大小的表示。

给定无限内存和计算，一个简单的解决方案是使用无条件Transformer解码器处理整个上下文序列，类似于前馈神经网络。然而，在实践中，由于资源有限，这通常是不可行的。

一种可行但比较粗略的近似方法是将整个语料库分割成可管理大小的更短的片段，只在每个片段中训练模型，忽略来自前一段的所有上下文信息。这是上面讲到的对比论文提出的想法，我们称之为原始模型(vanilla model)，它的图示如图1a。

在评估过程中，vanilla 模型在每个步骤都消耗与训练期间相同长度的一个segment，但是在最后一个位置只是进行一次预测。然后，在下一步中，这个segment只向右移动一个位置，新的segment必须从头开始处理。

如图1b所示，该过程保证了每个预测在训练过程中利用的上下文尽可能长，同时也缓解了训练过程中遇到的上下文碎片问题。然而，这个评估过程成本是非常高的。

transformer-xl

为了解决固定长度上下文的局限性，我们在Transformer架构中引入一种递归机制(recurrence mechanism)。

在训练过程中，对上一个segment计算的隐藏状态序列进行fixed和cached，并在模型处理下一个新的segment时将其缓存为可重用的扩展上下文，如图2a所示。

这种递归机制应用于整个语料库的每两个连续的segment，它本质上是在隐藏状态中创建一个segment-level的递归。因此，所使用的有效上下文可以远远超出两个segments。

除了实现超长的上下文和解决碎片问题外，这种递归方案的另一个好处是显著加快了评估速度。

具体地说，在评估期间，可以重用前面部分的表示，而不是像普通模型那样从头开始计算。在enwiki8数据集的实验中，Transformer-XL在评估过程比普通模型快1800倍以上。

分词工具

2019-01-09T00:00:00+00:00

参考北大开源全新中文分词工具包：准确率远超THULAC、结巴分词

github：https://github.com/lancopku/PKUSeg-python

特点：

高分词准确率：相比于其他的分词工具包，该工具包在不同领域的数据上都大幅提高了分词的准确度。根据北大研究组的测试结果，pkuseg 分别在示例数据集（MSRA 和 CTB8）上降低了 79.33% 和 63.67% 的分词错误率。
多领域分词：研究组训练了多种不同领域的分词模型。根据待分词的领域特点，用户可以自由地选择不同的模型。
支持用户自训练模型：支持用户使用全新的标注数据进行训练。

目前仅支持python3…不支持python2

安装

git clone https://github.com/lancopku/pkuseg-python.git
python setup.py install

graph embedding

2019-01-05T00:00:00+00:00

概述
- DeepWalk
- LINE
- node2vec
- SDNE
其他embedding
- tweet2vec

概述

参考https://blog.csdn.net/u013527419/article/details/76017528/

DeepWalk

LINE

node2vec

开源代码实现：

http://snap.stanford.edu/node2vec/

node2vec: Scalable Feature Learning for Networks

Efficient Estimation of Word Representations in Vector Space

在计算广告、推荐领域中，围绕着node2vec有俩很有意思的应用：

Facebook：http://geek.csdn.net/news/detail/200138
Tencent：http://www.sohu.com/a/124091440_355140

SDNE

其他embedding

tweet2vec

Tweet2Vec: Learning Tweet Embeddings Using Character-level CNN-LSTM Encoder-Decoder

图神经网络

2019-01-05T00:00:00+00:00

概述
引言
模型
应用
开放性问题
GNN的普适与局限性
kdd 2019

概述

最近图神经网络有点火。。先mark一下：

清华大学孙茂松组：图神经网络必读论文列表

github链接：https://github.com/thunlp/GNNPapers

综述Graph Neural Networks: A Review of Methods and Applications

解读：图神经网络综述：模型与应用

又一篇综述：图神经网络概述第三弹：来自IEEE Fellow的GNN综述

又一个文献合集https://github.com/DeepGraphLearning/LiteratureDL4Graph

引言

图是一种数据结构，它对一组对象 （节点） 及其关系 （边） 进行建模。图神经网络（GNN）是一类基于深度学习的处理图域信息的方法。由于其较好的性能和可解释性，GNN 最近已成为一种广泛应用的图分析方法。

GNN的第一个动机源于卷积神经网络（CNN）：CNN只能在规则的Euclidean数据上运行，如图像（2维网格）和文本（1维序列）。如何将CNN应用于图结构这一非欧几里德空间，成为GNN模型重点解决的问题。

GNN的另一个动机来自图嵌入（Graph Embedding），它学习图中节点、边或子图的低维向量空间表示。DeepWalk、node2vec、LINE、SDNE等方法在网络表示学习领域取得了很大的成功。然而，这些方法在计算上较为复杂并且在大规模上的图上并不是最优的，GNN旨在解决这些问题。

模型

原始GNN

2009年的第一篇GNN的文章The graph neural network model。GNN的target是要学习包括了每个节点的邻居的信息的state embedding $h_v\in R^s$。这里的state embedding $h_v$是节点$v$的一个$s$维的向量，能用来产生输出$o_v$，例如节点的label。$f$是一个带有参数的函数，称为local transition function，被所有的节点共享，能根据输入的邻居来更新节点状态。$g$是local output function，表示如何产生output。所以：

\[ \begin{matrix} h_v=f(x_v,x_{co[v]},h_{ne[v]},x_{ne[v]})\\ o_v=g(h_v,x_v)\\ \end{matrix} \]

其中，

$x_v$：节点$v$的特征。
$x_{co[v]}$：节点$v$的边的特征。
$h_{ne[v]}$：节点$v$的邻居节点的state。
$x_{ne[v]}$：节点$v$的邻居节点的特征。

把所有状态、输出、特征、所有节点的特征stack到一起，就有了向量$X$、$O$、$X$和$X_N$。所以有：

\[ \begin{matrix} H=F(H,X)\\ O=G(H,X_N)\\ \end{matrix} \]

使用如下方式对状态进行迭代：

\[ H^{t+1}=F(H^t,X) \]

其中的$f$和$g$都可以用神经网络来表示。loss如下：

\[ loss=\sum ^p_{i=1}(t_i-o_i) \]

GNN变种

图类型

Directed Graphs

有向图。如图中的ADGPM【Rethinking knowledge graph propagation for zero-shot learning】，有两种权重矩阵$W_p$和$W_c$

\[H^t=\sigma(D^{-1}_pA_p\sigma(D^{-1}_cA_cH^{t-1}W_c)W_p)\]

其中的$D^{-1}_pA_p$和$D^{-1}_cA_c$分别是parent和children的normalized adjacency matrix。

Heterogeneous Graphs

异构图。如图中的GraphInception。

Graphs with Edge Information

边带有信息的图，如图中的G2S以及R-GCN。

传播类型(propagation types)

propagation step和output step这两部是很重要的，主要分为以下类别：

卷积：Graph Convolutional Network（GCN）希望将卷积操作应用在图结构数据上，主要分为Spectral Method和Spatial Method（Non-spectral Method）两类。
- Spectral Method：希望使用谱分解的方法，应用图的拉普拉斯矩阵分解进行节点的信息收集。
- Spatial Method：直接使用图的拓扑结构，根据图的邻居信息进行信息收集。
注意力机制：Graph Attention Network 致力于将注意力机制应用在图中的信息收集阶段。
门机制：门机制应用于节点更新阶段。Gated graph neural network 将GRU机制应用于节点更新。很多工作致力于将 LSTM应用于不同类型的图上，主要包括Tree LSTM、Graph LSTM和Sentence LSTM等
残差连接：堆叠多层图神经网络可能引起噪声在指数级增加的邻居中传播，所以很多工作将残差机制应用于图神经网络中。主要包括Highway GNN和Jump Knowledge Network两种不同的处理方式。

信息传递函数主要包括信息收集（agggregation）和节点信息更新（update）两个部分，公式见：

训练方法

譬如GraphSAGE从附近的邻居收集信息，并且能够应用于inductive learning领域；FastGCN使用了importance sampling的方法，使用采样替代使用节点所有的邻居信息，加快了训练过程。

General Frameworks

图神经网络通用框架主要包括MPNN（Message Passing Neural Network）、NLNN（Non-local Neural Network）以及 Deepmind 的 GN（Graph Network）。

Message Passing Neural Networks(MPNN)

MPNN将模型总结为信息传递阶段和节点更新阶段，概括了多种图神经网络和图卷积神经网络方法。

Non-local Neural Networks(NLNN)

NLNN总结了很多种基于自注意力机制的方法。

Graph Networks(GN)

GN提出了更加通用的模型，能够总结概括几乎所有文中提到的框架，并且拥有更加灵活的表示能力、易于配置的块内结构以及易于组合的多模块架构。

应用

应用见：

结构化场景

GNN 被广泛应用在社交网络、推荐系统、物理系统、化学分子预测、知识图谱等领域。

非结构化场景

在图像和文本中的应用

其他场景

图生成模型以及使用GNN来解决组合优化问题的场景。

开放性问题

浅层结构。经验上使用更多参数的神经网络能够得到更好的实验效果，然而堆叠多层的GNN却会产生over-smoothing的问题。具体来说，堆叠层数越多，节点考虑的邻居个数也会越多，导致最终所有节点的表示会趋向于一致。
动态图。目前大部分方法关注于在静态图上的处理，对于如何处理节点信息和边信息随着时间步动态变化的图仍是一个开放问题。
非结构化场景。虽然很多工作应用于非结构化的场景（比如文本），然而并没有通用的方法用于处理非结构化的数据。
扩展性。虽然已经有一些方法尝试解决这个问题，将图神经网络的方法应用于大规模数据上仍然是一个开放性问题。

GNN的普适与局限性

图神经网络火了？谈下它的普适性与局限性

kdd 2019

近期必读的12篇KDD 2019【图神经网络（GNN）】相关论文

drn

2019-01-01T00:00:00+00:00

背景
模型
具体实现

参考强化学习系列一——基于深度强化学习的新闻推荐模型DRN

DRN: A Deep Reinforcement Learning Framework for News Recommendation

背景

现有推荐模型的几大问题：

新闻推荐中的动态变化难以处理

动态变化表现在两种层次：一个是新闻的时效性，可能会很快过时；另一个是用户的浏览兴趣，随着时间会动态变化。虽然通过在线学习的方式可以捕获新闻特征和用户兴趣的动态变化，但是这些方法只注重短期回报，并未考虑长期回报。

仅使用是否点击作为用户反馈

现有方法只考虑是否点击或者打分来作为用户的反馈。作者提出引入用户返回APP的时间，因为该指标也反映了用户对推荐的满意度。

现有方法推荐结果重复较多

现有方法倾向于给用户推荐相似item，而这将降低用户对相似topic的兴趣，也不利于探索用户新的兴趣。

模型

将用户和news的特征表示输入给DQN来预测可能的reward，也就是用户点击news的概率。该框架通过DQN的在线更新来处理新闻推荐中的动态变化，并注重长期回报。框架除了用户点击的反馈之外，引入了user activeness（用户在一次推荐后返回到APP的频率）作为回报。另外为避免传统的exploration策略比如$\varepsilon-greedy$或UCB可能带来的不准确推荐，作者引入Dueling Bandit Gradient Descent策略来改善推荐的多样性。

离线部分：主要是使用离线的用户点击日志来训练，给点击和未点击的news不同的奖励，然后训练一个Q网络，其实就是一个监督学习的过程。
在线部分：涉及推荐agent和用户的交互过程，按下面的流程对网络进行更新：
- Push：每当用户发送一个请求，推荐智能体G会根据用户和候选news集合的特征表示，综合exploitation network和exploration network两个网络的结果，生成top-k的news列表L
- FeedBack：用户针对接受的列表L将会有点击行为。
- Minor Update：在每个时间戳后，根据user、news列表L和反馈B，智能体G将会比较exploitation network $Q$和exploration network $\tilde{Q}$的推荐效果来更新模型。如果$\tilde{Q}$给出的推荐结果最终效果更好，则将Q往 $\tilde{Q}$的方向更新，否则$Q$保持不变。每次推荐发生之后都会进行Minor update。
- Major Update：在一个特定时期$T_R$后，智能体G将使用用户反馈B和用户activeness来更新网络Q。这里使用经验回放来实现，智能体G保存近期历史click和用户activeness记录，当触发Major Update时，智能体随机选择一个batch来更新模型。Major Update通常间隔比如一个小时来进行，在这段时间会收集很多次的展现和反馈的记录。

具体实现

dueling double DQN

使用DQN来建模用户是否点击某一news的概率，而这一概率也是智能体能得到的奖励即reward：

\[ y_{s,a}=Q(s,a)=r_{immediate}+\gamma r_{future} \]

状态state：context feature和user feature
动作action：news feature和user-news交互特征
$r_{immediate}$和$r_{future}$分别表示当前情况下奖励（也就是用户是否点击新闻）和未来回报。

给定当前状态s、动作a和时间戳t，使用DDQN来对total reward进行预测：

\[ y_{s,a,t}=r_{a,t+1}+\gamma Q(s_{a,t+1},\mathop{\arg\max}_{a^{'}}Q(s_{a,t+1},a^{'};w_t);w_{t}^{'}) \]

其中，$r_{a,t+1}$表示采取动作a的立即回报，$w_t$和$w_t^{'}$表示DQN中的两个不同参数集合。

首先给定候选动作集，在参数$w_t$的设置下根据长期回报最大选择出动作$a^{'}$。
然后估计$s_{a,t+1}$采取动作$a^{'}$所得到的长期回报。
每几轮迭代之后$w_t$和$w_t^{'}$将互换。

DDQN(double DQN)可解决Q值过高估计的问题。通过这个过程，模型可兼顾total reward进行决策。

所以看起来，是先dueling dqn算q，再double dqn算reward

Q网络底层将四类特征输入到网络中，user feature和context feature作为state feature，而user-news feature和news feature作为action feature。

一方面，在一个特定状态采用某个动作的reward和所有特征均有关。
另一方面，reward受user本身特征的影响（例如user是否active，user今天是否看了足够多的News了已经）要大于只用用户和context特征。

基于此，文中类似Dueling Network将Q函数分解成$V(s)$和$A(s,a)$，其中$V(s)$只受state特征(即user+context)影响，而$A(s,a)$则会受到state特征和action特征（即user+context+item+user-item-cross）影响。

User activeness

采用留存模型来对用户activeness来建模。时间t后用户返回App的概率定义为$s(t)=e^{-\int_{0}^{t}\lambda(x)dx}$，其中一个生命周期$T_{0}=\int_{0}^{\infty}s(t)dt$（文中$T_0$设为一天）。每次检测到一个用户返回App，我们将使得$s(t)=s(t)+s_a$。如下图，开始时$s_0=0.5$，然后activeness衰减，在$t_1$时刻用户返回App，使得activeness增加$s_a=0.32$，后续以此类推。整个过程保证活跃度保持在0-1之间，如果超过1的话直接截断成1。这里$s_0$、$s_a$等值的设定都是数据中的真实用户行为模式确定的。

Exploration

常见的探索方法包括$\epsilon-greedy$和UCB等，其中前者会随机推荐一些新item，后者会选择一些未探索充分的item，这些都会导致推荐效果有一定下降。因此作者使用了Dueling Bandit Gradient Descent算法(最早来自online LTR领域)来进行exploration。智能体G使用当前网络Q产出推荐列表L，并使用explore网络$\tilde{Q}$产生另一个推荐列表$\tilde{L}$。$\tilde{Q}$的参数可以通过Q的参数基础上增加微小扰动得到。然后使用L和$\tilde{L}$进行interleave来产生一个融合的列表$\hat L$。如果探索网络$\tilde{Q}$产生的item得到更好的反馈，则智能体G将网络Q向$\tilde{Q}$的方向更新，表示为$w^{'}=w+\eta \tilde{w}$，否则Q的参数保持不变。

bert as service

2019-01-01T00:00:00+00:00

基本使用

https://github.com/hanxiao/bert-as-service

官网：https://bert-as-service.readthedocs.io/en/latest/

基本使用

安装：

pip install -U bert-serving-server bert-serving-client

要求：

server的py要>=3.5,tf要>=1.10
client可以是py2或者py3

另外需要把预训练好的模型下下来~

启动server

$workspace/bin/python3.6 \
        $workspace/bin/bert-serving-start \
        -model_dir=$workspace/../chinese_L-12_H-768_A-12/ \
        -num_worker=4

启动client

from bert_serving.client import BertClient
remote_ip = 'xx.xx.xx.xx'
bc = BertClient(ip=remote_ip)  
print(bc.encode(['First do it', 'then do it right', 'then do it better']))

Pointer Networks和组合优化

2019-01-01T00:00:00+00:00

Pointer Networks
Pointer Networks in RL

Pointer Networks

发表在NIPS2015上

Pointer Networks

参考Pointer-network理论及tensorflow实战

Pointer Networks in RL

发表在ICLR2017上

Neural Combinatorial Optimization with Reinforcement Learning

tf-ranking

2018-12-21T00:00:00+00:00

安装
简介

参考TF-Ranking：为 Learning-to-Rank 打造的可扩展 TensorFlow 库

https://github.com/tensorflow/ranking

https://github.com/tensorflow/ranking/tree/master/tensorflow_ranking/examples

TF-Ranking: Scalable TensorFlow Library for Learning-to-Rank

安装

bazel build //tensorflow_ranking/tools/pip_package:build_pip_package
bazel-bin/tensorflow_ranking/tools/pip_package/build_pip_package /tmp/ranking_pip

这样就产生了一个whl文件（要求tf1.12.0+）

TF-Ranking 能通过嵌入和扩展至数百亿个训练实例来处理稀疏特征（如原始文本）

TF-Ranking 支持许多常用的排名指标，包括平均倒序排名 (MRR) 和标准化折扣累积收益 (NDCG)。

TF-Ranking 支持一种新颖的评分机制，可以对多个项目（例如网页）执行联合评分，这是对传统评分范例（对单个项目进行独立评分）的扩展。关于多项目评分，我们经常面临的一个挑战是，难以判断需将哪些项目进行分组并在子组中进行评分。然后，累计每个项目的评分并用于排序。为了让用户免于接触这些复杂原理，TF-Ranking 提供了一个List-In-List-Out (LILO) API，将所有逻辑封装于导出的 TensorFlow 模型内。

简介

定义

$x$

打分函数

损失函数

pytext

2018-12-16T00:00:00+00:00

安装
训练
导出模型
c++的predictor部分
部署predictor服务

安装

使用python3

pip install pytext-nlp

注意：https://github.com/facebookresearch/pytext/issues/115

训练

pytext train < demo/configs/docnn.json

导出模型

训练完了后，可以导出模型

mkdir ./models
pytext export --output-path ./models/demo.c2 < ./demo/configs/docnn.json

c++的predictor部分

thrift api

其中predictor.thrift如下

namespace cpp predictor_service

service Predictor {
   // Returns list of scores for each label
   map<string,list<double>> predict(1:string doc),
}

实现server

完整代码见https://github.com/facebookresearch/pytext/blob/master/demo/predictor_service/server.cpp

class PredictorHandler : virtual public PredictorIf {
  private:
    NetDef mPredictNet;
    Workspace mWorkspace;

    NetDef loadAndInitModel(Workspace& workspace, string& modelFile) {
      auto db = unique_ptr<DBReader>(new DBReader("minidb", modelFile));
      auto metaNetDef = runGlobalInitialization(move(db), &workspace);
      const auto predictInitNet = getNet(
        *metaNetDef.get(),
        PredictorConsts::default_instance().predict_init_net_type()
      );
      CAFFE_ENFORCE(workspace.RunNetOnce(predictInitNet));

      auto predictNet = NetDef(getNet(
        *metaNetDef.get(),
        PredictorConsts::default_instance().predict_net_type()
      ));
      CAFFE_ENFORCE(workspace.CreateNet(predictNet));

      return predictNet;
    }
// ...
  public:
    PredictorHandler(string &modelFile): mWorkspace("workspace") {
      mPredictNet = loadAndInitModel(mWorkspace, modelFile);
    }
// ...
}

实现predict函数

class PredictorHandler : virtual public PredictorIf {
// ...
  public:
    void predict(map<string, vector<double>>& _return, const string& doc) {
      // Pre-process: tokenize input doc
      vector<string> tokens;
      string docCopy = doc;
      tokenize(tokens, docCopy);

      // Feed input to model as tensors
      Tensor valTensor = TensorCPUFromValues<string>(
        {static_cast<int64_t>(1), static_cast<int64_t>(tokens.size())}, {tokens}
      );
      BlobGetMutableTensor(mWorkspace.CreateBlob("tokens_vals_str:value"), CPU)
        ->CopyFrom(valTensor);
      Tensor lensTensor = TensorCPUFromValues<int>(
        {static_cast<int64_t>(1)}, {static_cast<int>(tokens.size())}
      );
      BlobGetMutableTensor(mWorkspace.CreateBlob("tokens_lens"), CPU)
        ->CopyFrom(lensTensor);

      // Run the model
      CAFFE_ENFORCE(mWorkspace.RunNet(mPredictNet.name()));

      // Extract and populate results into the response
      for (int i = 0; i < mPredictNet.external_output().size(); i++) {
        string label = mPredictNet.external_output()[i];
        _return[label] = vector<double>();
        Tensor scoresTensor = mWorkspace.GetBlob(label)->Get<Tensor>();
        for (int j = 0; j < scoresTensor.numel(); j++) {
          float score = scoresTensor.data<float>()[j];
          _return[label].push_back(score);
        }
      }
    }
// ...
}

编译

需要有libthrift.so, libcaffe2.so, libprotobuf.so and libc10.so。

Makefile文件如下

CPPFLAGS += -g -std=c++11 -std=c++14 \
  -I./gen-cpp \
  -I/pytorch -I/pytorch/build \
      -I/pytorch/aten/src/ \
      -I/pytorch/third_party/protobuf/src/
CLIENT_LDFLAGS += -lthrift
SERVER_LDFLAGS += -L/pytorch/build/lib -lthrift -lcaffe2 -lprotobuf -lc10

# ...

server: server.o gen-cpp/Predictor.o
      g++ $^ $(SERVER_LDFLAGS) -o $@

clean:
      rm -f *.o server

在Dockerfile中，有如下命令

# Copy local files to /app
COPY . /app
WORKDIR /app

# Compile app
RUN thrift -r --gen cpp predictor.thrift
RUN make

# Add library search paths
RUN echo '/pytorch/build/lib/' >> /etc/ld.so.conf.d/local.conf
RUN echo '/usr/local/lib/' >> /etc/ld.so.conf.d/local.conf
RUN ldconfig

部署predictor服务

参考https://pytext-pytext.readthedocs-hosted.com/en/latest/serving_models_in_production.html#test-run-the-server

可以自己build一个镜像，

cd demo/predictor_service/
docker build -t predictor_service .

当然也可以用我编好的啦https://hub.docker.com/r/daiwk/caffe2

docker pull daiwk/caffe2
docker run -it -v ~/git_daiwk/pytext/models/:/models -p 8080:8080 daiwk/caffe2

然后在container中

/app/server /models/demo.c2

然后新开一个窗口直接curl就行：

curl -G "http://localhost:8080" --data-urlencode "doc=Flights from Seattle to San Francisco"

会得到输出：

doc_scores:alarm/modify_alarm:-2.13494
doc_scores:alarm/set_alarm:-2.02492
doc_scores:alarm/show_alarms:-2.05924
doc_scores:alarm/snooze_alarm:-2.02332
doc_scores:alarm/time_left_on_alarm:-2.11147
doc_scores:reminder/set_reminder:-2.00476
doc_scores:reminder/show_reminders:-2.21686
doc_scores:weather/find:-2.07725

gnn frameworks

2018-12-10T00:00:00+00:00

graph-nets(tf)
DGL(mxnet+pytorch)
PyG(pytorch)
GraphVite
pgl
Angel 3.0

graph-nets(tf)

https://github.com/deepmind/graph_nets

..好像并没有多少功能。。。

DGL(mxnet+pytorch)

参考NYU、AWS联合推出：全新图神经网络框架DGL正式发布

参考专栏 | 手把手教你用DGL框架进行批量图分类

参考性能提升19倍，DGL重大更新支持亿级规模图神经网络训练

PyG(pytorch)

参考比DGL快14倍：PyTorch图神经网络库PyG上线了

GraphVite

已开源！GraphVite 超高速图表示学习系统，1 分钟可学百万节点

单机支持最大20亿边的图。

GraphVite 框架由两个部分组成，核心库和 Python wrapper。Python wrapper 可以为核心库中的类提供自动打包功能，并为应用程序和数据集提供了实现。

核心库用 C+11 和 CUDA 实现，并使用 pybind11 绑定到 python 中。它涵盖了 GraphVite 中所有与计算相关类的实现，例如图、求解器和优化器。所有这些成分都可以打包成类，这类似于 Python 接口。

在 C+实现中，Python 有一些不同之处。图和求解器由底层数据类型和嵌入向量长度实现。该设计支持 Python 接口中的动态数据类型，以及对最大化优化编译时（compile-time）。为了方便了对 GraphVite 的进一步开发，开发者还对 C+接口进行了高度抽象。通过连接核心接口，用户可以实现图形的深度学习例程，而无需关注调度细节。

include/base/实现基本数据结构
include/util/实现基本用途
include/core/实现优化器、图和求解器的核心接口
include/gpu/实现所有模型的前向和后向传播
include/instance/实现图和求解器的实例
include/bind.h 实现Python绑定
src/graphvite.cu 实例化所有Python类

https://graphvite.io/

https://github.com/DeepGraphLearning/graphvite

pgl

paddle的graph learning

可以从这里搞些examples来试试：

https://github.com/PaddlePaddle/PGL

安装不赘述了，还有官方文档：https://pgl.readthedocs.io/en/latest/instruction.html

看看这个demo：

import pgl
from pgl import graph  # import pgl module
import numpy as np

def build_graph():
    # define the number of nodes; we can use number to represent every node
    num_node = 10
    # add edges, we represent all edges as a list of tuple (src, dst)
    edge_list = [(2, 0), (2, 1), (3, 1),(4, 0), (5, 0),
             (6, 0), (6, 4), (6, 5), (7, 0), (7, 1),
             (7, 2), (7, 3), (8, 0), (9, 7)]

    # Each node can be represented by a d-dimensional feature vector, here for simple, the feature vectors are randomly generated.
    d = 16
    feature = np.random.randn(num_node, d).astype("float32")
    # each edge also can be represented by a feature vector
    edge_feature = np.random.randn(len(edge_list), d).astype("float32")

    # create a graph
    g = graph.Graph(num_nodes = num_node,
                    edges = edge_list,
                    node_feat = {'feature':feature},
                    edge_feat ={'edge_feature': edge_feature})

    return g

# create a graph object for saving graph data
g = build_graph()


print('There are %d nodes in the graph.'%g.num_nodes)
print('There are %d edges in the graph.'%g.num_edges)

# Out:
# There are 10 nodes in the graph.
# There are 14 edges in the graph.

import paddle.fluid as fluid

use_cuda = False
place = fluid.GPUPlace(0) if use_cuda else fluid.CPUPlace()

# use GraphWrapper as a container for graph data to construct a graph neural network
gw = pgl.graph_wrapper.GraphWrapper(name='graph',
                        place = place,
                        node_feat=g.node_feat_info())



# define GCN layer function
def gcn_layer(gw, feature, hidden_size, name, activation):
    # gw is a GraphWrapper；feature is the feature vectors of nodes

    # define message function
    def send_func(src_feat, dst_feat, edge_feat):
        # In this tutorial, we return the feature vector of the source node as message
        return src_feat['h']

    # define reduce function
    def recv_func(feat):
        # we sum the feature vector of the source node
        return fluid.layers.sequence_pool(feat, pool_type='sum')

    # trigger message to passing
    msg = gw.send(send_func, nfeat_list=[('h', feature)])
    # recv funciton receives message and trigger reduce funcition to handle message
    output = gw.recv(msg, recv_func)
    output = fluid.layers.fc(output,
                    size=hidden_size,
                    bias_attr=False,
                    act=activation,
                    name=name)
    return output

output = gcn_layer(gw, gw.node_feat['feature'],
                hidden_size=8, name='gcn_layer_1', activation='relu')
output = gcn_layer(gw, output, hidden_size=1,
                name='gcn_layer_2', activation=None)

y = [0,1,1,1,0,0,0,1,0,1]
label = np.array(y, dtype="float32")
label = np.expand_dims(label, -1)

# create a label layer as a container
node_label = fluid.layers.data("node_label", shape=[None, 1],
            dtype="float32", append_batch_size=False)

# using cross-entropy with sigmoid layer as the loss function
loss = fluid.layers.sigmoid_cross_entropy_with_logits(x=output, label=node_label)

# calculate the mean loss
loss = fluid.layers.mean(loss)

# choose the Adam optimizer and set the learning rate to be 0.01
adam = fluid.optimizer.Adam(learning_rate=0.01)
adam.minimize(loss)

# create the executor
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
feed_dict = gw.to_feed(g) # gets graph data

for epoch in range(30):
    feed_dict['node_label'] = label

    train_loss = exe.run(fluid.default_main_program(),
        feed=feed_dict,
        fetch_list=[loss],
        return_numpy=True)
    print('Epoch %d | Loss: %f'%(epoch, train_loss[0]))

Angel 3.0

腾讯开源全栈机器学习平台 Angel 3.0，支持三大类型图计算算法

https://github.com/Angel-ML/angel

腾讯Angel在稀疏数据高维模型的训练上具有独特优势，擅长推荐模型和图网络模型相关领域。当前业界主流的大规模图计算系统主要有Facebook的Big Graph、Power graph、Data bricks的 Spark GraphX等，但这些系统并不都支持图挖掘、图表示学习、图神经网络的三大类型算法。

从性能上来看，Angel优于现有图计算系统，能够支持十亿级节点、千亿级边的传统图挖掘算法，以及百亿边的图神经网络算法需求。Angel可运行于多任务集群以及公有云环境，具备高效容错恢复机制，能够进行端到端的训练，新算法容易支持，同时，Angel能够支持图挖掘、图表示、图神经网络算法，具备图学习的能力。

Angel的PS是针对高维稀疏模型设计的, 而大图是非常高维、有多达十亿的节点，也是稀疏的, 因此PS架构也适合处理图数据。图算法有多种类型，如图挖掘算法、图表示学习、图神经网络。由于Angel的PS有自定义接口, 可以灵活地应对这几类算法，整个平台不需要改动，只要实现所需接口即可。关于可靠性问题，Angel从一开始就是针对共享集群、公有云环境设计的, 并与Spark的结合. Spark也具有很强的稳定性。易用性主要指与上下游是否完整配套。Spark On Angel可以与大数据处理结合，PyTorch On Angel可以跟深度学习结合，将把大数据计算、深度学习统一起来，用户不用借助第三方平台就能完成整个流程, 易用性好。

Angel可以运行在Yarn/Kubernetes环境上，它上面现在支持三类算法

图挖掘: PageRank、Kcore、Closeness，共同好友、三角结构、社团发现、其他；
图神经网络: GCN、GraphSage、DGI等神经网络算法；
图表示学习: LINE、Node2Vec算法。

图算法比较多，先将这些算法分类，每一类采取不同的优化方式去实现和优化。

第一类是三角结构类，数三角形。这类算法是暴力算法, 没有捷径可走。例如共同好友就是三角结构。基于三角结构可以实现一系列算法, 如Cluster Rank, Clustering coefficient, Ego Network.
第二类算法是连通分量，有WCC和SCC。这类算法核心的思想是要做图的折叠或者图的压缩。这类算法有一定的捷径可走，发现连通结点后，就可以进行合并,迭代时图在会不断变小，就可以加快迭代速度。
第三类算法是节点的排序。比如PageRank、KCore、Closeness，这类算法的迭代轮数较多，可能好几百轮。有一些方法加速它，主要有两种，一种是让它的迭代变得少一点，另一种是让它每一轮迭代越来越快。
第四类算法是图表示学习的算法, 也是没有捷径可走, 主要考虑一些图的划分策略。像GNN，也归为一类
最后一类算法是图神经网络。图有很多节点，每个节点都有自己的特征。经过一层层的图卷积，每个节点上的特征就输出一个表示，再经过一层图卷积，又输出另外一层表示，不断的改变图每一个节点的表示，最后根据任务类型需求，对每一个节点的表示把它都加起来，再做softmax，对全图做分类。对任何两个节点，算他们俩俩相交，计算它们的概率，预测它们俩是不是有边。它的核心是一个图，一层卷积，两层卷积，然后输出。图神经网络的问题是图数据规模比较大，需要做深度学习。

seqgan

2018-12-02T00:00:00+00:00

概述

SeqGAN: Sequence Generative Adversarial Nets with Policy Gradient

参考https://www.jianshu.com/p/e1b87286bfae

参考https://zhuanlan.zhihu.com/p/36880287

概述

GAN 在生成连续离散序列时会遇到两个问题：

一是因为生成器的输出是离散的，梯度更新从判别器传到生成器比较困难；
二是判别器只有当序列被完全生成后才能进行判断，但此刻指导用处已不太大，而如果生成器生成序列的同时判别器来判断，如何平衡当前序列的分数和未来序列的分数又是一个难题。

在这篇论文中：

将生成器看作是强化学习中的随机policy，这样就可以直接通过gradient policy的更新来避免生成器中的求导问题。
判别器对整个序列的评分作为强化学习的reward信号可以通过Monte Carlo搜索传递到序列生成的中间时刻。

G和D的定义如下：

通过生成器$G_{\theta}$产生序列$Y_{1 : T}=\left(y_{1}, \ldots, y_{t}, \ldots, y_{T}\right), y_{t} \in \mathcal{Y}$，其中的$\mathcal{Y}$是整个词表。在时间步$t$时，
- 状态是前$t-1$的序列$\left(y_{1}, \ldots, y_{t-1}\right)$，
- 动作是$y_{t}$
- $G_{\theta}\left(y_{t} | Y_{1 : t-1}\right)$是随机策略
- 状态转移是确定性的
通过判别器$D_{\phi}\left(Y_{1 : T}\right)$判断序列$Y_{1 : T}$是真实序列的概率。

训练过程如下：

通过正样本（真实序列）和负样本（生成的序列）来训练判别器
基于判别器给出的reward，通过policy gradient和MC搜索来训练生成器。其中的reward是通过生成器能欺骗判别器的likelihood来估计的。

SeqGAN via Policy Gradient

生成器相关

对于生成器$G_{\theta}\left(y_{t} | Y_{1 : t-1}\right)$来讲，其实没有中间的reward，只有整个sequence生成之后的final reward，所以目标就是最大化：

\[ J(\theta)=\mathbb{E}\left[R_{T} | s_{0}, \theta\right]=\sum_{y_{1} \in \mathcal{Y}} G_{\theta}\left(y_{1} | s_{0}\right) \cdot Q_{D_{\phi}}^{G_{\theta}}\left(s_{0}, y_{1}\right) \]

上式中的$R_{T}$是完整的长度为T的序列的reward。

而$Q_{D_{\phi}}^{G_{\theta}}(s, a)$是一个序列的action-value function。指的是从状态s开始，执行动作a，再$G_{\theta}$，再得到的累积期望reward。

对于倒数第二个状态，执行一步就是长度为T的序列了，那么，这个reward就是判别器的输出：

\[ Q_{D_{\phi}}^{G_{\theta}}\left(a=y_{T}, s=Y_{1 : T-1}\right)=D_{\phi}\left(Y_{1 : T}\right) \]

而对于中间状态呢，就要用MC了。

先看下面这个式子，给定一个长度为t-1的序列，使用带有roll-out policy $G_{\beta}$的MC搜索采样N次，每次采样T-t个token，得到一个长度为T的序列。所以产生的就是N个长度为T的序列。在这里，$G_{\beta}$和生成器$G_\theta$一样。

\[ \left\{Y_{1 : T}^{1}, \ldots, Y_{1 : T}^{N}\right\}=\mathrm{MC}^{G_{\beta}}\left(Y_{1 : t} ; N\right) \]

于是，t<T时，就是采样出N个长度为T的结果，然后每个结果算一下D，再对这N个结果取平均

\[ Q_{D_{\phi}}^{G_{\theta}}\left(s=Y_{1 : t-1}, a=y_{t}\right)=\left\{\begin{array}{ll}{\frac{1}{N} \sum_{n=1}^{N} D_{\phi}\left(Y_{1 : T}^{n}\right), Y_{1 : T}^{n} \in \mathrm{MC}^{G_{\beta}}\left(Y_{1 : t} ; N\right)} & {\text { for } t<T} \\ {D_{\phi}\left(Y_{1 : t}\right)} & {\text { for } t=T}\end{array}\right. \]

然后生成器的目标函数的导数就是：

\[ \nabla_{\theta} J(\theta)=\sum_{t=1}^{T} \mathbb{E}_{Y_{1 : t-1} \sim G_{\theta}}\left[\sum_{y_{t} \in \mathcal{Y}} \nabla_{\theta} G_{\theta}\left(y_{t} | Y_{1 : t-1}\right) \cdot Q_{D_{\phi}}^{G_{\theta}}\left(Y_{1 : t-1}, y_{t}\right)\right] \]

近似一下就是：

\[ \begin{array}{l}{\nabla_{\theta} J(\theta) \simeq \sum_{t=1}^{T} \sum_{y_{t} \in \mathcal{Y}} \nabla_{\theta} G_{\theta}\left(y_{t} | Y_{1 : t-1}\right) \cdot Q_{D_{\phi}}^{G_{\theta}}\left(Y_{1 : t-1}, y_{t}\right)} \\ {=\sum_{t=1}^{T} \sum_{y_{t} \in \mathcal{Y}} G_{\theta}\left(y_{t} | Y_{1 : t-1}\right) \nabla_{\theta} \log G_{\theta}\left(y_{t} | Y_{1 : t-1}\right) \cdot Q_{D_{\phi}}^{G_{\theta}}\left(Y_{1 : t-1}, y_{t}\right)} \\ {=\sum_{t=1}^{T} \mathbb{E}_{y_{t} \sim G_{\theta}\left(y_{t} | Y_{1 : t-1}\right)}\left[\nabla_{\theta} \log G_{\theta}\left(y_{t} | Y_{1 : t-1}\right) \cdot Q_{D_{\phi}}^{G_{\theta}}\left(Y_{1 : t-1}, y_{t}\right)\right]}\end{array} \]

其中的$Y_{1 : t-1}$是从$G_{\theta}$里sample出来的observed的中间状态。然后通过上面这个梯度来对$\theta$进行梯度下降更新。

判别器相关

训练判别器使用的损失函数则是

\[ \min _{\phi}-\mathbb{E}_{Y \sim p_{\text {data }}}\left[\log D_{\phi}(Y)\right]-\mathbb{E}_{Y \sim G_{\theta}}\left[\log \left(1-D_{\phi}(Y)\right)\right] \]

把负号取出来，第一项就是要让真实分布采样出来的最大，第二项就是让从G出来的最小也就是1-D最大。

算法流程

The Generative Model for Sequences

使用rnn

The Discriminative Model for Sequences

使用cnn

Horizon

2018-11-01T00:00:00+00:00

参考资源 | Facebook开源首个适应大规模产品的强化学习平台Horizon，基于PyTorch 1.0

代码地址：https://github.com/facebookresearch/Horizon

论文：Horizon: Facebook’s Open Source Applied Reinforcement Learning Platform

adanet

2018-11-01T00:00:00+00:00

快速易用
学习保证
可扩展

参考资源 | 谷歌开源AdaNet：基于TensorFlow的AutoML框架

Github 项目地址：https://github.com/tensorflow/adanet

教程 notebook：https://github.com/tensorflow/adanet/tree/v0.1.0/adanet/examples/tutorials

基于 TensorFlow 的轻量级框架 AdaNet，该框架可以使用少量专家干预来自动学习高质量模型。AdaNet 在谷歌近期的强化学习和基于进化的 AutoML 的基础上构建，快速灵活同时能够提供学习保证（learning guarantee）。重要的是，AdaNet 提供通用框架，不仅能用于学习神经网络架构，还能学习集成架构以获取更好的模型。

AdaNet 易于使用，能够创建高质量模型，节省 ML 从业者在选择最优神经网络架构上所花费的时间，实现学习神经架构作为集成子网络的自适应算法。AdaNet 能够添加不同深度、宽度的子网络，从而创建不同的集成，并在性能改进和参数数量之间进行权衡。

快速易用

AdaNet 实现了 TensorFlow Estimator 接口，通过压缩训练、评估、预测和导出极大地简化了机器学习编程。它整合如 TensorFlow Hub modules、TensorFlow Model Analysis、Google Cloud』s Hyperparameter Tuner 这样的开源工具。它支持分布式训练，极大减少了训练时间，使用可用 CPU 和加速器（例如 GPU）实现线性扩展。

AdaNet 将 TensorBoard 无缝集成，以监控子网络的训练、集成组合和性能。AdaNet 完成训练后将导出一个 SavedModel，可使用 TensorFlow Serving 进行部署。

学习保证

构建神经网络集成存在多个挑战：最佳子网络架构是什么？重复使用同样的架构好还是鼓励差异化好？虽然具备更多参数的复杂子网络在训练集上表现更好，但也因其极大的复杂性它们难以泛化到未见过的数据上。这些挑战源自对模型性能的评估。我们可以在训练集分留出的数据集上评估模型表现，但是这么做会降低训练神经网络的样本数量。

不同的是，AdaNet 的方法是优化一个目标函数，在神经网络集成在训练集上的表现与泛化能力之间进行权衡。直观上，即仅在候选子网络改进网络集成训练损失的程度超过其对泛化能力的影响时，选择该候选子网络。这保证了：

集成网络的泛化误差受训练误差和复杂度的约束。
通过优化这一目标函数，能够直接最小化这一约束。

优化这一目标函数的实际收益是它能减少选择哪个候选子网络加入集成时对留出数据集的需求。另一个益处是允许使用更多训练数据来训练子网络。

可扩展

谷歌认为，创建有用的 AutoML 框架的关键是：研究和产品使用方面不仅能够提供合理的默认设置，还要让用户尝试自己的子网络/模型定义。这样，机器学习研究者、从业者、喜爱者都能够使用 tf.layers 这样的 API 定义自己的 AdaNet adanet.subnetwork.Builder。

已在自己系统中融合 TensorFlow 模型的用户可以轻松将 TensorFlow 代码转换到 AdaNet 子网络中，并使用 adanet.Estimator 来提升模型表现同时获取学习保证。AdaNet 将探索他们定义的候选子网络搜索空间，并学习集成这些子网络。例如，采用 NASNet-A CIFAR 架构的开源实现，把它迁移到一个子网络，经过 8 次 AdaNet 迭代后提高其在 CIFAR-10 上的当前最优结果。

通过固定或自定义 tf.contrib.estimator.Heads，用户可以使用自己定义的损失函数作为 AdaNet 目标函数的一部分来训练回归、分类和多任务学习问题。

用户也可以通过拓展 adanet.subnetwork.Generator 类别，完全定义要探索的候选子网络搜索空间。这使得用户能够基于硬件扩大或缩小搜索空间范围。子网络的搜索空间可以简单到复制具备不同随机种子的同一子网络配置，从而训练数十种具备不同超参数组合的子网络，并让 AdaNet 选择其中一个进入最终的集成模型。

bert代码

2018-11-01T00:00:00+00:00

pretrained model
Sentence (and sentence-pair) classification tasks
- glue data数据集
- 运行
pretraining
抽取feature vector(类似ELMo)
自己尝试
注意

北京时间10.31 23时许，bert官方版代码正式出炉~

https://github.com/google-research/bert

原文的解读和pytorch版本的解读参考：https://daiwk.github.io/posts/nlp-bert.html

参考参考机器之心发的谷歌终于开源BERT代码：3 亿参数量，机器之心全面解读

代码结构：

`-- bert
    |-- CONTRIBUTING.md
    |-- create_pretraining_data.py
    |-- extract_features.py
    |-- __init__.py
    |-- LICENSE
    |-- modeling.py
    |-- modeling_test.py
    |-- optimization.py
    |-- optimization_test.py
    |-- README.md
    |-- run_classifier.py
    |-- run_pretraining.py
    |-- run_squad.py
    |-- sample_text.txt
    |-- tokenization.py
    `-- tokenization_test.py

1 directory, 16 files

pretrained model

有这几个版本（在进行WordPiece分词之前是否区分大小写：是：cased，否：uncased(即全部转为小写)）：

BERT-Base, Uncased: 12-layer, 768-hidden, 12-heads, 110M parameters
BERT-Large, Uncased: 24-layer, 1024-hidden, 16-heads, 340M parameters
BERT-Base, Cased: 12-layer, 768-hidden, 12-heads , 110M parameters
BERT-Large, Cased: 24-layer, 1024-hidden, 16-heads, 340M parameters (Not available yet. Needs to be re-generated).
BERT-Base, Multilingual: 102 languages, 12-layer, 768-hidden, 12-heads, 110M parameters
BERT-Base, Chinese: Chinese Simplified and Traditional, 12-layer, 768-hidden, 12-heads, 110M parameters

每个zip中包含如下三个文件：

一个TensorFlow checkpoint (bert_model.ckpt) ：包含pre-trained weights（里面有3个文件）
一个vocab文件(vocab.txt)：将WordPiece映射成word id
一个config file (bert_config.json) ：存储hyperparameters

例如：

uncased_L-12_H-768_A-12
|-- bert_config.json
|-- bert_model.ckpt.data-00000-of-00001
|-- bert_model.ckpt.index
|-- bert_model.ckpt.meta
|-- checkpoint
`-- vocab.txt

0 directories, 6 files

Sentence (and sentence-pair) classification tasks

glue data数据集

下载glue数据，使用https://gist.github.com/W4ngatang/60c2bdb54d156a41194446737ce03e2e的py，执行【记住要是python3!!!!!】。。不过在墙内好像怎么都下不下来。。

python download_glue_data.py --data_dir glue_data --tasks all

官方文档：https://github.com/nyu-mll/GLUE-baselines

如果是国内，先把这个clone下来：https://github.com/wasiahmad/paraphrase_identification

然后

python download_glue_data.py --data_dir glue_data --tasks all --path_to_mrpc=paraphrase_identification/dataset/msr-paraphrase-corpus

注意，如果要用glove，从https://nlp.stanford.edu/projects/glove/下载下来的840B版本的zip就有2G多，直接unzip解压不了。。可以

7z x glove.840B.300d.zip

然后就很风骚。。。

7z x glove.840B.300d.zip

7-Zip [64] 16.02 : Copyright (c) 1999-2016 Igor Pavlov : 2016-05-21
p7zip Version 16.02 (locale=en_US,Utf16=on,HugeFiles=on,64 bits,56 CPUs x64)

Scanning the drive for archives:
1 file, 2176768927 bytes (2076 MiB)

Extracting archive: glove.840B.300d.zip
--
Path = glove.840B.300d.zip
Type = zip
Physical Size = 2176768927
64-bit = +

Everything is Ok

Size:       5646236541
Compressed: 2176768927

参考https://github.com/nyu-mll/GLUE-baselines，装allennlp==0.7.0，torch>=0.4.1，可以跑glue数据集的baseline：

py=/home/xxx/python-3-tf-cpu/bin/python3.6
alias superhead='/opt/compiler/gcc-4.8.2/lib/ld-linux-x86-64.so.2 --library-path /opt/compiler/gcc-4.8.2/lib:$LD_LIBRARY_PATH '
alias python='superhead $py'
python main.py \
    --exp_dir EXP_DIR \
    --run_dir RUN_DIR \
    --train_tasks all \
    --cove 0 \
    --cuda -1 \
    --eval_tasks all \
    --glove 1 \
    --word_embs_file ./emb_dir/glove.840B.300d.txt

运行

export BERT_BASE_DIR=/path/to/bert/uncased_L-12_H-768_A-12
export GLUE_DIR=/path/to/glue

python run_classifier.py \
  --task_name=MRPC \
  --do_train=true \
  --do_eval=true \
  --data_dir=$GLUE_DIR/MRPC \
  --vocab_file=$BERT_BASE_DIR/vocab.txt \
  --bert_config_file=$BERT_BASE_DIR/bert_config.json \
  --init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \
  --max_seq_length=128 \
  --train_batch_size=32 \
  --learning_rate=2e-5 \
  --num_train_epochs=3.0 \
  --output_dir=/tmp/mrpc_output/

输出：

***** Eval results *****
  eval_accuracy = 0.845588
  eval_loss = 0.505248
  global_step = 343
  loss = 0.505248

表示dev set上有84.55%的准确率，像MRPC（glue_data中的一个数据集）这样的小数据集，即使从pretrained的checkpoint开始，仍然可能在dev set的accuracy上会有很高的variance（跑多次，可能结果在84-88%之间）。

pretraining

step1. create-pretraining-data

paper的源码是用c++写的，这里用py又实现了一遍。。实现masked lm和next sentence prediction。

输入文件的格式：一行一句话（对于next sentence prediction这很重要），不同文档间用空行分隔。例如sample_text.txt：

Something glittered in the nearest red pool before him.
Gold, surely!
But, wonderful to relate, not an irregular, shapeless fragment of crude ore, fresh from Nature's crucible, but a bit of jeweler's handicraft in the form of a pla
in gold ring.
Looking at it more attentively, he saw that it bore the inscription, "May to Cass."
Like most of his fellow gold-seekers, Cass was superstitious.

The fountain of classic wisdom, Hypatia herself.
As the ancient sage--the name is unimportant to a monk--pumped water nightly that he might study by day, so I, the guardian of cloaks and parasols, at the sacred
 doors of her lecture-room, imbibe celestial knowledge.
From my youth I felt in me a soul above the matter-entangled herd.
She revealed to me the glorious fact, that I am a spark of Divinity itself.

输出是一系列的TFRecord的tf.train.Example。

注意：这个脚本把整个输入文件都放到内存里了，所以对于大文件，你可能需要把文件分片，然后跑多次这个脚本，得到一堆tf_examples.tf_record*，然后把这些文件都作为下一个脚本run_pretraining.py的输入。

参数：

max_predictions_per_seq：每个序列里最大的masked lm predictions。建议设置为max_seq_length*masked_lm_prob（这个脚本不会自动设置）

python create_pretraining_data.py \
  --input_file=./sample_text.txt \
  --output_file=/tmp/tf_examples.tfrecord \
  --vocab_file=$BERT_BASE_DIR/vocab.txt \
  --do_lower_case=True \
  --max_seq_length=128 \
  --max_predictions_per_seq=20 \
  --masked_lm_prob=0.15 \
  --random_seed=12345 \
  --dupe_factor=5

输出如下：

INFO:tensorflow:*** Example ***
INFO:tensorflow:tokens: [CLS] indeed , it was recorded in [MASK] star that a fortunate early [MASK] ##r had once picked up on the highway a solid chunk [MASK] gold quartz which the [MASK] had freed from its inc [MASK] ##ing soil , and washed into immediate and [MASK] popularity . [SEP] rainy season , [MASK] insult show habit of body , and seldom lifted their eyes to the rift ##ed [MASK] india - ink washed skies [MASK] them . " cass " beard [MASK] elliot early that morning , but not with a view to [MASK] . a leak in his [MASK] roof , - - quite [MASK] with his careless , imp ##rov ##ide ##nt habits , - - had rouse ##d him at 4 a [MASK] m [SEP]
INFO:tensorflow:input_ids: 101 5262 1010 2009 2001 2680 1999 103 2732 2008 1037 19590 2220 103 2099 2018 2320 3856 2039 2006 1996 3307 1037 5024 20000 103 2751 20971 2029 1996 103 2018 10650 2013 2049 4297 103 2075 5800 1010 1998 8871 2046 6234 1998 103 6217 1012 102 16373 2161 1010 103 15301 2265 10427 1997 2303 1010 1998 15839 4196 2037 2159 2000 1996 16931 2098 103 2634 1011 10710 8871 15717 103 2068 1012 1000 16220 1000 10154 103 11759 2220 2008 2851 1010 2021 2025 2007 1037 3193 2000 103 1012 1037 17271 1999 2010 103 4412 1010 1011 1011 3243 103 2007 2010 23358 1010 17727 12298 5178 3372 14243 1010 1011 1011 2018 27384 2094 2032 2012 1018 1037 103 1049 102
INFO:tensorflow:input_mask: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
INFO:tensorflow:segment_ids: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
INFO:tensorflow:masked_lm_positions: 7 12 13 25 30 36 45 52 53 54 68 74 81 82 93 99 103 105 125 0
INFO:tensorflow:masked_lm_ids: 17162 2220 4125 1997 4542 29440 20332 4233 1037 16465 2030 2682 2018 13763 5456 6644 1011 8335 1012 0
INFO:tensorflow:masked_lm_weights: 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 1.0 0.0
INFO:tensorflow:next_sentence_labels: 0
INFO:tensorflow:*** Example ***
INFO:tensorflow:tokens: [CLS] and there burst on phil ##am ##mon ' s astonished eyes a vast semi ##ci ##rcle of blue sea [MASK] ring ##ed with palaces and towers [MASK] [SEP] like most of [MASK] fellow gold - seekers , cass was super ##sti [MASK] . [SEP]
INFO:tensorflow:input_ids: 101 1998 2045 6532 2006 6316 3286 8202 1005 1055 22741 2159 1037 6565 4100 6895 21769 1997 2630 2712 103 3614 2098 2007 22763 1998 7626 103 102 2066 2087 1997 103 3507 2751 1011 24071 1010 16220 2001 3565 16643 103 1012 102 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
INFO:tensorflow:input_mask: 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
INFO:tensorflow:segment_ids: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
INFO:tensorflow:masked_lm_positions: 10 20 23 27 32 39 42 0 0 0 0 0 0 0 0 0 0 0 0 0
INFO:tensorflow:masked_lm_ids: 22741 1010 2007 1012 2010 2001 20771 0 0 0 0 0 0 0 0 0 0 0 0 0
INFO:tensorflow:masked_lm_weights: 1.0 1.0 1.0 1.0 1.0 1.0 1.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0
INFO:tensorflow:next_sentence_labels: 1
INFO:tensorflow:Wrote 60 total instances

step2. run-pretraining

如果你是从头开始pretrain，不要include init_checkpoint
模型配置（包括vocab size）在bert_config_file中设置
num_train_steps在现实中一般要设置10000以上
max_seq_length和max_predictions_per_seq要和传给create_pretraining_data的一样

python run_pretraining.py \
  --input_file=/tmp/tf_examples.tfrecord \
  --output_dir=/tmp/pretraining_output \
  --do_train=True \
  --do_eval=True \
  --bert_config_file=$BERT_BASE_DIR/bert_config.json \
  --init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \
  --train_batch_size=32 \
  --max_seq_length=128 \
  --max_predictions_per_seq=20 \
  --num_train_steps=20 \
  --num_warmup_steps=10 \
  --learning_rate=2e-5

跑的时候发现会充分利用显存，具体不是特别清楚，显存太小应该也跑不了吧。由于sample_text.txt很小，所以会overfit。log如下(最后会生成一个eval_results.txt文件，记录***** Eval results *****部分)：

INFO:tensorflow:Done running local_init_op.
INFO:tensorflow:Evaluation [10/100]
INFO:tensorflow:Evaluation [20/100]
INFO:tensorflow:Evaluation [30/100]
INFO:tensorflow:Evaluation [40/100]
INFO:tensorflow:Evaluation [50/100]
INFO:tensorflow:Evaluation [60/100]
INFO:tensorflow:Evaluation [70/100]
INFO:tensorflow:Evaluation [80/100]
INFO:tensorflow:Evaluation [90/100]
INFO:tensorflow:Evaluation [100/100]
INFO:tensorflow:Finished evaluation at 2018-10-31-18:13:12
INFO:tensorflow:Saving dict for global step 20: global_step = 20, loss = 0.27842212, masked_lm_accuracy = 0.94665253, masked_lm_loss = 0.27976906, next_sentence_accuracy = 1.0, next_sentence_loss = 0.0002133457
INFO:tensorflow:Saving 'checkpoint_path' summary for global step 20: ./pretraining_output/model.ckpt-20
INFO:tensorflow:***** Eval results *****
INFO:tensorflow:  global_step = 20
INFO:tensorflow:  loss = 0.27842212
INFO:tensorflow:  masked_lm_accuracy = 0.94665253
INFO:tensorflow:  masked_lm_loss = 0.27976906
INFO:tensorflow:  next_sentence_accuracy = 1.0
INFO:tensorflow:  next_sentence_loss = 0.0002133457

具体可以看对应的tensorboard，比较卡，猜测是模型比较大，截图如下：

还有个projector，如下：

左边可以选哪个模型的哪一层

然后在中间的图中可以选中一个点，这样在最右边会显示出与这个点最近的n个点，度量方式可以选择cos或者欧氏距离。

pretrain tips and caveats

如果你的任务有很大的domain-specific语料，最好从bert的checkpoint开始，在你的语料上进行多一些的pre-train
paper中的学习率设为1e-4，如果基于已有bert checkpoint继续pretrain，建议把学习率调小（如2e-5）
当前的bert模型只是English的，2018年11月底会放出更多语言的！！
更长的序列的计算代价会非常大，因为attention是序列长度平方的复杂度。例如，一个长度是512的minibatch-size=64的batch，比一个长度为128的minibatch-size=256的batch计算代码要大得多。对于全连接或者cnn来讲，其实这个计算代价是一样的。但对attention而言，长度是512的计算代价会大得多。所以，建议对长度为128的序列进行9w个step的预训练，然后对长度为512的序列再做1w个step的预训练是更好的~对于非常长的序列，最需要的是学习positional embeddings，这是很快就能学到的啦。注意，这样做就需要使用不同的max_seq_length来生成两次数据。
如果你从头开始pretrain，计算代价是很大的，特别是在gpu上。建议的是在一个preemptible Cloud TPU v2上pretrain一个bert-base（2周要500美刀…）。如果在一个single cloud TPU上的话，需要把batchsize scale down。建议使用能占满TPU内存的最大batchsize…

抽取feature vector(类似ELMo)

输入文件input.txt格式：

如果是两个句子，那就是sentence A ||| sentence B
如果是一个句子，那就是sentence A，不要分隔符

python extract_features.py \
  --input_file=input.txt \
  --output_file=/tmp/output.json \
  --vocab_file=$BERT_BASE_DIR/vocab.txt \
  --bert_config_file=$BERT_BASE_DIR/bert_config.json \
  --init_checkpoint=$BERT_BASE_DIR/bert_model.ckpt \
  --layers=-1,-2,-3,-4 \
  --max_seq_length=128 \
  --batch_size=8

例如输入的内容是『大家』，那么输出的output.json格式如下：

其中的”linex_index”表示第几行

{
  "linex_index": 0,
  "features": [{
    "token": "[CLS]",
    "layers": [{
      "index": -1,
      "values": [1.507966, -0.155272, 0.108119, ..., 0.111],
    }, {
      "index": -2,
      "values": [1.39443, 0.307064, 0.483496, ..., 0.332],
    }, {
      "index": -3,
      "values": [0.961682, 0.757408, 0.720898, ..., 0.332],
    }, {
      "index": -4,
      "values": [-0.275457, 0.632056, 1.063737, ..., 0.332],
    }, {
    "token": "大",
    "layers": [{
      "index": -1,
      "values": [0.326004, -0.313136, 0.233399, ..., 0.111],
    }, {
      "index": -2,
      "values": [0.795364, 0.361322, -0.116774, ..., 0.332],
    }, {
      "index": -3,
      "values": [0.807957, 0.206743, -0.359639, ..., 0.332],
    }, {
      "index": -4,
      "values": [-0.226106, -0.129655, -0.128466, ..., 0.332],
    }, {
    "token": "家",
    "layers": [{
      "index": -1,
      "values": [1.768678, -0.814265, 0.016321, ..., 0.111],
    }, {
      "index": -2,
      "values": [1.76887, -0.020193, 0.44832, 0.193271, ..., 0.332],
    }, {
      "index": -3,
      "values": [1.695086, 0.050979, 0.188321, -0.537057, ..., 0.332],
    }, {
      "index": -4,
      "values": [0.745073, -0.09894, 0.166217, -1.045382, ..., 0.332],
    }, {
    "token": "[SEP]",
    "layers": [{
      "index": -1,
      "values": [0.881939, -0.34753, 0.210375, ..., 0.111],
    }, {
      "index": -2,
      "values": [-0.047698, -0.030813, 0.041558, ..., 0.332],
    }, {
      "index": -3,
      "values": [-0.049113, -0.067705, 0.018293, ..., 0.332],
    }, {
      "index": -4,
      "values": [0.000215, -0.057331, -3.2e-05, ..., 0.332],
    }]
  }]
}

自己尝试

基于预训练的中文模型中的vocab，把网络改小，基于190w的中文语料（还是用默认的wordpiece分词）进行单机cpu训练，一个句子当成一篇文档，这个句子当成sentence2，这个句子的tag当成sentence1：

模型配置如下：

{
  "attention_probs_dropout_prob": 0.1, 
  "directionality": "bidi", 
  "hidden_act": "gelu", 
  "hidden_dropout_prob": 0.1, 
  "hidden_size": 64, 
  "initializer_range": 0.02, 
  "intermediate_size": 3072, 
  "max_position_embeddings": 512, 
  "num_attention_heads": 8, 
  "num_hidden_layers": 2, 
  "pooler_fc_size": 64, 
  "pooler_num_attention_heads": 12, 
  "pooler_num_fc_layers": 3, 
  "pooler_size_per_head": 32, 
  "pooler_type": "first_token_transform", 
  "type_vocab_size": 2, 
  "vocab_size": 21128
}

参数设置如下：

## g_max_predictions_per_seq approx_to g_max_seq_length * g_masked_lm_prob

# online or offline
export train_mode=offline
export param_name=param1
export g_train_batch_size=128
export g_num_train_steps=10000
export g_max_seq_length=128
export g_max_predictions_per_seq=20
export g_masked_lm_prob=0.15
export g_dupe_factor=3

sh -x scripts/run_train_bert.sh  > log/$param_name.log &

# online or offline
export train_mode=offline
export param_name=param2
export g_train_batch_size=64
export g_num_train_steps=10000
export g_max_seq_length=128
export g_max_predictions_per_seq=20
export g_masked_lm_prob=0.15
export g_dupe_factor=3

sh -x scripts/run_train_bert.sh  > log/$param_name.log &

# online or offline
export train_mode=offline
export param_name=param3
export g_train_batch_size=128
export g_num_train_steps=10000
export g_max_seq_length=128
export g_max_predictions_per_seq=8
export g_masked_lm_prob=0.05
export g_dupe_factor=5

sh -x scripts/run_train_bert.sh  > log/$param_name.log &

# online or offline
export train_mode=offline
export param_name=param4
export g_train_batch_size=64
export g_num_train_steps=10000
export g_max_seq_length=128
export g_max_predictions_per_seq=8
export g_masked_lm_prob=0.05
export g_dupe_factor=5

sh -x scripts/run_train_bert.sh  > log/$param_name.log &

# online or offline
export train_mode=offline
export param_name=param5
export g_train_batch_size=32
export g_num_train_steps=10000
export g_max_seq_length=128
export g_max_predictions_per_seq=20
export g_masked_lm_prob=0.15
export g_dupe_factor=3

sh -x scripts/run_train_bert.sh  > log/$param_name.log &

# online or offline
export train_mode=offline
export param_name=param6
export g_train_batch_size=32
export g_num_train_steps=10000
export g_max_seq_length=128
export g_max_predictions_per_seq=8
export g_masked_lm_prob=0.05
export g_dupe_factor=5

sh -x scripts/run_train_bert.sh  > log/$param_name.log &

wait

跑1w个step，效果如下（图中训了2w步的那个忘了是啥配置了…）：

可见，同为1w个step，参数1训练时间最久，但loss最低

每秒的example数：

每秒的global-steps：

拿来eval时，next sentence的准确率：

拿来eval时，masked lm的准确率就比较。。。了：

注意

我们发现，代码里没看到tf.summary相关的代码，却可以看到tensorboard…

是因为用了tpuestimator。。。”TPUEstimator API 不支持 tensorboard 的自定义摘要。但是，基本摘要会自动记录到模型目录中的事件文件中。”

https://cloud.google.com/tpu/docs/tutorials/migrating-to-tpuestimator-api

bert代码解读——framework

2018-11-01T00:00:00+00:00

modeling.py
optimization.py
tokenization.py
- 常用函数
小结

注：由于标题不能有下划线，所以把函数名/文件名里的_换成了-

modeling.py

高仿https://github.com/tensorflow/tensor2tensor/blob/master/tensor2tensor/layers/transformer_layers.py#L99的transformer_encoder部分。

公共函数

get-assignment-map-from-checkpoint

从checkpoint的list_variables中，获取tvars（一般是tvars = tf.trainable_variables()）中的变量

def get_assignment_map_from_checkpoint(tvars, init_checkpoint):
  """Compute the union of the current variables and checkpoint variables."""
  assignment_map = {}
  initialized_variable_names = {}

  name_to_variable = collections.OrderedDict()
  for var in tvars:
    name = var.name
    m = re.match("^(.*):\\d+$", name)
    if m is not None:
      name = m.group(1)
    name_to_variable[name] = var
  # 返回一个list，每个元素是(name, shape)
  init_vars = tf.train.list_variables(init_checkpoint)

  assignment_map = collections.OrderedDict()
  for x in init_vars:
    (name, var) = (x[0], x[1])
    if name not in name_to_variable:
      continue
    assignment_map[name] = name
    initialized_variable_names[name] = 1
    initialized_variable_names[name + ":0"] = 1

  return (assignment_map, initialized_variable_names)

reshape-to-matrix

def reshape_to_matrix(input_tensor):
  """Reshapes a >= rank 2 tensor to a rank 2 tensor (i.e., a matrix)."""
  ndims = input_tensor.shape.ndims
  if ndims < 2:
    raise ValueError("Input tensor must have at least rank 2. Shape = %s" %
                     (input_tensor.shape))
  if ndims == 2:
    return input_tensor

  width = input_tensor.shape[-1]
  output_tensor = tf.reshape(input_tensor, [-1, width])
  return output_tensor

reshape-from-matrix

def reshape_from_matrix(output_tensor, orig_shape_list):
  """Reshapes a rank 2 tensor back to its original rank >= 2 tensor."""
  if len(orig_shape_list) == 2:
    return output_tensor

  output_shape = get_shape_list(output_tensor)

  orig_dims = orig_shape_list[0:-1]
  width = output_shape[-1]

  return tf.reshape(output_tensor, orig_dims + [width])

assert-rank

注意：

tensor的rank表示一个tensor需要的索引数目来唯一表示任何一个元素。也就是通常所说的 “order”, “degree”或”ndims”，不是矩阵的秩。。参考https://blog.csdn.net/lenbow/article/details/52152766

例如：

#’t’ is [[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]]
# shape of tensor ‘t’ is [2, 2, 3]
rank(t) = 3

函数的功能：如果输入tensor的rank和预期的不一样，就抛异常

参数：

tensor：输入的tf.Tensor
expected_rank：Python integer or list of integers，期望的rank
name：error message中的tensor的名字

def assert_rank(tensor, expected_rank, name=None):
  if name is None:
    name = tensor.name

  expected_rank_dict = {}
  if isinstance(expected_rank, six.integer_types):
    expected_rank_dict[expected_rank] = True
  else:
    for x in expected_rank:
      expected_rank_dict[x] = True

  actual_rank = tensor.shape.ndims
  if actual_rank not in expected_rank_dict:
    scope_name = tf.get_variable_scope().name
    raise ValueError(
        "For the tensor `%s` in scope `%s`, the actual rank "
        "`%d` (shape = %s) is not equal to the expected rank `%s`" %
        (name, scope_name, actual_rank, str(tensor.shape), str(expected_rank)))

get-shape-list

参数：

tensor：一个需要返回shape的tf.Tensor
expected_rank：int或者是一个int的list。输入tensor期望的rank，如果输入tensor的rank不等于这个数，或者不是这个list的元素之一，会抛异常

def get_shape_list(tensor, expected_rank=None, name=None):
  if name is None:
    name = tensor.name

  if expected_rank is not None:
    assert_rank(tensor, expected_rank, name)

  shape = tensor.shape.as_list()

  non_static_indexes = []
  for (index, dim) in enumerate(shape):
    if dim is None:
      non_static_indexes.append(index)

  if not non_static_indexes:
    return shape

  dyn_shape = tf.shape(tensor)
  for index in non_static_indexes:
    shape[index] = dyn_shape[index]
  return shape

gelu

其中的tf.erf是tensorflow/python/ops/gen_math_ops.py中的函数，计算Gauss error function of `x` element-wise.

def gelu(input_tensor):
  """Gaussian Error Linear Unit.

  This is a smoother version of the RELU.
  Original paper: https://arxiv.org/abs/1606.08415

  Args:
    input_tensor: float Tensor to perform activation.

  Returns:
    `input_tensor` with the GELU activation applied.
  """
  cdf = 0.5 * (1.0 + tf.erf(input_tensor / tf.sqrt(2.0)))
  return input_tensor * cdf

create-initializer

对tf.truncated_normal_initializer的简单封装

def create_initializer(initializer_range=0.02):
  """Creates a `truncated_normal_initializer` with the given range."""
  return tf.truncated_normal_initializer(stddev=initializer_range)

dropout

def dropout(input_tensor, dropout_prob):
  """Perform dropout.

  Args:
    input_tensor: float Tensor.
    dropout_prob: Python float. The probability of dropping out a value (NOT of
      *keeping* a dimension as in `tf.nn.dropout`).

  Returns:
    A version of `input_tensor` with dropout applied.
  """
  if dropout_prob is None or dropout_prob == 0.0:
    return input_tensor

  output = tf.nn.dropout(input_tensor, 1.0 - dropout_prob)
  return output

layer-norm

只在shape的最后一维做layer norm

def layer_norm(input_tensor, name=None):
  """Run layer normalization on the last dimension of the tensor."""
  return tf.contrib.layers.layer_norm(
      inputs=input_tensor, begin_norm_axis=-1, begin_params_axis=-1, scope=name)

layer-norm-and-dropout

def layer_norm_and_dropout(input_tensor, dropout_prob, name=None):
  """Runs layer normalization followed by dropout."""
  output_tensor = layer_norm(input_tensor, name)
  output_tensor = dropout(output_tensor, dropout_prob)
  return output_tensor

embedding-lookup

返回一个shape是[batch_size, seq_length, embedding_size]的tensor，还有shape为[vocab_size, embedding_size]的整个embedding_table

参数：

input_ids：shape为包含了word ids的[batch_size, seq_length]的tensor
vocab_size：embedding vocabulary的size
embedding_size：word embeddings的width
initializer_range：Embedding初始化的range
word_embedding_name：embedding table的名字
use_one_hot_embeddings：true: 使用one-hot的embedding；false：使用tf.nn.embedding_lookup()，如下所述，tpu用one-hot好，cpu/gpu用非one-hot好

def embedding_lookup(input_ids,
                     vocab_size,
                     embedding_size=128,
                     initializer_range=0.02,
                     word_embedding_name="word_embeddings",
                     use_one_hot_embeddings=False):
  ## 此函数假设输入的shape是[batch_size, seq_length, num_inputs]。如果是[batch_size, seq_length]，会reshape成[batch_size, seq_length, 1]
  if input_ids.shape.ndims == 2:
    ## tf.expand_dims在axis处插入维度1进入一个tensor中
    input_ids = tf.expand_dims(input_ids, axis=[-1])

  ## shape是[vocab_size, embedding_size]的embedding table
  embedding_table = tf.get_variable(
      name=word_embedding_name,
      shape=[vocab_size, embedding_size],
      initializer=create_initializer(initializer_range))

  if use_one_hot_embeddings:
    ## 把[batch_size, seq_length, 1]的input_ids变成[batch_size*seq_length]的一个tensor
    flat_input_ids = tf.reshape(input_ids, [-1])
    ## 变成一个[batch_size*seq_length, vocab_size]的one-hot的tensor，depth参数的含义就是vocab_size
    one_hot_input_ids = tf.one_hot(flat_input_ids, depth=vocab_size)
    ## [batch_size*seq_length, vocab_size]的one_hot_input_ids和[vocab_size, embedding_size]的embedding_table矩阵相乘，得到[batch_size*seq_length,embedding_size]的output
    output = tf.matmul(one_hot_input_ids, embedding_table)
  else:
    ## [batch_size, seq_length, 1]的input_ids去[vocab_size, embedding_size]的embedding_table中lookup，得到一个[batch_size, seq_length, 1, embedding_size]的output
    output = tf.nn.embedding_lookup(embedding_table, input_ids)

  input_shape = get_shape_list(input_ids)

  ## reshape成[batch_size, seq_length, 1 * embedding_size]的输出
  output = tf.reshape(output,
                      input_shape[0:-1] + [input_shape[-1] * embedding_size])
  return (output, embedding_table)

embedding-postprocessor

参数：

input_tensor：shape是[batch_size, seq_length, embedding_size]的float Tensor
use_token_type：是否要为embedding加上token_type_ids
token_type_ids：shape是[batch_size, seq_length]的int32 Tensor
token_type_vocab_size：token_type_ids的vocabulary size
token_type_embedding_name：token_type_ids的embedding_table的名字，默认”token_type_embeddings”
use_position_embeddings：是否要为序列里每个token的位置加上position embeddings
position_embedding_name：position_embeddings的embedding_table的名字，默认”position_embeddings”
initializer_range：权重初始化的range
max_position_embeddings：最大的sequence length，可以比输入的sequence length长，但不能比它短
dropout_prob：最终输出tensor的dropout rate

def embedding_postprocessor(input_tensor,
                            use_token_type=False,
                            token_type_ids=None,
                            token_type_vocab_size=16,
                            token_type_embedding_name="token_type_embeddings",
                            use_position_embeddings=True,
                            position_embedding_name="position_embeddings",
                            initializer_range=0.02,
                            max_position_embeddings=512,
                            dropout_prob=0.1):
  ## input_shape是[batch_size, seq_length, embedding_size]
  input_shape = get_shape_list(input_tensor, expected_rank=3)
  batch_size = input_shape[0]
  seq_length = input_shape[1]
  width = input_shape[2]

  if seq_length > max_position_embeddings:
    raise ValueError("The seq length (%d) cannot be greater than "
                     "`max_position_embeddings` (%d)" %
                     (seq_length, max_position_embeddings))

  output = input_tensor

  if use_token_type:
    if token_type_ids is None:
      raise ValueError("`token_type_ids` must be specified if"
                       "`use_token_type` is True.")
    ## 搞一个[token_type_vocab_size, embedding_size]的token_type的embedding_table
    token_type_table = tf.get_variable(
        name=token_type_embedding_name,
        shape=[token_type_vocab_size, width],
        initializer=create_initializer(initializer_range))
    # 由于token_type的vocab很小，所以直接用one-hot，这样能更快，这个用法和上面的embedding_lookup函数一样，不再赘述
    flat_token_type_ids = tf.reshape(token_type_ids, [-1])
    one_hot_ids = tf.one_hot(flat_token_type_ids, depth=token_type_vocab_size)
    token_type_embeddings = tf.matmul(one_hot_ids, token_type_table)
    token_type_embeddings = tf.reshape(token_type_embeddings,
                                       [batch_size, seq_length, width])
    output += token_type_embeddings

  if use_position_embeddings:
    full_position_embeddings = tf.get_variable(
        name=position_embedding_name,
        shape=[max_position_embeddings, width],
        initializer=create_initializer(initializer_range))
    # position embedding table是一个learned variable，对[0, 1, 2, ..., max_position_embeddings-1]来讲，
    # full_position_embeddings的shape就是[max_position_embeddings, width]
    #
    # 而当前的序列长度是seq_length，所以针对[0, 1, 2, ... seq_length-1], 可以对full_position_embeddings做个slice
    # 传入给slice的begin是[0,0]，size是[seq_length,-1]，所以是对输入的shape取[0:seq_len, 0:-1]，所以
    # slice的结果position_embeddings的shape是[seq_length, width]
    if seq_length < max_position_embeddings:
      position_embeddings = tf.slice(full_position_embeddings, [0, 0],
                                     [seq_length, -1])
    else:
      position_embeddings = full_position_embeddings
    # output.shape是[batch_size, seq_length, embedding_size]，num_dims是3
    num_dims = len(output.shape.as_list())

    ## 其实这里就是把position_broadcast_shape写成[1, seq_length, width]
    position_broadcast_shape = []
    for _ in range(num_dims - 2):
      position_broadcast_shape.append(1)
    position_broadcast_shape.extend([seq_length, width])
    # 把position_embeddings从[seq_length, width]给reshape成[1, seq_length, width]，方便和output相加
    # 第一维是1，是因为batch里的每一条数据，相同position加的position embedding是一样的
    position_embeddings = tf.reshape(position_embeddings,
                                     position_broadcast_shape)
    output += position_embeddings
  # 注意,layer_norm里只对最后一维做norm，即只对embedding_size这一维做norm
  output = layer_norm_and_dropout(output, dropout_prob)
  return output

create-attention-mask-from-input-mask

输入：

from_tensor：2D或者3D的Tensor，shape是[batch_size, from_seq_length]或者[batch_size, from_seq_length, xxx]
to_mask：int32的Tensor，shape是[batch_size, to_seq_length]

def create_attention_mask_from_input_mask(from_tensor, to_mask):
  """Create 3D attention mask from a 2D tensor mask.

  Args:
    from_tensor: 2D or 3D Tensor of shape [batch_size, from_seq_length, ...].
    to_mask: int32 Tensor of shape [batch_size, to_seq_length].

  Returns:
    float Tensor of shape [batch_size, from_seq_length, to_seq_length].
  """
  # 确保输入的tensor是2D或者3D，前两维是batch_size和from_seq_length
  from_shape = get_shape_list(from_tensor, expected_rank=[2, 3])
  batch_size = from_shape[0]
  from_seq_length = from_shape[1]

  # 确保to_mask是2D的，shape是[batch_size, to_seq_length]
  to_shape = get_shape_list(to_mask, expected_rank=2)
  to_seq_length = to_shape[1]

  # 1. 把to_mask的shape从[batch_size, to_seq_length]转成[batch_size, 1, to_seq_length]
  # 2. 把to_mask的数据类型从int32转成float
  to_mask = tf.cast(
      tf.reshape(to_mask, [batch_size, 1, to_seq_length]), tf.float32)

  # We don't assume that `from_tensor` is a mask (although it could be). We
  # don't actually care if we attend *from* padding tokens (only *to* padding)
  # tokens so we create a tensor of all ones.
  #
  # `broadcast_ones` = [batch_size, from_seq_length, 1]
  # broadcast_ones是一个float32的[batch_size, from_seq_length, 1]的全1 tensor
  broadcast_ones = tf.ones(
      shape=[batch_size, from_seq_length, 1], dtype=tf.float32)

  # [batch_size, from_seq_length, 1]和[[batch_size, 1, from_seq_length]相乘(element-wise乘积)，经过broadcast后
  # 得到[batch_size, from_seq_length, from_seq_length]
  mask = broadcast_ones * to_mask

对mask = broadcast_ones * to_mask的理解如下：

参考https://www.cnblogs.com/yangmang/p/7125458.html提到的广播原则：如果两个数组的后缘维度(即：从末尾开始算起的维度)的轴长相符或其中一方的长度为1，则认为它们是广播兼容的，广播会在缺失和(或)长度为1的轴上进行。

>>> b = np.random.randn(2,1,3)
>>> a = np.ones((2,3,1))
>>> b
array([[[-0.79036561, -0.6795738 , -0.80898213]],

       [[-1.03638711, -0.34853504, -1.48699898]]])
>>> a
array([[[1.],
        [1.],
        [1.]],

       [[1.],
        [1.],
        [1.]]])
>>> c=a*b
>>> c
array([[[-0.79036561, -0.6795738 , -0.80898213],
        [-0.79036561, -0.6795738 , -0.80898213],
        [-0.79036561, -0.6795738 , -0.80898213]],

       [[-1.03638711, -0.34853504, -1.48699898],
        [-1.03638711, -0.34853504, -1.48699898],
        [-1.03638711, -0.34853504, -1.48699898]]])
>>> c.shape
(2, 3, 3)

attention-layer

如果from_tensor和to_tensor一样，那就是self-attention。from_tensor的每一个timestep会attend to to_tensor的对应序列，然后返回一个fixed-with vector。

首先，将from_tensor映射到一个”query” tensor，并把to_tensor映射成”key” tensors和”value” tensors。这些是一个长度为num_attention_heads的list的tensors，每个tensor的shape是[batch_size, seq_length, size_per_head]。

然后，对query和key tensors进行dot-product，然后scale。这是通过softmax来获得attention probabilities。然后把value tensors通过这些probabilities进行interpolate(插值？。。)，再然后concate到一起形成一个single tensor并返回。

实践中，multi-head attention通过transpose和reshape，而非真正地将tensors进行separate。。

参数如下：

from_tensor：float Tensor，shape是[batch_size, from_seq_length, from_width]
to_tensor：float Tensor，shape是[batch_size, to_seq_length, to_width]
attention_mask：int32 Tensor，shape是[batch_size, from_seq_length, to_seq_length]，每个元素的值要是0/1。如果mask的值是0，那它对应的attention score会被设成-infinity，如果是mask的值是1，那么attention score不变。
num_attention_heads：attention heads的个数
size_per_head：每个attention head的size
query_act：query transform的激活函数
key_act：key transform的激活函数
value_act：value transform的激活函数
attention_probs_dropout_prob：attention probabilities的dropout rate
initializer_range：weight初始化的range
do_return_2d_tensor：是否返回2d tensor。具体取值和对应的返回shape如下所述
batch_size：如果输入是2D，这个参数是3D版本的from_tensor和to_tensor的batch_size
from_seq_length：如果输入是2D，这个参数是3D版本的from_tensor的seq_length
to_seq_length：如果输入是2D，这个参数是to_tensor的seq_length

返回值：

如果do_return_2d_tensor是true，那么返回一个shape是[batch_size, from_seq_length,num_attention_heads * size_per_head]的float Tensor
反之，返回一个shape是[batch_size * from_seq_length, num_attention_heads * size_per_head]的float Tensor。

def attention_layer(from_tensor,
                    to_tensor,
                    attention_mask=None,
                    num_attention_heads=1,
                    size_per_head=512,
                    query_act=None,
                    key_act=None,
                    value_act=None,
                    attention_probs_dropout_prob=0.0,
                    initializer_range=0.02,
                    do_return_2d_tensor=False,
                    batch_size=None,
                    from_seq_length=None,
                    to_seq_length=None):
  def transpose_for_scores(input_tensor, batch_size, num_attention_heads,
                           seq_length, width):
    output_tensor = tf.reshape(
        input_tensor, [batch_size, seq_length, num_attention_heads, width])

    output_tensor = tf.transpose(output_tensor, [0, 2, 1, 3])
    return output_tensor

  # from_tensor和to_tensor的shape要么是2([from_seq_length * seq_length, from_width])，要么是3([batch_size, seq_length, from_width]) -->详见reshape_to_matrix和reshape_from_matrix，，应该是这样吧2D的时候。。
  from_shape = get_shape_list(from_tensor, expected_rank=[2, 3])
  to_shape = get_shape_list(to_tensor, expected_rank=[2, 3])

  if len(from_shape) != len(to_shape):
    raise ValueError(
        "The rank of `from_tensor` must match the rank of `to_tensor`.")

  if len(from_shape) == 3:
    batch_size = from_shape[0]
    from_seq_length = from_shape[1]
    to_seq_length = to_shape[1]
  elif len(from_shape) == 2:
    if (batch_size is None or from_seq_length is None or to_seq_length is None):
      raise ValueError(
          "When passing in rank 2 tensors to attention_layer, the values "
          "for `batch_size`, `from_seq_length`, and `to_seq_length` "
          "must all be specified.")

  # Scalar dimensions referenced here:
  #   B = batch size (number of sequences)
  #   F = `from_tensor` sequence length
  #   T = `to_tensor` sequence length
  #   N = `num_attention_heads`
  #   H = `size_per_head`

  from_tensor_2d = reshape_to_matrix(from_tensor)
  to_tensor_2d = reshape_to_matrix(to_tensor)

  # `query_layer` = [B*F, N*H]
  query_layer = tf.layers.dense(
      from_tensor_2d,
      num_attention_heads * size_per_head,
      activation=query_act,
      name="query",
      kernel_initializer=create_initializer(initializer_range))

  # `key_layer` = [B*T, N*H]
  key_layer = tf.layers.dense(
      to_tensor_2d,
      num_attention_heads * size_per_head,
      activation=key_act,
      name="key",
      kernel_initializer=create_initializer(initializer_range))

  # `value_layer` = [B*T, N*H]
  value_layer = tf.layers.dense(
      to_tensor_2d,
      num_attention_heads * size_per_head,
      activation=value_act,
      name="value",
      kernel_initializer=create_initializer(initializer_range))

  # `query_layer` = [B, N, F, H]
  query_layer = transpose_for_scores(query_layer, batch_size,
                                     num_attention_heads, from_seq_length,
                                     size_per_head)

  # `key_layer` = [B, N, T, H]
  key_layer = transpose_for_scores(key_layer, batch_size, num_attention_heads,
                                   to_seq_length, size_per_head)

  # Take the dot product between "query" and "key" to get the raw
  # attention scores.
  # `attention_scores` = [B, N, F, T]
  attention_scores = tf.matmul(query_layer, key_layer, transpose_b=True)
  attention_scores = tf.multiply(attention_scores,
                                 1.0 / math.sqrt(float(size_per_head)))

  if attention_mask is not None:
    # `attention_mask` = [B, 1, F, T]
    attention_mask = tf.expand_dims(attention_mask, axis=[1])

    # Since attention_mask is 1.0 for positions we want to attend and 0.0 for
    # masked positions, this operation will create a tensor which is 0.0 for
    # positions we want to attend and -10000.0 for masked positions.
    adder = (1.0 - tf.cast(attention_mask, tf.float32)) * -10000.0

    # Since we are adding it to the raw scores before the softmax, this is
    # effectively the same as removing these entirely.
    attention_scores += adder

  # Normalize the attention scores to probabilities.
  # `attention_probs` = [B, N, F, T]
  attention_probs = tf.nn.softmax(attention_scores)

  # This is actually dropping out entire tokens to attend to, which might
  # seem a bit unusual, but is taken from the original Transformer paper.
  attention_probs = dropout(attention_probs, attention_probs_dropout_prob)

  # `value_layer` = [B, T, N, H]
  value_layer = tf.reshape(
      value_layer,
      [batch_size, to_seq_length, num_attention_heads, size_per_head])

  # `value_layer` = [B, N, T, H]
  value_layer = tf.transpose(value_layer, [0, 2, 1, 3])

  # `context_layer` = [B, N, F, H]
  context_layer = tf.matmul(attention_probs, value_layer)

  # `context_layer` = [B, F, N, H]
  context_layer = tf.transpose(context_layer, [0, 2, 1, 3])

  if do_return_2d_tensor:
    # `context_layer` = [B*F, N*V]
    context_layer = tf.reshape(
        context_layer,
        [batch_size * from_seq_length, num_attention_heads * size_per_head])
  else:
    # `context_layer` = [B, F, N*V]
    context_layer = tf.reshape(
        context_layer,
        [batch_size, from_seq_length, num_attention_heads * size_per_head])

  return context_layer

transformer-model

最后一个隐层的shape是[batch_size, seq_length, hidden_size]。

参数：

input_tensor：shape为[batch_size, seq_length, hidden_size]的float Tensor
attention_mask：shape为[batch_size, seq_length, seq_length]的int32 Tensor（实际上是float??）。1表示可以被attended to的positions，0表示不能
hidden_size：Transformer的hidden size
num_hidden_layers：Transformer中的layers (blocks)个数
num_attention_heads：Transformer中的attention heads数
intermediate_size：”intermediate”层(例如feed-forward)的size
intermediate_act_fn：”intermediate”层输出的激活函数
hidden_dropout_prob：隐层的dropout rate
attention_probs_dropout_prob：attention probabilities的dropout rate
initializer_range：初始化权重的range
do_return_all_layers：返回所有层或者只返回最后一层

def transformer_model(input_tensor,
                      attention_mask=None,
                      hidden_size=768,
                      num_hidden_layers=12,
                      num_attention_heads=12,
                      intermediate_size=3072,
                      intermediate_act_fn=gelu,
                      hidden_dropout_prob=0.1,
                      attention_probs_dropout_prob=0.1,
                      initializer_range=0.02,
                      do_return_all_layers=False):
  ## 首先保证hidden_size能被num_attention_heads整除，因为后面要hidden_size / num_attention_heads
  if hidden_size % num_attention_heads != 0:
    raise ValueError(
        "The hidden size (%d) is not a multiple of the number of attention "
        "heads (%d)" % (hidden_size, num_attention_heads))

  attention_head_size = int(hidden_size / num_attention_heads)
  ## 输入的shape是[batch_size, seq_length, hidden_size]
  input_shape = get_shape_list(input_tensor, expected_rank=3)
  batch_size = input_shape[0]
  seq_length = input_shape[1]
  input_width = input_shape[2]

  # The Transformer performs sum residuals on all layers so the input needs
  # to be the same as the hidden size.
  if input_width != hidden_size:
    raise ValueError("The width of the input tensor (%d) != hidden size (%d)" %
                     (input_width, hidden_size))

  # We keep the representation as a 2D tensor to avoid re-shaping it back and
  # forth from a 3D tensor to a 2D tensor. Re-shapes are normally free on
  # the GPU/CPU but may not be free on the TPU, so we want to minimize them to
  # help the optimizer.
  prev_output = reshape_to_matrix(input_tensor)

  all_layer_outputs = []
  for layer_idx in range(num_hidden_layers):
    with tf.variable_scope("layer_%d" % layer_idx):
      layer_input = prev_output

      with tf.variable_scope("attention"):
        attention_heads = []
        with tf.variable_scope("self"):
          attention_head = attention_layer(
              from_tensor=layer_input,
              to_tensor=layer_input,
              attention_mask=attention_mask,
              num_attention_heads=num_attention_heads,
              size_per_head=attention_head_size,
              attention_probs_dropout_prob=attention_probs_dropout_prob,
              initializer_range=initializer_range,
              do_return_2d_tensor=True,
              batch_size=batch_size,
              from_seq_length=seq_length,
              to_seq_length=seq_length)
          attention_heads.append(attention_head)

        attention_output = None
        if len(attention_heads) == 1:
          attention_output = attention_heads[0]
        else:
          # In the case where we have other sequences, we just concatenate
          # them to the self-attention head before the projection.
          attention_output = tf.concat(attention_heads, axis=-1)

        # Run a linear projection of `hidden_size` then add a residual
        # with `layer_input`.
        with tf.variable_scope("output"):
          attention_output = tf.layers.dense(
              attention_output,
              hidden_size,
              kernel_initializer=create_initializer(initializer_range))
          attention_output = dropout(attention_output, hidden_dropout_prob)
          attention_output = layer_norm(attention_output + layer_input)

      # The activation is only applied to the "intermediate" hidden layer.
      with tf.variable_scope("intermediate"):
        intermediate_output = tf.layers.dense(
            attention_output,
            intermediate_size,
            activation=intermediate_act_fn,
            kernel_initializer=create_initializer(initializer_range))

      # Down-project back to `hidden_size` then add the residual.
      with tf.variable_scope("output"):
        layer_output = tf.layers.dense(
            intermediate_output,
            hidden_size,
            kernel_initializer=create_initializer(initializer_range))
        layer_output = dropout(layer_output, hidden_dropout_prob)
        layer_output = layer_norm(layer_output + attention_output)
        prev_output = layer_output
        all_layer_outputs.append(layer_output)

  if do_return_all_layers:
    final_outputs = []
    for layer_output in all_layer_outputs:
      ## 将输出reshape成和input_shape一样的shape，即[batch_size, seq_length, hidden_size]
      final_output = reshape_from_matrix(layer_output, input_shape)
      final_outputs.append(final_output)
    return final_outputs
  else:
    ## 将输出reshape成和input_shape一样的shape，即[batch_size, seq_length, hidden_size]
    final_output = reshape_from_matrix(prev_output, input_shape)
    return final_output

BertConfig

BertConfig初始化

class BertConfig(object):
  """Configuration for `BertModel`."""

  def __init__(self,
               vocab_size,
               hidden_size=768,
               num_hidden_layers=12,
               num_attention_heads=12,
               intermediate_size=3072,
               hidden_act="gelu",
               hidden_dropout_prob=0.1,
               attention_probs_dropout_prob=0.1,
               max_position_embeddings=512,
               type_vocab_size=16,
               initializer_range=0.02):
    self.vocab_size = vocab_size
    self.hidden_size = hidden_size
    self.num_hidden_layers = num_hidden_layers
    self.num_attention_heads = num_attention_heads
    self.hidden_act = hidden_act
    self.intermediate_size = intermediate_size
    self.hidden_dropout_prob = hidden_dropout_prob
    self.attention_probs_dropout_prob = attention_probs_dropout_prob
    self.max_position_embeddings = max_position_embeddings
    self.type_vocab_size = type_vocab_size
    self.initializer_range = initializer_range

参数如下：

vocab_size：inputs_ids的vocabulary size
hidden_size：encoder layers和pooler layer的size
num_hidden_layers：Transformer encoder的hidden layer数
num_attention_heads：Transformer encoder的每个attention layer的attention heads数
intermediate_size：Transformer encoder的”intermediate” layer(例如feed-forward)的size
hidden_act：encoder and pooler的激活函数
hidden_dropout_prob：embeddings, encoder, 和pooler的所有全连接的dropout rate
attention_probs_dropout_prob：attention probabilities的dropout rate
max_position_embeddings：最大的sequence长度，通常设得比较大（512 or 1024 or 2048）
type_vocab_size：token_type_ids的vocabulary size
initializer_range：所有权重矩阵的truncated_normal_initializer的stdev

BertConfig方法

classmethod

注：classmethod修饰符对应的函数不需要实例化，不需要self参数，但第一个参数需要是表示自身类的cls参数，可以来调用类的属性，类的方法，实例化对象等。

例如：

class A(object):
    bar = 1
    def func1(self):  
        print ('foo') 
    @classmethod
    def func2(cls):
        print ('func2')
        print (cls.bar)
        cls().func1()   # 调用 foo 方法
 
A.func2()               # 不需要实例化

__dict__变量

实例的__dict__仅存储与该实例相关的实例属性，

>>> x = BertConfig(vocab_size=None)
>>> print x.__dict__
{'type_vocab_size': 16, 'vocab_size': None, 'num_attention_heads': 12, 'num_hidden_layers': 12, 'attention_probs_dropout_prob': 0.1, 'max_position_embeddings': 512, 'initializer_range': 0.02, 'hidden_act': 'gelu', 'hidden_size': 768, 'intermediate_size': 3072, 'hidden_dropout_prob': 0.1}

类的__dict__存储所有实例共享的变量和函数(类属性，方法等)，类的__dict__并不包含其父类的属性。

class A(object):
    def __init__(self, a):
        self.a = a
    def func1(self, xx):
        self.xx = xx

    @classmethod
    def func2(cls, mm):
        return mm

ccc = A(a=3)
print ccc.__dict__
print A.__dict__

# 输出

{'a': 3}
{'func2': <classmethod object at 0x100812478>, '__module__': '__main__', 'func1': <function func1 at 0x1007fc758>, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None, '__init__': <function __init__ at 0x1007fc140>}

看看BertConfig的方法们：

from-dict(classmethod)

  @classmethod
  def from_dict(cls, json_object):
    """Constructs a `BertConfig` from a Python dictionary of parameters."""
    config = BertConfig(vocab_size=None)
    for (key, value) in six.iteritems(json_object):
      config.__dict__[key] = value
    return config

其中的six.iteritems函数如下：

    def iteritems(d, **kw):
        return iter(d.items(**kw))

使用如下：

>>> a={"a":3, "b":9}
>>> for i in six.iteritems(a):
...     print i
...
('a', 3)
('b', 9)

from-json-file(classmethod)

  @classmethod
  def from_json_file(cls, json_file):
    """Constructs a `BertConfig` from a json file of parameters."""
    with tf.gfile.GFile(json_file, "r") as reader:
      text = reader.read()
    return cls.from_dict(json.loads(text))

to-dict

关于deepcopy，参考https://daiwk.github.io/posts/knowledge-python.html#copy-deepcopy

  def to_dict(self):
    """Serializes this instance to a Python dictionary."""
    output = copy.deepcopy(self.__dict__)
    return output

to-json-string

  def to_json_string(self):
    """Serializes this instance to a JSON string."""
    return json.dumps(self.to_dict(), indent=2, sort_keys=True) + "\n"

BertModel

初始化

class BertModel(object):
  def __init__(self,
               config,
               is_training,
               input_ids,
               input_mask=None,
               token_type_ids=None,
               use_one_hot_embeddings=True,
               scope=None):

参数如下：

config：BertConfiginstance.
is_training：true: training model；false：eval model。用于控制是否dropout。
input_ids：shape是[batch_size, seq_length]的int32 Tensor。
input_mask：shape是[batch_size, seq_length]的int32 Tensor。
token_type_ids：shape是[batch_size, seq_length]的int32 Tensor。
use_one_hot_embeddings：使用one-hot embedding，还是tf.embedding_lookup()。TPU上设成True会更快，cpu/gpu上设成False更快。
scope：variable scope，默认是bert。

实现分成以下几步：

首先是input_mask/token_type_ids/batch_size/seq_length的确定：

    config = copy.deepcopy(config)
    if not is_training:
      config.hidden_dropout_prob = 0.0
      config.attention_probs_dropout_prob = 0.0
    # 期望input_ids的shape是两维，即[batch_size, seq_length]
    input_shape = get_shape_list(input_ids, expected_rank=2)
    batch_size = input_shape[0]
    seq_length = input_shape[1]

    if input_mask is None:
      ## 默认input_mask全是1
      input_mask = tf.ones(shape=[batch_size, seq_length], dtype=tf.int32)

    if token_type_ids is None:
      ## 默认token_type_ids全是0
      token_type_ids = tf.zeros(shape=[batch_size, seq_length], dtype=tf.int32)

然后确定网络结构：

    with tf.variable_scope("bert", scope):
      with tf.variable_scope("embeddings"):
        # 对输入的word ids进行emb
        (self.embedding_output, self.embedding_table) = embedding_lookup(
            input_ids=input_ids,
            vocab_size=config.vocab_size,
            embedding_size=config.hidden_size,
            initializer_range=config.initializer_range,
            word_embedding_name="word_embeddings",
            use_one_hot_embeddings=use_one_hot_embeddings)
        # 对wordid的emb结果，加上type embed和position emb，然后normalize并dropout输出
        self.embedding_output = embedding_postprocessor(
            input_tensor=self.embedding_output,
            use_token_type=True,
            token_type_ids=token_type_ids,
            token_type_vocab_size=config.type_vocab_size,
            token_type_embedding_name="token_type_embeddings",
            use_position_embeddings=True,
            position_embedding_name="position_embeddings",
            initializer_range=config.initializer_range,
            max_position_embeddings=config.max_position_embeddings,
            dropout_prob=config.hidden_dropout_prob)

      with tf.variable_scope("encoder"):
        # 将shape是[batch_size, seq_length]的input_ids和
        # shape是[batch_size, seq_length]的input_mask转成
        # shape是[batch_size, seq_length, seq_length]的3D mask，给attention scores用
        attention_mask = create_attention_mask_from_input_mask(
            input_ids, input_mask)

        # Run the stacked transformer.
        # `sequence_output` shape = [batch_size, seq_length, hidden_size].
        self.all_encoder_layers = transformer_model(
            input_tensor=self.embedding_output,
            attention_mask=attention_mask,
            hidden_size=config.hidden_size,
            num_hidden_layers=config.num_hidden_layers,
            num_attention_heads=config.num_attention_heads,
            intermediate_size=config.intermediate_size,
            intermediate_act_fn=get_activation(config.hidden_act),
            hidden_dropout_prob=config.hidden_dropout_prob,
            attention_probs_dropout_prob=config.attention_probs_dropout_prob,
            initializer_range=config.initializer_range,
            do_return_all_layers=True)

      # sequence_output只取all_encoder_layers的最后一个元素，shape是[batch_size, seq_length, hidden_size]
      self.sequence_output = self.all_encoder_layers[-1]
      # 对于segment-level或者segment-pair-level的分类任务，我们需要对segment的一个
      # fixed dimensional representation，所以需要这么一个"pool"操作，
      # 把shape是[batch_size, seq_length, hidden_size]的tensor变成
      # shape是[batch_size, hidden_size]的输出
      with tf.variable_scope("pooler"):
        # We "pool" the model by simply taking the hidden state corresponding
        # to the first token. We assume that this has been pre-trained
        # 假设已经pretrained:
        # 只拿出batchsize个序列的每个序列的第一个token的向量(下面的[:,0:1,:])出来
        # 从[batch_size, seq_length, hidden_size]变成了[batch_size, hidden_size]
        first_token_tensor = tf.squeeze(self.sequence_output[:, 0:1, :], axis=1)
        # 接一个size是hidden_size的fc，输出的shape还是[batch_size, hidden_size]
        self.pooled_output = tf.layers.dense(
            first_token_tensor,
            config.hidden_size,
            activation=tf.tanh,
            kernel_initializer=create_initializer(config.initializer_range))

get-pooled-output

返回pooled_output

  def get_pooled_output(self):
    return self.pooled_output

get-sequence-output

返回encoder的最后一个隐层

  def get_sequence_output(self):
    """Gets final hidden layer of encoder.

    Returns:
      float Tensor of shape [batch_size, seq_length, hidden_size] corresponding
      to the final hidden of the transformer encoder.
    """
    return self.sequence_output

get-all-encoder-layers

返回all_encoder_layers

  def get_all_encoder_layers(self):
    return self.all_encoder_layers

get-embedding-output

返回embedding_output，shape是[batch_size, seq_length, hidden_size]，是加好了positional embeddings和token type embeddings，然后过了layer norm的结果，即transformer的input。

  def get_embedding_output(self):
    """Gets output of the embedding lookup (i.e., input to the transformer).

    Returns:
      float Tensor of shape [batch_size, seq_length, hidden_size] corresponding
      to the output of the embedding layer, after summing the word
      embeddings with the positional embeddings and the token type embeddings,
      then performing layer normalization. This is the input to the transformer.
    """
    return self.embedding_output

get-embedding-table

返回embedding_table

  def get_embedding_table(self):
    return self.embedding_table

optimization.py

tokenization.py

常用函数

convert-to-unicode

从utf8转成unicode

def convert_to_unicode(text):
  """Converts `text` to Unicode (if it's not already), assuming utf-8 input."""
  if six.PY3:
    if isinstance(text, str):
      return text
    elif isinstance(text, bytes):
      return text.decode("utf-8", "ignore")
    else:
      raise ValueError("Unsupported string type: %s" % (type(text)))
  elif six.PY2:
    if isinstance(text, str):
      return text.decode("utf-8", "ignore")
    elif isinstance(text, unicode):
      return text
    else:
      raise ValueError("Unsupported string type: %s" % (type(text)))
  else:
    raise ValueError("Not running on Python2 or Python 3?")

printable-text

将输入变成tf.logging可以打印的类型：

如果是python3，那就是str或者unicode
如果是python2，那就是str或者utf8

def printable_text(text):
  """Returns text encoded in a way suitable for print or `tf.logging`."""

  # These functions want `str` for both Python2 and Python3, but in one case
  # it's a Unicode string and in the other it's a byte string.
  if six.PY3:
    if isinstance(text, str):
      return text
    elif isinstance(text, bytes):
      return text.decode("utf-8", "ignore")
    else:
      raise ValueError("Unsupported string type: %s" % (type(text)))
  elif six.PY2:
    if isinstance(text, str):
      return text
    elif isinstance(text, unicode):
      return text.encode("utf-8")
    else:
      raise ValueError("Unsupported string type: %s" % (type(text)))
  else:
    raise ValueError("Not running on Python2 or Python 3?")

load-vocab

加载vocab，每行是一词，转成unicode，行号是词的id

def load_vocab(vocab_file):
  """Loads a vocabulary file into a dictionary."""
  vocab = collections.OrderedDict()
  index = 0
  with tf.gfile.GFile(vocab_file, "r") as reader:
    while True:
      token = convert_to_unicode(reader.readline())
      if not token:
        break
      token = token.strip()
      vocab[token] = index
      index += 1
  return vocab

xxx

小结

embedding部分

transformer部分

pool部分

bert代码解读——application

2018-11-01T00:00:00+00:00

basics
- TPUEstimator
  - train
  - predict
  - evaluate
extract-features
- extract-features.py
pretrain
- create-pretraining-data.py
- run-pretraining.py
classification
- run-classifier.py
squad
- run-squad.py
可视化分析

basics

TPUEstimator

类的定义在site-packages/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py中

train

在tensorflow/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py文件中（如果装的是cpu/gpu版的，好像没这个函数）：

  def train(self,
            input_fn,
            hooks=None,
            steps=None,
            max_steps=None,
            saving_listeners=None):
    rendezvous = error_handling.ErrorRendezvous(num_sources=3)
    self._rendezvous[model_fn_lib.ModeKeys.TRAIN] = rendezvous
    try:
      return super(TPUEstimator, self).train(
          input_fn=input_fn, hooks=hooks, steps=steps, max_steps=max_steps,
          saving_listeners=saving_listeners
      )
    except Exception:  # pylint: disable=broad-except
      rendezvous.record_error('training_loop', sys.exc_info())
    finally:
      rendezvous.record_done('training_loop')
      rendezvous.raise_errors()

predict

在tensorflow/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py文件中（如果装的是cpu/gpu版的，好像没这个函数）：

  def predict(self,
              input_fn,
              predict_keys=None,
              hooks=None,
              checkpoint_path=None,
              yield_single_examples=True):
    rendezvous = error_handling.ErrorRendezvous(num_sources=3)
    self._rendezvous[model_fn_lib.ModeKeys.PREDICT] = rendezvous
    try:
      for result in super(TPUEstimator, self).predict(
          input_fn=input_fn,
          predict_keys=predict_keys,
          hooks=hooks,
          checkpoint_path=checkpoint_path,
          yield_single_examples=yield_single_examples):
        yield result
    except Exception:  # pylint: disable=broad-except
      rendezvous.record_error('prediction_loop', sys.exc_info())
    finally:
      rendezvous.record_done('prediction_loop')
      rendezvous.raise_errors()

    rendezvous.record_done('prediction_loop')
    rendezvous.raise_errors()

evaluate

看tf的源码，在tensorflow/tensorflow/contrib/tpu/python/tpu/tpu_estimator.py文件中（如果装的是cpu/gpu版的，好像没这个函数）：

  def evaluate(self, input_fn, steps=None, hooks=None, checkpoint_path=None,
               name=None):
    rendezvous = error_handling.ErrorRendezvous(num_sources=3)
    self._rendezvous[model_fn_lib.ModeKeys.EVAL] = rendezvous
    try:
      return super(TPUEstimator, self).evaluate(
          input_fn, steps=steps, hooks=hooks, checkpoint_path=checkpoint_path,
          name=name
      )
    except Exception:  # pylint: disable=broad-except
      rendezvous.record_error('evaluation_loop', sys.exc_info())
    finally:
      rendezvous.record_done('evaluation_loop')
      rendezvous.raise_errors()

extract-features

extract-features.py

InputExample

class InputExample(object):

  def __init__(self, unique_id, text_a, text_b):
    self.unique_id = unique_id
    self.text_a = text_a
    self.text_b = text_b

InputFeatures

class InputFeatures(object):
  """A single set of features of data."""

  def __init__(self, unique_id, tokens, input_ids, input_mask, input_type_ids):
    self.unique_id = unique_id
    self.tokens = tokens
    self.input_ids = input_ids
    self.input_mask = input_mask
    self.input_type_ids = input_type_ids

truncate-seq-pair(extract-feature中)

def _truncate_seq_pair(tokens_a, tokens_b, max_length):
  """Truncates a sequence pair in place to the maximum length."""
  # 保证tokens_a+tokens_b的总长度小于等于max_length
  # 如果不满足，把比较长的那个list的最后一个元素删了，然后循环，直到满足为止
  # 当一个句子很短时，这样做与对每个句子删掉相同比例的token要更make sense，
  # 因为短句子中的token信息量应该会比长句子更大
  while True:
    total_length = len(tokens_a) + len(tokens_b)
    if total_length <= max_length:
      break
    if len(tokens_a) > len(tokens_b):
      tokens_a.pop() # 把tokens_a的最后一个元素删了
    else:
      tokens_b.pop() # 把tokens_b的最后一个元素删了

read-examples

def read_examples(input_file):
  """Read a list of `InputExample`s from an input file."""
  examples = []
  unique_id = 0
  with tf.gfile.GFile(input_file, "r") as reader:
    while True:
      # 将每行转成unicode
      line = tokenization.convert_to_unicode(reader.readline())
      if not line:
        break
      line = line.strip()
      text_a = None
      text_b = None
      # 以『|||』进行分隔，前面是句子A，后面是句子B
      m = re.match(r"^(.*) \|\|\| (.*)$", line)
      if m is None:
        text_a = line
      else:
        text_a = m.group(1)
        text_b = m.group(2)
      # 使用InputExample类封装一下
      examples.append( 
          InputExample(unique_id=unique_id, text_a=text_a, text_b=text_b))
      unique_id += 1
  return examples

convert-examples-to-features

def convert_examples_to_features(examples, seq_length, tokenizer):
  """Loads a data file into a list of `InputFeatures`s."""

  features = []
  for (ex_index, example) in enumerate(examples):
    # 对句子a进行分词
    tokens_a = tokenizer.tokenize(example.text_a)

    tokens_b = None
    # 对句子b进行分词
    if example.text_b:
      tokens_b = tokenizer.tokenize(example.text_b)

    if tokens_b:
      # 对tokens_a和tokens_b进行裁剪，保证总长度不大于seq_length - 3
      # -3是因为有[CLS], [SEP], [SEP]
      _truncate_seq_pair(tokens_a, tokens_b, seq_length - 3)
    else:
      # -2是因为没有tokens_b的时候，只有[CLS], [SEP]
      if len(tokens_a) > seq_length - 2:
        tokens_a = tokens_a[0:(seq_length - 2)]

    # The convention in BERT is:
    # (a) For sequence pairs:
    #  tokens:   [CLS] is this jack ##son ##ville ? [SEP] no it is not . [SEP]
    #  type_ids: 0     0  0    0    0     0       0 0     1  1  1  1   1 1
    # (b) For single sequences:
    #  tokens:   [CLS] the dog is hairy . [SEP]
    #  type_ids: 0     0   0   0  0     0 0
    # 其中，"type_ids"表示是第一句(0)还是第二句(1)
    #
    # 对于classification tasks, [CLS]的向量可以被当做是"sentence vector". 当然，只有当整个model已经fine-tuned的时候，这才make sense
    tokens = []
    input_type_ids = []
    tokens.append("[CLS]")
    input_type_ids.append(0)
    for token in tokens_a:
      tokens.append(token)
      input_type_ids.append(0)
    tokens.append("[SEP]")
    input_type_ids.append(0)

    if tokens_b:
      for token in tokens_b:
        tokens.append(token)
        input_type_ids.append(1)
      tokens.append("[SEP]")
      input_type_ids.append(1)
    # 将token转成id（在tokenizer中，读vocab文件，行号就是其id，所以不能简单地增量训）
    input_ids = tokenizer.convert_tokens_to_ids(tokens)

    # 因为seq_len可能比实际输入的序列长，所以需要padding
    # 实际输入的mask是1
    input_mask = [1] * len(input_ids)

    # 比实际输入长，到seq_length的部分，用0进行padding，mask也写成0
    # 注意，vocab文件中，第0行，也就是第0个token，是[PAD]，专门用来padding的
    while len(input_ids) < seq_length:
      input_ids.append(0)
      input_mask.append(0)
      input_type_ids.append(0)

    assert len(input_ids) == seq_length
    assert len(input_mask) == seq_length
    assert len(input_type_ids) == seq_length

    if ex_index < 5: # ex_index是第几个输入example，只有前5个example打这个日志
      tf.logging.info("*** Example ***")
      tf.logging.info("unique_id: %s" % (example.unique_id))
      tf.logging.info("tokens: %s" % " ".join(
          [tokenization.printable_text(x) for x in tokens]))
      tf.logging.info("input_ids: %s" % " ".join([str(x) for x in input_ids]))
      tf.logging.info("input_mask: %s" % " ".join([str(x) for x in input_mask]))
      tf.logging.info(
          "input_type_ids: %s" % " ".join([str(x) for x in input_type_ids]))

    features.append(
        InputFeatures(
            unique_id=example.unique_id,
            tokens=tokens,
            input_ids=input_ids,
            input_mask=input_mask,
            input_type_ids=input_type_ids))
  return features

input-fn-builder

def input_fn_builder(features, seq_length):
  """Creates an `input_fn` closure to be passed to TPUEstimator."""

  all_unique_ids = []
  all_input_ids = []
  all_input_mask = []
  all_input_type_ids = []

  for feature in features:
    all_unique_ids.append(feature.unique_id)
    all_input_ids.append(feature.input_ids)
    all_input_mask.append(feature.input_mask)
    all_input_type_ids.append(feature.input_type_ids)

  def input_fn(params):
    """The actual input function."""
    batch_size = params["batch_size"]

    num_examples = len(features)

    # This is for demo purposes and does NOT scale to large data sets. We do
    # not use Dataset.from_generator() because that uses tf.py_func which is
    # not TPU compatible. The right way to load data is with TFRecordReader.
    d = tf.data.Dataset.from_tensor_slices({
        "unique_ids":
            tf.constant(all_unique_ids, shape=[num_examples], dtype=tf.int32),
        "input_ids":
            tf.constant(
                all_input_ids, shape=[num_examples, seq_length],
                dtype=tf.int32),
        "input_mask":
            tf.constant(
                all_input_mask,
                shape=[num_examples, seq_length],
                dtype=tf.int32),
        "input_type_ids":
            tf.constant(
                all_input_type_ids,
                shape=[num_examples, seq_length],
                dtype=tf.int32),
    })

    d = d.batch(batch_size=batch_size, drop_remainder=False)
    return d

  return input_fn

model-fn-builder

def model_fn_builder(bert_config, init_checkpoint, layer_indexes, use_tpu,
                     use_one_hot_embeddings):
  """Returns `model_fn` closure for TPUEstimator."""

  def model_fn(features, labels, mode, params):  # pylint: disable=unused-argument
    """The `model_fn` for TPUEstimator."""

    # 这里的features是input_fn_builder的输出，格式如上
    unique_ids = features["unique_ids"]
    input_ids = features["input_ids"]
    input_mask = features["input_mask"]
    input_type_ids = features["input_type_ids"]

    model = modeling.BertModel(
        config=bert_config,
        is_training=False,
        input_ids=input_ids,
        input_mask=input_mask,
        token_type_ids=input_type_ids,
        use_one_hot_embeddings=use_one_hot_embeddings)

    if mode != tf.estimator.ModeKeys.PREDICT:
      raise ValueError("Only PREDICT modes are supported: %s" % (mode))

    tvars = tf.trainable_variables()
    scaffold_fn = None

    # initialized_variable_names: 有哪些变量在checkpoint中已经初始化了
    (assignment_map,
     initialized_variable_names) = modeling.get_assignment_map_from_checkpoint(
         tvars, init_checkpoint)
    if use_tpu:

      def tpu_scaffold():
        tf.train.init_from_checkpoint(init_checkpoint, assignment_map)
        return tf.train.Scaffold()

      scaffold_fn = tpu_scaffold
    else:
      tf.train.init_from_checkpoint(init_checkpoint, assignment_map)

    tf.logging.info("**** Trainable Variables ****")
    for var in tvars:
      init_string = ""
      if var.name in initialized_variable_names:
        # 这些变量在checkpoint中已经init了
        init_string = ", *INIT_FROM_CKPT*"
      tf.logging.info("  name = %s, shape = %s%s", var.name, var.shape,
                      init_string)

    # 是一个list，每个元素的shape是[batch_size, seq_length, hidden_size]
    all_layers = model.get_all_encoder_layers()

    predictions = {
        "unique_id": unique_ids,
    }

    ## 对于需要输出的indexes，从all_layers里取出来
    for (i, layer_index) in enumerate(layer_indexes):
      predictions["layer_output_%d" % i] = all_layers[layer_index]

    output_spec = tf.contrib.tpu.TPUEstimatorSpec(
        mode=mode, predictions=predictions, scaffold_fn=scaffold_fn)
    return output_spec

  return model_fn

main

首先，定义如下几个变量：

  tf.logging.set_verbosity(tf.logging.INFO)
  # 期望输出的layer_index们，例如: -1,-2,-3
  layer_indexes = [int(x) for x in FLAGS.layers.split(",")]

  bert_config = modeling.BertConfig.from_json_file(FLAGS.bert_config_file)
  # 切词类
  tokenizer = tokenization.FullTokenizer(
      vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)

  is_per_host = tf.contrib.tpu.InputPipelineConfig.PER_HOST_V2
  # tpu run_config
  run_config = tf.contrib.tpu.RunConfig(
      master=FLAGS.master,
      tpu_config=tf.contrib.tpu.TPUConfig(
          num_shards=FLAGS.num_tpu_cores,
          per_host_input_for_training=is_per_host))

然后

  # 读文件
  examples = read_examples(FLAGS.input_file)
  # 切词，并保证句子a+句子b再加上padding和[CLS]/[SEP]等的总长度不大于max_seq_length
  # 把unique_id/oken/input_ids/mask/input_type_ids存在features中
  features = convert_examples_to_features(
      examples=examples, seq_length=FLAGS.max_seq_length, tokenizer=tokenizer)
  # unique_id就是输入样本的行号，把每行对应的具体feature存到dict里
  unique_id_to_feature = {}
  for feature in features:
    unique_id_to_feature[feature.unique_id] = feature

然后

  model_fn = model_fn_builder(
      bert_config=bert_config,
      init_checkpoint=FLAGS.init_checkpoint,
      layer_indexes=layer_indexes,
      use_tpu=FLAGS.use_tpu,
      use_one_hot_embeddings=FLAGS.use_one_hot_embeddings)

  # If TPU is not available, this will fall back to normal Estimator on CPU
  # or GPU.
  estimator = tf.contrib.tpu.TPUEstimator(
      use_tpu=FLAGS.use_tpu,
      model_fn=model_fn,
      config=run_config,
      predict_batch_size=FLAGS.batch_size)

  input_fn = input_fn_builder(
      features=features, seq_length=FLAGS.max_seq_length)

然后

  with codecs.getwriter("utf-8")(tf.gfile.Open(FLAGS.output_file,
                                               "w")) as writer:
    # yield_single_examples参数是True时，会把一个batch的结果拆成batch条结果。
    # 如果是False，不分解，当结果的第一维不是batch_size时要这么用~
    for result in estimator.predict(input_fn, yield_single_examples=True):
      unique_id = int(result["unique_id"])
      feature = unique_id_to_feature[unique_id]
      output_json = collections.OrderedDict()
      output_json["linex_index"] = unique_id # 第几个样本
      all_features = []
      for (i, token) in enumerate(feature.tokens):
        all_layers = []
        for (j, layer_index) in enumerate(layer_indexes):
          layer_output = result["layer_output_%d" % j]
          layers = collections.OrderedDict()
          layers["index"] = layer_index
          layers["values"] = [
              round(float(x), 6) for x in layer_output[i:(i + 1)].flat
          ]
          all_layers.append(layers)
        features = collections.OrderedDict()
        features["token"] = token
        features["layers"] = all_layers
        all_features.append(features)
      output_json["features"] = all_features
      writer.write(json.dumps(output_json) + "\n")

pretrain

create-pretraining-data.py

将输入文件转换成tfrecords格式

工具函数与类

TrainingInstance

有以下几个成员变量：

tokens
segment_ids
is_random_next
masked_lm_positions
masked_lm_labels

class TrainingInstance(object):
  """A single training instance (sentence pair)."""

  def __init__(self, tokens, segment_ids, masked_lm_positions, masked_lm_labels,
               is_random_next):
    self.tokens = tokens
    self.segment_ids = segment_ids
    self.is_random_next = is_random_next
    self.masked_lm_positions = masked_lm_positions
    self.masked_lm_labels = masked_lm_labels

  def __str__(self):
    s = ""
    s += "tokens: %s\n" % (" ".join(
        [tokenization.printable_text(x) for x in self.tokens]))
    s += "segment_ids: %s\n" % (" ".join([str(x) for x in self.segment_ids]))
    s += "is_random_next: %s\n" % self.is_random_next
    s += "masked_lm_positions: %s\n" % (" ".join(
        [str(x) for x in self.masked_lm_positions]))
    s += "masked_lm_labels: %s\n" % (" ".join(
        [tokenization.printable_text(x) for x in self.masked_lm_labels]))
    s += "\n"
    return s

  def __repr__(self):
    return self.__str__()

create-int-feature

生成int特征

def create_int_feature(values):
  feature = tf.train.Feature(int64_list=tf.train.Int64List(value=list(values)))
  return feature

create-float-feature

生成float特征

def create_float_feature(values):
  feature = tf.train.Feature(float_list=tf.train.FloatList(value=list(values)))
  return feature

write-instance-to-example-files

将结果落盘

def write_instance_to_example_files(instances, tokenizer, max_seq_length,
                                    max_predictions_per_seq, output_files):
  """Create TF example files from `TrainingInstance`s."""
  writers = []
  for output_file in output_files:
    writers.append(tf.python_io.TFRecordWriter(output_file))

  writer_index = 0

  total_written = 0
  for (inst_index, instance) in enumerate(instances):
    # 使用convert_tokens_to_ids将tokens转换为对应的input_ids
    input_ids = tokenizer.convert_tokens_to_ids(instance.tokens)
    input_mask = [1] * len(input_ids)
    segment_ids = list(instance.segment_ids)
    assert len(input_ids) <= max_seq_length

    while len(input_ids) < max_seq_length:
      input_ids.append(0)
      input_mask.append(0)
      segment_ids.append(0)

    assert len(input_ids) == max_seq_length
    assert len(input_mask) == max_seq_length
    assert len(segment_ids) == max_seq_length

    masked_lm_positions = list(instance.masked_lm_positions)
    masked_lm_ids = tokenizer.convert_tokens_to_ids(instance.masked_lm_labels)
    masked_lm_weights = [1.0] * len(masked_lm_ids)

    while len(masked_lm_positions) < max_predictions_per_seq:
      masked_lm_positions.append(0)
      masked_lm_ids.append(0)
      masked_lm_weights.append(0.0)

    next_sentence_label = 1 if instance.is_random_next else 0

    features = collections.OrderedDict()
    features["input_ids"] = create_int_feature(input_ids)
    features["input_mask"] = create_int_feature(input_mask)
    features["segment_ids"] = create_int_feature(segment_ids)
    features["masked_lm_positions"] = create_int_feature(masked_lm_positions)
    features["masked_lm_ids"] = create_int_feature(masked_lm_ids)
    features["masked_lm_weights"] = create_float_feature(masked_lm_weights)
    features["next_sentence_labels"] = create_int_feature([next_sentence_label])

    tf_example = tf.train.Example(features=tf.train.Features(feature=features))

    writers[writer_index].write(tf_example.SerializeToString())
    writer_index = (writer_index + 1) % len(writers)

    total_written += 1

    if inst_index < 20:
      tf.logging.info("*** Example ***")
      tf.logging.info("tokens: %s" % " ".join(
          [tokenization.printable_text(x) for x in instance.tokens]))

      for feature_name in features.keys():
        feature = features[feature_name]
        values = []
        if feature.int64_list.value:
          values = feature.int64_list.value
        elif feature.float_list.value:
          values = feature.float_list.value
        tf.logging.info(
            "%s: %s" % (feature_name, " ".join([str(x) for x in values])))

  for writer in writers:
    writer.close()

  tf.logging.info("Wrote %d total instances", total_written)

main

首先建立tokenizer

  tokenizer = tokenization.FullTokenizer(
      vocab_file=FLAGS.vocab_file, do_lower_case=FLAGS.do_lower_case)

然后create_training_instances

  rng = random.Random(FLAGS.random_seed)
  instances = create_training_instances(
      input_files, tokenizer, FLAGS.max_seq_length, FLAGS.dupe_factor,
      FLAGS.short_seq_prob, FLAGS.masked_lm_prob, FLAGS.max_predictions_per_seq,
      rng)

然后把结果落盘：

  write_instance_to_example_files(instances, tokenizer, FLAGS.max_seq_length,
                                  FLAGS.max_predictions_per_seq, output_files)

create-training-instances

def create_training_instances(input_files, tokenizer, max_seq_length,
                              dupe_factor, short_seq_prob, masked_lm_prob,
                              max_predictions_per_seq, rng):
  """Create `TrainingInstance`s from raw text."""
  all_documents = [[]]

  # Input file format:
  # (1) One sentence per line. These should ideally be actual sentences, not
  # entire paragraphs or arbitrary spans of text. (Because we use the
  # sentence boundaries for the "next sentence prediction" task).
  # (2) Blank lines between documents. Document boundaries are needed so
  # that the "next sentence prediction" task doesn't span between documents.
  # (1) 一行一句话，最好就是一句完整的话，而不是一段话或者半句话（因为会使用句子边界来给next sentence prediction任务用）
  # (2) 文档间用空行隔开
  for input_file in input_files:
    with tf.gfile.GFile(input_file, "r") as reader:
      while True:
        line = tokenization.convert_to_unicode(reader.readline())
        if not line:
          break
        line = line.strip()

        # Empty lines are used as document delimiters
        # 空行被视为文档的分隔符
        if not line:
          all_documents.append([])
        tokens = tokenizer.tokenize(line)
        if tokens:
          all_documents[-1].append(tokens)

  # Remove empty documents
  all_documents = [x for x in all_documents if x]
  # 全部load到内存，所以如果有非常多的训练语料，建议在外面拆分成多个小文件，然后多进程调用这个函数。
  rng.shuffle(all_documents)

  vocab_words = list(tokenizer.vocab.keys())
  instances = []
  for _ in range(dupe_factor):
    for document_index in range(len(all_documents)):
      instances.extend(
          ## 调用这个函数生成一条ins
          create_instances_from_document(
              all_documents, document_index, max_seq_length, short_seq_prob,
              masked_lm_prob, max_predictions_per_seq, vocab_words, rng))

  rng.shuffle(instances)
  return instances

truncate-seq-pair(create-pretrain中)

def truncate_seq_pair(tokens_a, tokens_b, max_num_tokens, rng):
  """Truncates a pair of sequences to a maximum sequence length."""
  while True:
    total_length = len(tokens_a) + len(tokens_b)
    if total_length <= max_num_tokens:
      break
    ## a和b两个部分，每次对比较长的那个进行trunc，当两部分差不多长时，交替trunc，保证不要一直对一个部分去trunc。。
    trunc_tokens = tokens_a if len(tokens_a) > len(tokens_b) else tokens_b
    assert len(trunc_tokens) >= 1

    # We want to sometimes truncate from the front and sometimes from the
    # back to add more randomness and avoid biases.
    # 一半的概率扔掉头，一半概率扔掉尾
    if rng.random() < 0.5:
      del trunc_tokens[0]
    else:
      trunc_tokens.pop()

create-instances-from-document

def create_instances_from_document(
    all_documents, document_index, max_seq_length, short_seq_prob,
    masked_lm_prob, max_predictions_per_seq, vocab_words, rng):
  """Creates `TrainingInstance`s for a single document."""
  # 获取当前文档
  document = all_documents[document_index]

  # Account for [CLS], [SEP], [SEP]
  max_num_tokens = max_seq_length - 3

  # We *usually* want to fill up the entire sequence since we are padding
  # to `max_seq_length` anyways, so short sequences are generally wasted
  # computation. However, we *sometimes*
  # (i.e., short_seq_prob == 0.1 == 10% of the time) want to use shorter
  # sequences to minimize the mismatch between pre-training and fine-tuning.
  # The `target_seq_length` is just a rough target however, whereas
  # `max_seq_length` is a hard limit.
  # 有一定的比例，如10%的概率，我们使用比较短的序列长度，以缓解预训练的长序列和finetune阶段（可能的）短序列的不一致情况
  target_seq_length = max_num_tokens
  if rng.random() < short_seq_prob:
    target_seq_length = rng.randint(2, max_num_tokens)

  # We DON'T just concatenate all of the tokens from a document into a long
  # sequence and choose an arbitrary split point because this would make the
  # next sentence prediction task too easy. Instead, we split the input into
  # segments "A" and "B" based on the actual "sentences" provided by the user
  # input.
  # A和B都使用完整的句子，而非半句话
  instances = []
  current_chunk = []
  current_length = 0
  i = 0
  while i < len(document):
    segment = document[i] #获取当前的一句话，并扔到current_chunk里
    current_chunk.append(segment)
    current_length += len(segment) # curren_length是这些句子的总长度
    ## 要么遍历完文档了，要么句子总长度已经超过target_seq_length了（够一条样本了）
    if i == len(document) - 1 or current_length >= target_seq_length:
      if current_chunk:
        # `a_end` is how many segments from `current_chunk` go into the `A`
        # (first) sentence.
        # a_end是当前chunk的多少句话可以放到A的候选中
        a_end = 1
        if len(current_chunk) >= 2:
          a_end = rng.randint(1, len(current_chunk) - 1)

        tokens_a = []
        # 从第0句到第a_end句，首尾相连！！扔到tokens_a里
        for j in range(a_end):
          tokens_a.extend(current_chunk[j])

        tokens_b = []
        # Random next
        is_random_next = False
        # 当文档只有一句话，或者以0.5的概率，从其他文档随机采样
        if len(current_chunk) == 1 or rng.random() < 0.5:
          is_random_next = True
          target_b_length = target_seq_length - len(tokens_a)

          # This should rarely go for more than one iteration for large
          # corpora. However, just to be careful, we try to make sure that
          # the random document is not the same as the document
          # we're processing.
          for _ in range(10):
            random_document_index = rng.randint(0, len(all_documents) - 1)
            if random_document_index != document_index:
              break
          # 随机一个文档出来
          random_document = all_documents[random_document_index]
          random_start = rng.randint(0, len(random_document) - 1)
          # 在这篇随机出的文档中，随机出一个位置，这个位置开始的后面所有句子，首尾相连地连起来！！作为tokens_b
          for j in range(random_start, len(random_document)):
            tokens_b.extend(random_document[j])
            if len(tokens_b) >= target_b_length:
              break
          # We didn't actually use these segments so we "put them back" so
          # they don't go to waste.
          num_unused_segments = len(current_chunk) - a_end
          i -= num_unused_segments
        # Actual next
        else:
          is_random_next = False
          for j in range(a_end, len(current_chunk)):
            tokens_b.extend(current_chunk[j])
        truncate_seq_pair(tokens_a, tokens_b, max_num_tokens, rng)

        assert len(tokens_a) >= 1
        assert len(tokens_b) >= 1

        tokens = []
        segment_ids = []
        tokens.append("[CLS]")
        segment_ids.append(0)
        for token in tokens_a:
          tokens.append(token)
          segment_ids.append(0)

        tokens.append("[SEP]")
        segment_ids.append(0)

        for token in tokens_b:
          tokens.append(token)
          segment_ids.append(1)
        tokens.append("[SEP]")
        segment_ids.append(1)

        (tokens, masked_lm_positions,
         masked_lm_labels) = create_masked_lm_predictions(
             tokens, masked_lm_prob, max_predictions_per_seq, vocab_words, rng)
        instance = TrainingInstance(
            tokens=tokens,
            segment_ids=segment_ids,
            is_random_next=is_random_next,
            masked_lm_positions=masked_lm_positions,
            masked_lm_labels=masked_lm_labels)
        instances.append(instance)
      current_chunk = []
      current_length = 0
    i += 1

  return instances

create-masked-lm-predictions

首先定义了一个namedtuple：

MaskedLmInstance = collections.namedtuple("MaskedLmInstance",
                                          ["index", "label"])

然后是这个函数的实现：

def create_masked_lm_predictions(tokens, masked_lm_prob,
                                 max_predictions_per_seq, vocab_words, rng):
  """Creates the predictions for the masked LM objective."""

  cand_indexes = []
  for (i, token) in enumerate(tokens):
    if token == "[CLS]" or token == "[SEP]":
      continue
    # wordpieces涉及到Whole Word Masking(WWM)。wordpieces中，同一个词的第一个token没有marker，中间的token以##开头，所以见到##开头的话，就和前一个词的下标拼到一起去！！
    # 如果是中文，可能参考albert_zh的实现：https://github.com/daiwk/dl-frame/blob/43d120ad5cb6e1766b0a0b26f8f5c5376ec36069/demos/thirdparty/albert_zh/resources/create_pretraining_data_roberta.py#L261
    # Whole Word Masking means that if we mask all of the wordpieces
    # corresponding to an original word. When a word has been split into
    # WordPieces, the first token does not have any marker and any subsequence
    # tokens are prefixed with ##. So whenever we see the ## token, we
    # append it to the previous set of word indexes.
    #
    # Note that Whole Word Masking does *not* change the training code
    # at all -- we still predict each WordPiece independently, softmaxed
    # over the entire vocabulary.
    if (FLAGS.do_whole_word_mask and len(cand_indexes) >= 1 and
        token.startswith("##")):
      cand_indexes[-1].append(i)
    else:
      cand_indexes.append([i])

  rng.shuffle(cand_indexes)

  output_tokens = list(tokens)

  num_to_predict = min(max_predictions_per_seq,
                       max(1, int(round(len(tokens) * masked_lm_prob))))

  masked_lms = []
  covered_indexes = set()
  for index_set in cand_indexes:
    if len(masked_lms) >= num_to_predict:
      break
    # If adding a whole-word mask would exceed the maximum number of
    # predictions, then just skip this candidate.
    if len(masked_lms) + len(index_set) > num_to_predict:
      continue
    is_any_index_covered = False
    for index in index_set:
      if index in covered_indexes:
        is_any_index_covered = True
        break
    if is_any_index_covered:
      continue
    for index in index_set:
      covered_indexes.add(index)

      masked_token = None
      # 80% of the time, replace with [MASK]
      if rng.random() < 0.8:
        masked_token = "[MASK]"
      else:
        # 10% of the time, keep original
        if rng.random() < 0.5:
          masked_token = tokens[index]
        # 10% of the time, replace with random word
        else:
          masked_token = vocab_words[rng.randint(0, len(vocab_words) - 1)]

      output_tokens[index] = masked_token

      masked_lms.append(MaskedLmInstance(index=index, label=tokens[index]))
  assert len(masked_lms) <= num_to_predict
  masked_lms = sorted(masked_lms, key=lambda x: x.index)

  masked_lm_positions = []
  masked_lm_labels = []
  for p in masked_lms:
    masked_lm_positions.append(p.index)
    masked_lm_labels.append(p.label)

  return (output_tokens, masked_lm_positions, masked_lm_labels)

run-pretraining.py

读入tfrecords格式的训练样本，进行训练

classification

使用自己的数据集基于现有模型进行finetune

run-classifier.py

squad

run-squad.py

可视化分析

参考https://towardsdatascience.com/deconstructing-bert-part-2-visualizing-the-inner-workings-of-attention-60a16d86b5c1

github：https://github.com/jessevig/bertviz

googlecloud k8s

2018-10-16T00:00:00+00:00

教程 | 如何使用 Kubernetes 轻松部署深度学习模型

bert

2018-10-13T00:00:00+00:00

概述
BERT
实验
Ablation Studies
代码实现
- pytorch版本
  - 代码解读
官方版

参考最强NLP预训练模型！谷歌BERT横扫11项NLP任务记录

参考https://www.zhihu.com/question/298203515/answer/509703208

概述

本文介绍了一种新的语言表征模型BERT——来自Transformer的双向编码器表征。与最近的语言表征模型不同，BERT旨在基于所有层的左、右语境来预训练深度双向表征。BERT是首个在大批句子层面和token层面任务中取得当前最优性能的基于微调的表征模型，其性能超越许多使用任务特定架构的系统，刷新了11项NLP任务的当前最优性能记录。

目前将预训练语言表征应用于下游任务存在两种策略：feature-based的策略和fine-tuning策略。

feature-based策略（如 ELMo）使用将预训练表征作为额外特征的任务专用架构。
fine-tuning策略（如生成预训练 Transformer (OpenAI GPT)）引入了任务特定最小参数，通过简单地微调预训练参数在下游任务中进行训练。

在之前的研究中，两种策略在预训练期间使用相同的目标函数，利用单向语言模型来学习通用语言表征。

作者认为现有的技术严重制约了预训练表征的能力，微调策略尤其如此。其主要局限在于标准语言模型是单向的，这限制了可以在预训练期间使用的架构类型。例如，OpenAI GPT使用的是从左到右的架构，其中每个token只能注意Transformer自注意力层中的先前token。这些局限对于句子层面的任务而言不是最佳选择，对于token级任务（如 SQuAD 问答）则可能是毁灭性的，因为在这种任务中，结合两个方向的语境至关重要。

BERT（Bidirectional Encoder Representations from Transformers）改进了基于微调的策略。

BERT提出一种新的预训练目标——遮蔽语言模型（masked language model，MLM），来克服上文提到的单向局限。MLM 的灵感来自 Cloze 任务（Taylor, 1953）。MLM随机遮蔽输入中的一些token，目标在于仅基于遮蔽词的语境来预测其原始词汇id。与从左到右的语言模型预训练不同，MLM目标允许表征融合左右两侧的语境，从而预训练一个深度双向Transformer。除了 MLM，我们还引入了一个“下一句预测”（next sentence prediction）任务，该任务联合预训练文本对表征。

贡献：

展示了双向预训练语言表征的重要性。不同于 Radford 等人（2018）使用单向语言模型进行预训练，BERT使用MLM预训练深度双向表征。本研究与 Peters 等人（2018）的研究也不同，后者使用的是独立训练的从左到右和从右到左LM的浅层级联。
证明了预训练表征可以消除对许多精心设计的任务特定架构的需求。BERT是首个在大批句子层面和token层面任务中取得当前最优性能的基于微调的表征模型，其性能超越许多使用任务特定架构的系统。
BERT 刷新了11项NLP任务的当前最优性能记录。本论文还报告了BERT的模型简化测试（ablation study），证明该模型的双向特性是最重要的一项新贡献。代码和预训练模型将发布在goo.gl/language/bert。

BERT

模型架构

BERT 旨在基于所有层的左、右语境来预训练深度双向表征。因此，预训练的 BERT 表征可以仅用一个额外的输出层进行微调，进而为很多任务（如问答和语言推断任务）创建当前最优模型，无需对任务特定架构做出大量修改。

BERT 的模型架构是一个多层双向Transformer编码器，基于Vaswani 等人 (2017)描述的原始实现，在tensor2tensor库中发布(当然，可以抽空看看https://daiwk.github.io/posts/platform-tensor-to-tensor.html和https://daiwk.github.io/posts/platform-tensor-to-tensor-coding.html)。

本文中，我们将层数（即Transformer块）表示为$L$，将隐层的size表示为$H$、自注意力头数表示为$A$。在所有实验中，我们将feed-forward/filter的size设置为$4H$，即H=768时为3072，H=1024时为4096。我们主要看下在两种模型尺寸上的结果：

$BERT_{BASE}$: L=12, H=768, A=12, Total Parameters=110M
$BERT_{LARGE}$: L=24, H=1024, A=16, Total Parameters=340M

其中，$BERT_{BASE}$和OpenAI GPT的大小是一样的。BERT Transformer使用双向自注意力机制，而GPT Transformer使用受限的自注意力机制，导致每个token只能关注其左侧的语境。双向Transformer在文献中通常称为“Transformer 编码器”，而只关注左侧语境的版本则因能用于文本生成而被称为“Transformer 解码器”。

下图显示了BERT/GPT Transformer/ELMo的结构区别：

BERT 使用双向Transformer
OpenAI GPT 使用从左到右的Transformer
ELMo 使用独立训练的从左到右和从右到左LSTM的级联来生成下游任务的特征。

三种模型中，只有BERT表征会基于所有层中的左右两侧语境。

Input Representation

论文的输入表示（input representation）能够在一个token序列中明确地表示单个文本句子或一对文本句子（例如， [Question, Answer]）。对于给定token，其输入表示通过对相应的token、segment和position embeddings进行求和来构造：

使用WordPiece嵌入【GNMT，Google’s neural machine translation system: Bridging the gap between human and machine translation】和30,000个token的词汇表。用##表示分词。
使用learned positional embeddings，支持的序列长度最多为512个token。
每个序列的第一个token始终是特殊分类嵌入（[CLS]）。对应于该token的最终隐藏状态（即，Transformer的输出）被用作分类任务的聚合序列表示。对于非分类任务，将忽略此向量。
句子对被打包成一个序列。以两种方式区分句子。
- 首先，用特殊标记（[SEP]）将它们分开。
- 其次，添加一个learned sentence A嵌入到第一个句子的每个token中，一个sentence B嵌入到第二个句子的每个token中。
对于单个句子输入，只使用 sentence A嵌入。

Pre-training Tasks

它在训练双向语言模型时以减小的概率把少量的词替成了Mask或者另一个随机的词。感觉其目的在于使模型被迫增加对上下文的记忆。（知乎的回答）
增加了一个预测下一句的loss。

Task #1: Masked LM

标准条件语言模型只能从左到右或从右到左进行训练，因为双向条件作用将允许每个单词在多层上下文中间接地“see itself”。

为了训练一个深度双向表示（deep bidirectional representation），研究团队采用了一种简单的方法，即随机屏蔽（masking）部分输入token，然后只预测那些被屏蔽的token。论文将这个过程称为“masked LM”(MLM)，尽管在文献中它经常被称为Cloze任务(Taylor, 1953)。

在这个例子中，与masked token对应的最终隐藏向量被输入到词汇表上的输出softmax中，就像在标准LM中一样。在团队所有实验中，随机地屏蔽了每个序列中15%的WordPiece token。与去噪的自动编码器（Vincent et al.， 2008）相反，只预测masked words而不是重建整个输入。

虽然这确实能让团队获得双向预训练模型，但这种方法有两个缺点。

缺点1：预训练和finetuning之间不匹配，因为在finetuning期间从未看到[MASK]token。

为了解决这个问题，团队并不总是用实际的[MASK]token替换被“masked”的词汇。相反，训练数据生成器随机选择15％的token。

例如在这个句子“my dog is hairy”中，它选择的token是“hairy”。然后，执行以下过程：

数据生成器将执行以下操作，而不是始终用[MASK]替换所选单词：

80％的时间：用[MASK]标记替换单词，例如，my dog is hairy → my dog is [MASK]
10％的时间：用一个随机的单词替换该单词，例如，my dog is hairy → my dog is apple
10％的时间：保持单词不变，例如，my dog is hairy → my dog is hairy. 这样做的目的是将表示偏向于实际观察到的单词。

Transformer encoder不知道它将被要求预测哪些单词或哪些单词已被随机单词替换，因此它被迫保持每个输入token的分布式上下文表示。此外，因为随机替换只发生在所有token的1.5％（即15％的10％），这似乎不会损害模型的语言理解能力。

缺点2：每个batch只预测了15％的token，这表明模型可能需要更多的预训练步骤才能收敛。

团队证明MLM的收敛速度略慢于 left-to-right的模型（预测每个token），但MLM模型在实验上获得的提升远远超过增加的训练成本。

Task #2: Next Sentence Prediction

在为了训练一个理解句子的模型关系，预先训练一个二分类的下一句测任务，这一任务可以从任何单语语料库中生成。具体地说，当选择句子A和B作为预训练样本时，B有50％的可能是A的下一个句子，也有50％的可能是来自语料库的随机句子。例如：

Input = 
[CLS] the man went to [MASK] store [SEP]
he bought a gallon [MASK] milk [SEP]
Label = IsNext

Input = 
[CLS] the man [MASK] to the store [SEP]
penguin [MASK] are flight ##less birds [SEP]
Label = NotNext

完全随机地选择了NotNext语句，最终的预训练模型在此任务上实现了97％-98％的准确率。

Pre-training Procedure

使用gelu激活函数（Bridging nonlinearities and stochastic regularizers with gaus- sian error linear units），在pytorch里实现如下：

class GELU(nn.Module):
    """
    Paper Section 3.4, last paragraph notice that BERT used the GELU instead of RELU
    """

    def forward(self, x):
        return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))

Fine-tuning Procedure

Comparison of BERT and OpenAI GPT

实验

网络结构如下：

GLUE Datasets

GLUE Results

SQuAD v1.1

Named Entity Recognition

SWAG

Ablation Studies

Effect of Pre-training Tasks

Effect of Model Size

Effect of Number of Training Steps

Feature-based Approach with BERT

代码实现

pytorch版本

https://github.com/codertimo/BERT-pytorch

fork了一份：https://github.com/daiwk/BERT-pytorch

输入data/corpus.small：

Welcome to the \t the jungle \n
I can stay \t here all night \n

可视化，需要：

brew install graphviz # mac
pip3 install git+https://github.com/szagoruyko/pytorchviz

画出bert的架构图的方法(先生成vocab，如果机器的dot不支持pdf，只支持png/jpg等，需要在lib/python3.6/site-packages/torchviz/dot.py中把dot = Digraph(node_attr=node_attr, graph_attr=dict(size="12,12"))改成dot = Digraph(node_attr=node_attr, graph_attr=dict(size="12,12"), format="png"))：

import torch
from torch import nn
from torchviz import make_dot, make_dot_from_trace

import sys

sys.path.append("./bert_pytorch-0.0.1a4.src/")
#from trainer import BERTTrainer
from model import BERTLM, BERT
from dataset import BERTDataset, WordVocab
from torch.utils.data import DataLoader

def demo():
    lstm_cell = nn.LSTMCell(128, 128)
    x = torch.randn(1, 128)
    dot = make_dot(lstm_cell(x), params=dict(list(lstm_cell.named_parameters())))
    file_out = "xx"
    dot.render(file_out)

def bert_dot():
    """
    """
    vocab_size = 128
    train_dataset_path = "data/bert_train_data.xxx"
    vocab_path = "data/vocab.all.xxx"
    vocab = WordVocab.load_vocab(vocab_path)

    train_dataset = BERTDataset(train_dataset_path, vocab, seq_len=20,
                                corpus_lines=2000, on_memory=True)


    train_data_loader = DataLoader(train_dataset, batch_size=8, num_workers=8)
    bert = BERT(len(vocab), hidden=256, n_layers=8, attn_heads=8)
    device = torch.device("cpu")
    mymodel = BERTLM(bert, vocab_size).to(device)
    data_iter = train_data_loader
    out_idx = 0
    for data in data_iter:
        data = {key: value.to(device) for key, value in data.items()}
        if out_idx == 0:
            g = make_dot(mymodel(data["bert_input"], data["segment_label"]), params=dict(mymodel.named_parameters()))
            g.render("./bert-arch")
            break

bert_dot()

可以画出这么个图。。图太大，自己下载看看

https://daiwk.github.io/assets/bert-arch.jpeg

对应的pdf如

https://daiwk.github.io/assets/bert-arch.pdf

对应的dot文件

https://daiwk.github.io/assets/bert-arch

把dot文件转换成其他格式的方式：

input=./bert-arch
output=./bert-arch
dot $input -Tjpeg -o $output.jpeg
dot $input -Tpdf -o $output.pdf

设置一个layer的简单版pdf如下：

https://daiwk.github.io/assets/bert-arch-1layer.pdf

代码解读

transformer部分参考http://nlp.seas.harvard.edu/2018/04/03/attention.htm

可以学习下https://blog.csdn.net/stupid_3/article/details/83184691，讲得很细致呢！

基础知识

参考https://daiwk.github.io/posts/knowledge-pytorch-usage.html

position encoding

代码

class PositionalEncoding(nn.Module):
    "Implement the PE function."
    def __init__(self, d_model, dropout, max_len=5000):
        super(PositionalEncoding, self).__init__()
        self.dropout = nn.Dropout(p=dropout)
        
        # Compute the positional encodings once in log space.
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len).unsqueeze(1)
        div_term = torch.exp(torch.arange(0, d_model, 2) *
                             -(math.log(10000.0) / d_model))
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)
        
    def forward(self, x):
        x = x + Variable(self.pe[:, :x.size(1)], 
                         requires_grad=False)
        return self.dropout(x)

输入是shape为(max_len, d_model)的矩阵，d_model是emb的size。如下图，输入是一个max_len=100，d_model=20的矩阵，图中画的是这20维里的4、5、6、7每一维在100个position的取值。

bert里改名了一下：

class PositionalEmbedding(nn.Module):

    def __init__(self, d_model, max_len=512):
        super().__init__()

        # Compute the positional encodings once in log space.
        pe = torch.zeros(max_len, d_model).float()
        pe.require_grad = False

        position = torch.arange(0, max_len).float().unsqueeze(1)
        div_term = (torch.arange(0, d_model, 2).float() * -(math.log(10000.0) / d_model)).exp()

        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)

        pe = pe.unsqueeze(0)
        self.register_buffer('pe', pe)

    def forward(self, x):
        return self.pe[:, :x.size(1)]

而bert还有另外两个embedding，就是segment和token，这里用很简单的实现：

class SegmentEmbedding(nn.Embedding):
    def __init__(self, embed_size=512):
        ### 输入是segment_label，表示是第1句话，第2句话，还是padding，所以num_embeddings是3
        super().__init__(3, embed_size, padding_idx=0)

class TokenEmbedding(nn.Embedding):
    def __init__(self, vocab_size, embed_size=512):
        super().__init__(vocab_size, embed_size, padding_idx=0)

用的时候是把三者加起来：

class BERTEmbedding(nn.Module):
    """
    BERT Embedding which is consisted with under features
        1. TokenEmbedding : normal embedding matrix
        2. PositionalEmbedding : adding positional information using sin, cos
        2. SegmentEmbedding : adding sentence segment info, (sent_A:1, sent_B:2)

        sum of all these features are output of BERTEmbedding
    """

    def __init__(self, vocab_size, embed_size, dropout=0.1):
        """
        :param vocab_size: total vocab size
        :param embed_size: embedding size of token embedding
        :param dropout: dropout rate
        """
        super().__init__()
        self.token = TokenEmbedding(vocab_size=vocab_size, embed_size=embed_size)
        self.position = PositionalEmbedding(d_model=self.token.embedding_dim)
        self.segment = SegmentEmbedding(embed_size=self.token.embedding_dim)
        self.dropout = nn.Dropout(p=dropout)
        self.embed_size = embed_size

    def forward(self, sequence, segment_label):
        x = self.token(sequence) + self.position(sequence) + self.segment(segment_label)
        return self.dropout(x)

这部分画出来的图就应该是下面这个了：

position-wise feed forward

class PositionwiseFeedForward(nn.Module):
    "Implements FFN equation."
    def __init__(self, d_model, d_ff, dropout=0.1):
        super(PositionwiseFeedForward, self).__init__()
        self.w_1 = nn.Linear(d_model, d_ff)
        self.w_2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        return self.w_2(self.dropout(F.relu(self.w_1(x))))

在bert中，把relu改为gelu，所以：

class GELU(nn.Module):
    """
    Paper Section 3.4, last paragraph notice that BERT used the GELU instead of RELU
    """

    def forward(self, x):
        return 0.5 * x * (1 + torch.tanh(math.sqrt(2 / math.pi) * (x + 0.044715 * torch.pow(x, 3))))


class PositionwiseFeedForward(nn.Module):
    "Implements FFN equation."

    def __init__(self, d_model, d_ff, dropout=0.1):
        super(PositionwiseFeedForward, self).__init__()
        self.w_1 = nn.Linear(d_model, d_ff)
        self.w_2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)
        self.activation = GELU()

    def forward(self, x):
        return self.w_2(self.dropout(self.activation(self.w_1(x))))

attention和Multi-head attention

代码如下：

def attention(query, key, value, mask=None, dropout=None):
    "Compute 'Scaled Dot Product Attention'"
    d_k = query.size(-1)
    scores = torch.matmul(query, key.transpose(-2, -1)) \
             / math.sqrt(d_k)
    if mask is not None:
        scores = scores.masked_fill(mask == 0, -1e9)
    p_attn = F.softmax(scores, dim = -1)
    if dropout is not None:
        p_attn = dropout(p_attn)
    return torch.matmul(p_attn, value), p_attn

class MultiHeadedAttention(nn.Module):
    def __init__(self, h, d_model, dropout=0.1):
        "Take in model size and number of heads."
        super(MultiHeadedAttention, self).__init__()
        assert d_model % h == 0
        # We assume d_v always equals d_k
        self.d_k = d_model // h
        self.h = h

        self.linears = clones(nn.Linear(d_model, d_model), 4)
        self.attn = None
        self.dropout = nn.Dropout(p=dropout)
        
    def forward(self, query, key, value, mask=None):
        "Implements Figure 2"
        if mask is not None:
            # Same mask applied to all h heads.
            mask = mask.unsqueeze(1)
        nbatches = query.size(0)
        
        # 1) Do all the linear projections in batch from d_model => h x d_k 
        query, key, value = \
            [l(x).view(nbatches, -1, self.h, self.d_k).transpose(1, 2)
             for l, x in zip(self.linears, (query, key, value))]
        
        # 2) Apply attention on all the projected vectors in batch. 
        x, self.attn = attention(query, key, value, mask=mask, 
                                 dropout=self.dropout)
        
        # 3) "Concat" using a view and apply a final linear. 
        x = x.transpose(1, 2).contiguous() \
             .view(nbatches, -1, self.h * self.d_k)
        return self.linears[-1](x)

注：

画出来的图可以参考[https://daiwk.github.io/assets/bert-arch-1layer.pdf]

有4个Linear，其中三个分别和q,k,v相乘，最后一个和concat后的相乘。大小都是d_model,d_model。因为d_k=d_v=d_model/h，对于q来讲，有h个(d_k, d_model)，所以一个(d_model, d_model)就行了。k,v同理。当然，后面还搞了下batches，所以画出来的图是q和k先bmm一下，再和v去bmm一下，最后的concat是就是view一下，然后再和最后那个linear去mm一下。

封装一下：

class Attention(nn.Module):
    """
    Compute 'Scaled Dot Product Attention
    """

    def forward(self, query, key, value, mask=None, dropout=None):
        scores = torch.matmul(query, key.transpose(-2, -1)) \
                 / math.sqrt(query.size(-1))

        if mask is not None:
            scores = scores.masked_fill(mask == 0, -1e9)

        p_attn = F.softmax(scores, dim=-1)

        if dropout is not None:
            p_attn = dropout(p_attn)

        return torch.matmul(p_attn, value), p_attn

class MultiHeadedAttention(nn.Module):
    """
    Take in model size and number of heads.
    """

    def __init__(self, h, d_model, dropout=0.1):
        super().__init__()
        assert d_model % h == 0

        # We assume d_v always equals d_k
        self.d_k = d_model // h
        self.h = h

        self.linear_layers = nn.ModuleList([nn.Linear(d_model, d_model) for _ in range(3)])
        self.output_linear = nn.Linear(d_model, d_model)
        self.attention = Attention()

        self.dropout = nn.Dropout(p=dropout)

    def forward(self, query, key, value, mask=None):
        batch_size = query.size(0)

        # 1) Do all the linear projections in batch from d_model => h x d_k
        query, key, value = [l(x).view(batch_size, -1, self.h, self.d_k).transpose(1, 2)
                             for l, x in zip(self.linear_layers, (query, key, value))]

        # 2) Apply attention on all the projected vectors in batch.
        x, attn = self.attention(query, key, value, mask=mask, dropout=self.dropout)

        # 3) "Concat" using a view and apply a final linear.
        x = x.transpose(1, 2).contiguous().view(batch_size, -1, self.h * self.d_k)

        return self.output_linear(x)

layernorm和sublayer

class LayerNorm(nn.Module):
    "Construct a layernorm module (See citation for details)."
    def __init__(self, features, eps=1e-6):
        super(LayerNorm, self).__init__()
        self.a_2 = nn.Parameter(torch.ones(features))
        self.b_2 = nn.Parameter(torch.zeros(features))
        self.eps = eps

    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.a_2 * (x - mean) / (std + self.eps) + self.b_2

class SublayerConnection(nn.Module):
    """
    A residual connection followed by a layer norm.
    Note for code simplicity the norm is first as opposed to last.
    """
    def __init__(self, size, dropout):
        super(SublayerConnection, self).__init__()
        self.norm = LayerNorm(size)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x, sublayer):
        "Apply residual connection to any sublayer with the same size."
        return x + self.dropout(sublayer(self.norm(x)))

transformer里的encoder：

class EncoderLayer(nn.Module):
    "Encoder is made up of self-attn and feed forward (defined below)"
    def __init__(self, size, self_attn, feed_forward, dropout):
        super(EncoderLayer, self).__init__()
        self.self_attn = self_attn
        self.feed_forward = feed_forward
        self.sublayer = clones(SublayerConnection(size, dropout), 2)
        self.size = size

    def forward(self, x, mask):
        "Follow Figure 1 (left) for connections."
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, mask))
        return self.sublayer[1](x, self.feed_forward)

decoder部分：

class Decoder(nn.Module):
    "Generic N layer decoder with masking."
    def __init__(self, layer, N):
        super(Decoder, self).__init__()
        self.layers = clones(layer, N)
        self.norm = LayerNorm(layer.size)
        
    def forward(self, x, memory, src_mask, tgt_mask):
        for layer in self.layers:
            x = layer(x, memory, src_mask, tgt_mask)
        return self.norm(x)

class DecoderLayer(nn.Module):
    "Decoder is made of self-attn, src-attn, and feed forward (defined below)"
    def __init__(self, size, self_attn, src_attn, feed_forward, dropout):
        super(DecoderLayer, self).__init__()
        self.size = size
        self.self_attn = self_attn
        self.src_attn = src_attn
        self.feed_forward = feed_forward
        self.sublayer = clones(SublayerConnection(size, dropout), 3)
 
    def forward(self, x, memory, src_mask, tgt_mask):
        "Follow Figure 1 (right) for connections."
        m = memory
        x = self.sublayer[0](x, lambda x: self.self_attn(x, x, x, tgt_mask))
        x = self.sublayer[1](x, lambda x: self.src_attn(x, m, m, src_mask))
        return self.sublayer[2](x, self.feed_forward)

其中的mask部分：

def subsequent_mask(size):
    "Mask out subsequent positions."
    attn_shape = (1, size, size)
    ## np.triu：一个上三角矩阵（注意：这里是一个方阵）右上角都是1，左下角都是0
    subsequent_mask = np.triu(np.ones(attn_shape), k=1).astype('uint8')
    return torch.from_numpy(subsequent_mask) == 0

class Batch:
    "Object for holding a batch of data with mask during training."
    def __init__(self, src, trg=None, pad=0):
        self.src = src
        self.src_mask = (src != pad).unsqueeze(-2)
        if trg is not None:
            self.trg = trg[:, :-1]
            self.trg_y = trg[:, 1:]
            self.trg_mask = \
                self.make_std_mask(self.trg, pad)
            self.ntokens = (self.trg_y != pad).data.sum()
    
    @staticmethod
    def make_std_mask(tgt, pad):
        "Create a mask to hide padding and future words."
        tgt_mask = (tgt != pad).unsqueeze(-2)
        tgt_mask = tgt_mask & Variable(
            subsequent_mask(tgt.size(-1)).type_as(tgt_mask.data))
        return tgt_mask

在产出数据时把mask加上：

def data_gen(V, batch, nbatches):
    "Generate random data for a src-tgt copy task."
    for i in range(nbatches):
        data = torch.from_numpy(np.random.randint(1, V, size=(batch, 10)))
        data[:, 0] = 1
        src = Variable(data, requires_grad=False)
        tgt = Variable(data, requires_grad=False)
        yield Batch(src, tgt, 0)

整个模型：

class EncoderDecoder(nn.Module):
    """
    A standard Encoder-Decoder architecture. Base for this and many 
    other models.
    """
    def __init__(self, encoder, decoder, src_embed, tgt_embed, generator):
        super(EncoderDecoder, self).__init__()
        self.encoder = encoder
        self.decoder = decoder
        self.src_embed = src_embed
        self.tgt_embed = tgt_embed
        self.generator = generator
        
    def forward(self, src, tgt, src_mask, tgt_mask):
        "Take in and process masked src and target sequences."
        return self.decode(self.encode(src, src_mask), src_mask,
                            tgt, tgt_mask)
    
    def encode(self, src, src_mask):
        return self.encoder(self.src_embed(src), src_mask)
    
    def decode(self, memory, src_mask, tgt, tgt_mask):
        return self.decoder(self.tgt_embed(tgt), memory, src_mask, tgt_mask)

class Generator(nn.Module):
    "Define standard linear + softmax generation step."
    def __init__(self, d_model, vocab):
        super(Generator, self).__init__()
        self.proj = nn.Linear(d_model, vocab)

    def forward(self, x):
        return F.log_softmax(self.proj(x), dim=-1)

def make_model(src_vocab, tgt_vocab, N=6, 
               d_model=512, d_ff=2048, h=8, dropout=0.1):
    "Helper: Construct a model from hyperparameters."
    c = copy.deepcopy
    attn = MultiHeadedAttention(h, d_model)
    ff = PositionwiseFeedForward(d_model, d_ff, dropout)
    position = PositionalEncoding(d_model, dropout)
    model = EncoderDecoder(
        Encoder(EncoderLayer(d_model, c(attn), c(ff), dropout), N),
        Decoder(DecoderLayer(d_model, c(attn), c(attn), 
                             c(ff), dropout), N),
        nn.Sequential(Embeddings(d_model, src_vocab), c(position)),
        nn.Sequential(Embeddings(d_model, tgt_vocab), c(position)),
        Generator(d_model, tgt_vocab))
    
    # This was important from their code. 
    # Initialize parameters with Glorot / fan_avg.
    for p in model.parameters():
        if p.dim() > 1:
            nn.init.xavier_uniform(p)
    return model

bert中的transformerblock(相当于只有encoder，但是加入了自己的mask)：

class TransformerBlock(nn.Module):
    """
    Bidirectional Encoder = Transformer (self-attention)
    Transformer = MultiHead_Attention + Feed_Forward with sublayer connection
    """

    def __init__(self, hidden, attn_heads, feed_forward_hidden, dropout):
        """
        :param hidden: hidden size of transformer
        :param attn_heads: head sizes of multi-head attention
        :param feed_forward_hidden: feed_forward_hidden, usually 4*hidden_size
        :param dropout: dropout rate
        """

        super().__init__()
        self.attention = MultiHeadedAttention(h=attn_heads, d_model=hidden)
        self.feed_forward = PositionwiseFeedForward(d_model=hidden, d_ff=feed_forward_hidden, dropout=dropout)
        self.input_sublayer = SublayerConnection(size=hidden, dropout=dropout)
        self.output_sublayer = SublayerConnection(size=hidden, dropout=dropout)
        self.dropout = nn.Dropout(p=dropout)

    def forward(self, x, mask):
        x = self.input_sublayer(x, lambda _x: self.attention.forward(_x, _x, _x, mask=mask))
        x = self.output_sublayer(x, self.feed_forward)
        return self.dropout(x)

完整的bert

class BERT(nn.Module):
    """
    BERT model : Bidirectional Encoder Representations from Transformers.
    """

    def __init__(self, vocab_size, hidden=768, n_layers=12, attn_heads=12, dropout=0.1):
        """
        :param vocab_size: vocab_size of total words
        :param hidden: BERT model hidden size
        :param n_layers: numbers of Transformer blocks(layers)
        :param attn_heads: number of attention heads
        :param dropout: dropout rate
        """

        super().__init__()
        self.hidden = hidden
        self.n_layers = n_layers
        self.attn_heads = attn_heads

        # paper noted they used 4*hidden_size for ff_network_hidden_size
        self.feed_forward_hidden = hidden * 4

        # embedding for BERT, sum of positional, segment, token embeddings
        self.embedding = BERTEmbedding(vocab_size=vocab_size, embed_size=hidden)

        # multi-layers transformer blocks, deep network
        self.transformer_blocks = nn.ModuleList(
            [TransformerBlock(hidden, attn_heads, hidden * 4, dropout) for _ in range(n_layers)])

    def forward(self, x, segment_info):
        # attention masking for padded token
        # torch.ByteTensor([batch_size, 1, seq_len, seq_len)
        mask = (x > 0).unsqueeze(1).repeat(1, x.size(1), 1).unsqueeze(1)

        # embedding the indexed sequence to sequence of vectors
        x = self.embedding(x, segment_info)

        # running over multiple transformer blocks
        for transformer in self.transformer_blocks:
            x = transformer.forward(x, mask)

        return x

对于pretrain来讲：

class BERTLM(nn.Module):
    """
    BERT Language Model
    Next Sentence Prediction Model + Masked Language Model
    """

    def __init__(self, bert: BERT, vocab_size):
        """
        :param bert: BERT model which should be trained
        :param vocab_size: total vocab size for masked_lm
        """

        super().__init__()
        self.bert = bert
        self.next_sentence = NextSentencePrediction(self.bert.hidden)
        self.mask_lm = MaskedLanguageModel(self.bert.hidden, vocab_size)

    def forward(self, x, segment_label):
        x = self.bert(x, segment_label)
        return self.next_sentence(x), self.mask_lm(x)


class NextSentencePrediction(nn.Module):
    """
    2-class classification model : is_next, is_not_next
    """

    def __init__(self, hidden):
        """
        :param hidden: BERT model output size
        """
        super().__init__()
        self.linear = nn.Linear(hidden, 2)
        self.softmax = nn.LogSoftmax(dim=-1)

    def forward(self, x):
        return self.softmax(self.linear(x[:, 0]))


class MaskedLanguageModel(nn.Module):
    """
    predicting origin token from masked input sequence
    n-class classification problem, n-class = vocab_size
    """

    def __init__(self, hidden, vocab_size):
        """
        :param hidden: output size of BERT model
        :param vocab_size: total vocab size
        """
        super().__init__()
        self.linear = nn.Linear(hidden, vocab_size)
        self.softmax = nn.LogSoftmax(dim=-1)

    def forward(self, x):
        return self.softmax(self.linear(x))

整个训练过程：

class BERTTrainer:
    """
    BERTTrainer make the pretrained BERT model with two LM training method.

        1. Masked Language Model : 3.3.1 Task #1: Masked LM
        2. Next Sentence prediction : 3.3.2 Task #2: Next Sentence Prediction

    please check the details on README.md with simple example.

    """

    def __init__(self, bert: BERT, vocab_size: int,
                 train_dataloader: DataLoader, test_dataloader: DataLoader = None,
                 lr: float = 1e-4, betas=(0.9, 0.999), weight_decay: float = 0.01, warmup_steps=10000,
                 with_cuda: bool = True, cuda_devices=None, log_freq: int = 10):
        """
        :param bert: BERT model which you want to train
        :param vocab_size: total word vocab size
        :param train_dataloader: train dataset data loader
        :param test_dataloader: test dataset data loader [can be None]
        :param lr: learning rate of optimizer
        :param betas: Adam optimizer betas
        :param weight_decay: Adam optimizer weight decay param
        :param with_cuda: traning with cuda
        :param log_freq: logging frequency of the batch iteration
        """

        # Setup cuda device for BERT training, argument -c, --cuda should be true
        cuda_condition = torch.cuda.is_available() and with_cuda
        self.device = torch.device("cuda:0" if cuda_condition else "cpu")

        # This BERT model will be saved every epoch
        self.bert = bert
        # Initialize the BERT Language Model, with BERT model
        self.model = BERTLM(bert, vocab_size).to(self.device)

        # Distributed GPU training if CUDA can detect more than 1 GPU
        if with_cuda and torch.cuda.device_count() > 1:
            print("Using %d GPUS for BERT" % torch.cuda.device_count())
            self.model = nn.DataParallel(self.model, device_ids=cuda_devices)

        # Setting the train and test data loader
        self.train_data = train_dataloader
        self.test_data = test_dataloader

        # Setting the Adam optimizer with hyper-param
        self.optim = Adam(self.model.parameters(), lr=lr, betas=betas, weight_decay=weight_decay)
        self.optim_schedule = ScheduledOptim(self.optim, self.bert.hidden, n_warmup_steps=warmup_steps)

        # Using Negative Log Likelihood Loss function for predicting the masked_token
        self.criterion = nn.NLLLoss(ignore_index=0)

        self.log_freq = log_freq

        print("Total Parameters:", sum([p.nelement() for p in self.model.parameters()]))

    def train(self, epoch):
        self.iteration(epoch, self.train_data)

    def test(self, epoch):
        self.iteration(epoch, self.test_data, train=False)

    def iteration(self, epoch, data_loader, train=True):
        """
        loop over the data_loader for training or testing
        if on train status, backward operation is activated
        and also auto save the model every peoch

        :param epoch: current epoch index
        :param data_loader: torch.utils.data.DataLoader for iteration
        :param train: boolean value of is train or test
        :return: None
        """
        str_code = "train" if train else "test"

        # Setting the tqdm progress bar
        data_iter = tqdm.tqdm(enumerate(data_loader),
                              desc="EP_%s:%d" % (str_code, epoch),
                              total=len(data_loader),
                              bar_format="{l_bar}{r_bar}")

        avg_loss = 0.0
        total_correct = 0
        total_element = 0

        for i, data in data_iter:
            # 0. batch_data will be sent into the device(GPU or cpu)
            data = {key: value.to(self.device) for key, value in data.items()}

            # 1. forward the next_sentence_prediction and masked_lm model
            next_sent_output, mask_lm_output = self.model.forward(data["bert_input"], data["segment_label"])

            # 2-1. NLL(negative log likelihood) loss of is_next classification result
            next_loss = self.criterion(next_sent_output, data["is_next"])

            # 2-2. NLLLoss of predicting masked token word
            mask_loss = self.criterion(mask_lm_output.transpose(1, 2), data["bert_label"])

            # 2-3. Adding next_loss and mask_loss : 3.4 Pre-training Procedure
            loss = next_loss + mask_loss

            # 3. backward and optimization only in train
            if train:
                self.optim_schedule.zero_grad()
                loss.backward()
                self.optim_schedule.step_and_update_lr()

            # next sentence prediction accuracy
            correct = next_sent_output.argmax(dim=-1).eq(data["is_next"]).sum().item()
            avg_loss += loss.item()
            total_correct += correct
            total_element += data["is_next"].nelement()

            post_fix = {
                "epoch": epoch,
                "iter": i,
                "avg_loss": avg_loss / (i + 1),
                "avg_acc": total_correct / total_element * 100,
                "loss": loss.item()
            }

            if i % self.log_freq == 0:
                data_iter.write(str(post_fix))

        print("EP%d_%s, avg_loss=" % (epoch, str_code), avg_loss / len(data_iter), "total_acc=",
              total_correct * 100.0 / total_element)

    def save(self, epoch, file_path="output/bert_trained.model"):
        """
        Saving the current BERT model on file_path

        :param epoch: current epoch number
        :param file_path: model output path which gonna be file_path+"ep%d" % epoch
        :return: final_output_path
        """
        output_path = file_path + ".ep%d" % epoch
        torch.save(self.bert.cpu(), output_path)
        self.bert.to(self.device)
        print("EP:%d Model Saved on:" % epoch, output_path)
        return output_path

vocab和dataset

vocab部分：

from collections import Counter


class TorchVocab(object):
    """Defines a vocabulary object that will be used to numericalize a field.
    Attributes:
        freqs: A collections.Counter object holding the frequencies of tokens
            in the data used to build the Vocab.
        stoi: A collections.defaultdict instance mapping token strings to
            numerical identifiers.
        itos: A list of token strings indexed by their numerical identifiers.
    """

    def __init__(self, counter, max_size=None, min_freq=1, specials=['<pad>', '<oov>'],
                 vectors=None, unk_init=None, vectors_cache=None):
        """Create a Vocab object from a collections.Counter.
        Arguments:
            counter: collections.Counter object holding the frequencies of
                each value found in the data.
            max_size: The maximum size of the vocabulary, or None for no
                maximum. Default: None.
            min_freq: The minimum frequency needed to include a token in the
                vocabulary. Values less than 1 will be set to 1. Default: 1.
            specials: The list of special tokens (e.g., padding or eos) that
                will be prepended to the vocabulary in addition to an <unk>
                token. Default: ['<pad>']
            vectors: One of either the available pretrained vectors
                or custom pretrained vectors (see Vocab.load_vectors);
                or a list of aforementioned vectors
            unk_init (callback): by default, initialize out-of-vocabulary word vectors
                to zero vectors; can be any function that takes in a Tensor and
                returns a Tensor of the same size. Default: torch.Tensor.zero_
            vectors_cache: directory for cached vectors. Default: '.vector_cache'
        """
        self.freqs = counter
        counter = counter.copy()
        min_freq = max(min_freq, 1)

        self.itos = list(specials)
        # frequencies of special tokens are not counted when building vocabulary
        # in frequency order
        for tok in specials:
            del counter[tok]

        max_size = None if max_size is None else max_size + len(self.itos)

        # sort by frequency, then alphabetically
        words_and_frequencies = sorted(counter.items(), key=lambda tup: tup[0])
        words_and_frequencies.sort(key=lambda tup: tup[1], reverse=True)

        for word, freq in words_and_frequencies:
            if freq < min_freq or len(self.itos) == max_size:
                break
            self.itos.append(word)

        # stoi is simply a reverse dict for itos
        self.stoi = {tok: i for i, tok in enumerate(self.itos)}

        self.vectors = None
        if vectors is not None:
            self.load_vectors(vectors, unk_init=unk_init, cache=vectors_cache)
        else:
            assert unk_init is None and vectors_cache is None

    def __eq__(self, other):
        if self.freqs != other.freqs:
            return False
        if self.stoi != other.stoi:
            return False
        if self.itos != other.itos:
            return False
        if self.vectors != other.vectors:
            return False
        return True

    def __len__(self):
        return len(self.itos)

    def vocab_rerank(self):
        self.stoi = {word: i for i, word in enumerate(self.itos)}

    def extend(self, v, sort=False):
        words = sorted(v.itos) if sort else v.itos
        for w in words:
            if w not in self.stoi:
                self.itos.append(w)
                self.stoi[w] = len(self.itos) - 1


class Vocab(TorchVocab):
    def __init__(self, counter, max_size=None, min_freq=1):
        self.pad_index = 0
        self.unk_index = 1
        self.eos_index = 2
        self.sos_index = 3
        self.mask_index = 4
        super().__init__(counter, specials=["<pad>", "<unk>", "<eos>", "<sos>", "<mask>"],
                         max_size=max_size, min_freq=min_freq)

    def to_seq(self, sentece, seq_len, with_eos=False, with_sos=False) -> list:
        pass

    def from_seq(self, seq, join=False, with_pad=False):
        pass

    @staticmethod
    def load_vocab(vocab_path: str) -> 'Vocab':
        with open(vocab_path, "rb") as f:
            return pickle.load(f)

    def save_vocab(self, vocab_path):
        with open(vocab_path, "wb") as f:
            pickle.dump(self, f)


# Building Vocab with text files
class WordVocab(Vocab):
    def __init__(self, texts, max_size=None, min_freq=1):
        print("Building Vocab")
        counter = Counter()
        for line in tqdm.tqdm(texts):
            if isinstance(line, list):
                words = line
            else:
                words = line.replace("\n", "").replace("\t", "").split()

            for word in words:
                counter[word] += 1
        super().__init__(counter, max_size=max_size, min_freq=min_freq)

    def to_seq(self, sentence, seq_len=None, with_eos=False, with_sos=False, with_len=False):
        if isinstance(sentence, str):
            sentence = sentence.split()

        seq = [self.stoi.get(word, self.unk_index) for word in sentence]

        if with_eos:
            seq += [self.eos_index]  # this would be index 1
        if with_sos:
            seq = [self.sos_index] + seq

        origin_seq_len = len(seq)

        if seq_len is None:
            pass
        elif len(seq) <= seq_len:
            seq += [self.pad_index for _ in range(seq_len - len(seq))]
        else:
            seq = seq[:seq_len]

        return (seq, origin_seq_len) if with_len else seq

    def from_seq(self, seq, join=False, with_pad=False):
        words = [self.itos[idx]
                 if idx < len(self.itos)
                 else "<%d>" % idx
                 for idx in seq
                 if not with_pad or idx != self.pad_index]

        return " ".join(words) if join else words

    @staticmethod
    def load_vocab(vocab_path: str) -> 'WordVocab':
        with open(vocab_path, "rb") as f:
            return pickle.load(f)


def build():
    import argparse

    parser = argparse.ArgumentParser()
    parser.add_argument("-c", "--corpus_path", required=True, type=str)
    parser.add_argument("-o", "--output_path", required=True, type=str)
    parser.add_argument("-s", "--vocab_size", type=int, default=None)
    parser.add_argument("-e", "--encoding", type=str, default="utf-8")
    parser.add_argument("-m", "--min_freq", type=int, default=1)
    args = parser.parse_args()

    with open(args.corpus_path, "r", encoding=args.encoding) as f:
        vocab = WordVocab(f, max_size=args.vocab_size, min_freq=args.min_freq)

    print("VOCAB SIZE:", len(vocab))
    vocab.save_vocab(args.output_path)

main函数

    print("Loading Vocab", args.vocab_path)
    vocab = WordVocab.load_vocab(args.vocab_path)
    print("Vocab Size: ", len(vocab))

    print("Loading Train Dataset", args.train_dataset)
    train_dataset = BERTDataset(args.train_dataset, vocab, seq_len=args.seq_len,
                                corpus_lines=args.corpus_lines, on_memory=args.on_memory)

    print("Loading Test Dataset", args.test_dataset)
    test_dataset = BERTDataset(args.test_dataset, vocab, seq_len=args.seq_len, on_memory=args.on_memory) \
        if args.test_dataset is not None else None

    print("Creating Dataloader")
    train_data_loader = DataLoader(train_dataset, batch_size=args.batch_size, num_workers=args.num_workers)
    test_data_loader = DataLoader(test_dataset, batch_size=args.batch_size, num_workers=args.num_workers) \
        if test_dataset is not None else None

    print("Building BERT model")
    bert = BERT(len(vocab), hidden=args.hidden, n_layers=args.layers, attn_heads=args.attn_heads)

    print("Creating BERT Trainer")
    trainer = BERTTrainer(bert, len(vocab), train_dataloader=train_data_loader, test_dataloader=test_data_loader,
                          lr=args.lr, betas=(args.adam_beta1, args.adam_beta2), weight_decay=args.adam_weight_decay,
                          with_cuda=args.with_cuda, cuda_devices=args.cuda_devices, log_freq=args.log_freq)

    print("Training Start")
    for epoch in range(args.epochs):
        trainer.train(epoch)
        trainer.save(epoch, args.output_path)

        if test_data_loader is not None:
            trainer.test(epoch)

dataset部分：

from torch.utils.data import Dataset
import tqdm
import torch
import random


class BERTDataset(Dataset):
    def __init__(self, corpus_path, vocab, seq_len, encoding="utf-8", corpus_lines=None, on_memory=True):
        self.vocab = vocab
        self.seq_len = seq_len

        self.on_memory = on_memory
        self.corpus_lines = corpus_lines
        self.corpus_path = corpus_path
        self.encoding = encoding

        with open(corpus_path, "r", encoding=encoding) as f:
            if self.corpus_lines is None and not on_memory:
                for _ in tqdm.tqdm(f, desc="Loading Dataset", total=corpus_lines):
                    self.corpus_lines += 1

            if on_memory:
                self.lines = [line[:-1].split("\t")
                              for line in tqdm.tqdm(f, desc="Loading Dataset", total=corpus_lines)]
                self.corpus_lines = len(self.lines)

        if not on_memory:
            self.file = open(corpus_path, "r", encoding=encoding)
            self.random_file = open(corpus_path, "r", encoding=encoding)

            for _ in range(random.randint(self.corpus_lines if self.corpus_lines < 1000 else 1000)):
                self.random_file.__next__()

    def __len__(self):
        return self.corpus_lines

    def __getitem__(self, item):
        t1, t2, is_next_label = self.random_sent(item)
        t1_random, t1_label = self.random_word(t1)
        t2_random, t2_label = self.random_word(t2)

        # [CLS] tag = SOS tag, [SEP] tag = EOS tag
        t1 = [self.vocab.sos_index] + t1_random + [self.vocab.eos_index]
        t2 = t2_random + [self.vocab.eos_index]

        t1_label = [self.vocab.pad_index] + t1_label + [self.vocab.pad_index]
        t2_label = t2_label + [self.vocab.pad_index]

        segment_label = ([1 for _ in range(len(t1))] + [2 for _ in range(len(t2))])[:self.seq_len]
        bert_input = (t1 + t2)[:self.seq_len]
        bert_label = (t1_label + t2_label)[:self.seq_len]

        padding = [self.vocab.pad_index for _ in range(self.seq_len - len(bert_input))]
        bert_input.extend(padding), bert_label.extend(padding), segment_label.extend(padding)

        output = {"bert_input": bert_input,
                  "bert_label": bert_label,
                  "segment_label": segment_label,
                  "is_next": is_next_label}

        return {key: torch.tensor(value) for key, value in output.items()}

    def random_word(self, sentence):
        tokens = sentence.split()
        output_label = []

        for i, token in enumerate(tokens):
            prob = random.random()
            if prob < 0.15:
                prob /= 0.15

                # 80% randomly change token to mask token
                if prob < 0.8:
                    tokens[i] = self.vocab.mask_index

                # 10% randomly change token to random token
                elif prob < 0.9:
                    tokens[i] = random.randrange(len(self.vocab))

                # 10% randomly change token to current token
                else:
                    tokens[i] = self.vocab.stoi.get(token, self.vocab.unk_index)

                output_label.append(self.vocab.stoi.get(token, self.vocab.unk_index))

            else:
                tokens[i] = self.vocab.stoi.get(token, self.vocab.unk_index)
                output_label.append(0)

        return tokens, output_label

    def random_sent(self, index):
        t1, t2 = self.get_corpus_line(index)

        # output_text, label(isNotNext:0, isNext:1)
        if random.random() > 0.5:
            return t1, t2, 1
        else:
            return t1, self.get_random_line(), 0

    def get_corpus_line(self, item):
        if self.on_memory:
            return self.lines[item][0], self.lines[item][1]
        else:
            line = self.file.__next__()
            if line is None:
                self.file.close()
                self.file = open(self.corpus_path, "r", encoding=self.encoding)
                line = self.file.__next__()

            t1, t2 = line[:-1].split("\t")
            return t1, t2

    def get_random_line(self):
        if self.on_memory:
            return self.lines[random.randrange(len(self.lines))][1]

        line = self.file.__next__()
        if line is None:
            self.file.close()
            self.file = open(self.corpus_path, "r", encoding=self.encoding)
            for _ in range(random.randint(self.corpus_lines if self.corpus_lines < 1000 else 1000)):
                self.random_file.__next__()
            line = self.random_file.__next__()
        return line[:-1].split("\t")[1]

官方版

https://github.com/google-research/bert

详见https://daiwk.github.io/posts/nlp-bert-code.html

TensorFlow Serving的深度学习在线预估优化

2018-10-11T00:00:00+00:00

概述
应用案例

参考基于TensorFlow Serving的深度学习在线预估

概述

应用案例

参考强化学习在美团“猜你喜欢”的实践

treegan

2018-10-06T00:00:00+00:00

参考学界 | TreeGAN：为序列生成任务构建有句法意识的GAN

TreeGAN: Syntax-Aware Sequence Generation with Generative Adversarial Networks

生成对抗网络是由生成网络和判别网络组成的无监督学习框架。我们将它们称为生成器（G）和判别器（D）。D 学着去区分某个数据实例是来自真实世界还是人为合成的。G 试图通过生成高质量的合成实例来迷惑 D。在 GAN 框架中，D 和 G 被不断地轮流训练直到它们达到纳什均衡。训练好的 GAN 会得到一个能够产生看起来与真实数据十分相似的高质量数据实例的生成器。

受到其在图像生成和相关领域取得的巨大成功的启发，GAN[1] 最近已经被扩展到序列生成任务中 [2，3]。用于序列生成的 GAN 在现实世界中有许多重要的应用。例如，为了给一个数据库构建一个良好的查询优化器，研究人员可能希望生成大量高质量的合成 SQL 查询语句对优化器进行基准对比测试。不同于图像生成任务，大多数语言都有其固有的语法或句法。现有的用于序列生成的 GAN 模型 [2，3，7] 主要着眼于如图 1a 所示的句法无关（grammar-free）的环境。这些方法试图从数据中学习到复杂的底层句法和语法模式，这通常是非常具有挑战性的，需要大量的真实数据样本才能取得不错的性能。在许多形式语言中，语法规则或句法（例如，SQL 句法，Python PL 句法）是预定义好的。将这样的句法引入到 GAN 的训练中，应该会得出一个具有句法意识的更好的序列生成器，并且在训练阶段显著缩小搜索空间。有句法意识的现有序列生成模型 [4] 主要是通过极大似然估计（MLE）进行训练的，它们高度依赖于真实数据样本的质量和数量。一些研究 [2，5] 表明，对抗性训练可以进一步提高基于极大似然估计的序列生成性能。即使有句法意识的现有序列生成方法引入了语法信息，其生成结果也可能不是最好的。

stackGAN

2018-09-30T00:00:00+00:00

https://www.sohu.com/a/128047728_505880

输入文本–》图片：stack gan (反img caption)

deblurGAN

2018-09-30T00:00:00+00:00

用GAN使模糊图片变清晰(ECCV2018)

g: resnet+反卷积

7x7conv,3x3conv,9个resblock,再接convtranspose(反卷积)

d: 简单的cnn

loss：adversarial_loss + lambda * content_loss

content_loss: 生成的图片和真实图片过vgg，得到第一层的输出，算perceptual loss(本质是l2 loss)

adversarial_loss: wasserstein distance

数据集：gopro有1k数据，成对的数据：效果好，但会产生伪影和亮点。因为都是运动图片

还会生成一些棋盘图（相邻像素灰度值一个高一个低）==》因为图片size不同，所以在采样时会出现重叠，然后在重叠处==》把一个反卷积改成上采样(邻近插值)

参考Deconvolution and Checkerboard Artifacts

pytorch的修改方式参考：

https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/pull/64/commits/3b6a5bb36b018ffc6dd43833c5d31af1e7a5b770

用nn.UpsamplingNearest2d(scale_factor=2)替换nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2)

cycleGAN

2018-09-30T00:00:00+00:00

模糊-》清晰

清晰-》模糊

一组到另一组的标记，不需要像素级相似（背景、姿态之类的）

BigGAN

2018-09-30T00:00:00+00:00

biggan
bigbigan

biggan

参考学界 | 史上最强GAN图像生成器，Inception分数提高两倍

https://openreview.net/pdf?id=B1xsqj09Fm

升级版：史上最强图像生成器BigGAN变身DeepGAN？四倍深度实现更强效果

bigbigan

又升级。。BigBiGAN：

GAN用于无监督表征学习，效果依然惊人……

DeepMind爆出无监督表示学习模型BigBiGAN，GAN之父点赞！

BigBiGAN的前世今生，走向成熟的特征抽取器

DeepMind开源最牛无监督学习BigBiGAN预训练模型

Large Scale Adversarial Representation Learning

预训练模型地址：https://tfhub.dev/s?publisher=deepmind&q=bigbigan

match for search recommendation（深度学习部分）

2018-09-09T00:00:00+00:00

概述
搜索领域的deep match
- 学习搜索representation
- 学习搜索match函数
  - 学习query-document的matching matrix
    - ARC-II
    - MatchPyramid
    - Match-SRNN
    - K-NRM
    - Conv-KNRM
  - 使用attention model进行match
推荐的deep match
- 学习推荐representation
  - Pure CF models
    - DeepMF
    - AutoRec
    - CDAE
  - CF with side information
    - DCF
    - DUIF
    - ACF
    - CKB
- 学习推荐match函数
  - Pure CF models的match学习
    - 基于Neural Collaborative Filtering框架
      - NeuMF
      - NNCF
      - ConvNCF
    - 基于Translation框架
      - TransRec
      - LRML
  - Feature-based models的match学习
    - 基于MLP
      - Wide&Deep
    - 基于FM
      - Neural FM
      - Attentional FM
    - 基于树
      - GB-CENT
      - DEF
      - TEM

有两个版本，一个是www18的：https://www.comp.nus.edu.sg/~xiangnan/papers/www18-tutorial-deep-matching.pdf

一个是sigir18的：https://www.comp.nus.edu.sg/~xiangnan/sigir18-deep.pdf

好像都403了。。可以看这个http://www.hangli-hl.com/uploads/3/4/4/6/34465961/wsdm_2019_tutorial.pdf

sigir的这个比较新。。看之

这里讲深度学习部分，传统部分见：https://daiwk.github.io/posts/dl-match-for-search-recommendation-traditional.html

概述

搜索领域的deep match

学习搜索representation

学习搜索match函数

学习query-document的matching matrix

ARC-II

AAAI’16 Convolutional Neural Network Architectures for Matching Natural Language Sentences

MatchPyramid

AAAI’16 Text Matching as Image Recognition

Match-SRNN

IJCAI’16 Match-SRNN: Modeling the Recursive Matching Structure with Spatial RNN

K-NRM

SIGIR’17 End-to-End Neural Ad-hoc Ranking with Kernel Pooling

Conv-KNRM

WSDM’18 Convolutional Neural Networks for So-Matching N-Grams in Ad-hoc Search

使用attention model进行match

EMNLP 2016 A Decomposable Attention Model for Natural Language Inference

match for search recommendation（传统部分）

2018-09-09T00:00:00+00:00

概述
搜索领域的传统匹配模型
- 使用机器翻译匹配
- 在latent space中匹配
  - Partial Least Square (PLS)
  - Regularized Mapping to Latent Space(RMLS)
推荐领域的传统匹配模型
- Collaborative Filtering Models
- Generic Feature-based Models

这里讲传统部分，深度学习部分见：https://daiwk.github.io/posts/dl-match-for-search-recommendation.html

概述

搜索领域的传统匹配模型

使用机器翻译匹配

Statistical Machine Translation (SMT)

Word-based Model: IBM Model One

使用Word-based Translation Models进行匹配

使用Phrase-based translation models进行匹配

在latent space中匹配

Partial Least Square (PLS)

Regularized Mapping to Latent Space(RMLS)

autokeras

2018-08-04T00:00:00+00:00

参考https://mp.weixin.qq.com/s/NAjaco_dC1y3Eo_-UfAsbg

超参数搜索不够高效？这几大策略了解一下

官网：http://autokeras.com/

代码：https://github.com/jhfjhfj1/autokeras

另一篇enas的论文 Efficient Neural Architecture Search via Parameter Sharing

enas对应的tf和pytorch实现：

tf：https://github.com/melodyguan/enas
pytorch：https://github.com/carpedm20/ENAS-pytorch

NAS：

Neural Architecture Search with Reinforcement Learning

神经架构搜索（NAS）是自动机器学习中一种有效的计算工具，旨在为给定的学习任务搜索最佳的神经网络架构。然而，现有的 NAS 算法通常计算成本很高。另一方面，网络态射（network morphism）已经成功地应用于神经架构搜索。网络态射是一种改变神经网络架构但保留其功能的技术。因此，我们可以利用网络态射操作将训练好的神经网络改成新的体系架构，如，插入一层或添加一个残差连接。然后，只需再加几个 epoch 就可以进一步训练新架构以获得更好的性能。

基于网络态射的 NAS 方法要解决的最重要问题是运算的选择，即从网络态射运算集里进行选择，将现有的架构改变为一种新的架构。基于最新网络态射的方法使用深度强化学习控制器，这需要大量的训练样例。另一个简单的方法是使用随机算法和爬山法，这种方法每次只能探索搜索区域的邻域，并且有可能陷入局部最优值。

贝叶斯优化已被广泛用于基于观察有限数据的寻找函数最优值过程。它经常被用于寻找黑箱函数的最优点，其中函数的观察值很难获取。贝叶斯优化的独特性质启发了研究者探索它在指导网络态射减少已训练神经网络数量的能力，从而使搜索更加高效。

为基于网络态射的神经架构搜索设计贝叶斯优化方法是很困难的，因为存在如下挑战：

首先，其潜在的高斯过程（GP）在传统上是用于欧氏空间的，为了用观察数据更新贝叶斯优化，潜在高斯过程将使用搜索到的架构和它们的性能来训练。然而，神经网络架构并不位于欧氏空间，并且很难参数化为固定长度的向量。
其次，采集函数需要进行优化以生成下一个架构用于贝叶斯优化。然而，这个过程不是最大化欧氏空间里的一个函数来态射神经架构，而是选择一个节点在一个树架构搜索空间中扩展，其中每个节点表示一个架构，且每条边表示一个态射运算。传统的类牛顿或基于梯度的方法不能简单地进行应用。第三，网络态射运算改变神经架构的的一个层可能会导致其它层的很多变化，以保持输入和输出的一致性，这在以前的研究中并没有定义。网络态射运算在结合了跳过连接的神经架构搜索空间中是很复杂的。

在 AutoKeras 作者提交的论文中，研究人员们提出了一种带有网络态射的高效神经架构搜索，它利用贝叶斯优化通过每次选择最佳运算来引导搜索空间。为应对上述挑战，研究者创建了一种基于编辑距离（edit-distance）的神经网络核函数。与网络态射的关键思路一致，它给出了将一个神经网络转化为另一个神经网络需要多少运算。此外，研究者为树形架构搜索空间专门设计了一种新的采集函数（acquisition function）优化器，使贝叶斯优化能够从运算中进行选择。优化方法可以在优化过程中平衡探索和利用。此外，作者还定义了一个网络级态射，以解决基于前一层网络态射的神经架构中的复杂变化。该方法被封装成一个开源软件，即 AutoKeras，在基准数据集上进行评估，并与最先进的基线方法进行比较。

论文：Efficient Neural Architecture Search with Network Morphism

之前还有一篇enas的文章：

安装：

pip install autokeras

如果装完后提示libgcc_s.so里的GCC_VERSION找不到啥的，可以试一下用root：

cp /opt/compiler/gcc-4.8.2/lib/libgcc_s.so* /lib64/

tf与开源框架的集成

2018-07-20T00:00:00+00:00

kubeflow
- 安装
  - 安装kubernets
  - 从bootstrapper安装kubeflow
tf on k8s
tf on marathon
tf on hadoop
tf on spark
附录
- 使用minikube(没成功过…)

https://github.com/tensorflow/ecosystem

kubeflow

https://github.com/kubeflow/kubeflow

安装

安装kubernets

参考http://blog.sina.com.cn/s/blog_48c95a190102wqpq.html

首先安装go：直接去官网https://www.golangtc.com/download搞一个下来，然后解压，然后设置一下export GOROOT=xxxxx，再把bin目录下的go*丢到/usr/local/bin下面就行了。

然后从https://github.com/kubernetes/kubernetes/releases这里找一个版本的源码进行下载，例如kubernetes-1.9.7.tar.gz这个版本，然后解压

然后进入解压后的目录，直接make就行了，这样会自己把最必需的kubectl、kubelet、kubeadm放到/usr/local/bin下，而且在_output目录下生成kube-apiserver、kube-proxy、kube-controller-manager、kube-scheduler等各种bin。

然后把etcd和flannel搞下来

wget https://github.com/coreos/etcd/releases/download/v2.3.8/etcd-v2.3.8-linux-amd64.tar.gz
wget https://github.com/coreos/flannel/releases/download/v0.6.2/flannel-v0.6.2-linux-amd64.tar.gz

放到/usr/local/bin下面去，然后修改 /etc/sysctl.conf

net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-arptables = 1

执行

sysctl -p

master_hostname=11.11.2.3

nohup etcd --name infra0 --initial-advertise-peer-urls http://${master_hostname}:2380,http://${master_hostname}:7001 --listen-peer-urls http://${master_hostname}:2380,http://${master_hostname}:7001 --listen-client-urls http://${master_hostname}:2379,http://${master_hostname}:4001 --advertise-client-urls http://${master_hostname}:2379,http://${master_hostname}:4001 --initial-cluster-token etcd-cluster --initial-cluster infra0=http://${master_hostname}:2380,infra0=http://${master_hostname}:7001 --data-dir /root/data/etcd/data --initial-cluster-state new &

nohup etcdctl --endpoints=http://${master_hostname}:2379,http://${master_hostname}:4001 mk /coreos.com/network/config '{"Network":"172.17.0.0/16", "SubnetMin": "172.17.1.0", "SubnetMax": "172.17.254.0"}' &

nohup flanneld -etcd-endpoints=http://${master_hostname}:2379,http://${master_hostname}:4001 &

从bootstrapper安装kubeflow

curl -O https://raw.githubusercontent.com/kubeflow/kubeflow/master/bootstrap/bootstrapper.yaml

然后

kubectl create -f bootstrapper.yaml

tf on k8s

tf on marathon

marathon是基于mesos的

tf on hadoop

tf on spark

附录

使用minikube(没成功过…)

安装kubectl

kubectl即kubernetes的客户端，通过他可以进行类似docker run等容器管理操作

+ ubuntu

sudo apt-get update && sudo apt-get install -y apt-transport-https
curl -s https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -
sudo touch /etc/apt/sources.list.d/kubernetes.list
echo "deb http://apt.kubernetes.io/ kubernetes-xenial main" | sudo tee -a /etc/apt/sources.list.d/kubernetes.list
sudo apt-get update
sudo apt-get install -y kubectl

centos

cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://packages.cloud.google.com/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://packages.cloud.google.com/yum/doc/yum-key.gpg https://packages.cloud.google.com/yum/doc/rpm-package-key.gpg
EOF

sudo yum install -y kubectl

brew install kubectl

安装minikube(local安装)

ubuntu/centos

curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.28.0/minikube-linux-amd64
chmod +x minikube
sudo mv minikube /usr/local/bin/

先从官网安装virtualbox https://www.virtualbox.org/wiki/Downloads

curl -Lo minikube https://storage.googleapis.com/minikube/releases/v0.28.0/minikube-darwin-amd64
chmod +x minikube
sudo mv minikube /usr/local/bin/

启动minikube

以下参数是kubeflow的最低配置

minikube start --cpus 4 --memory 8096 --disk-size=40g 

如果在linux下，可以指定不要虚拟机：

minikube start --cpus 4 --memory 8096 --disk-size=40g --vm-driver=none

如果发现被墙，下不下来…就手动开浏览器下载提示出错的url，例如ttps://storage.googleapis.com/minikube/iso/minikube-v0.28.0.iso

mv git_daiwk/minikube-v0.28.0.iso ~/.minikube/cache/iso/

如果kubelet下载超时，如https://storage.googleapis.com/kubernetes-release/release/v1.10.0/bin/linux/amd64/kubelet和https://storage.googleapis.com/kubernetes-release/release/v1.10.0/bin/linux/amd64/kubeadm

然后

mv kubelet ~/.minikube/cache/v1.10.0/
mv kubeadm ~/.minikube/cache/v1.10.0/

ubuntu/centos

curl --output ./k8s_version_stable.txt https://storage.googleapis.com/kubernetes-release/release/stable.txt # v1.11.1
curl --output ./kubectl "https://storage.googleapis.com/kubernetes-release/release/$(cat /tmp/kubectl_version)/bin/linux/amd64/kubectl"
curl --output ./kubelet "https://storage.googleapis.com/kubernetes-release/release/$(cat /tmp/kubectl_version)/bin/linux/amd64/kubelet"
curl --output ./kubeadm "https://storage.googleapis.com/kubernetes-release/release/$(cat /tmp/kubectl_version)/bin/linux/amd64/kubeadm"

超分辨率

2018-07-16T00:00:00+00:00

SRCNN
FSRCNN
ESPCN
VDSR
DRCN
RED
DRRN
LapSRN
SRDenseNet
SRGAN(SRResNet)
EDSR
deblurGAN
讨论
优酷数据集

综述：从网络设计到实际应用，深度学习图像超分辨率综述

基于深度学习的超分辨率图像技术一览

参考https://blog.csdn.net/sinat_39372048/article/details/81628945

可以自己搞

找图，然后加运动模糊（随机添加运动方向和位移）
视频压缩所导致的模糊，自己压缩构造样本（边缘块状）

图片物理变化：用pil直接调锐度、亮度、对比度（有参照的，在原图基础上）之类的，其中亮度、锐度可以有个整体平均灰度值，可以往这个均值附近靠

SRCNN

FSRCNN

ESPCN

VDSR

DRCN

RED

DRRN

LapSRN

SRDenseNet

SRGAN(SRResNet)

EDSR

deblurGAN

讨论

最新的能精确控制某个神经元对应哪一部分（比如眼睛鼻子之类的）

视频：用gan时，细节并没有损失，切帧，每一帧去做传统超分，可以。但做清晰度重建不行，因为运动的图片模糊部分比如帧1补了个脚。。可能帧2会补个手。。

传统超分可以先超分成大图，再下采样变小。可以省带宽，传输时下采样变小。

分辨率重建，是本身图片大小不变，直接改图。

还有另一个相似的课题：图像补全(image inpainting)

https://blog.csdn.net/gavinmiaoc/article/details/80802967

优酷数据集

优酷发布最大工业级超高清视频数据集，超分辨率算法大赛落幕

https://tianchi.aliyun.com/dataset/dataDetail?datald=39568

glow

2018-07-16T00:00:00+00:00

参考换脸效果媲美GAN！一文解析OpenAI最新流生成模型「Glow」

Glow: Generative Flow with Invertible 1x1 Convolutions

虽然基于流的生成模型在 2014 年就已经提出来了，但是一直没有得到重视。Glow 的作者在之前已经在基于流的生成模型上提出了NICE: Non-linear Independent Components Estimation和 Density estimation using Real NVP，Glow 正是在这两个模型基础加入可逆 1 x 1 卷积进行扩展，精确的潜在变量推断在人脸属性上展示了惊艳的实验效果，具体效果可在 OpenAI 放出的 Demo(https://blog.openai.com/glow/)下查看。

目前已有的生成模型除了 Glow 外包括三大类，GAN、VAE 和 Autoregressive Model（自回归模型）。其中自回归模型和VAE是基于似然的方法，GAN则是通过缩小样本和生成之间的分布实现数据的生成。

自回归模型（Autoregressive Model）：自回归模型在PixelCNN和PixelRNN上展示了很不错的实验效果，但是由于是按照像素点去生成图像导致计算成本高，在可并行性上受限，在处理大型数据如大型图像或视频是具有一定麻烦的。
变分自编码器（VAE）：VAE是在Autoencoder的基础上让图像编码的潜在向量服从高斯分布从而实现图像的生成，优化了数据对数似然的下界，VAE 在图像生成上是可并行的，但是VAE存在着生成图像模糊的问题，Glow 文中称之为优化相对具有挑战性。
生成对抗网络（GAN）：GAN 的思想就是利用博弈不断的优化生成器和判别器从而使得生成的图像与真实图像在分布上越来越相近。GAN 生成的图像比较清晰，在很多 GAN 的拓展工作中也取得了很大的提高。但是GAN生成中的多样性不足以及训练过程不稳定是GAN一直以来的问题，同时GAN没有潜在空间编码器，从而缺乏对数据的全面支持。

Glow 在图像的生成，尤其是在图像编码得到的潜在向量精确推断上展示了很好的效果。

基于流的生成模型总结一下具有以下优点：

精确的潜在变量推断和对数似然评估。在 VAE 中编码后只能推理出对应于数据点的潜在变量的近似值，GAN 根本就没有编码器更不用谈潜在变量的推断了。在 Glow 这样的可逆生成模型中，可以在没有近似的情况下实现潜在变量的精确的推理，还可以优化数据的精确对数似然，而不是其下限。
高效的推理和合成。自回归模型如 PixelCNN，也是可逆的，然而这样的模型合成难以实现并行化，并且通常在并行硬件上效率低下。而基于流的生成模型如 Glow 和 RealNVP 都能有效实现推理与合成的并行化。
对下游任务有用的潜在空间。自回归模型的隐藏层有未知的边际分布，使其执行有效的数据操作上很困难；在 GAN 中，由于模型没有编码器使得数据点通常不能在潜在空间中直接被表征，并且表征完整的数据分布也是不容易的。而在可逆生成模型和 VAE 中不会如此，它们允许多种应用，例如数据点之间的插值，和已有数据点的有目的修改。
内存的巨大潜力。如 RevNet 论文所述，在可逆神经网络中计算梯度需要一定量的内存，而不是线性的深度。

gan landscape

2018-07-16T00:00:00+00:00

1. 概述
x. 代码

1. 概述

谷歌大脑发布GAN全景图：看百家争鸣的生成对抗网络

有以下两篇：

训练 GAN 需要在生成器和判别器的参数上求解一个极小极大问题。由于生成器和判别器通常被参数化为深度卷积神经网络，这个极小极大问题在实践中非常困难。

作者主要从损失函数、判别器的正则化与归一化、生成器与判别器的架构、评估度量与数据集等 5 个方面进行了讨论。

损失函数：作者讨论了原版 GAN 的 JS 距离、WGAN 的 Wasserstein 距离和最小二乘等损失函数。
判别器的正则化与归一化：
- 判别器的正则化主要为梯度范数罚项，例如在 WGAN 中，这种梯度范数惩罚主要体现在对违反 1-Lipschitzness 平滑的软惩罚。此外，模型还能根据数据流形评估梯度范数惩罚，并鼓励判别器在该数据流形上成分段线性。
- 判别器的归一化主要体现在最优化与表征上，即归一化能获得更高效的梯度流与更稳点的优化过程，以及修正各权重矩阵的谱结构而获得更更丰富的层级特征。
生成器与判别器架构：
- 深度卷积生成对抗网络：生成器与判别器分别包含 5 个卷积层，且带有谱归一化的变体称为 SNDCGAN。
- 残差网络：ResNet19 的生成器包含 5 个残差模块，判别器包含 6 个残差模块。
评估度量：包括 Inception Score (IS)、Frechet Inception Distance (FID) 和 Kernel Inception distance (KID) 等，它们都提供生成样本质量的定量分析
数据集：IFAR10、CELEBA-HQ-128 和 LSUN-BEDROOM。

x. 代码

代码：https://github.com/google/compare_gan 安装： clone下来

然后需要修改一下setup.py，改为：

    scripts=[
        'compare_gan/bin/compare_gan_generate_tasks',
        'compare_gan/bin/compare_gan_prepare_datasets.sh',
        'compare_gan/bin/compare_gan_run_one_task',
        'compare_gan/bin/compare_gan_run_test.sh',
    ],

然后安装

pip install -e .

然后运行下面的代码，把数据集准备好

cd bin && bash -x compare_gan_prepare_datasets.sh
## 可能需要修改一下t2t_datagen的路径，例如：
#T2T_DATAGEN="$HOME/.local/bin/t2t-datagen"
#T2T_DATAGEN="/usr/local/lib/python3.6/site-packages/tensor2tensor/bin/t2t_datagen.py"

注意，这两个数据集没装：

Lsun bedrooms dataset: If you want to install lsun-bedrooms you need to run t2t-datagen yourself (this dataset will take couple hours to download and unpack).
CelebaHQ dataset: currently it is not available in tensor2tensor. Please use the ProgressiveGAN https://github.com/tkarras/progressive_growing_of_gans for instructions on how to prepare it.

然后就可以跑了(compare_gan_generate_tasks和compare_gan_run_one_task是安装的两个bin)

# Create tasks for experiment "test" in directory /tmp/results. See "src/generate_tasks_lib.py" to see other possible experiments.
compare_gan_generate_tasks --workdir=/tmp/results --experiment=test

# Run task 0 (training and eval)
compare_gan_run_one_task --workdir=/tmp/results --task_num=0 --dataset_root=/tmp/datasets

# Run task 1 (training and eval)
compare_gan_run_one_task --workdir=/tmp/results --task_num=1 --dataset_root=/tmp/datasets

分布式深度学习

2018-07-09T00:00:00+00:00

11.1的文章
7.9的文章

11.1的文章

参考学界 | 深度神经网络的分布式训练概述：常用方法和技巧全面总结

7.9的文章

参考分布式深度学习新进展：让“分布式”和“深度学习”真正深度融合

DC-ASGD算法：补偿异步通信中梯度的延迟

Asynchronous Stochastic Gradient Descent with Delay Compensation, ICML2017

其实这个在tensorRS里提到了呢

https://daiwk.github.io/posts/platform-tensorflow-optimizations.html#%E6%A2%AF%E5%BA%A6%E8%A1%A5%E5%81%BF

Ensemble-Compression算法：改进非凸模型的聚合方法

Ensemble-Compression: A New Method for Parallel Training of Deep Neural Networks, ECML 2017

随机重排下算法的收敛性分析：改进分布式深度学习理论

Convergence Analysis of Distributed Stochastic Gradient Descent with Shuffling

https://arxiv.org/abs/1709.10432

fastai

2018-07-01T00:00:00+00:00

使用多个而不是单一学习率
如何找到合适的学习率
cosine annealing
带重启的SGD算法

参考称霸Kaggle的十大深度学习技巧

原文：https://blog.floydhub.com/ten-techniques-from-fast-ai/

安装直接(目前这个版本要求torch<0.4，而autokeras要求>=0.4.0，会有点小diff咯)

pip install fastai

使用多个而不是单一学习率

差分学习率（Differential Learning rates）意味着在训练时变换网络层比提高网络深度更重要。

参考https://github.com/fastai/fastai/blob/master/courses/dl1/lesson1-vgg.ipynb

例如：

from fastai.imports import *

from fastai.transforms import *
from fastai.conv_learner import *
from fastai.model import *
from fastai.dataset import *
from fastai.sgdr import *
from fastai.plots import *

# import library for creating learning object for convolutional #networks

sz=224
arch=vgg16

# assign model to resnet, vgg, or even your own custom model
PATH = './imgs' ##文件夹要是imgs/train/1/xx.jpg, images/valid/1/xx.jpg
data = ImageClassifierData.from_paths(PATH, tfms=tfms_from_model(arch, sz))

# create fast ai data object, in this method we use from_paths where 
# inside PATH each image class is separated into different folders

learn = ConvLearner.pretrained(arch, data, precompute=True)

# create a learn object to quickly utilise state of the art
# techniques from the fast ai library

然后，冻结前面网络层并微调后面网络层：

learn.freeze()

# freeze layers up to the last one, so weights will not be updated.

learning_rate = 0.1
learn.fit(learning_rate, epochs=3)

# train only the last layer for a few epochs

当后面的网络效果比较好的时候，可以用差分学习率来改变前面的网络层，实践中，一般将学习率的缩小倍数设置为10倍：

learn.unfreeze()

# set requires_grads to be True for all layers, so they can be updated

learning_rate = [0.001, 0.01, 0.1]
# learning rate is set so that deepest third of layers have a rate of 0.001, # middle layers have a rate of 0.01, and final layers 0.1.

learn.fit(learning_rate, epochs=3)
# train model for three epoch with using differential learning rates

如何找到合适的学习率

一篇周期性学习率的paper:Cyclical Learning Rates for Training Neural Networks

用较低的学习率来训练，但在每个batch中以指数形式增加：

learn.lr_find()
# run on learn object where learning rate is increased  exponentially

learn.sched.plot_lr()
# plot graph of learning rate against iterationslr

然后可以看看学习率和loss的关系

learn.sched.plot()
# plots the loss against the learning rate

通过找出学习率最高且Loss值仍在下降的值来确定最佳学习率。在上述情况中，该值将为0.01。

cosine annealing

当逐渐接近loss最小值时，学习率应该变得更小来使得模型不会超调且尽可能接近这一点。余弦退火（Cosine annealing）利用余弦函数来降低学习率。

从上图可以看出，随着x的增加，余弦值首先缓慢下降，然后加速下降，再次缓慢下降。

learn.fit(0.1, 1)
# Calling learn fit automatically takes advantage of cosine annealing

Fast.ai库中的learn.fit()函数，来快速实现这个算法，在整个周期中不断降低学习率，如下图所示：

带重启的SGD算法

梯度下降算法可能陷入局部最小值，而不是全局最小值。

可以通过突然提高学习率，来跳出局部最小值并找到通向全局最小值的路径。这种方式称为带重启的随机梯度下降方法（stochastic gradient descent with restarts, SGDR），这个方法在Loshchilov和Hutter的ICLR论文中展示出了很好的效果。SGDR: Stochastic Gradient Descent with Warm Restarts

当调用learn.fit(learning_rate, epochs)函数时，学习率在每个周期开始时重置为参数输入时的初始值，然后像上面余弦退火部分描述的那样，逐渐减小。

每当学习率下降到最小点，在上图中为每100次迭代，我们称为一个循环。

cycle_len = 1
# decide how many epochs it takes for the learning rate to fall to
# its minimum point. In this case, 1 epoch

cycle_mult=2
# at the end of each cycle, multiply the cycle_len value by 2

learn.fit(0.1, 3, cycle_len=2, cycle_mult=2)
# in this case there will be three restarts. The first time with
# cycle_len of 1, so it will take 1 epoch to complete the cycle.
# cycle_mult=2 so the next cycle with have a length of two epochs, 
# and the next four.

如果我们把cycle_mult设成2：

关于这两个cycle_mult和cycle_len的函数，可以参考http://forums.fast.ai/t/understanding-cycle-len-and-cycle-mult/9413/8

openai gpt

2018-07-01T00:00:00+00:00

gpt
gpt-2

gpt

openai的gpt(generative pre-training)：Improving language understanding with unsupervised learning。。改名字了『Improving Language Understanding by Generative Pre-Training』

代码https://github.com/openai/finetune-transformer-lm

参考https://www.jiqizhixin.com/articles/2018-06-12-6

blog原文：https://blog.openai.com/language-unsupervised/

该方法主要结合了两个已存的研究，即 Transformer 和无监督预训练。实验结果提供了非常令人信服的证据，其表明联合监督学习方法和无监督预训练能够得到非常好的性能。

研究者开发的这种方式借鉴了他们关于 Sentiment Neuron，即https://blog.openai.com/unsupervised-sentiment-neuron/方面的研究成果，他们发现无监督学习技术在足够多的数据集上训练能产生令人惊讶的可区分特征。

主要分为两个阶段：

首先以无监督的方式在大型数据集上训练一个 Transformer，即使用语言建模作为训练信号，
然后在小得多的有监督数据集上精调模型以解决具体任务。

左图是transformer的结构，有两个目标
右图是不同应用场景下的fine-tuning方法

这一项研究任务建立在Semi-supervised Sequence Learning论文中所提出的方法，该方法展示了如何通过无监督预训练的 LSTM 与有监督的精调提升文本分类性能。这一项研究还扩展了论文Universal Language Model Fine-tuning for Text Classification所提出的 ULMFiT 方法，它展示了单个与数据集无关的 LSTM 语言模型如何进行精调以在各种文本分类数据集上获得当前最优的性能。

OpenAI 的研究工作展示了如何使用基于 Transformer 的模型，并在精调后能适应于除文本分类外其它更多的任务，例如常识推理、语义相似性和阅读理解。

该方法与 ELMo 相似但更加通用，ELMo 同样也结合了预训练，但需要使用为任务定制的架构以在各种任务中取得当前顶尖的性能。

OpenAI 只需要很少的调整就能实现最后的结果。所有数据集都使用单一的前向语言模型，且不使用任何集成方法，超参配置也与大多数研究成果相同。

缺点：

计算需求：很多之前的解决 NLP 任务的方法可以在单块 GPU 上从零开始训练相对较小的模型。OpenAI 的方法在预训练步骤中需要很高的成本——在 8 块 GPU 上训练 1 个月。幸运的是，这仅需要做一次，OpenAI 会发布他们的模型，从而其他人可以避免这一步。它也是一个很大的模型（相比于之前的工作），因而需要更多的计算和内存。OpenAI 使用了一个37 层（12 个模块）的 Tranformer架构，并且在达到512 个 token的序列上训练。多数实验都是在 4 和 8 块 GPU 的系统上构建的。该模型确实能很快速地精调到新的任务上，这缓解了额外的资源需求。
通过文本学习而导致的对世界理解的局限和偏差：在互联网上可用的书籍和文本并没有囊括关于世界的完整甚至是准确的信息。近期的研究表明特定类型的信息很难仅通过文本学习到，其它研究表明模型会从数据分布中学习和利用偏差。
泛化能力仍然很脆弱：虽然 OpenAI 的方法在多种任务中提高了性能，目前的深度学习 NLP 模型仍然展现出令人吃惊的和反直觉的行为，特别是当在系统化、对抗性或超出数据分布的方式进行评估的时候。OpenAI 的方法相比于之前的纯神经网络的方法在文本蕴涵任务上展示了提升的词法鲁棒性。在 Glockner 等人的论文《Breaking NLI Systems with Sentences that Require Simple Lexical Inferences》引入的数据集中，他们的模型达到了 83.75% 的准确率，和 KIM（Knowledge-based Inference Model，来自《NATURAL LANGUAGE INFERENCE WITH EXTERNAL KNOWLEDGE》）的性能相近（通过 WordNet 整合了外部知识）。

未来方向：

扩展该方法：研究者观察到语言模型性能的提高和下游任务的提高有很大关联。他们目前使用的是商用 GPU（单个 8GPU 机器）以及仅包含数千本书籍的训练数据集（约 5GB 的文本）。这意味着如果使用验证效果好的方法以及更多的计算资源和数据，该模型还有很大的提升空间。
改善精调过程：研究者的方法目前还很简单。有可能使用更复杂的适应和迁移技术例如在ULMFiT中所探索的方法，可以让该模型获得显著的提升。
更好地理解生成式预训练的有效性：虽然本文中片面地讨论了一些思想，更多的目标指向的实验和研究将帮助分辨不同的解释。例如，实验中观察到的性能增益有多少是由于处理更广泛上下文的能力的提高，有多少是由于世界知识的提高。

gpt-2

完全图解GPT-2：看完这篇就够了（一）完全图解GPT-2：看完这篇就够了（二）

https://jalammar.github.io/illustrated-gpt2/

Deep contextualized word representations(ELMo)

2018-07-01T00:00:00+00:00

概述
ELMo
代码
- pytorch版本
- tensorflow版本

https://zhuanlan.zhihu.com/p/37915351

https://cstsunfu.github.io/2018/06/ELMo/

https://blog.csdn.net/triplemeng/article/details/82380202

Deep contextualized word representations

https://allennlp.org/elmo

概述

之前的glove以及word2vec的word embedding在nlp任务中都取得了最好的效果, 现在几乎没有一个NLP的任务中不加word embedding.

我们常用的获取embedding方法都是通过训练language model, 将language model中预测的hidden state做为word的表示, 给定N个tokens的序列$(t_1, t_2,...,t_n)$, 前向language model就是通过前k-1个输入序列$(t_1, t_2, ...,t_k)$的hidden表示, 预测第k个位置的token, 反向的language model就是给定后面的序列, 预测之前的, 然后将language model的第k个位置的hidden输出做为word embedding。

之前的做法的缺点是对于每一个单词都有唯一的一个embedding表示, 而对于多义词显然这种做法不符合直觉, 而单词的意思又和上下文相关, ELMo的做法是我们只预训练language model, 而word embedding是通过输入的句子实时输出的, 这样单词的意思就是上下文相关的了, 这样就很大程度上缓解了歧义的发生。且ELMo输出多个层的embedding表示, 试验中已经发现每层LM输出的信息对于不同的任务效果不同, 因此对每个token用不同层的embedding表示会提升效果。

ELMo

使用双向的language model, 给定N个tokens$(t1, t2,…,tN)$, language model通过给定前面的k-1个位置的token序列计算第k个token的出现的概率:

\[ p(t_1, t_2, ..., t_N) = \prod_{k=1}^N p(t_k|t_1, t_2, ..., t_{k-1}) \]

后向的计算方法与前向相似:

\[ p(t_1, t_2, ..., t_N) = \prod_{k=1}^N p(t_k\vert t_{k+1}, t_{k+2}, ..., t_{N}) \]

双向的biLM训练过程中的目标就是最大化:

\[ \sum^N_{k=1}(\log p(t_k| t_1, ...,t_{k-1};\Theta _x, \overrightarrow{\Theta}_{LSTM}, \Theta _s) + \log p(t_k\vert t_{k+1}, ...,t_{N}; \Theta _x, \overleftarrow{\Theta}_{LSTM}, \Theta _s)) \]

ELMo对于每一个token $t_k$，通过一个L层的biLM得到2L+1个表示：

\[ R_k = \{x_k^{LM}, \overrightarrow{h}_{k,j}^{LM}, \overleftarrow{h}_{k, j}^{LM} \vert j=1, ..., L\} = \{h_{k,j}^{LM} \vert j=0,..., L\} \]

其中，

\[h_{k,0}^{LM}\]是对token直接编码的结果((这里是对字符进行CNN编码)，即上式的\[x_k^{LM}\]
$h_{k,j}^{LM} = [\overrightarrow{h}_{k,j}^{LM}; \overleftarrow{h}_{k, j}^{LM}]$是每个biLSTM层输出的结果

在应用中，将ELMo中所有层的输出R压缩为单个向量$ELMo_k = E(R_k;\Theta _\epsilon)$，最简单的压缩方法是取最后一层的输出做为token的表示: $E(R_k) = h_{k,L}^{LM}$。更通用的做法是通过一些参数来联合所有层的信息:

\[ ELMo_k^{task} = E(R_k;\Theta ^{task}) = \gamma ^{task} \sum _{j=0}^L s_j^{task}h_{k,j}^{LM} \]

其中，

$s_j$是一个softmax出来的结果
$\gamma$是任务相关的scale参数

Pre-trained的language model是用了两层的biLM, 对token进行上下文无关的编码是通过CNN对字符进行编码, 然后将三层的输出scale到1024维,最后对每个token输出3个1024维的向量表示。

这里之所以将3层的输出都作为token的embedding表示是因为实验已经证实不同层的LM输出的信息对于不同的任务作用是不同的, 也就是所不同层的输出捕捉到的token的信息是不相同的.

ELMo只是提供了word级别的解决方案：利用它的pretrained biLM来产生word embedding,然后提供给下游的模型。这里的模型往往是sequence model，其效果已经在相应的NLP任务上得到验证。

如何使用ElMo产生的表征呢？对于一个supervised NLP任务，可以分以下三步:

产生pre-trained biLM模型。模型由两层bi-LSTM组成，之间用residual connection连接起来。
在任务语料上(注意是语料，忽略label)fine tuning上一步得到的biLM模型。可以把这一步看为biLM的domain transfer。
利用ELMo的word embedding来对任务进行训练。通常的做法是把它们作为输入加到已有的模型中，一般能够明显的提高原模型的表现。

在QA，Textual entailment，Semanic role labeling, Coreference resolution, NER，和 Sentiment analysis上的表现：

其中，

Textual entailment(文本蕴含)：给定一个前提文本（premise），根据这个前提去推断假说文本（hypothesis）与premise的关系，一般分为蕴含关系（entailment）和矛盾关系（contradiction），蕴含关系（entailment）表示从premise中可以推断出hypothesis；矛盾关系（contradiction）即hypothesis与premise矛盾。文本蕴含的结果就是这几个概率值。使用的语料是Stanford Natural Language Inference (SNLI) corpus。
Coreference resolution(共指解析)：目的在于自动识别表示同一个实体的名词短语或代词，并将他们归类

和state of art比基本上每个任务都有明显的改善。表中的OUR BASELINE在论文中有详细介绍，它指的是作者选定的某些已有的模型。ELMo+BASELINE指的是作者把ELMo的word representation作为输入提供给选定的模型。

代码

pytorch版本

https://github.com/allenai/allennlp/blob/master/tutorials/how_to/elmo.md

tensorflow版本

https://github.com/allenai/bilm-tf

代码解析：https://blog.csdn.net/jeryjeryjery/article/details/81183433

看下cnn部分：

正向lstm：每个时间步预测下一个词：

反向lstm：输入序列逆序，每个时间步还是预测下一个词：

深入浅出强化学习-chap13 值迭代网络

2018-06-11T00:00:00+00:00

1. 背景
- 1.1 DQN的缺陷
- 2.2 具有规划能力的策略网络
2. 值迭代网络
3. 代码解读
- 3.1 基础知识：
- 3.2 代码

参考《深入浅出强化学习》

1. 背景

Value Iteration Networks

参考 https://zhuanlan.zhihu.com/p/25515755

slide：https://daiwk.github.io/assets/value-iteration-networks-slide.pdf

1.1 DQN的缺陷

先从以下几个角度来理解DQN：

DQN是一个深度神经网络：是一个由3个卷积层和2个全连接层组成的深度神经网络
DQN的训练方法是强化学习：调整神经网络权值有很多方法，只是在DQN中使用的是强化学习。详见第6章（https://daiwk.github.io/posts/rl-stepbystep-chap6.html）

Tamar等发现，已经调优的深度神经网络，很难泛化到其他游戏中，即，该网络并没有学到本质。。。

原因就在于，DQN的网络结构是前向的多层神经网络。输入是状态，输出是动作，也就是策略。Tamar等人称这种策略为『reactive policy(反应式策略)』。也就是给定一个状态，得到一个反应动作。

从强化学习要解决的任务来看，强化学习要解决的是序贯决策问题，即当前的决策要考虑后续的决策，使得整个策略总体最优，而反应式策略并不能表达后续策略对当前策略的影响。。

2.2 具有规划能力的策略网络

所谓的规划就是考虑后续的回报。目前大部分强化学习所用的深度网络都是反应是网络，缺少显式的规划计算。但由于训练方法用的是强化学习训练方法，在训练时考虑了规划问题，所以很多网络还是比较成功的。但由于网络本身没有规划模块，所以运用到新环境时，大部分需要重新训练，即泛化能力差。

如果训练策略本身有规划模块，有以下两个好处：

可以利用已经训练好的规划模块规划新的任务，泛化能力很强
训练方法可以更灵活，不必依赖强化学习算法。可以利用成熟的监督学习方法和模仿学习方法。而，如果没有数据标签时，仍然要用强化学习的训练方法。

2. 值迭代网络

最常用的规划算法是值迭代算法，第3章讲了动态规划的思想。规划实际蕴含的是一个优化问题，基于贝尔曼优化原理：

\[ \upsilon ^*(s)=\underset{a}{max}R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon ^*(s') \]

基于该原理，具体的算法实现是值迭代算法，在第3章中提到了https://daiwk.github.io/posts/rl-stepbystep-chap3.html#13-%E5%80%BC%E5%87%BD%E6%95%B0%E8%BF%AD%E4%BB%A3%E7%AE%97%E6%B3%95：

输入：状态转移概率$P^a_{ss'}$，回报函数$R^a_{s}$，折扣因子$\gamma$，初始化值函数$\upsilon(s)=0$，初始化策略$\pi_0$

Repeat $l=0,1,...$

for every $s$ do

$\upsilon _{l+1}(s)=\underset{a}{max}R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon _l(s')$

Until $\upsilon _{l+1}=\upsilon _l$

输出：$\pi(s)=argmax_aR^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon _l(s')$

由于值迭代的计算过程与CNN的传播过程很相似，所以可以利用CNN来表示值迭代过程。

先看看值迭代计算过程与CNN传播过程的相似之处：

值迭代中，最关键的公式是：

\[ \upsilon _{l+1}(s)=\underset{a}{max}R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon _l(s') \]

可以分解为两个步骤：

遍历动作$a$，得到不同动作$a$对应的值函数更新，即：

\[ \upsilon _{l+1}(s)=R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon _l(s') \]

这一步相当于CNN中的卷积操作。相当于图中的，输入$\bar{R}$和$Prev.\ Value$，得到$\bar{Q}$

遍历动作$a$，找到最大的$\upsilon_{l+1}(s,a)$：

\[ \upsilon _{l+1}(s)=\underset{a}{max}\upsilon _{l+1}(s,a) \]

这一步相当于CNN中的池化操作。相当于图中的，输入$\bar{Q}$，得到$New\ Value\ \bar{V}$

所以，可以将值迭代的过程用CNN嵌入到策略网络中，而与CNN有如下的不同：

偏移量$R^a_s$对应着每个像素的偏移量(bias)
状态转移函数$P^a_{ss'}$对应着卷积核，因为它要和$\bar{V}$进行点积再求和
卷积核的个数对应着动作空间的维数

这个网络迭代k次，可以理解为网络往后多看了k步之后的值函数。【相当于一个k个时间步的cnn(conv+maxpooling)，然后再和原始输入做个attention？】

k步之后得到的最优策略为：

\[ \pi ^*(s)=argmax_aR(s,a)+\gamma \sum _{s'} P(s'|s,a)V^*(s') \]

状态$s$处的策略只和它的邻域的值函数$V^*(s')$有关。而在nn中，当给定的标签只与输入特征的一个局部相关时，就是attention机制。所以，VIN在VI模块后，加了一个attention网络。

训练方法的话，可以采用模仿学习（IL），也可以采用强化学习（RL）。模仿学习就是利用专家数据对网络参数进行训练，例如针对导航任务，专家数据可以来自传统的规划算法，如Dijkstra算法或者$A^*$算法。

3. 代码解读

tf：https://github.com/TheAbhiKumar/tensorflow-value-iteration-networks

pytorch：https://github.com/kentsommer/pytorch-value-iteration-networks

tf版本

3.1 基础知识：

python的slice函数

class slice(stop)
class slice(start, stop[, step])
### start -- 起始位置
### stop -- 结束位置
### step -- 间距
## 示例

>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]
>>>

tf.nn.conv2d

参考https://daiwk.github.io/posts/knowledge-tf-usage.html#tfnnconv2d

tf.reduce_*

参考https://daiwk.github.io/posts/knowledge-tf-usage.html#tfreduce_

3.2 代码

def flipkernel(kern):
    return kern[(slice(None, None, -1),) * 2 + (slice(None), slice(None))]

def conv2d_flipkernel(x, k, name=None):
    return tf.nn.conv2d(x, flipkernel(k), name=name,
                        strides=(1, 1, 1, 1), padding='SAME')

def VI_Block(X, S1, S2, config):
    k    = config.k    # Number of value iterations performed
    ch_i = config.ch_i # Channels in input layer
    ch_h = config.ch_h # Channels in initial hidden layer
    ch_q = config.ch_q # Channels in q layer (~actions)
    state_batch_size = config.statebatchsize # k+1 state inputs for each channel

    bias  = tf.Variable(np.random.randn(1, 1, 1, ch_h)    * 0.01, dtype=tf.float32)
    # weights from inputs to q layer (~reward in Bellman equation)
    w0    = tf.Variable(np.random.randn(3, 3, ch_i, ch_h) * 0.01, dtype=tf.float32) # 从X到h？
    w1    = tf.Variable(np.random.randn(1, 1, ch_h, 1)    * 0.01, dtype=tf.float32) # 从h到reward？
    w     = tf.Variable(np.random.randn(3, 3, 1, ch_q)    * 0.01, dtype=tf.float32) # 从reward到q？
    # feedback weights from v layer into q layer (~transition probabilities in Bellman equation)
    w_fb  = tf.Variable(np.random.randn(3, 3, 1, ch_q)    * 0.01, dtype=tf.float32)
    w_o   = tf.Variable(np.random.randn(ch_q, 8)          * 0.01, dtype=tf.float32)

    # initial conv layer over image+reward prior
    h = conv2d_flipkernel(X, w0, name="h0") + bias

    r = conv2d_flipkernel(h, w1, name="r")
    q = conv2d_flipkernel(r, w, name="q")
    v = tf.reduce_max(q, axis=3, keep_dims=True, name="v") # 相当于maxpooling

    for i in range(0, k-1):
        rv = tf.concat([r, v], 3) # reward和上一步的v一起，接下来进行卷积
        wwfb = tf.concat([w, w_fb], 2)
        q = conv2d_flipkernel(rv, wwfb, name="q")
        v = tf.reduce_max(q, axis=3, keep_dims=True, name="v")

    # do one last convolution
    q = conv2d_flipkernel(tf.concat([r, v], 3),
                          tf.concat([w, w_fb], 2), name="q")

    # CHANGE TO THEANO ORDERING
    # Since we are selecting over channels, it becomes easier to work with
    # the tensor when it is in NCHW format vs NHWC
    q = tf.transpose(q, perm=[0, 3, 1, 2])

    # Select the conv-net channels at the state position (S1,S2).
    # This intuitively corresponds to each channel representing an action, and the convnet the Q function.
    # The tricky thing is we want to select the same (S1,S2) position *for each* channel and for each sample
    # TODO: performance can be improved here by substituting expensive
    #       transpose calls with better indexing for gather_nd
    bs = tf.shape(q)[0]
    rprn = tf.reshape(tf.tile(tf.reshape(tf.range(bs), [-1, 1]), [1, state_batch_size]), [-1])
    ins1 = tf.cast(tf.reshape(S1, [-1]), tf.int32)
    ins2 = tf.cast(tf.reshape(S2, [-1]), tf.int32)
    idx_in = tf.transpose(tf.stack([ins1, ins2, rprn]), [1, 0])
    q_out = tf.gather_nd(tf.transpose(q, [2, 3, 0, 1]), idx_in, name="q_out")

    # add logits
    logits = tf.matmul(q_out, w_o)
    # softmax output weights
    output = tf.nn.softmax(logits, name="output")
    return logits, output

ray

2018-06-05T00:00:00+00:00

简介
ray的ui
使用
- 简单的数据并行
- 有任务依赖的并行
ray-rllib

简介

参考伯克利AI分布式框架Ray，兼容TensorFlow、PyTorch与MXNet

github: https://github.com/ray-project

tutorials: http://ray.readthedocs.io/en/latest/tutorial.html

ray的ui

首先参考http://ipywidgets.readthedocs.io/en/latest/user_install.html

pip install ipywidgets

然后设置一下：

jupyter nbextension enable --py widgetsnbextension

再然后，启动jupyter:

nohup jupyter notebook &

还需要装个chrome的插件trace-viewer：

https://github.com/catapult-project/catapult

git clone https://github.com/catapult-project/catapult.git

然后还要安装bokeh

pip install bokeh

在我们执行ray.init(num_cpus=4, redirect_output=True)的时候会有提示，例如：

View the web UI at http://localhost:8889/notebooks/ray_ui82961.ipynb?token=43724f05dc0a2b1897bf50e9c9d01541a1bfef8ba9030eac

点开这个url，就可以看到ui的几个用法了：

import ray.experimental.ui as ui
ray.init(redis_address=os.environ["REDIS_ADDRESS"]) ## 从刚init的那个环境再init一下下

使用ui.object_search_bar()可以查看objectid的信息，例如：

Search for an object: 95f3bf18ee668c11d8f3d2c51861718daea2240d
## 输出
{'DataSize': 516,
 'Hash': '725b5c6d41876612000000001400000095f3bf18ee668c11d8f3d2c51861718d',
 'IsPut': False,
 'ManagerIDs': ['ba72fda097848a8638b6b6d66a7eb58d65748e88'],
 'TaskID': '94f3bf18ee668c11d8f3d2c51861718daea2240d'}

使用ui.task_search_bar()可以查看taskid的信息，例如：

Search for a task: 94f3bf18ee668c11d8f3d2c51861718daea2240d
{'ExecutionDependencies': [],
 'ExecutionDependenciesString': b'\x0c\x00\x00\x00\x00\x00\x06\x00'
                                b'\x08\x00\x04\x00\x06\x00\x00\x00'
                                b'\x04\x00\x00\x00\x00\x00\x00\x00',
 'LocalSchedulerID': 'd70027558552b191028c0fde93adc09114eb4c52',
 'SpillbackCount': 0,
 'State': 16,
 'TaskSpec': {'ActorCounter': 0,
              'ActorCreationDummyObjectID': 'ffffffffffffffffffffffffffffffffffffffff',
              'ActorCreationID': 'ffffffffffffffffffffffffffffffffffffffff',
              'ActorID': 'ffffffffffffffffffffffffffffffffffffffff',
              'Args': [1],
              'DriverID': '6ed2713441d1e526abb1f1bc591727511c627f4b',
              'FunctionID': 'e7ebc6e9f04fcacac3d998ac5c3b611067cc9b8d',
              'ParentCounter': 25,
              'ParentTaskID': 'b256658bf683d1525d52fb4a6b6faed08fba35ac',
              'RequiredResources': {'CPU': 1.0},
              'ReturnObjectIDs': [ObjectID(95f3bf18ee668c11d8f3d2c51861718daea2240d)],
              'TaskID': '94f3bf18ee668c11d8f3d2c51861718daea2240d'}}

而使用ui.task_timeline()则稍微有点复杂。。点击”View task timeline”，会生成一个json文件，例如/var/folders/9q/91xmxq4d1zl__l2w9lsp22mj6x47pl/T/tmpr6x81_js.json，然后就需要执行：

catapult/tracing/bin/trace2html /var/folders/9q/91xmxq4d1zl__l2w9lsp22mj6x47pl/T/tmpr6x81_js.json --output=my_trace.html && open my_trace.html

这样就可以在浏览器中打开啦~

参考：https://daiwk.github.io/assets/my_trace.html

从图中可以看出，我跑了三次，

第一次是20多个tasks，分布在4个不同的worker上并行执行
第二次1个task，建了一个新的worker
第三次7个task，分布在4个worker上并行执行

另外，下面这几个是基于bokeh的，可以直接在jupyter里看：

ui.task_completion_time_distribution()
ui.cpu_usage()
ui.cluster_usage()

使用

简单的数据并行

定义：

# A regular Python function.
def regular_function(x):
    return x

# A Ray remote function.
@ray.remote
def remote_function(x):
    return x

运行时，remote_function.remote()返回的是一个objectID，然后create了一个task。想要拿到结果，就要执行ray.get：

 >>> regular_function()
 1

 >>> remote_function.remote(1)
 ObjectID(1c80d6937802cd7786ad25e50caf2f023c95e350)

 >>> ray.get(remote_function.remote(1))
 1

数据并行：

results = [slow_function.remote(i) for i in range(7)]
ray.get(results)

会发现最后的结果是保持了原来的顺序的，应该是并行执行，然后最后会按先后顺序聚合。

有任务依赖的并行

只要不get，就可以把objectid一路传下去，最后get一下就行，这样多个remote间就是有依赖关系的了，例如(只get了一次：ray.get(losses))：

@ray.remote
def load_data(filename):
    time.sleep(0.1)
    return np.ones((1000, 100))
@ray.remote
def normalize_data(data):
    time.sleep(0.1)
    return data - np.mean(data, axis=0)
@ray.remote
def extract_features(normalized_data):
    time.sleep(0.1)
    return np.hstack([normalized_data, normalized_data ** 2])
@ray.remote
def compute_loss(features):
    num_data, dim = features.shape
    time.sleep(0.1)
    return np.sum((np.dot(features, np.ones(dim)) - np.ones(num_data)) ** 2)

time.sleep(2.0)
start_time = time.time()

losses = []
for filename in ['file1', 'file2', 'file3', 'file4']:
    data = load_data.remote(filename)
    normalized_data = normalize_data.remote(data)
    features = extract_features.remote(normalized_data)
    loss = compute_loss.remote(features)
    losses.append(loss)

print('The losses are {}.'.format(losses) + '\n')
loss = sum(ray.get(losses))

end_time = time.time()
duration = end_time - start_time

print('The loss is {}. This took {} seconds. Run the next cell to see '
      'if the exercise was done correctly.'.format(loss, duration))

可见一个task里，是串行地执行load_data->normalize_data->extract_features->compute_loss的。而每一个函数内部又分为get_arguments->execute->store_outputs三个阶段。

参考：https://daiwk.github.io/assets/my_trace.dependency.html

ray-rllib

参考https://daiwk.github.io/posts/platform-ray-rllib.html

ray-tune

2018-06-05T00:00:00+00:00

简介
使用

简介

Tune: A Research Platform for Distributed Model Selection and Training https://ray.readthedocs.io/en/latest/tune.html

一个常见的例子涉及到模型的建立。数据科学家要花费相当多的时间进行实验，其中许多涉及调整他们最爱的机器学习算法的参数。随着深度学习和RL变得越来越流行，数据科学家将需要某种软件工具来进行高效的超参数调整和其他形式的实验和模拟。 RayTune是一个新的深度学习和RL分布式超参数搜索框架。它建立在Ray之上，与RLlib紧密结合。 RayTune基于网格搜索，并使用early stopping的想法，包括中位数停止规则和HyperBand。

有越来越多的开放源代码软件工具可用于希望深入学习和RL的公司。我们处于经验时代，我们需要能够实现快速并行实验的工具，同时让我们能够利用流行的软件库，算法和组件。 Ray刚刚添加了两个库，让公司可以进行强化学习，并有效搜索神经网络架构的空间。

强化学习应用程序涉及多个组件，每个组件提供分布式计算的机会。 Ray RLlib采用了一种编程模型，可以轻松组合和重用组件，并利用多层次并行性和物理设备的并行性。在短期内，RISE实验室计划添加更多的RL算法，用于与在线服务集成的API，支持多智能体场景，以及一组扩展的优化策略。

使用

首先import

import ray
import ray.tune as tune

ray.init()

然后对想要tune的函数，加一个reporter参数，并把metrics传给reporter:

def train_func(config, reporter):  # add a reporter arg
     model = ( ... )
     optimizer = SGD(model.parameters(),
                     momentum=config["momentum"])
     dataset = ( ... )

     for idx, (data, target) in enumerate(dataset):
         accuracy = model.fit(data, target)
         reporter(mean_accuracy=accuracy) # report metrics

最后，设置搜索范围并执行：

all_trials = tune.run_experiments({
    "my_experiment": {
        "run": train_func,
        "stop": {"mean_accuracy": 99},
        "config": {"momentum": tune.grid_search([0.1, 0.2])}
    }
})

ray-rllib

2018-06-05T00:00:00+00:00

简介
tune
使用
- gym自带的环境

简介

RLlib: Abstractions for Distributed Reinforcement Learning

部分参考自：https://blog.csdn.net/zkh880loLh3h21AJTH/article/details/79620311

现有的强化学习libs：

几个出发点：

需要支持现有的机器学习库。因为RL通常使用基于梯度下降或进化算法来学习和拟合策略函数，所以您需要它支持您最喜欢的库（TensorFlow，Keras，PyTorch等）。
可扩展性。RL是计算密集型的，并且在关键应用程序中开始使用RL时，可以选择以分布式方式运行。
可组合性。RL算法通常涉及模拟和许多其他组件。您将需要一个库，允许您重用与多种深度学习框架兼容的RL算法组件（例如策略图，走子演算[这是啥。。]等），并提供可组合的分布式执行原语（嵌套并行）。

tune

https://daiwk.github.io/posts/platform-ray-tune.html

使用

最基础用法(使用lib/python2.7/site-packages/ray/rllib/train.py)：

python ./train.py --run DQN --env CartPole-v0 
python ./train.py --run APEX --env CartPole-v0
python ./train.py --run APEX_DDPG --env Pendulum-v0
python ./train.py --run DDPG --env Pendulum-v0
python ./train.py --run DDPG2 --env Pendulum-v0
python ./train.py --run A3C --env CartPole-v0 

gym自带的环境

gym的所有自带的环境（注意，rllib里的ddpg适用的问题是Box的，Discrete的不能解）

https://github.com/openai/gym/wiki/Table-of-environments

bazel

2018-06-02T00:00:00+00:00

c++

下载demo

git clone https://github.com/bazelbuild/examples/

examples
└── cpp-tutorial
    ├──stage1
    │  ├── main
    │  │   ├── BUILD
    │  │   └── hello-world.cc
    │  └── WORKSPACE
    ├──stage2
    │  ├── main
    │  │   ├── BUILD
    │  │   ├── hello-world.cc
    │  │   ├── hello-greet.cc
    │  │   └── hello-greet.h
    │  └── WORKSPACE
    └──stage3
       ├── main
       │   ├── BUILD
       │   ├── hello-world.cc
       │   ├── hello-greet.cc
       │   └── hello-greet.h
       ├── lib
       │   ├── BUILD
       │   ├── hello-time.cc
       │   └── hello-time.h
       └── WORKSPACE

在project的根目录有一个WORKSPACE文件
有一个BUILD文件的目录是一个package

常用命令

build WORKSPACE 下面所有的 target，会扫所有的目录

bazel build //...

单独的 build 的 target 则直接 //:demo，这里 :demo 是 target name

bazel build //:demo

执行 :demo

bazel run //:demo

跑 demo_test 测试

baze test //:demo_test

tf serving docker+k8s

2018-06-02T00:00:00+00:00

tf-serving
基本流程
docker + tf-serving[from 阿里云]
docker + k8s + tf-serving[自己搞]
- docker+tf-serving
k8s

tf-serving

https://github.com/tensorflow/serving

安装方式见https://github.com/tensorflow/serving/blob/master/tensorflow_serving/g3doc/setup.md

基本流程

参考没人告诉你的大规模部署AI高效流程！

将graph固化为Protobuf二进制文件
调整推断代码，使它可以处理固化的图
容器化应用程序
在最上面加上API层

将graph进行freeze

「固化」graph要用所有命名节点、权重、架构和检查点元数据，并创建一个protobuf二进制文件。最常用的是tf自己的工具，它可以固化任何给定输出节点名字的graph。参考https://www.tensorflow.org/guide/extend/model_files#freezing

调整推断代码

在大多数情况下，feed_dict 是不变的，主要区别在于添加了加载模型的代码，也许还有输出节点的规范。

容器化

只要在 Dockerfile 中设置环境即可

添加API层

两种通用的方法：

部署可以运行推断脚本的扩展容器

这些容器根据输入运行脚本，脚本启动一个会话并执行推断，再通过管道返回输出结果。这种方法效率是很低的：

对大多数云供应商而言添加一个可以操纵容器和管道进出的 API 层并不容易
在启动容器、分配硬件、启动会话以及推断时会损失宝贵的时间
你让stdin开着并保持管道输出，那么你的脚本就会加速但是会失去可扩展性

部署运行API层的扩展容器

这种方法效率更高:

虽然这需要更多资源，但它已经用了最少资源而且没有垂直扩展
允许每个容器保持运行状态
由于这种情况下 API 是分散的，因此可以将特定的stdin/stout连接到主要的请求路由器上
省去了启动时间，可以在服务多个请求的同时维持速度并保证水平扩展
可以用负载平衡器集中容器，并用Kubernetes保证近乎100%的运行时间并管理集群

缓解计算成本的累积

通过容器集群分散 API 的主要缺点在于计算成本会相对较快地累积起来。这在AI中是不可避免的，但有一些方法可以缓解这一问题。

重复使用会话

集群会根据负载成比例地增长和收缩，因此你的目标是最小化执行推断的时间，使容器可以释放出来处理另外的请求。

所以可以初始化tf.Session和tf.Graph后就将它们存储起来并将它们作为全局变量传递，以达到重复使用tf.Session和tf.Graph的目的。

这样做可以减少启动会话和构建图的时间，从而大大提高推断任务的速度，即便是单个容器，这个方法也是有效的。这一技术被广泛用于资源再分配最小化和效率最大化。

缓存输入

如果可能的话还要缓存输出。

动态规划范式在AI中是最重要的。缓存输入，你可以节省预处理输入或从远程获得输入的时间；缓存输出，你可以节省运行推断的时间。

通常，你的模型会随着时间的推移变得更好，但这会很大程度上影响你的输出缓存机制。例如，可以使用80-20原则，当模型准确率低于80% 时，不会缓存任何输出；一旦准确率到了80%，就开始缓存并设置为在准确率到一定值（而不是某个时间点）的时候停止缓存。

随着模型变得越来越准确，输出也会发生变化，但是在「80-20」缓存中，性能和速度之间存在的权衡更少。

使用任务队列

一般需要运行或大或小的推断任务，对UX来说，使用堆队列（heap queue）可能更好，它会优先处理小一些的任务，这样，要运行简单步骤的用户只要等这一步结束就行了，而不必等另一个用户的更大推断任务先完成。

在带有任务队列的专用GPU上训练模型。如果你要将每个交互返回到模型中进行训练，请考虑在单独的服务器或GPU上运行。一旦训练结束，你就可以将模型（在AWS中，你可以将模型repo集中在S3中）部署到容器中了。

部署小结

固化图并将推断封装在API下
重复使用会话和图，缓存输入和输出
用Docker容器化应用程序（包括API层）
将大规模应用程序与Kubernetes一起部署在你选择的云上
将训练从推断中分离出来
建立任务队列，提高较小的任务的运行优先级

docker + tf-serving[from 阿里云]

注意：1.6版本的docker不行（没有–link参数，-p参数不是port），亲测1.9.1的docker可以。。

参考：https://yq.aliyun.com/articles/60894

这两个镜像[发现bazel是0.3.0，而serving是2016.9时的版本]：

registry.cn-hangzhou.aliyuncs.com/denverdino/tensorflow-serving : TensorFlow Serving的基础镜像
registry.cn-hangzhou.aliyuncs.com/denverdino/inception-serving : 基于上述基础镜像添加Inception模型实现的服务镜像

docker + k8s + tf-serving[自己搞]

https://www.tensorflow.org/serving/serving_inception

docker+tf-serving

参考https://www.tensorflow.org/serving/docker

创建docker镜像

首先把这个搞下来https://github.com/tensorflow/serving/blob/master/tensorflow_serving/tools/docker/Dockerfile.devel：

然后，把bazel的version改成0.11.0（编译1.7版本的serving需要），另外，我还补充了automake/libtool【当然，目前可以work的是1.4版本的serving，要把bazel版本改成0.5.4】：

FROM ubuntu:16.04

MAINTAINER Jeremiah Harmsen <jeremiah@google.com>

RUN apt-get update && apt-get install -y \
        build-essential \
        curl \
        git \
        libfreetype6-dev \
        libpng12-dev \
        libzmq3-dev \
        mlocate \
        pkg-config \
        python-dev \
        python-numpy \
        python-pip \
        software-properties-common \
        swig \
        zip \
        zlib1g-dev \
        libcurl3-dev \
        openjdk-8-jdk\
        openjdk-8-jre-headless \
        wget \
        automake \
        libtool \
        && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

# Set up grpc

RUN pip install mock grpcio

# Set up Bazel.

ENV BAZELRC /root/.bazelrc
# Install the most recent bazel release.
ENV BAZEL_VERSION 0.11.0
WORKDIR /
RUN mkdir /bazel && \
    cd /bazel && \
    curl -fSsL -O https://github.com/bazelbuild/bazel/releases/download/$BAZEL_VERSION/bazel-$BAZEL_VERSION-installer-linux-x86_64.sh && \
    curl -fSsL -o /bazel/LICENSE.txt https://raw.githubusercontent.com/bazelbuild/bazel/master/LICENSE && \
    chmod +x bazel-*.sh && \
    ./bazel-$BAZEL_VERSION-installer-linux-x86_64.sh && \
    cd / && \
    rm -f /bazel/bazel-$BAZEL_VERSION-installer-linux-x86_64.sh

CMD ["/bin/bash"]

docker build --pull -t $USER/tensorflow-serving-devel -f Dockerfile.tf-serving . 

启动docker并进入

docker run -idt -v /home/disk1/tf_space:/home/work/data $USER/tensorflow-serving-devel /bin/bash

编译server

root@cb189256755# cd /home/work/data/serving/serving_1.4/
root@0cb189256755:/home/work/data/serving/serving_1.4# git clone -b r1.4 --recurse-submodules https://github.com/tensorflow/serving
root@0cb189256755:/home/work/data/serving/serving_1.4# cd serving/tensorflow
root@0cb189256755:/home/work/data/serving/serving_1.4/serving/tensorflow# ./configure
root@0cb189256755:/home/work/data/serving/serving_1.4/serving# cd ..
root@0cb189256755:/home/work/data/serving/serving_1.4/serving# bazel build -c opt tensorflow_serving/model_servers:tensorflow_model_server

这样，生成的bazel-bin/tensorflow_serving/model_servers/tensorflow_model_server就是我们想要的啦

编译examples

编译一下tf-serving的example:

root@0cb189256755:/home/work/data/serving/serving_1.4/serving# bazel build -c opt tensorflow_serving/example/...

mnist example

训练并export一个模型

root@0cb189256755:/home/work/data/serving/serving_1.4/serving# rm /tmp/mnist_model/ -rf
root@0cb189256755:/home/work/data/serving/serving_1.4/serving# bazel-bin/tensorflow_serving/example/mnist_saved_model /tmp/mnist_model
Training model...
Extracting /tmp/train-images-idx3-ubyte.gz
Extracting /tmp/train-labels-idx1-ubyte.gz
Extracting /tmp/t10k-images-idx3-ubyte.gz
Extracting /tmp/t10k-labels-idx1-ubyte.gz
2018-06-03 10:29:58.144101: I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:137] Your CPU supports instructions that this TensorFlow binary was not compiled to use: SSE4.1 SSE4.2 AVX AVX2 FMA
training accuracy 0.9092
Done training!
Exporting trained model to /tmp/mnist_model/1
Done exporting!

看到/tmp/mnist_model下面有一个文件夹1，就代表version，下面有两部分：

saved_model.pb：序列化后的 tensorflow::SavedModel. It includes one or more graph definitions of the model, as well as metadata of the model such as signatures.
variables: files that hold the serialized variables of the graphs.

启动server

root@0cb189256755:/home/work/data/serving/serving_1.4/serving# nohup bazel-bin/tensorflow_serving/model_servers/tensorflow_model_server --port=9000 --model_name=mnist --model_base_path=/tmp/mnist_model/ &

启动client

root@0cb189256755:/home/work/data/serving/serving_1.4/serving# bazel-bin/tensorflow_serving/example/mnist_client --num_tests=1000 --server=localhost:9000
Extracting /tmp/train-images-idx3-ubyte.gz
Extracting /tmp/train-labels-idx1-ubyte.gz
Extracting /tmp/t10k-images-idx3-ubyte.gz
Extracting /tmp/t10k-labels-idx1-ubyte.gz
........................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................
Inference error rate: 10.4%

inception example

export一个训练好的模型并存储到/tmp/inception-export

root@0cb189256755:/home/work/data/serving/serving_1.4/serving# curl -O http://download.tensorflow.org/models/image/imagenet/inception-v3-2016-03-01.tar.gz
root@0cb189256755:/home/work/data/serving/serving_1.4/serving# tar xzf inception-v3-2016-03-01.tar.gz
root@0cb189256755:/home/work/data/serving/serving_1.4/serving# ls inception-v3
README.txt  checkpoint  model.ckpt-157585
root@0cb189256755:/home/work/data/serving/serving_1.4/serving# bazel-bin/tensorflow_serving/example/inception_saved_model --checkpoint_dir=inception-v3 --output_dir=/tmp/inception-export
Successfully loaded model from inception-v3/model.ckpt-157585 at step=157585.
Successfully exported model to /tmp/inception-export

启动server

root@0cb189256755:/home/work/data/serving/serving_1.4/serving# nohup bazel-bin/tensorflow_serving/model_servers/tensorflow_model_server --port=9000 --model_name=inception --model_base_path=/tmp/inception-export &> inception_log &

启动client：

root@0cb189256755:/home/work/data/serving/serving_1.4/serving# bazel-bin/tensorflow_serving/example/inception_client --server=localhost:9000 --image=persian_cat_image.jpg   
outputs {
  key: "classes"
  value {
    dtype: DT_STRING
    tensor_shape {
      dim {
        size: 1
      }
      dim {
        size: 5
      }
    }
    string_val: "Persian cat"
    string_val: "lynx, catamount"
    string_val: "Egyptian cat"
    string_val: "tabby, tabby cat"
    string_val: "Angora, Angora rabbit"
  }
}
outputs {
  key: "scores"
  value {
    dtype: DT_FLOAT
    tensor_shape {
      dim {
        size: 1
      }
      dim {
        size: 5
      }
    }
    float_val: 9.48267459869
    float_val: 3.10385608673
    float_val: 2.89405298233
    float_val: 2.83001184464
    float_val: 2.81639647484
  }
}

大功告成咯~~

commit container

docker commit 0cb189256755 root/tf_serving_1.4

然后就可以看到

docker images
REPOSITORY                                                        TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
root/tf_serving_1.4                                               latest              e6eae34c8754        41 seconds ago      3.014 GB

在2个容器间进行访问

然后启动两个容器：

## 谨慎使用，删除现有所有容器
docker ps -aq| xargs docker stop | xargs docker rm

docker run -dti \
        -p 9001:9000 \
        --name inception-serving \
        root/tf_serving_1.4 \
        /bin/bash


docker run -dti \
        --name client \
        --link inception-serving:serving \
        -v /home/disk1/tf_space:/home/work/data \
        root/tf_serving_1.4 \
        /bin/bash

启动客户端，并定义容器link，允许在容器内部通过“serving”别名来访问“inception-serving”容器

此时，

 docker ps   
CONTAINER ID        IMAGE                           COMMAND             CREATED             STATUS              PORTS                    NAMES
910de959f1ae        root/tf_serving_1.4             "/bin/bash"         41 seconds ago      Up 40 seconds                                client
3e3134158f9c        root/tf_serving_1.4             "/bin/bash"         41 seconds ago      Up 40 seconds       0.0.0.0:9001->9000/tcp   inception-serving

进入server 3e3134158f9c：

root@3e3134158f9c:~# cd /home/work/data/serving/serving_1.4/serving/
root@3e3134158f9c:/home/work/data/serving/serving_1.4/serving# nohup bazel-bin/tensorflow_serving/model_servers/tensorflow_model_server --port=9000 --model_name=inception --model_base_path=/tmp/inception-export &> inception_log &

进入client 910de959f1ae，注意，这里的--server=serving:9000，serving就是刚刚–link取的别名~

root@910de959f1ae:~# cd /home/work/data/serving/serving_1.4/serving/
root@910de959f1ae:/home/work/data/serving/serving_1.4/serving# bazel-bin/tensorflow_serving/example/inception_client --server=serving:9000 --image=persian_cat_image.jpg 

k8s

crf v.s. softmax

2018-05-30T00:00:00+00:00

softmax与crf对比
Optimal Hyperparameters for Deep LSTM-Networks for Sequence Labeling Tasks

softmax与crf对比

参考https://www.jiqizhixin.com/articles/2018-05-23-3

摘一句重点：

逐帧 softmax 和 CRF 的根本不同：前者将序列标注看成是 n 个 k 分类问题，后者将序列标注看成是 1 个 k^n 分类问题。

参考https://blog.csdn.net/bobobe/article/details/80489303

Optimal Hyperparameters for Deep LSTM-Networks for Sequence Labeling Tasks

knowledge distill

2018-05-22T00:00:00+00:00

introduction
distillation
- Matching logits是distillation的一个特例
在MNIST上的初步实验
在speech recognition上的实验
training ensembles of specialists on very big datasets
soft targets as regularizers
- 使用soft targets以阻止specialists过拟合
与mixtures of experts的关系

https://www.zhihu.com/question/50519680

原始paper：Distilling the Knowledge in a Neural Network

参考蒸馏神经网络(Distill the Knowledge in a Neural Network)

introduction

核心思想：一个复杂的网络结构模型是若干个单独模型组成的集合，或者是一些很强的约束条件下（比如dropout率很高）训练得到的一个很大的网络模型。一旦复杂网络模型训练完成，我们便可以用另一种训练方法：“蒸馏”，把复杂模型中的knowledge transfer到一个更易于部署的小模型中。

“蒸馏”的难点在于如何缩减网络结构但是把网络中的知识保留下来。知识就从输入向量到输出向量的一个learned mapping。做复杂网络的训练时，目标是将正确答案的概率最大化，但这引入了一个副作用：这种网络为所有错误答案分配了概率，即使这些概率非常小。而这些错误答案间也有的比别的大，例如一辆宝马车，错误答案货车的概率就比错误答案胡萝卜的概率要大得多，这也是模型泛化能力的体现。

将复杂模型转化为小模型时需要注意保留模型的泛化能力：

一种方法是利用由复杂模型产生的分类概率作为软目标来训练小模型。在transfer阶段，我们可以用同样的训练集或者是单独的transfer set。当复杂模型是由简单模型复合而成时，我们可以用各自的概率分布的算术平均或者几何平均作为软目标。当软目标的熵值较高时，相对硬目标，它每次训练可以提供更多的信息和更小的梯度方差，因此小模型可以用更少的数据和更高的学习率进行训练。

像MNIST这种任务，复杂模型可以给出很完美的结果，大部分信息分布在小概率的软目标中。比如一张2的图片被认为是3的概率为0.000001，被认为是7的概率是0.000000001，但对于cross entropy的损失函数的值来讲，就没什么区分性了，因为他们都接近0。

Caruana用logits（softmax层的输入）而不是softmax层的输出作为“软目标”。他们目标是是的复杂模型的logits和小模型的logits的平方差最小。

distillation：

第一步，提升final softmax中的调节参数T，使得复杂模型产生合适的『软目标』。
第二步，采用同样的T来训练小模型，让它去匹配『软目标』
第三步，训练完成之后，T变回1

后面发现，匹配复杂模型的logits其实就是distillation的一个special case。

transfer set可以由无标签数据组成(Model Compression)，也可以用原训练集。我们发现使用原训练集效果很好，特别是我们在目标函数中加了一项目之后，这一项会encourage小模型预测真实目标，同时尽量匹配『软目标』。要注意的是，小模型并不能完全无误的匹配“软目标”，而正确结果的犯错方向(erring in the direction of the correct answer)是有帮助的。

distillation

softmax层公式如下：

\[ q_i=\frac{\exp(z_i/T)}{\sum _j \exp(z_j/T)} \]

$z_i$：logit，也就是softmax层的输入
$q_i$：softmax层算出的分类概率
$T$：temperature，就是调节参数，一般设为1。T越大，分类的概率分布越『软』

复制粘贴一下上面提到的：

distillation：

第一步，提升final softmax中的调节参数T，使得复杂模型产生合适的『软目标』。
第二步，采用同样的T来训练小模型，让它去匹配『软目标』
第三步，训练完成之后，T变回1

当transfer set中部分或者所有数据都有标签时，这种方式可以通过同时训练模型使得模型得到正确的标签来大大提升效果。

一种实现方法是用正确标签来修正『软目标』，但一种更好的方法是：对两个目标函数进行加权平均。

第一个目标函数是两个模型的『软目标』的交叉熵，这个交叉熵用开始的那个比较大的T来计算。
第二个目标函数是正确标签的交叉熵，这个交叉熵用小模型softmax层的logits来计算且T等于1。

发现当第二个目标函数权重较低时可以得到最好的结果。

因为梯度的量级(magnitude)被『软目标』缩放了$1/T^2$(下面有讲)，所以同时使用hard和soft target的时候，需要乘以$T^2$，这样可以保证即使T在实验的过程中改了，hard和soft targets的贡献程度相对不变。

Matching logits是distillation的一个特例

那么，我们先看一下交叉熵的求导(参考简单易懂的softmax交叉熵损失函数求导)，假设$z_i$是logit，经过softmax后得到$a_i$，label是$y_i$，那么，由于n个类，只有一个类是1，其他都是0，所以$\sum_j y_j = 0$，所以：

\[ \frac{\partial C}{\partial z_i}=\frac{\partial C}{\partial a_i}\frac{\partial a_i}{\partial z_i}=...=a_i\sum_j y_j-y_i=a_i-y_i \]

然后看回这个distill模型

大模型的logit是$v_i$，算出来的soft target的probability是$p_i$，
小模型的logit是$z_i$，算出来的soft target的probability是$q_i$

交叉熵损失函数对小模型的logit，也就是$z_i$进行求导（把$p_i$看成一个常量），得到的梯度$dC/dz_i$如下：

\[ \frac{\partial C}{\partial z_i}=\frac{1}{T}(q_i-p_i)=\frac{1}{T}(\frac{e^{z_i/T}}{\sum_je^{z_j/T}}-\frac{e^{v_i/T}}{\sum_je^{v_j/T}}) \]

然后，如果temperature T比logits的量级（magnitude）要大得多，那么，$z_i/T$趋向于0（是一个很小的数），$z_i<0$的时候是从左边趋向于0，$z_i\>0$的时候是从右边趋向于0，所以，$e^{z_i/T}\approx e^0+z_i/T$。因此，可以如下方式近似：

\[ \frac{\partial C}{\partial z_i}\approx \frac{1}{T}(\frac{1+z_i/T}{N+\sum _jz_j/T}-\frac{1+v_i/T}{N+\sum_jv_j/T}) \]

假设对于每一个transfer case，都有logits的均值为0，那么就有$\sum_jz_j=\sum_jv_j=0$，所以上式可以简化为：

\[ \frac{\partial C}{\partial z_i}\approx \frac{1}{T}(\frac{1+z_i/T}{N}-\frac{1+v_i/T}{N})=\frac{1}{NT^2}(z_i-v_i) \]

所以，如果temperature T很高，如果对于每一个transfer case，都有logits的均值为0，那么distillation就等价于最小化$1/2(z_i-v_i)^2$，也就是Caruana提出的使得复杂模型的logits和小模型的logits的平方差最小。

而对于比较低的temperature T来讲，distillation对那些比平均值negative很多的logits的matching，会给予更少的关注。因为这样的logits在大模型的损失函数中几乎是unconstrained，也就是noisy的，所以这是potentially advantageous的。另一方面，这些很negative的logits可能可以传递大模型学到的知识中的很有用的信息。上面的这些效果哪个起了决定性作用其实是一个empirical(经验主义) question。当distilled model比大模型小太多，以至于无法捕捉到大模型的所有知识时，intermediate（中间的）的temperature效果最好，强烈建议把large negative logits直接忽略掉是很有用的。

在MNIST上的初步实验

在speech recognition上的实验

training ensembles of specialists on very big datasets

JFT dataset

specialist models

assigning classes to specialists

performing inference with ensumbles of specialists

结果

soft targets as regularizers

使用soft targets以阻止specialists过拟合

与mixtures of experts的关系

rl summary

2018-05-14T00:00:00+00:00

概览
基于值函数的强化学习方法
策略搜索方法
自己的小结

概览

基于值函数的强化学习方法

基于值函数的方法是间接方法，即通过学习值函数（value function）或者动作值函数（action-value function）来得到policy。

策略搜索方法

直接对policy进行建模和学习

自己的小结

某个时候整理了个ppt：

rl tutorial-pytorch

2018-05-05T00:00:00+00:00

DQN
pytorch tutorial

DQN

原文是DeepMind发表在Nature上的文章Human-level control through deep reinforcement learning

参考DQN起源《Human-level control through deep reinforcement learning》论文笔记

论文笔记 Human-Level control through deep reinforcement learning

pytorch tutorial

参考https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html

mlperf

2018-05-05T00:00:00+00:00

代码地址：

https://github.com/mlperf/reference

目前有7个任务：

image_classification - Resnet-50 v1 applied to Imagenet.(tensorflow)
object_detection - Mask R-CNN applied to COCO.(caffe2)
speech_recognition - DeepSpeech2 applied to Librispeech.(pytorch)
translation - Transformer applied to WMT English-German.(tensorflow)
recommendation - Neural Collaborative Filtering applied to MovieLens 20 Million (ml-20m).(pytorch)
sentiment_analysis - Seq-CNN applied to IMDB dataset.(paddle)
reinforcement - Mini-go applied to predicting pro game moves.(tensorflow)

分布式强化学习框架

2018-05-01T00:00:00+00:00

1. 概述
2. A3C
3. PPO
4. rainbow
5. APE-X
6. rudder
7. IMPALA
xx. 自己搞一下
其他RL平台
- open spiel
- rlpyt
FEN

1. 概述

略大部分在ray中都已经有啦，还有openai的baselines

https://github.com/ray-project/ray/blob/master/doc/source/rllib-algorithms.rst

https://github.com/openai/baselines

2. A3C

参考https://blog.csdn.net/jinzhuojun/article/details/72851548

ICML2016，提出了Asynchronous Methods for Deep Reinforcement Learning，即A3C（asynchronous advantage actor-critic）算法。

A3C不仅适用于离散也适用于连续动作空间的控制问题。DRL领域也确实有很成功的分布式机器学习系统，比如Google的Gorila。这篇文章另辟蹊径，发明了“平民版”的DRL算法，而且效果还不比前者差。

传统经验认为，online的RL算法在和DNN简单结合后会不稳定。主要原因是观察数据往往波动很大且前后sample相互关联。像Neural fitted Q iteration和TRPO方法通过将经验数据batch，或者像DQN中通过experience replay memory对之随机采样，这些方法有效解决了前面所说的两个问题，但是也将算法限定在了off-policy方法中。

而A3C是通过创建多个agent，在多个环境实例中并行且异步的执行和学习。于是，在DNN下，解锁了一大批online/offline的RL算法（如Sarsa, AC, Q-learning）。A3C不那么依赖于GPU或大型分布式系统，可以跑在一个多核CPU上。

将value function的估计作为baseline可以使得PG方法有更低的variance。这种设定下，就有了所谓的A - advantage，即，$R_t−b_t(s_t)$，即$A(s_t,s_t)=Q(a_t,s_t)−V(s_t)$，就是advantage function的估计。

将one-step Sarsa, one-step Q-learning, n-step Q-learning和advantage AC扩展至多线程异步架构。

注意，该框架是具有通用性的，例如，AC是on-policy的policy搜索方法，而Q-learning是off-policy value-based方法。

每个线程都有agent运行在环境的拷贝中，每一步生成一个参数的梯度，多个线程的这些梯度累加起来，一定步数后一起更新共享参数。

优点：

它运行在单个机器的多个CPU线程上，而非使用parameter server的分布式系统，这样就可以避免通信开销和利用lock-free的高效数据同步方法（Hogwild!方法）【2011年的Hogwild ! : A Lock-Free Approach to Parallelizing Stochastic Gradient Descent是一种并行SGD方法。该方法在多个CPU时间进行并行。处理器通过共享内存来访问参数，并且这些参数不进行加锁。它为每一个cpu分配不重叠的一部分参数（分配互斥），每个cpu只更新其负责的参数。该方法只适合处理数据特征是稀疏的。该方法几乎可以达到一个最优的收敛速度，因为cpu之间不会进行相同信息重写。】
多个并行的actor可以有助于exploration。在不同线程上使用不同的探索策略，使得经验数据在时间上的相关性很小。这样不需要DQN中的experience replay也可以起到稳定学习过程的作用，意味着学习过程可以是on-policy的，所以可以使用on-policy方法（如Sarsa），且能保证稳定。

A3C和DDPG类似，通过DNN维护了policy和value function的估计，但它没用deterministic policy。在学习过程中使用n-step回报来同时更新policy和value function。

网络结构使用了CNN，其中一个softmax output作为policy，即$\pi(a_t|s_t;\theta)$，另一个linear output为value function，即$V(s_t;\theta _v)$，其余layer都共享。

作者还发现一个古老的技巧，即将policy的entropy加到目标函数可以避免收敛到次优确定性解。直观上，加上该正则项后目标函数更鼓励找entropy大的，即形状“扁平”的分布，这样就不容易在训练过程中聚集到某一个动作上去。

在优化方法上，作者使用了基于RPMProp的一种变体。

ray的a3c代码：https://github.com/ray-project/ray/tree/master/python/ray/rllib/agents/a3c

3. PPO

参考业界 | OpenAI 提出强化学习近端策略优化，可替代策略梯度法

Proximal Policy Optimization Algorithms

openai的blog：https://blog.openai.com/openai-baselines-ppo/

策略梯度法（Policy gradient methods）是近来使用深度神经网络进行控制的突破基础，不论是视频游戏还是 3D 移动或者围棋控制等，它们都基于策略梯度法。但但是通过策略梯度法获得优秀的结果是十分困难的，policy gradient有以下几点不足：

它对步长大小的选择非常敏感。如果迭代步长太小，那么训练进展会非常慢，但如果迭代步长太大，那么信号将受到噪声的强烈干扰，因此我们会看到性能会急剧降低。
策略梯度法有非常低的样本效率，它需要数百万（或数十亿）的时间步骤来学习一个简单的任务。

研究人员希望能通过约束或其他优化策略更新（policy update）大小的方法来消除这些缺陷，如 TRPO 和 ACER 等方法。

ACER（Sample Efficient Actor-Critic with Experience Replay）方法要比PPO方法复杂得多，需要额外添加代码来修正off-policy和重构缓冲器，但它在Atari基准上仅仅比PPO好一点点
TRPO（Trust region policy optimization，置信域策略优化）虽然对连续控制任务非常有用，但它并不容易与那些在策略和值函数或辅助损失函数（auxiliary losses）间共享参数的算法兼容，即那些用于解决 Atari 和其他视觉输入很重要领域的算法。

PPO 算法很好地权衡了实现简单性、样本复杂度和调参难度，它尝试在每一迭代步计算一个更新以最小化成本函数，在计算梯度时还需要确保与先前策略有相对较小的偏差。

之前介绍过一个 PPO 变体（在NIPS2016上有一个talk Deep Reinforcement Learning Through Policy Optimization），即使用一个适应性 KL 惩罚项来控制每一次迭代中的策略改变。这次的目标函数实现了一种与随机梯度下降相匹配的置信域（Trust Region）更新方法，它同时还移除了 KL 惩罚项以简化算法和构建适应性更新。在测试中该算法在连续控制任务中取得了最好的性能，并且尽管实现起来非常简单，但它同样在 Atari 上获得了与 ACER 算法相匹配的性能。

4. rainbow

Rainbow: Combining improvements in deep reinforcement learning

参考DeepMind提出Rainbow：整合DQN算法中的六种变体

Double DQN（DDQN；van Hasselt、Guez&Silver；2016）通过解耦选择（decoupling selection）和引导行动评估解决了Q-learning过度估计偏差的问题。
Prioritized experience replay（Schaul 等人；2015）通过重放（replay）学习到更频繁的转换，提升了数据效率。
dueling 网络架构（Wang 等人；2016）可以通过分别表示状态值和动作奖励来概括各种动作。
从多步骤引导程序目标中学习（Sutton；1988；Sutton & Barto 1998）如 A3C（Mnih 等人；2016）中使用偏差-方差权衡，而帮助将最新观察到的奖励快速传播到旧状态中。
分布式 Q-learning（Bellemare、Dabney & Munos；2017）学习了折扣回报（discounted returns）的分类分布（代替了估计平均值）。
Noisy DQN（Fortunato 等人；2017）使用随机网络层进行exploration。

以上这些算法各自都可以提升 DQN 性能的某个方面，因为它们都着力于解决不同的问题，而且都构建在同一个框架上，所以能够被我们整合起来。

5. APE-X

5.1 简介

参考最前沿：当我们以为Rainbow就是Atari游戏的巅峰时，Ape-X出来把Rainbow秒成了渣！

Distributed Prioritized Experience Replay

只使用一个learner和一个Replay buffer，但是分布式的使用了多个Actor来生成数据，paper中实验使用了360个Actor（一个Actor一个CPU）。DeepMind产生专门做这个的想法主要是从Rainbow的研究中发现：Prioritization was found to be the most important ingredient contributing to the agent’s performance.

Replay的优先级对于性能影响是最大的，而之前的Prioritised Replay Buffer只用单一Actor来采集数据，效率偏低。那么这篇文章中，加上分布式，并且让每一个Actor都不完全一样，用$\varepsilon -greedy$采样时的$\varepsilon $不一样。这样可以更好的做explore，并且更全面的寻找优先级最高的replay来训练。

比以前方法大得多得多的Replay Buffer，毕竟同时用几百个actor来采集数据，充分挖掘了计算资源。这个本身可以大幅度加快训练速度。
通过不同的Actor得到不同优先级Priority的Replay，如上面所说，大幅度提升explore的能力，防止过拟合。这是为什么Ape-X效果提升的最主要原因。

整个算法也就是训练架构上发生改变，算法实质并没有变化。同时，由于使用Replay Buffer是Off-Policy独有，因此，这篇paper就在DQN和DDPG上进行改变验证。

如上图，

多个actor，每个有自己的环境，并且可以产生experience，并将其写入一个共享的experience replay memory，并且能计算initial priorities
一个learner，从memory中sample，然后更新memory中的experience的priorities，并更新网络参数
每个actor的网络定期地从learner获取最新的网络参数

5.2 Actor的算法

procedure $ACTOR(B, T)$ // 在environment instance中运行agent，并存储experiences

$\theta_0\leftarrow LEARNER.PARAMETERS()$ // remote call以获取最新的网络参数

$s_0\leftarrow ENVIRONMENT.INITIALIZE() $ // 从环境中获取初始状态

for t = 1 to T do

$a_{t-1}\leftarrow \pi \theta _{t-1}(s_{t-1})$ // 使用当前policy选择一个动作

$r_t,\gamma_t,s_t\leftarrow ENVIRONMENT.STEP(a_{t-1})$ // 在环境中执行这个动作

$LOCALBUFFER.ADD((s_{t-1},a_{t-1},r_t,\gamma_t))$ // 将data放入local buffer中

if $LOCALBUFFER.SIZE() \gt B$ then // 在一个后台线程中，定期地send data to replay

$\tau \leftarrow LOCALBUFFER.GET(B)$ // 获取buffered data(例如，batch of multi-step transitions)

$p \leftarrow COMPUTEPRIORITIES(\tau)$ // 计算experience的优先级（例如，绝对TD error）

$REPLAY.ADD(\tau,p)$ // remote call以将experience加入replay memory中

endif

$PERIODICALLY(\theta_t\leftarrow LEARNER.PARAMETERS())$ // 获取最新的网络参数

endfor

end procedure

5.3 Learner的算法

procedure $LEARNER(T)$ // 使用从memory中sampled的batches来更新网络

$\theta_0\leftarrow INITIALIZENETWORK()$

for t = 1 to T do // 更新参数T次

$id,\tau \leftarrow REPLAY.SAMPLE()$ // 在后台线程中sample一个 prioritized batch的transitions

$l_t \leftarrow COMPUTELOSS(\tau;\theta_t)$ // Apply learning rule，例如double Q-learning或者DDPG

$\theta_{t+1}\leftarrow UPDATEPARAMETERS(l_t;\theta_t)$

$p \leftarrow COMPUTEPRIORITIES()$ // 计算experience的优先级（例如，绝对TD error）【和Actor一样】

$REPLAY.SETPRIORITY(id,p)$ // remote call以更新优先级

$PERIODICALLY(REPLAY.REMOVETOFIT())$ // 从replay memory中删掉旧的experience

endfor

end procedure

效果：

代码

ray的ape-x代码：https://github.com/ray-project/ray/blob/master/python/ray/rllib/agents/dqn/apex.py

6. rudder

参考比TD、MC、MCTS指数级快，性能超越A3C、DDQN等模型，这篇RL算法论文在Reddit上火了

在强化学习中，延迟奖励的存在会严重影响性能，主要表现在随着延迟步数的增加，对时间差分（TD）估计偏差的纠正时间的指数级增长，和蒙特卡洛（MC）估计方差的指数级增长。针对这一问题，来自奥地利约翰开普勒林茨大学 LIT AI Lab 的研究者提出了一种基于返回值分解的新方法 RUDDER。实验表明，RUDDER 的速度是 TD、MC 以及 MC 树搜索（MCTS）的指数级，并在特定 Atari 游戏的训练中很快超越 rainbow、A3C、DDQN 等多种著名强化学习模型的性能。

RUDDER: Return Decomposition for Delayed Rewards

源码：https://github.com/ml-jku/baselines-rudder

7. IMPALA

参考前沿 | DeepMind提出新型架构IMPALA：帮助实现单智能体的多任务强化学习

IMPALA 受流行的 A3C 架构的启发，A3C架构使用多个分布式actor来学习智能体的参数。在此类模型中，每个actor使用策略参数在环境中动作。actor周期性地暂停探索，和中央参数服务器共享它们计算出的梯度，用于梯度更新

IMPALA的actor不用于计算梯度，而是用于收集经验，然后传输至可计算梯度的中央学习器，生成一个具备完全独立的actor和learner的模型。为了利用现代计算系统，IMPALA可使用单个学习器或执行同步更新的多个学习器来实现。用这种方式分离学习和动作可以有效地提高整个系统的吞吐量，因为 actor不再需要等待学习步（像 batched A2C 架构中那样）。这使得我们可以在多个有趣的环境中训练IMPALA，无需经历帧渲染时间的变动或耗时的任务重启。

IMPALA: Scalable Distributed Deep-RL with Importance Weighted Actor-Learner Architectures

xx. 自己搞一下

参考一个简单的例子：强化学习异步分布式训练实现

其他RL平台

open spiel

DeepMind开源强化学习游戏框架，25款线上游戏等你来挑战

https://github.com/deepmind/open_spiel

目前大多是棋牌、博弈相关游戏。

rlpyt

https://github.com/astooke/rlpyt

集合三大类无模型强化学习算法，BAIR开源RL代码库rlpyt

rlpyt: A Research Code Base for Deep Reinforcement Learning in PyTorch

rlpyt 库的重要特征和能力包括：

以串行模式运行实验（对 debug 有帮助）；
以并行模式运行实验，具备并行采样和/或多 GPU 优化的选项；
同步或异步采样-优化（异步模式通过 replay buffer 实现）；
在环境采样中，使用 CPU 或 GPU 进行训练和/或分批动作选择；
全面支持循环智能体；
在训练过程中，执行在线或离线评估，以及智能体诊断日志记录；
在本地计算机上，启动对实验进行栈/队列（stacking / queueing）设置的程序；
模块化：易于修改和对已有组件的重用；
兼容 OpenAI Gym 环境接口。

rlpyt 库中的已实现算法包括：

策略梯度：A2C、PPO
DQN及其变体：Double、Dueling、Categorical、Rainbow minus Noisy Nets、Recurrent (R2D2-style)
QPG：DDPG、TD3、SAC

FEN

参考兼顾公平与效率？北大NeurIPS 19论文提出多智能体强化学习方法FEN

公平有助于人类社会的稳定和生产力的提高，同样对于多智能体系统也十分重要。然而让一组智能体学习提升系统效率并同时保持公平是一个复杂的、多目标的、联合策略优化问题。目前主流的多智能体强化学习算法没有考虑公平性的问题，一些针对特定情景公平性的方法又依赖专家知识，这对于一般性情景并不适用。

作者提出一种分层多智能体强化学习方法 Fair-Efficient Network（FEN，「分」），从三个方面解决这一问题：

提出 fair-efficient reward，用于学习效率与公平。
提出一种 hierarchy 架构，降低学习难度。
提出 FEN 的分布式训练方法。

Learning Fairness in Multi-Agent Systems

tensorflow优化

2018-04-29T00:00:00+00:00

阿里的TensorTlowRS

阿里的TensorTlowRS

专栏 | 阿里妈妈基于TensorFlow做了哪些深度优化？TensorFlowRS架构解析

简介

相比图像、语音、视频等领域，搜索、广告、推荐等场景有着独特的场景特点: 样本规模和特征空间通常非常巨大，千亿样本、百亿特征并不罕见，同时存在大量的稀疏特征作为Embedding输入。

阿里妈妈的优化：

解决了原生TF水平扩展能力不足的问题。在我们的测试中，绝大多数搜索广告模型的训练性能提升在十倍以上，某些模型的极限性能最高可提升百倍。
支持完备的在线学习语义，模型变更实时写出；稀疏特征无需做连续ID化，可以直接使用原始特征表征进行训练，大幅简化了特征工程的复杂度。
异步训练的梯度修正优化器（grad-compensation optimizer），有效减少了异步大规模并发引起的训练效果损失。
集成了高效的Graph Embedding、Memory Network、Cross Media等多种高级训练模式。
模型可视化系统DeepInSight提供深度模型训练的多维度可视化分析。

TensorFlowRS分布式架构

TF作为一个分布式训练系统有两个主要的问题：

水平扩展能力差：在大部分模型的性能测试中,我们发现随着数据并行度的增加，单个worker的样本处理QPS急剧下降。当worker数量增大到一定规模的时候，系统整体QPS不再有增长甚至有所下降。
缺乏完备的分布式Failover机制：
- TF基于静态拓扑配置来构建cluster，不支持动态组网，这就意味着当某个ps或者worker挂掉重启之后，如果ip或者端口发生变化（例如机器crash），训练将无法继续。
- 另外，TF的checkpoint只包含server存储的参数信息，不包含worker端的状态，不是全局一致性的checkpoint，无法实现Exactly-Once等基本的Failover语义。

TensorFlowRS的解决方案：

通过对接独立参数服务器提升水平扩展能力

在对TF做过细致的profiling之后，我们发现TF原生的PS由于设计和实现方面的多种原因（grpc，lock，graph-engine），很难达良好的水平扩展能力。于是我们决定丢掉TF-PS的包袱，重新实现一个高性能的参数服务器：PS-Plus。此外我们提供了完整的TF on PS-Plus方案，可以支持用户在Native-PS和PS-Plus之间自由切换，并且完全兼容TensorFlow的Graph语义和所有API。用户可以在深度网络代码一行不改的情况下，将参数分布和运行在PS-Plus上，享受高性能的参数交换和良好的水平扩展能力。

重新设计Failover机制，支持动态组网和Exactly-Once的Failover

TensorFlowRS引入了worker state，在checkpoint中存储了worker的状态信息，worker重启后，会从接着上次的进度继续训练。此外TensorFlowRS通过zk生成cluster配置，支持了动态组网的Failover。新的Failover机制可以保证任意角色挂掉的情况下，系统都能在分钟级完成Failover，并且不多算和漏算数据。

所谓的exactly-once，参考：https://www.jianshu.com/p/5d889a67dcd3:

在分布式系统中，构成系统的任何节点都是被定义为可以彼此独立失败的。比如在 Kafka中，broker可能会crash，在producer推送数据至topic的过程中也可能会遇到网络问题。根据producer处理此类故障所采取的提交策略类型，我们可以获得不同的语义：

at-least-once：如果producer收到来自Kafka broker的确认（ack）或者acks = all，则表示该消息已经写入到Kafka。但如果producer ack超时或收到错误，则可能会重试发送消息，客户端会认为该消息未写入Kafka。如果broker在发送Ack之前失败，但在消息成功写入Kafka之后，此重试将导致该消息被写入两次，因此消息会被不止一次地传递给最终consumer，这种策略可能导致重复的工作和不正确的结果。
at-most-once：如果在ack超时或返回错误时producer不重试，则该消息可能最终不会写入Kafka，因此不会传递给consumer。在大多数情况下，这样做是为了避免重复的可能性，业务上必须接受数据传递可能的丢失。
exactly-once：即使producer重试发送消息，消息也会保证最多一次地传递给最终consumer。该语义是最理想的，但也难以实现，这是因为它需要消息系统本身与生产和消费消息的应用程序进行协作。例如如果在消费消息成功后，将Kafka consumer的偏移量rollback，我们将会再次从该偏移量开始接收消息。这表明消息传递系统和客户端应用程序必须配合调整才能实现excactly-once。

PS-Plus

高性能：PS-Plus通过智能参数分配，零拷贝，seastar等多项技术，进一步提升了单台server的服务能力和系统整体的水平扩展能力。在实测中，在64core的机器上单个server能轻松用满55+的核心，在dense场景下io能打满双25G网卡，系统整体在1~4000 worker的范围内都具有近似线性的水平扩展能力
高度灵活：PS-Plus拥有完善的UDF接口，用户可使用SDK开发定制化的UDF插件，并且可以通过简单的C++以及Python接口进行调用。
完备的在线学习支持：PS-Plus支持非ID化特征训练，特征动态增删，以及模型增量实时导出等支撑在线学习的重要特性。

智能参数分配

参数分配策略(variable placement)，决定了如何将一个参数切分并放置到不同的server上。placement策略的好坏在高并发的情况下对PS的整体性能有着重大的影响。传统ParameterServer的placement方案是由系统预先实现几种常见的placement算法（比如平均切分+roundrobin），或者由用户在创建参数的时候手工划分，往往没有综合考虑全局的参数规模、Server的负载等。

PS-Plus实现了基于模拟退火算法的启发式参数分配策略，后续也在考虑实现基于运行时负载，动态rebalance的placement策略(是不是可以试试基于rl的呢，手动滑稽。。。)。PS-Plus的placement设计有如下优点：

综合考虑了全局参数的shape信息，在cpu，内存，网络带宽等限制条件下给出了近似最优的placement方案，避免了手工分配造成的不均匀、热点等问题。
整个参数分配过程由系统内部自动完成，用户无需配置即可获得接近最优的性能，用户无需了解PS底层实现的具体细节。
Partition由框架自动完成，在上层算法代码，如TF代码中，不需要额外使用PartitionedVariable等机制，使用简单方便。

去ID化特征支持

目前主流的深度学习框架都是以连续的内存来存储训练参数，通过偏移量（ID值）来寻址到具体的权重。为了避免内存的浪费，需要对特征做从0开始的连续ID化编码，这一过程我们称之为特征ID化。特征ID化是一个非常复杂的过程，尤其是当样本和特征数量非常庞大的时候，特征ID化会占用大量的时间和机器资源，给样本构建带来了很大的复杂度。

PS-Plus内部实现了一个定制化的hashmap，针对参数交换场景做了专门的优化，在支持特征动态增删的同时提供了超高的性能。通过hashmap，PS-Plus直接实现了对非ID特征的支持，极大的简化了样本构建的复杂度。

通信层优化

对于Parameter Server架构，延迟是影响整体性能的重要原因。尤其是在模型复杂度不高的情况下，模型计算部分往往在10~100ms量级，那么总体通信的延迟就成为一个关键因素。

在传统的pipeline线程模型

高并发情况下中断和线程上下文切换会导致很大的开销，同时会引起大量的cache-line miss。
此外，高频的锁竞争是带来延迟的最主要原因之一，即便是各类SpinLock、读写锁等优化也并不能有效消除这个问题。

我们认为polling + run to completion是一个正确的选择，并且设计了我们的整体通信层架构。

在新的通信层中，我们使用了Seastar作为底层的框架。对于Server、Worker上的connection，都严格保证connection绑定到固定的线程，同时线程与CPU核心绑定。Request、response直接采用run to completion的方式在当前线程处理。整体架构如下图所示：

在Seastar的基础上，做了很多功能、性能的改进和优化

外部线程交互队列。我们借鉴Seastar核心之间的交互机制，提供了一个M:N无锁生产者消费者队列，用于外部线程与Seastar内部线程进行交互。相比传统队列性能有极大的提升。
写请求顺序调度。从外部线程poll到的写请求，如果直接调用Seastar的写接口，会导致写buffer无法保证有序。我们通过队列机制的改造，自动保证了写顺序，同时基本不损失多connection的并发写的性能。
灵活的编解码层。我们提供了一套编解码层的抽象接口，方便用户使用，从而不需要借助protobuf等传统的序列化、反序列化的第三方库，同时也避免了protobuf的一些性能问题。

注：更多关于SeaStar可以参考：https://daiwk.github.io/posts/platform-seastar.html

关于run to completion：https://en.wikipedia.org/wiki/Run_to_completion_scheduling

性能

在Dense以及WDE(Wide-Deep-Embedding)两种经典模型的性能指标：

dense:
- Batch-size: 100
- Input-dimension: 1130
- Hidden-units: 5层全连接：256,128,64,32,1
wde:
- Batch-size: 100
- Deep:
  - Input-dimension:310
  - Hidden-units:256,128,64,32,1
- Wide:
  - Input-dimension:0.2B
  - Output-dimension: 1
- Embedding:
  - Input-dimension:0.5B / 7.5B
  - Output-dimension: 8

水平扩展能力比较:

在线学习

TensorFlowRS通过对接PS-Plus，给出了一套完整的端到端的在线学习解决方案，赋予了TF支持千亿规模非ID化特征在线训练的能力。

非ID化特征支持

在在线学习的场景下做特征实时ID化是比较复杂的，需要一个超高性能的全局的ID生成器，这给样本生成带来了很大的复杂度。TensorFlowRS利用PS-Plus直接实现了对非ID特征的支持，极大的简化了实时样本构建的复杂度。

特征动态增删

在在线训练的场景下，训练任务会以service的形式长期运行，在训练过程中，不断会有新特征加入到模型中，为了保证训练可以长期进行而不会因为新特征的不断加入导致OOM，PS-Plus在支持特征动态添加的同时，还提供了默认的特征删除策略，可以将低频或者低权重的特征删除掉，用户还可以通过UDF定制符合自身业务需求的删除策略

模型增量实时导出

在线学习模型更新的常见方式有全量和增量两种。在模型参数较多的情况下，全量更新的方式会对在线系统的带宽带来巨大的压力，而降低更新频率又会使模型的实效性降低。PS-Plus支持以任意频率将模型增量部分实时写出到消息队列，在大幅减少网络IO的同时实现了真正意义上的模型实时更新。

AUC Decay

在在线学习的场景下，我们希望在训练的过程中就可以尽快的发现模型本身的异常，而不是等模型更新到线上之后。因此我们需要有一些方法来评估模型在训练过程中的 AUC等指标。TF里默认的streaming auc的实现在历史数据累积了一定量的时候，无法及时反应当前模型的状态，反馈有很大的滞后性。因此我们引入了新的AUC计算机制：AUC Decay。AUC Decay本质上是一种特殊的Moving Average，通过基于时间的减益方式，弱化历史样本和模型在当前AUC计算中的比重，以达到更快反应模型变化的目的。

大规模训练场景下的收敛效果优化

问题阐述

大数据模型引入了分布式并行训练，同步并行训练受长尾worker的制约，并发数容易受限。异步并行是快速训练的主流。异步并行训练打破了普通SGD训练的串行性，计算的梯度与更新的模型不是严格一致，引入了梯度delay的问题。

在基于ParameterServer的训练框架里，系统分为两个角色：worker和ps。

ps的职责是模型的切块存储与更新；
worker的职责是加载从ps端获得最新的模型，读取数据进行模型训练，最后把学到梯度发送给ps，由ps更新模型。

异步并发训练打破了普通SGD训练的串行性，引入了梯度delay的问题。

如图，$worker_m$拿到了模型$w_t$，计算得到梯度$g_t$，但传给ps时，已经有r个worker向ps提交了梯度更新，所以，这个时候应用到的是模型$w_{t+r}$。虽然梯度更新的大方向可能偏差不大，但与模型$w_{t+r}$期望的梯度$g_{t+r}$相比，$g_t$是存在细微偏差的。

梯度补偿

微软在ICML2017提出过DC-ASGD optimizer【 Asynchronous Stochastic Gradient Descent with Delay Compensation】，使用泰勒展开来近似梯度补偿。我们测试在50并发以内收益良好。可是在上百并发训练里，泰勒展开超过了近似收敛半径，导致的误差增大，效果下降。

各框架实现dc-asgd的issue：

tf: https://github.com/tensorflow/tensorflow/issues/8744，但后来被removed了【https://github.com/tensorflow/tensorflow/pull/9551】，因为it was lacking an _apply_dense() implementation, there were typos that caused failures when used, etc.The commit is obviously in the history for somebody to re-use and fix, if they wanted, but they'd need to write more tests and probably refactor it to make it something that the team could accept to TensorFlow.
mxnet: https://github.com/apache/incubator-mxnet/pull/3614，代码在mxnet.optimizer.DCASGD

改进：引入$\Delta w$【maybe就是下面第一篇里讲到的隐式动量？，，再看看】与g的相关因子来衡量梯度delay的严重程度，从而用来boost主流的sgd-based optimizer。在每一维度上：

如果大部分$\Delta w$与-g是正相关，说明大部分worker都在往同方向更新，模型w在这个方向上已经走的挺远了，继续前进需要谨慎。这个时候，保持g的方向不变，但减少g的绝对值。
如果大部分$\Delta w$与-g是负相关，说明大部分worker都在往反方向更新，此时g是一个比较强烈的转折信号，揭示了模型w的更新方向要发生变化，我们需要重视这个信号，所以我们保持g的方向不变，但增大了g的绝对值。

引入相关因子是基于以下原因：

异步训练时，存在隐式的梯度动量加速情况。参见Asynchrony begets(产生) Momentum, with an Application to Deep Learning，并发越大，隐式动量越大，造成梯度往一个方向过度前进的情况。此文的abstract里说：For convolutional neural networks, we experimentally validate that the degree of asynchrony directly correlates with the momentum, confirming our main result. An important implication is that tuning the momentum parameter is important when considering different levels of asynchrony.
如果不是很老的w，相关因子是转折信号，暗示模型在多个worker的动量累积推动下前进的有些过度了。
存在着tradeoff，太老的w，信号准确率会下降，这时要控制(调小)系数lambda。

所以$\Delta w$与g的相关性具备普适性，可以和主流的sgd-based optimizer结合，适应不同场景的不同优化器并发训练需求。

实验结果

用相关性因子boost了SGD、Momentum、AdaGrad三种算法，

WDE模型

并行度	Boosted-sgd auc	Boosted-moment auc	Boosted-adagrad auc
100	+0.012%	+0.01%	+0.012%
200	+0.028%	+0.045%	+0.051%
400	+0.043%	+0.064%	+0.058%

Cifar10 Alexnet模型

并行度	Boosted-sgd accuracy	Boosted-moment accuracy	Boosted-adagrad accuracy
30	+0.43%	+0.2%	+0.25%
60	+0.56%	+0.25%	+0.46%

高级训练模式

TFRS中集成了多种高阶训练模式，例如Graph Embedding，Memory Network，Cross Media Training等。

Graph Embedding

Graph Embedding，图是一种表征能力极强的数据结构，但是无法直接作为神经网络的输入。TFRS支持样本以图的形式进行输入，并支持多种随机游走算法动态生成正负样本。目前Graph Embedding已经应用在了淘宝搜索直通车的向量化召回等多个项目里，通过在User-Query-Item三种节点的异构有向图中随机游走，生成深度神经网络能够处理的稀疏特征。最终学习出User，Query和Item三者的高维向量化的表示，用于线上广告的向量化召回。

值得一提的是，除了Graph Embedding，我们同样支持对图的结构进行学习，例如在训练过程中反馈调整图中的边的权重等。

Memory Network

Memory Network记忆网络最早由Facebook在2015年提出，用于QA系统中。在本模型出现之前，机器学习的模型都缺乏可以读取和写入外部知识的组件。对很多任务来说，这是一个很强的限制。比如，给定一系列事实或故事，然后要求回答关于该主题的问题，虽然原则上这可以用RNN等模型进行处理，然而它们的记忆（隐藏状态和权重编码）通常太小，并且不能精确地记住过去的事实。在阿里妈妈搜索广告场景下，我们使用记忆网络对用户行为进行建模。

相比一般的在样本组织阶段进行记忆体生成的方式，TFRS通过在训练过程中引入动态记忆存储模块，支持长短期记忆，大幅提高了序列化类行为数据的训练效率。

参考https://daiwk.github.io/posts/dl-ntm-memory-networks.html

可视化模型分析系统DeepInsight

DeepInsight是一个深度学习可视化质量评估系统，支持训练阶段模型内部数据的全面透出与可视化分析，用以解决模型评估、分析、调试等一系列问题，提高深度模型的可解释性。

下面我们通过一个过拟合的例子来说明DeepInsight在模型质量分析和问题定位方面发挥的作用：

上图是通过DeepInsight生成的特征权重分布,从图中我们可以看到右侧过拟合模型的边权重大小分布很不均匀，出现了大量权重极大的边，且集中在一条带状区域内，其为某一组特征输入所连接的所有边，这表明模型过度拟合了该组特征的信息。在使用正则项和dropout之后，过拟合的问题仍然没解决，因此我们最终定位到问题出现在该组特征的输入上。

目标检测汇总

2018-04-29T00:00:00+00:00

历史回顾
开源库：Detectron
YOLO nano
gaussian yolov3

历史回顾

从RCNN到SSD，这应该是最全的一份目标检测算法盘点

同时参考一文读懂目标检测：R-CNN、Fast R-CNN、Faster R-CNN、YOLO、SSD

传统的目标检测算法：Cascade + HOG/DPM + Haar/SVM以及上述方法的诸多改进、优化；
候选区域/框 + 深度学习分类：通过提取候选区域，并对相应区域进行以深度学习方法为主的分类的方案，如：
- R-CNN（Selective Search + CNN + SVM）
- SPP-net（ROI Pooling）
- Fast R-CNN（Selective Search + CNN + ROI）
- Faster R-CNN（RPN + CNN + ROI）
- R-FCN等系列方法；
基于深度学习的回归方法：YOLO/SSD/DenseBox 等方法；以及最近出现的结合RNN算法的RRC detection；结合DPM的Deformable CNN等

开源库：Detectron

https://github.com/facebookresearch/Detectron

如果你正在寻找最先进的物体检测算法，那么你可以使用Detectron。

它由Facebook开发，是AI Research软件系统的一部分。它利用Caffe2深度学习框架和Python。

YOLO nano

比Tiny YOLOv3小8倍，性能提升11个点，4MB的网络也能做目标检测

YOLO Nano: a Highly Compact You Only Look Once Convolutional Neural Network for Object Detection

研究者提出了名为 YOLO Nano 的网络。这一模型的大小在 4.0MB 左右，比 Tiny YOLOv2 和 Tiny YOLOv3 分别小了 15.1 倍和 8.3 倍。在计算上需要 4.57B 次推断运算，比后两个网络分别少了 34% 和 17%。

在性能表现上，在 VOC2007 数据集取得了 69.1% 的 mAP，准确率比后两者分别提升了 12 个点和 10.7 个点。研究者还在 Jetson AGX Xavier 嵌入式模块上，用不同的能源预算进行了测试，进一步说明 YOLO Nano 非常适合边缘设备与移动端。

gaussian yolov3

Gaussian YOLOv3: An Accurate and Fast Object Detector Using Localization Uncertainty for Autonomous Driving

rl代码集合

2018-04-27T00:00:00+00:00

tensorflow
keras
pytorch
mxnet
paddle

tensorflow

https://github.com/carpedm20/deep-rl-tensorflow

https://github.com/rlcode/reinforcement-learning

keras

https://github.com/keras-rl/keras-rl

pytorch

https://pytorch.org/tutorials/intermediate/reinforcement_q_learning.html

https://github.com/openai/baselines

mxnet

https://github.com/apache/incubator-mxnet/tree/master/example/reinforcement-learning

paddle

http://paddlepaddle.org/paddle/ModelPARL

GAN pytorch+keras实现

2018-04-26T00:00:00+00:00

参考这些资源你肯定需要！超全的GAN PyTorch+Keras实现集合

ResNet及其变种

2018-04-26T00:00:00+00:00

参考一文简述ResNet及其多种变体

深度神经网络的模型压缩和加速方法

2018-04-24T00:00:00+00:00

背景
研究现状
paddle的slim
DAFL

参考当前深度神经网络模型压缩和加速都有哪些方法？

论文：A Survey of Model Compression and Acceleration for Deep Neural Networks

背景

在2012年，Krizhevsky等人提出的alexnet（ImageNet Classification with Deep Convolutional），以超过第二名以传统人工设计特征方法准确率 10% 的巨大领先取得了 ImageNet图像分类比赛冠军。

alexnet是1个包含5个卷积层和3个全连接层的6000万参数的网络。通常情况下，即使使用当时性能顶级的GPU NVIDIA K40来训练整个模型仍需要花费两到三天时间。对于使用全连接的大规模网络，其参数规模甚至可以达到数十亿量级。

为了解决全连接层参数规模的问题，人们转而考虑增加卷积层，使全连接参数降低。随之带来的负面影响便是大大增长了计算时间与能耗。

Krizhevsky在2014年的文章中，提出的两点观察结论为后来的研究深度模型的压缩与加速提供了统计依据：

现代卷积神经网络主要由两种层构成，他们具有不一样的属性和性能(!!!!!!参考卷积神经网络的并行化模型——One weird trick for parallelizing convolutional neural networks)：

卷积层，占据了90% ~ 95%的计算量，5%的参数，但是对结果具有很大的表达能力。
全连接层，占据了5% ~ 10%的计算量，95%的参数，但是对于结果具有相对较小的表达的能力。

综上：卷积层计算量大，所需参数系数 W 少，全连接层计算量小，所需参数系数 W 多。因此对于卷积层适合使用数据并行，对于全连接层适合使用模型并行。

一个典型的例子是具有50个卷积层的ResNet-50需要超过 95MB的存储器以及38亿次浮点运算。在丢弃了一些冗余的权重后，网络仍照常工作，但节省了超过75％的参数和50％的计算时间。

研究现状

参数修剪和共享（parameter pruning and sharing)：针对模型参数的冗余性，试图去除冗余和不重要的项。
低秩因子分解（low-rank factorization）：使用矩阵/张量分解来估计深度学习模型的信息参数。
转移/紧凑卷积滤波器（transferred/compact convolutional filters）：设计了特殊的结构卷积滤波器来降低存储和计算复杂度。
知识蒸馏（knowledge distillation）：通过学习一个蒸馏模型，训练一个更紧凑的神经网络来重现一个更大的网络的输出。

参数修剪和共享、低秩分解和知识蒸馏方法可以用于全连接层和卷积层的CNN，但另一方面，使用转移/紧凑型卷积核的方法仅支持卷积层(因为只是修改卷积filter)。

低秩因子分解和基于转换/紧凑型卷积核的方法提供了一个端到端的流水线，可以很容易地在 CPU/GPU 环境中实现。

参数修剪和共享使用不同的方法，如矢量量化，二进制编码和稀疏约束来执行任务，这导致常需要几个步骤才能达到目标。

关于训练协议，基于参数修剪/共享、低秩分解的模型可以从预训练模型或者从头开始训练，因此灵活而有效。然而转移/紧凑的卷积核和知识蒸馏模型只能支持从零开始训练。

paddle的slim

自动模型压缩与架构搜索，这是飞桨PaddleSlim最全的解读

DAFL

重磅开源！ ICCV 2019，华为诺亚提出无需数据网络压缩技术

DAFL：Data-Free Learning of Student Networks

github: https://github.com/huawei-noah/DAFL

绝大多数的神经网络压缩算法都假设训练数据是可以获得的。然而，在现实生活应用中，数据集往往由于隐私、法律或传输限制等原因是不可获得的。

有很少的工作关注在无数据情况下的网络压缩，然而，这些方法得到的压缩后的网络准确率下降很多，这是因为这些方法没有利用待压缩网络中的信息。

提出了一个新的无需训练数据的网络压缩方法。具体的，我们把给定的待压缩网络看作一个固定的判别器，接着，我们设计了一系列的损失函数来训练生成网络，使得生成图片可以代替训练数据集进行训练，最后，我们使用生成数据结合蒸馏算法得到压缩后的网络。

tensorflow probability

2018-04-22T00:00:00+00:00

参考：

参考资源 | 概率编程工具：TensorFlow Probability官方简介

原文：https://medium.com/tensorflow/introducing-tensorflow-probability-dca4c304e245

TensorFlow Probability 适用于以下需求：

希望建立一个生成模型，推理其hidden processes。
需要量化预测结果的不确定性（uncertainty），而不是预测单个值。
训练集具有大量与数据点数量相关的特征。
训练数据是结构化的（例如，使用分组，空间，图表或语义），并且想使用先验信息（prior information）来捕捉其中的结构。
存在一个inverse problem - 参考 TFDS’18 演讲视频以重建测量中的融合等离子体。

安装：

pip install --user --upgrade tfp-nightly

源码：https://github.com/tensorflow/probability

talk to book

2018-04-18T00:00:00+00:00

实验效果：
- 准确率
- 性能
  - 计算复杂度
  - 内存占用

参考：

人人都可参与的AI技术体验：谷歌发布全新搜索引擎Talk to Books

Universal Sentence Encoder

pre-trained model: https://tfhub.dev/google/universal-sentence-encoder/1

使用示例： https://www.tensorflow.org/hub/modules/google/universal-sentence-encoder/1

my notebook: https://github.com/daiwk/workspace_tf/blob/master/talk_to_books/Semantic_Similarity_with_TF_Hub_Universal_Encoder.ipynb

项目链接：https://research.google.com/semanticexperiences/

主要的两篇参考文献：

attention is all you need，解读可以参考https://daiwk.github.io/posts/platform-tensor-to-tensor.html
DAN，即Deep Unordered Composition Rivals Syntactic Methods for Text Classification

实验效果：

准确率

在transfer learning的任务SST上，USE_T（Universal Sentence Encoder + Transformer）只需要1k的训练数据（这个数据集总共有67.3k的训练数据），就能够达到其他很多模型使用全量训练数据得到的准确率。

性能

假设句子长度为n。

计算复杂度

Transformer: $O(n^2)$
DAN: $O(n)$

内存占用

Transformer: $O(n^2)$。但对于短句，因为Transformer只要存储unigram的embedding，所以占用的内存几乎是DAN的一半。
DAN: 与句子长度无关，由用来存储unigram和bigram的embedding的参数决定

深入浅出强化学习-chap9 基于确定性策略搜索的强化学习方法

2018-04-12T00:00:00+00:00

1. 概述
2. 随机策略与确定性策略
3. AC框架

参考《深入浅出强化学习》

1. 概述

model-free的策略搜索方法可以分为随机策略搜索方法和确定性策略搜索方法。

2014年以前，学者们都在发展随机策略搜索方法。因为大家认为确定性策略梯度是不存在的。
2014年Silver在论文Deterministic Policy Gradient Algorithms中提出了确定性策略理论，即DPG。
2015年DeepMind又将DPG与DQN的成功经验相结合，提出了Continuous Control with Deep Reinforcement Learning，即DDPG
ICML2016，提出了Asynchronous Methods for Deep Reinforcement Learning，即A3C（asynchronous advantage actor-critic）算法。

2. 随机策略与确定性策略

2.1 随机策略

随机策略公式为：

\[ \pi_{\theta}(a|s)=P[a|s;\theta] \]

含义为，在状态$s$时，动作符合参数为$\theta$的概率分布，例如常用的高斯策略：

\[ \pi_{\theta}(a|s)=\frac{1}{\sqrt{2\pi \sigma}}exp(-\frac{(a-f_{\theta}(s))}{2\sigma ^2}) \]

在状态$s$处，采取的动作服从均值为$f_{\theta}(s)$，方差为$\sigma ^2$的正态分布。所以，即使在相同的状态下，每次采取的动作也可能不一样。

2.2 确定性策略

确定性策略的公式如下：

\[ a=\mu_{\theta}(s) \]

相同的策略（即相同$\theta$），在状态$s$时，动作是唯一确定的。

2.3 对比

确定性策略的优点在于：需要采样的数据少，算法效率高

随机策略的梯度计算公式：

\[ \triangledown _{\theta}J(\pi _{\theta})=E_{s\sim \rho ^{\pi},a\sim \pi_{\theta}}[\triangledown _{\theta}log\pi_{\theta}(a|s)Q^{\pi}(s,a)] \]

其中的$Q^{\pi}(s,a)$是状态-行为值函数。可见，策略梯度是关于状态和动作的期望，在求期望时，需要对状态分布和动作分布求积分，需要在状态空间和动作空间内大量采样，这样求出来的均值才能近似期望。

而确定性策略的动作是确定的，所以，如果存在确定性策略梯度，其求解不需要在动作空间采样，所以需要的样本数更少。对于动作空间很大的智能体（如多关节机器人），动作空间维数很大，有优势。

随机策略的优点：随机策略可以将探索和改善集成到一个策略中

随机策略本身自带探索，可以通过探索产生各种数据（有好有坏），好的数据可以让强化学习算法改进当前策略。

而确定性策略给定状态和策略参数时，动作是固定的，所以无法探索其他轨迹或者访问其他状态。

确定性策略无法探索环境，所以需要通过异策略（off-policy）方法来进行学习，即行动策略和评估策略不是同一个策略。行动策略采用随机策略，而评估策略要用确定性策略。而整个确定性策略的学习框架采用的是AC方法。

3. AC框架

这里会参考https://blog.csdn.net/jinzhuojun/article/details/72851548

Actor-Critic（AC）方法其实是policy-based和value-based方法的结合。因为它本身是一种PG方法，同时又结合了value estimation方法，所以有些地方将之归为PG方法的一种，有些地方把它列为policy-based和value-based以外的另一种方法。

Actor指的是行动策略，负责policy gradient学习策略
Critic指的是评估策略，负责policy evaluation估计value function

所以，

一方面actor学习策略，而策略更新依赖critic估计的value function；
另一方面critic估计value function，而value function又是策略的函数。

如果是Actor-only，那就是policy gradient，而如果是Critic-only，那就是Q-learning。

3.0 pg

https://www.jianshu.com/p/2ccbab48414b

https://blog.csdn.net/qq_30615903/article/details/80747380

如果一个动作得到的reward多，那么我们就使其出现的概率增加，如果一个动作得到的reward少，我们就使其出现的概率减小。

根据这个思想，我们构造如下的损失函数：

\[ loss= -log(prob)*v_t \]

上式中log(prob)表示在状态s对所选动作a的吃惊度, 如果概率越小, 反向的log(prob)反而越大. 而vt代表的是当前状态s下采取动作a所能得到的奖励，这是当前的奖励和未来奖励的贴现值的求和。也就是说，我们的策略梯度算法必须要完成一个完整的eposide才可以进行参数更新，而不是像值方法那样，每一个(s,a,r,s’)都可以进行参数更新。如果在prob很小的情况下, 得到了一个大的Reward, 也就是大的vt, 那么$log(prob)*v_t$就更大, 表示更吃惊, (我选了一个不常选的动作, 却发现原来它能得到了一个好的reward, 那我就得对我这次的参数进行一个大幅修改)。

Policy Gradient的核心思想是更新参数时有两个考虑：如果这个回合选择某一动作，下一回合选择该动作的概率大一些，然后再看奖惩值，如果奖惩是正的，那么会放大这个动作的概率，如果奖惩是负的，就会减小该动作的概率。

注意点：

算法输出的是动作的概率，而不是Q值。
损失函数的形式为：$loss= -log(prob)*v_t$
需要一次完整的episode才可以进行参数的更新

3.1 随机策略AC方法

随机策略的梯度为

\[ \triangledown _{\theta}J(\pi _{\theta})=E_{s\sim \rho ^{\pi},a\sim \pi_{\theta}}[\triangledown _{\theta}log\pi_{\theta}(a|s)Q^{\pi}(s,a)] \]

其中Actor方法用来调整$\theta$值，

Critic方法逼近值函数$Q^{w}(s,a)\approx Q^{\pi}(s,a)$，其中$w$为待逼近的参数，可以用TD学习的方法来评估值函数。

异策略随机梯度为

\[ \triangledown _{\theta}J_{\beta}(\pi _{\theta})=E_{s\sim \rho ^{\pi},a\sim \beta}[\frac{\pi_{\theta}(a|s)}{\beta_{\theta}(a|s)}\triangledown _{\theta}log\pi_{\theta}(a|s)Q^{\pi}(s,a)] \]

和原公式的区别在于采样策略为$\beta$，即$a\sim \beta$，与行动策略不同，所以叫异策略。从而，多了一项$\frac{\pi_{\theta}(a|s)}{\beta_{\theta}(a|s)}$。

3.2 确定性策略AC方法（DPG）

确定性的策略梯度为：

\[ \triangledown _{\theta}J(\mu _{\theta})=E_{s\sim \rho ^{\mu}}[\triangledown _{\theta}\mu_{\theta}(s)\triangledown _{a}Q^{\mu}(s,a)|_{a=\mu_{\theta}(s)}] \]

可见，区别如下：

$\pi_{\theta}$变成了$\mu_{\theta}$
原来的$Q^{\pi}(s,a)$改成了$Q^{\mu}(s,a)|_{a=\mu_{\theta}(s)}$
原来的$s\sim \rho ^{\pi}$变成了$s\sim \rho ^{\mu}$
去掉了对于动作的采样$a\sim \pi _{\theta}$，而改成确定性的动作$a=\mu_{\theta}(s)$
原来对$\pi$的梯度，即$\triangledown _{\theta}log\pi_{\theta}(a|s)$改成了对$\mu$的梯度$\triangledown _{\theta}\mu_{\theta}(s)$
对于$Q$也要求一次关于$a$的梯度，即：$\triangledown _{a}Q^{\mu}(s,a)|_{a=\mu_{\theta}(s)}$，即回报函数对动作的导数

所以异策略确定性策略梯度为

\[ \triangledown _{\theta}J_{\beta}(\mu _{\theta})=E_{s\sim \rho ^{\beta}}[\triangledown _{\theta}\mu_{\theta}(s)\triangledown _{a}Q^{\mu}(s,a)|_{a=\mu_{\theta}(s)}] \]

与异策略的随机策略梯度进行对比，可以发现少了重要性权重，即$\frac{\pi_{\theta}(a|s)}{\beta_{\theta}(a|s)}$。因为重要性采样是用简单的概率分布估计复杂的概率分布，而确定性策略的动作是确定值；

此外，确定性策略的值函数评估用的是Q-learning方法，也就是用TD(0)估计动作值函数，并且忽略重要性权重。

然后看一下确定性策略异策略AC算法的更新过程：

\[ \begin{matrix} \delta _t=r_t+ \gamma Q^{w}(s_{t+1},\mu_{\theta}(s_{t+1}))-Q^{w}(s_t,a_t)\\ w_{t+1}=w_t+\alpha _w\delta_t\triangledown _wQ^w(s_t,a_t)\\ \theta _{t+1}=\theta _t+\alpha _\theta \triangledown _{\theta} \mu _{\theta}(s_t)\triangledown _aQ^w(s_t,a_t)|_{a=\mu_{\theta}(s)} \end{matrix} \]

前两行是利用值函数逼近的方法更新值函数参数$w$，使用的是TD，用Q-learning。

第3行是用确定性策略梯度方法更新策略参数$\theta$

3.3 深度确定性策略梯度方法（DDPG）

Continuous Control with Deep Reinforcement Learning

DDPG是深度确定性策略，复用DNN逼近行为值函数$Q^w(s,a)$和确定性策略$\mu_\theta (s)$。

在讲DQN时，当利用DNN进行函数逼近时，强化学习算法常常不稳定。因为训练nn时往往假设输入数据是独立同分布的，而强化学习的数据是顺序采集的，数据间存在马尔科夫性，所以这些数据并非独立同分布。

为了打破数据间的相关性，DQN使用了两个技巧，经验回放和独立的目标网络。

DDPG就是将这两个技巧用到DPG算法中，DDPG的经验回放和DQN完全相同，这里介绍DDPG中的独立目标网络。

DDPG的目标值是上式中第一行的前两项，即

\[ r_t+ \gamma Q^{w}(s_{t+1},\mu_{\theta}(s_{t+1})) \]

而所谓的独立目标网络，就是将上式的$w$和$\theta$单独拿出来，利用独立的网络对其进行更新，所以DDPG的更新公式为：

\[ \begin{matrix} \delta _t=r_t+ \gamma Q^{w^-}(s_{t+1},\mu_{\theta^-}(s_{t+1}))-Q^{w}(s_t,a_t)\\ w_{t+1}=w_t+\alpha _w\delta_t\triangledown _wQ^w(s_t,a_t)\\ \theta _{t+1}=\theta _t+\alpha _\theta \triangledown _{\theta} \mu _{\theta}(s_t)\triangledown _aQ^w(s_t,a_t)|_{a=\mu_{\theta}(s)} \\ \theta^-=\tau \theta +(1-\tau)\theta^- \\w^-=\tau w+(1-\tau)w^- \end{matrix} \]

DDPG的整体流程如下：

使用权重$\theta ^Q$随机初始化critic网络$Q(s,a|\theta ^Q)$，使用权重$\theta ^{\mu}$随机初始化actor$\mu (s|\theta ^{\mu})$

使用权重${\theta ^{Q'}} \leftarrow \theta ^Q$初始化目标网络$Q'$，使用权重${\theta ^{\mu'}} \leftarrow \theta ^{\mu}$初始化$\mu'$

初始化replay buffer $R$

For $episode = [1,...,M]$ do

初始化一个随机过程$\mathcal {N}$，即noise，以用于action exploration

获取初始化的可观测状态$s_1$

For $t=[1,...T]$ do

根据当前的policy以用exploration noise，选择动作$a_t=\mu(s_t|\theta^{\mu})+\mathcal {N}_t$【这里体现了随机策略作为行动策略】

执行动作$a_t$，得到回报$r_t$以及新的状态$s_{t+1}$

将transition $(s_t,a_t,r_t,s_{t+1})$存入$R$。

从$R$中随机sample出一个minibatch($N$个)的transitions，$(s _i,a_i,r_i,s_{i+1})$

令$y_i=r_i+\gamma {Q'}{(s_{i+1},{\mu'}(s_{i+1}|\theta ^{\mu'})|\theta ^{Q'}})$【即使用两个目标网络得predict的值$y_i$】

通过最小化loss$L=\frac{1}{N}\sum_i(y_i-Q(s_i,a_i|\theta ^Q))^2$对critic $Q$进行更新

通过采样的梯度，对actor policy$\mu$进行更新： \[\triangledown _{\theta ^\mu} {J}\approx \frac{1}{N}\sum_i\triangledown_aQ(s,a|\theta ^Q)|_{s=s_i,a=\mu(s_i)}\triangledown _{\theta ^\mu} {\mu(s|\theta ^\mu)|_{s_i}}\]

更新critic的目标网络$Q'$和actor的目标网络$\mu'$： \[\begin{matrix} \theta^{Q'}\leftarrow\tau \theta ^Q +(1-\tau)\theta^{Q'} \\\theta^{\mu'}\leftarrow\tau \theta ^{\mu}+(1-\tau)\theta^{\mu'} \end{matrix}\]

End For

End For

注：

critic是$Q$，critic的目标网络是$Q'$
actor是$\mu$，actor的目标网络是$\mu'$
critic的参数$\theta ^Q$就是前面讲的$w$
critic的目标网络的参数$\theta ^{Q'}$就是前面讲的$w^-$
actor的参数$\theta ^\mu$就是前面讲的$\theta$
actor的目标网络的参数$\theta ^{\mu'}$就是前面讲的$\theta^-$

来看看ddpg的代码：https://github.com/MorvanZhou/Reinforcement-learning-with-tensorflow/blob/master/contents/9_Deep_Deterministic_Policy_Gradient_DDPG/DDPG_update.py

代码里有几个点可以注释下咯：

需要求导的参数定义

        self.ae_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/eval')
        self.at_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Actor/target')
        self.ce_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/eval')
        self.ct_params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Critic/target')

actor和critic的定义

        with tf.variable_scope('Actor'):
            self.a = self._build_a(self.S, scope='eval', trainable=True) # 是用来训练的
            a_ = self._build_a(self.S_, scope='target', trainable=False) # 目标网络只是隔tau后会直接更新参数
        with tf.variable_scope('Critic'):
            # assign self.a = a in memory when calculating q for td_error,
            # otherwise the self.a is from Actor when updating Actor
            q = self._build_c(self.S, self.a, scope='eval', trainable=True) # 是用来训练的
            q_ = self._build_c(self.S_, a_, scope='target', trainable=False) # 目标网络只是隔tau后会直接更新参数

actor网络，输入状态$s$，输出动作$a$，由于是连续动作空间，所以$a$是一个a_dim维的向量，在tanh后，是-1到1之间，乘一个a_bound把输出值缩放到正确的值域里。

    def _build_a(self, s, scope, trainable):
        with tf.variable_scope(scope):
            net = tf.layers.dense(s, 30, activation=tf.nn.relu, name='l1', trainable=trainable)
            a = tf.layers.dense(net, self.a_dim, activation=tf.nn.tanh, name='a', trainable=trainable)
            return tf.multiply(a, self.a_bound, name='scaled_a')

critic网络，输入有两个参数，状态$s$和动作$a$，输出q值(是一个数字)：

    def _build_c(self, s, a, scope, trainable):
        with tf.variable_scope(scope):
            n_l1 = 30
            w1_s = tf.get_variable('w1_s', [self.s_dim, n_l1], trainable=trainable)
            w1_a = tf.get_variable('w1_a', [self.a_dim, n_l1], trainable=trainable)
            b1 = tf.get_variable('b1', [1, n_l1], trainable=trainable)
            net = tf.nn.relu(tf.matmul(s, w1_s) + tf.matmul(a, w1_a) + b1)
            return tf.layers.dense(net, 1, trainable=trainable)  # Q(s,a)

critic的loss：当前reward加上gamma乘以目标critic网络输出的q，是我们的td目标（即上面提到的$y_i$），而critic网络输出的q，则是我们当前critic网络的输出，两者之差的mse就是td_error，而我们需要对critic的参数求导，所以ar_list=self.ce_params

        q_target = self.R + GAMMA * q_
        # in the feed_dic for the td_error, the self.a should change to actions in memory
        td_error = tf.losses.mean_squared_error(labels=q_target, predictions=q)
        self.ctrain = tf.train.AdamOptimizer(LR_C).minimize(td_error, var_list=self.ce_params)

actor的loss：可以发现上面讲的$\triangledown_aQ(s,a|\theta ^Q)|_{s=s_i,a=\mu(s_i)}\triangledown _{\theta ^\mu} {\mu(s|\theta ^\mu)|_{s_i}}$，其实就是$\frac{\partial Q(s,a)}{\partial a} \frac{\partial a}{\partial \theta ^\mu}$，也就是$\frac{\partial Q(s,a)}{\partial \theta ^\mu}$，所以就是以critic网络的输出q，对actor的参数进行求导，所以var_list=self.ae_params

        a_loss = - tf.reduce_mean(q)    # maximize the q
        self.atrain = tf.train.AdamOptimizer(LR_A).minimize(a_loss, var_list=self.ae_params)

更新目标网络的操作

        # target net replacement
        self.soft_replace = [tf.assign(t, (1 - TAU) * t + TAU * e)
                             for t, e in zip(self.at_params + self.ct_params, self.ae_params + self.ce_params)]

3.3 A3C(asynchronous advantage actor-critic)

详见：https://daiwk.github.io/posts/rl-distributed-rl.html#2-a3c

深入浅出强化学习-chap8 基于置信域策略搜索的强化学习方法

2018-04-12T00:00:00+00:00

1. 理论基础

参考《深入浅出强化学习》

1. 理论基础

策略梯度方法的参数更新公式为：

\[ \theta_{new}=\theta_{old}+\alpha \triangledown_{\theta}J \]

策略梯度方法最大的问题是步长的选取问题，如果步长太长，策略很容易发散；如果步长太短，收敛速度很慢。

合适的步长$\alpha$指的是当策略更新后，回报函数的值不能更差。因些TRPO要解决的就是如何找到新的策略，使得新的回报函数的值单调增长，或者单调不减。

用$\tau$表示一组状态行为序列$s_0,u_0,...,s_H,u_H$，强化学习的回报函数为：

\[ \eta (\tilde{\pi})=E_{\tau|\tilde{\pi}}[\sum _{t=0}^{\infty }\gamma^t(r(s_t))] \]

其中，$\tilde{\pi}$表示策略。如何找到新策略，使回报函数单调不减呢？一个自然想法就是把新策略对应的回报函数分解成旧策略对应的回报函数，加上其他项。保证这个其他项大于等于0就行了。2002年Sham Kakade就提出了这么一个等式：

\[ \eta (\tilde{\pi})=\eta (\pi)+E_{s_0,a_0,...\sim \tilde{\pi}}[\sum _{t=0}^{\infty }\gamma^t(A_{\pi}(s_t,a_t))] \]

其中$\pi$表示旧策略，$\tilde{\pi}$表示新策略。其中的$A_{\pi}(s,a)$是优势函数。

\[ A_{\pi}(s,a)=Q_\pi(s,a)-V_\pi(s)=E_{s'\sim P(s'|s,a)}[r(s)+\gamma V^{\pi}(s')-V^{\pi}(s)] \]

因为$V_\pi(s)=\sum _i\pi(a_i|s)Q_{\pi}(s,a_i)$，也就是说值函数$V(s)$可以理解为该状态$s$下，所有可能动作所对应的动作值函数$Q_{\pi}(s,a_i)$与采取该动作的概率$\pi(a_i|s)$的乘积之和，相当于是该状态下所有动作的值函数的平均。而$Q_{\pi}(s,a)$是单个动作所对应的值函数，所以所谓的优势就是当前动作值函数对于平均值函数的优势。

然后。。好复杂

深入浅出强化学习-chap7 基于策略梯度的强化学习方法

2018-04-12T00:00:00+00:00

问题定义
- 似然率的角度
- 重要性采样的角度
如何求解log梯度
- REINFORCE算法

参考《深入浅出强化学习》

问题定义

似然率的角度

$\tau$表示一组状态-行为序列（轨迹）$s_0,u_0,...,s_H,u_H$
$R(\tau) = \sum_{t=0}^{H}R(s_t,u_t)$表示这条轨迹的回报
$P(\tau;\theta)$表示轨迹$\tau$出现的概率

那么，强化学习的优化目标就是长期累积期望回报：

\[ U(\theta) = E(\sum^{H}_{t=0}R(s_t,u_t);\pi_{\theta})=\sum_{\tau}P(\tau;\theta)R(\tau) \]

所以强化学习就是要找到最优参数$\theta$，使得$\max_{\theta}U(\theta)=\max_{\theta}\sum_{\tau}P(\tau;\theta)R(\tau)$，那就可以用梯度上升（因为是求max）来解了。

关键在于如何对$U(\theta)$求导：

\[ \begin{split} \\ \triangledown _{\theta}(U_{\theta})&=\triangledown_{\theta}\sum_{\tau}P(\tau;\theta)R(\tau) \\&=\sum_{\tau}\triangledown_{\theta}P(\tau;\theta)R(\tau) \\&=\sum_{\tau} \frac{P(\tau;\theta)}{P(\tau;\theta)} \triangledown_{\theta}P(\tau;\theta)R(\tau) \\&=\sum_{\tau} P(\tau;\theta)\frac{\triangledown_{\theta}P(\tau;\theta)R(\tau)}{P(\tau;\theta)} \\&=\sum_{\tau} P(\tau;\theta)\triangledown_{\theta}\log P(\tau;\theta)R(\tau) \end{split} \]

其中，$\triangledown_x\log P(x)=\frac{1}{P(x)}\triangledown_xP(x)$

因此，策略梯度最终变成求$\triangledown_{\theta}\log P(\tau;\theta)$的期望。而这期望，可以通过利用当前策略$\pi_{\theta}$采样m条轨迹$\tau_1,...,\tau_m$之后，求平均来近似：

\[ \triangledown _{\theta}(U_{\theta})\approx \frac{1}{m}\sum_{i=1}^{m}\triangledown_{\theta}\log P(\tau_i;\theta)R(\tau_i) \]

也从另一个角度来证明，因为$R(\tau)$和$\theta$无关，所以其实也可以这么看：

\[ \triangledown_{\theta}\log P(\tau;\theta)=\frac{1}{P(\tau;\theta)}\triangledown_{\theta}P(\tau;\theta) \]

所以，

\[ \triangledown_{\theta}P(\tau;\theta)=P(\tau;\theta)\triangledown_{\theta}\log P(\tau;\theta) \]

所以

\[ \begin{split} \\ \triangledown _{\theta}(U_{\theta})&=\triangledown_{\theta}\sum_{\tau}P(\tau;\theta)R(\tau) \\&=\sum_{\tau}[\triangledown_{\theta}P(\tau;\theta)]R(\tau) \\&=\sum_{\tau} [P(\tau;\theta)\triangledown_{\theta}\log P(\tau;\theta)]R(\tau) \end{split} \]

重要性采样的角度

暂时略

如何求解log梯度

上面推导出了策略梯度的公式是：

\[ \triangledown _{\theta}(U_{\theta})\approx \frac{1}{m}\sum_{i=1}^{m}\triangledown_{\theta}\log P(\tau_i;\theta)R(\tau_i) \]

如何求解$\triangledown_{\theta}\log P(\tau;\theta)$呢？

REINFORCE算法

首先，轨迹$\tau=s_0,u_0,...,s_H,u_H$，那么：

\[ P(\tau;\theta)=P(s_0)\prod ^{H-1}_{i=0}P(s_{i+1}|s_{i},u_{i})\pi_{\theta}(u_i|s_i) \]

其中，$\pi_{\theta}(u_i|s_i)$是策略，也就是在状态$s_i$下，采用动作$u_i$的概率。

深入浅出强化学习-chap6 基于值函数逼近的强化学习方法

2018-04-12T00:00:00+00:00

1. 基于值函数逼近的理论讲解
2. DQN及其变种
3. 函数逼近方法
4. 各种其他优化

参考《深入浅出强化学习》

1. 基于值函数逼近的理论讲解

2. DQN及其变种

2.1 DQN方法

DeepMind发表在Nature上的文章Human-level control through deep reinforcement learning

最主要创新点是两个：

经验回放
设立单独的目标网络

大体框架是复用传统强化学习里的Qlearning方法。Qlearning包括两个关键点：

异策略：行动策略与 要评估的策略不是同一个策略。
- 行动策略（用来选择行动$a$的策略）是$\epsilon -greedy$策略
- 要评估和改进的策略是贪婪策略（即$max_aQ(s_{t+1},a)$，当前状态$s_{t+1}$下，使用各种a使$Q(s_{t+1},a)$达到的最大值），即，是最大的$Q$，与行动策略里随机选一个$a$得到的$Q$不同
时间差分（temporal difference, TD）：使用时间差分目标（即，$r_t+\gamma max_aQ(s_{t+1},a)$）来更新当前的行为值函数

注意，时间差分方法其实包括了异策略和同策略两种，

异策略(即off-policy)，如Qlearning，
同策略如Sarsa强化学习算法 （行为策略和目标策略都是$\epsilon $ -greedy策略）(书p77-79)

Qlearning的算法流程如下：

初始化$Q(s,a),\forall s\in S,a\in A(s)$，给定参数$\alpha, \gamma$

Repeat

给定起始状态$s$，并根据$\epsilon -greedy$策略在状态$s$选择动作$a$

Repeat

根据$\epsilon -greedy$策略选择动作$a_t$，得到回报$r_t$和下一个状态$s_{t+1}$

使用时间差分方法更新行为值函数$Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha [r_t+\gamma max_a(Q(s_{t+1},a))-Q(s_t,a_t)]$

$s=s'$, $a=a'$

Until $s$是最终状态

Until 所有的$Q(s,a)$收敛

输出最终策略：$\pi (s)=argmax_aQ(s,a)$

DQN对Qlearning主要进行了如下三个修改：

利用深度卷积神经网络逼近行为值函数
在强化学习的学习过程中引入经验回放
设立了独立的目标网络单独处理时间差分算法中的TD偏差

2.1.1 利用深度卷积神经网络逼近行为值函数

行为值函数$Q(s,a)$用参数为$\theta$的非线性参数逼近$Q(s,a;\theta)$来近似

2.1.2 在强化学习的学习过程中引入经验回放

其实20世纪90年代就已经有用神经网络逼近行为值函数的方法了，但常常出现不稳定不收敛的情况。

deepmind的创始人Hassabis是神经科学的博士，他是研究人类大脑中负责记忆和学习的主要部分——海马体的。在人类睡觉时，海马体会把一天的记忆重放给大脑皮层。

训练神经网络时，存在的假设是训练数据是独立同分布的，但通过强化学习采集的数据间存在关联性，利用这些数据进行训练，神经网络就不会稳定。而经验回放就可以打破数据间的关联。

2.1.3 设立了独立的目标网络单独处理时间差分算法中的TD偏差

经验回放的技巧可以打破数据间的关联性，这个技巧在2013年的NIPS已经发布了，而2015年的Nature论文进一步提出了目标网络，进一步降低数据间的关联性。

正常的Qlearning更新值函数的方法如下：

\[ Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha [r_t+\gamma max_a(Q(s_{t+1},a))-Q(s_t,a_t)] \]

但现在使用卷积神经网络来逼近，所以需要更新的是参数$\theta$，使用的方式自然是梯度下降：

\[ \theta_{t+1}=\theta _t+\alpha [r+\gamma max_{a'}(Q(s',a';\theta))-Q(s',a';\theta)]\nabla Q(s,a;\theta) \]

而这里的$r+\gamma max_{a'}(Q(s',a';\theta))$是TD目标，在计算$max_{a'}(Q(s',a';\theta))$时用到的网络参数为$\theta$。

在DQN之前，计算TD目标的动作值函数所用的网络参数$\theta$与梯度计算中要逼近的动作值函数所用的网络参数相同，这样就容易导致数据间存在关联性，从而使训练不稳定。

所以DQN的做法就是将TD目标的网络表示为$\theta ^{-}$，用于动作值函数逼近的网络$\theta$每一步都更新，而用于计算TD目标的网络$\theta ^{-}$则是每固定的步数才更新一次【这就可以使得在一段时间里目标Q值是保持不变的，从而使得在一段时间里能集中力量去优化真正的目标$\theta$，等真正的目标好一点了，再去更新$\theta^-$】：

\[ \theta_{t+1}=\theta _t+\alpha [r+\gamma max_{a'}(Q(s',a';\theta ^{-}))-Q(s,a;\theta)]\nabla Q(s,a;\theta) \]

DQN的训练算法如下：

初始化replay memory $D$，capacity设为$N$

使用随机权重$\theta$初始化动作值函数$Q$

使用权重$\theta^{-}=\theta$初始化目标动作值函数$\hat {Q}$

For $episode = [1,...,M]$ do

初始化事件的第一个状态($x_1$是第一张图片)$s_1=\{x_1\}$，并通过预处理得到状态对应的特征输入$\phi _1=\phi(s_1)$

For $t=[1,...T]$ do

根据概率$\epsilon$随机选择一个动作$a_t$

如果小概率事件没有发生，就用贪婪策略选择当前行为值函数最大的那个动作：$a_t=argmax_a(Q(\phi(s_t),a;\theta))$【上面那行和这行就是所谓的行动策略，$\epsilon -greedy$策略】

在模拟器中执行动作$a_t$，得到回报$r_t$以及图片$x_{t+1}$

令$s_{t+1}=s_t,a_t,x_{t+1}$，然后预处理$\phi _{t+1}=\phi(s_{t+1})$

将transition $(\phi_t,a_t,r_t,\phi _{t+1})$存入$D$。

从$D$中随机sample出一个minibatch的transitions，$(\phi _j,a_j,r_j,\phi _{j+1})$

令$y_j=\left\{\begin{matrix}r_j & if\ episode\ terminates\ at\ step\ j+1\\ r_j+\gamma max_{a'}\hat {Q}(\phi_{j+1},a';\theta^{-}) & otherwise \end{matrix}\right.$

对$(y_j-Q(\phi _j,a_j;\theta))^2$的参数$\theta$进行一个梯度下降step的更新，$\theta_{t+1}=\theta _t+\alpha [r+\gamma max_{a'}(\hat {Q}(s',a';\theta ^{-}))-Q(s,a;\theta)]\nabla Q(s,a;\theta)$

每$C$个step，令$\hat {Q}=Q$，即令$\theta ^{-}=\theta $

End For

End For

DQN小结（by daiwk）

算$y_i$的时候用的是目标网络$\hat{Q}$和$\theta ^-$
loss是目标网络算出来的$r+\gamma max \hat{Q}$与原网络$Q$之差
$y_i$是当前reward，基于状态$s_{t+1}$再执行一个action得到的新的reward。而原网络$Q$是当前的状态$s_t$。
总共有这么几大步：
- 当前状态$s_t$，处理后是$\phi _t$，通过$\epsilon -greedy$得到$Q$最大的$a_t$
- 执行$a_t$，得到$\phi _t, a_t,r_t,\phi_{t+1}$，扔进replay buffer中
- 采样出一个$\phi _j,a_j,r_j,\phi_{j+1}$
- 计算在$\phi _{j+1}$上再执行一个使得$\hat {Q}$(注意，这里不是$Q$)最大的动作$a'$得到的reward：$y_j=r_j+\gamma max \hat {Q}(\phi_{j+1},a')$
- 算$y_i$和当前$Q$的残差，梯度下降，更新当前$Q$的参数：$\theta += \alpha (y_j-Q)\nabla Q$
- $C$步之后，把当前$Q$的参数赋值给$\hat {Q}$
再次强调
- $maxQ$的是当前状态+当前动作；
- $max\hat {Q}$是下一状态+下一动作；
- 用来算残差的也是当前状态+当前动作得到的$Q$

2.2 Double DQN

2.2.1 Qlearning的过估计

DQN无法克服Qlearning本身固有的缺点：过估计

过估计指的是估计的值函数比真实值函数大，Qlearning出现过估计的问题，根源在于其中的最大化操作：

对于表格型，值函数评估的更新公式：

\[ Q(s_t,a_t)\leftarrow Q(s_t,a_t)+\alpha [r_t+\gamma \underset{a}{max}Q(s_{t+1},a)-Q(s_t,a_t)] \]

对于基于函数逼近的方法，值函数更新公式为：

\[ \theta _{t+1}=\theta_t+\alpha(R_{t+1}+\gamma \underset{a}{max}Q(S_{t+1},a;\theta_t)-Q(S_t,A_t;\theta_t))\triangledown _{\theta_t}Q(S_t,A_t;\theta_t) \]

可以发现不管是表格型，还是基于值函数逼近的方法，更新公式中都有max操作，使得估计的值函数比值函数的真实值大。

如果过估计是均匀的，即值函数的每一点的值都被过估计了相同的幅度，那么由于最优策略是贪婪策略，即找最在的值函数所对应的动作，在这种情况下一不会影响最优策略（因为每个值函数都变大一样的幅度，所以原来最大的那个还是最大），这样因为强化学习的目标是找到最优策略，所以不会影响我们解决问题~

但实际情况中，过估计量并不是均匀的，所以会影响最终策略，使得最终策略并非最优！！

在Qlearning的值函数更新中，TD目标为：

\[ Y^Q_t=R_{t+1}+\gamma max_aQ(S_{t+1},a;\theta_t) \]

动作选择

在求TD目标$Y^Q_t$时，首先需要选择一个动作$a^*$，该动作$a^*$应该满足在状态$S_{t+1}$处使得$Q(s_{t+1},a)$最大，这就是动作选择。

动作评估

选出$a^*$后，利用$a^*$处的动作值函数构造TD目标。

一般的Qlearning使用同一个参数$\theta_t$来选择和评估动作。

Double Qlearning将动作的选择和动作的评估分别用不同的值函数来实现，从而其TD目标为：

\[ Y^{DoubleQ}_t=R_{t+1}+\gamma Q(S_{t+1},argmax_aQ(S_{t+1},a;\theta_t);\theta_t') \]

所以，我们可以看出，动作的选择所选择的$a^*$为

\[ a^*=argmax_aQ(S_{t+1},s;\theta_t) \]

动作值函数网络的参数是$\theta_t$。当选出最大动作$a^*$之后，动作评估的公式为：

\[ Y^{DoubleQ}_t=R_{t+1}+\gamma Q(S_{t+1},a^*;\theta_t') \]

所以，引入DQN就是Double DQN：

Deep Reinforcement Learning with Double Q-learning

将TD error修改为：

\[ r+\gamma Q(s',argmax_{a'}Q(s',a',\theta),\theta^-)-Q(s,a,\theta) \]

其中

$\theta$是当前的网络参数，用来选择动作
$\theta^-$是前一步的网络参数（$delayed \theta$），用来评估动作

因为原来的DQN就已经引入了目标网络$\theta^-$，所以其实改动不大。但注意！！区别在于，原来DQN的TD error是$r+\gamma Q(s',argmax_{a'}Q(s',a',\theta^-),\theta^-)$，即动作选择和动作评估都是$\theta^-$。而Double DQN动作选择是$\theta$，动作评估是$\theta^-$

2.3 优先回放(Prioritized Replay)

2.4 Dueling DQN

参考书本，以及https://blog.csdn.net/u013236946/article/details/73161586

竞争网络（dueling net）从网络结构上改进了DQN，将动作值函数分解为状态值函数和优势函数，即：

\[ Q^{\pi}(s,a)=V^{\pi}(s)+A^{\pi}(s,a) \]

以往的DQN都是直接用神经网络逼近$Q^{\pi}(s,a)$，而Dueling DQN则是对$V^{\pi}(s)$和$A^{\pi}(s,a)$分别用神经网络来逼近。

状态值函数$V^{\pi}(s)$表示静态的状态环境本身具有的价值。是一个scalar。
依赖状态的动作优势函数$A^{\pi}(s,a)$(advantage function)，表示选择某个Action额外带来的价值。是一个vector。

更详细地，状态价值函数表示为

\[ V(s;\theta,\beta) \]

动作优势函数表示为

\[ A(s,a;\theta,\alpha) \]

动作Q值为两者相加

\[ Q(s,a;\theta,\alpha,\beta) = V(s;\theta,\beta)+A(s,a;\theta,\alpha) \]

其中，$\theta$是卷积层的参数，$\beta$和$\alpha$是两个支路全连接层的参数。

而在实际中，一般要将动作优势流设置为单独动作优势函数减去某状态下所有动作优势函数的平均值，这样做可以保证该状态下各动作的优势函数相对排序不变，而且可以缩小Q值的范围，去除多余的自由度，提高算法稳定性。

\[ Q(s,a;\theta,\alpha,\beta) = V(s;\theta,\beta)+(A(s,a;\theta,\alpha)-\frac{1}{|A|}\sum_{a'}A(s,a';\theta,\alpha)) \]

这种竞争结构能学到在没有动作的影响下环境状态的价值$V(s)$。如下图，在训练过程中，上下两行图表示不同时刻，左右两列表示属于$V(s)$和$A(a)$，（通过某种方法处理后）图中红色区域代表$V(s)$ 和$A(a)$所关注的地方。$V(s)$关注于地平线上是否有车辆出现（此时动作的选择影响不大）以及分数；$A(a)$则更关心会立即造成碰撞的车辆，此时动作的选择很重要。

论文中dueling net结合了DDQN(double dqn)以及优先级采样（Prioritized Experience Replay）的训练方式。

3. 函数逼近方法

3.1 基于非参数的函数逼近

基于核函数的方法

基于高斯过程的函数逼近方法

3.2 基于参数的函数逼近

3.3 卷积神经网络

3.3.1 卷积运算

稀疏连接

权值共享

3.3.2 池化

4. 各种其他优化

参考https://zhuanlan.zhihu.com/p/21547911

几个问题：

目标Q值的计算准确吗？全部通过max Q来计算有没有问题？
随机采样的方法好吗？按道理不同样本的重要性是不一样的
Q值代表状态，动作的价值，那么单独动作价值的评估会不会更准确？
DQN中使用$\epsilon-greedy$的方法来探索状态空间，有没有更好的做法？
使用卷积神经网络的结构是否有局限？加入RNN呢？
DQN无法解决一些高难度的Atari游戏比如Montezuma’s Revenge，如何处理这些游戏？
DQN训练时间太慢了，跑一个游戏要好几天，有没有办法更快？
DQN训练是单独的，也就是一个游戏弄一个网络进行训练，有没有办法弄一个网络同时掌握多个游戏，或者训练某一个游戏后将知识迁移到新的游戏？
DQN能否用在连续动作输出问题？

解法：

改进目标Q值计算：Deep Reinforcement Learning with Double Q-learning
改进随机采样：Prioritized Experience Replay
改进网络结构，评估单独动作价值：Dueling Network Architectures for Deep Reinforcement Learning ( 本文为ICML最佳论文之一）
改进探索状态空间方式：（1）Deep Exploration via Bootstrapped DQN （2）Incentivizing Exploration In Reinforcement Learning With Deep Predictive Models
改变网络结构，增加RNN：Deep Recurrent Q-Learning for Partially Observable MDPs（非DeepMind出品，效果很一般，谈不上改进，不考虑讲解）
实现DQN训练的迁移学习：（1）Policy Distillation （2） Actor-Mimic: Deep Multitask and Transfer Reinforcement Learning
解决高难度游戏Montezuma‘s Revenge：Unifying Count-Based Exploration and Intrinsic Motivation
加快DQN训练速度：Asynchronous Methods for Deep Reinforcement Learning（这篇文章还引出了可以替代DQN的A3C算法，效果4倍Nature DQN）
改变DQN使之能够应用在连续控制上面：Continuous Deep Q-Learning with Model-based Acceleration

multi-task learning

2018-04-12T00:00:00+00:00

两大类mtl方法
- hard参数共享
- soft参数共享
mtl为什么会work
非神经网络中的mtl
- Block-sparse regularization
- Learning task relationships
MTL Deep Learning的Recent work
Auxiliary tasks

参考：

http://ruder.io/multi-task/

阿里天池的一个讲解【深度学习系列09】Multi-Task Learning for E-commerce

两大类mtl方法

hard参数共享

所有task共享大的隐层表示，然后每个task有自己的output层。可以极大地减少过拟合，因为大的隐层表示的参数量比每个task自己的小output的参数量要大得多。

soft参数共享

每个task有自己的模型和自己的参数。模型参数间的距离一般会使用$\ell_2$正则进行正则化，目的是为了让参数间更相似。

mtl为什么会work

假设task A和task B，有共同的隐层表示F。

隐式数据增强

Attention focusing

Eavesdropping

Representation bias

Regularization

非神经网络中的mtl

Block-sparse regularization

Learning task relationships

MTL Deep Learning的Recent work

Deep Relationship Networks

Cross-stitch Networks

Low supervision

A Joint Many-Task model

Weighting losses with uncertainty

Tensor factorisation for MTL

Sluice Networks

Auxiliary tasks

Related task Adversarial Hints Focusing attention Quantization smoothing Predicting inputs Using the future to predict the present Representation learning What auxiliary tasks are helpful? Conclusion

tensorflow代码——数据持久化

2018-04-07T00:00:00+00:00

MetaGraphDef

参考：《TensorFlow实战Google深度学习框架（第2版）》第5章

MetaGraphDef

tf通过元图（MetaGraph）记录计算图中节点的信息及运行计算图中节点所需的元数据。

在tensorflow/core/protobuf/meta_graph.proto中定义了：

message MetaGraphDef {
  // Meta information regarding the graph to be exported.  To be used by users
  // of this protocol buffer to encode information regarding their meta graph.
  message MetaInfoDef {
    // User specified Version string. Can be the name of the model and revision,
    // steps this model has been trained to, etc.
    string meta_graph_version = 1;

    // A copy of the OpDefs used by the producer of this graph_def.
    // Descriptions and Ops not used in graph_def are stripped out.
    OpList stripped_op_list = 2;

    // A serialized protobuf. Can be the time this meta graph is created, or
    // modified, or name of the model.
    google.protobuf.Any any_info = 3;

    // User supplied tag(s) on the meta_graph and included graph_def.
    //
    // MetaGraphDefs should be tagged with their capabilities or use-cases.
    // Examples: "train", "serve", "gpu", "tpu", etc.
    // These tags enable loaders to access the MetaGraph(s) appropriate for a
    // specific use-case or runtime environment.
    repeated string tags = 4;

    // The __version__ string of the tensorflow build used to write this graph.
    // This will be populated by the framework, which will overwrite any user
    // supplied value.
    string tensorflow_version = 5;

    // The __git_version__ string of the tensorflow build used to write this
    // graph. This will be populated by the framework, which will overwrite any
    // user supplied value.
    string tensorflow_git_version = 6;

    // A flag to denote whether default-valued attrs have been stripped from
    // the nodes in this graph_def.
    bool stripped_default_attrs = 7;
  }
  MetaInfoDef meta_info_def = 1;

  // GraphDef.
  GraphDef graph_def = 2;

  // SaverDef.
  SaverDef saver_def = 3;

  // collection_def: Map from collection name to collections.
  // See CollectionDef section for details.
  map<string, CollectionDef> collection_def = 4;

  // signature_def: Map from user supplied key for a signature to a single
  // SignatureDef.
  map<string, SignatureDef> signature_def = 5;

  // Asset file def to be used with the defined graph.
  repeated AssetFileDef asset_file_def = 6;
}

保存MetaGraphDef的文件默认以.meta结尾，是二进制文件。tf有export_meta_graph函数，可以以json格式导出MetaGraphDef：

import tensorflow as tf

v1 = tf.Variable(tf.constant(1.0, shape=[1], name="v1"))
v2 = tf.Variable(tf.constant(13.8, shape=[1], name="v2"))

result = v1 + v2

init_op = tf.global_variables_initializer()

saver = tf.train.Saver()

ckpt_json_path = "./demo/model/model.ckpt.meta.json"

saver.export_meta_graph(ckpt_json_path, as_text=True)

ckpt_path = "./demo/model/model.ckpt"

with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)    
    saver.save(sess, ckpt_path)

输出：

https://daiwk.github.io/assets/tf.saver.demo.meta.json

meta_info_def

如上，MetaInfoDef中包含如下信息：

  message MetaInfoDef {
    // User specified Version string. Can be the name of the model and revision,
    // steps this model has been trained to, etc.
    string meta_graph_version = 1;

    // A copy of the OpDefs used by the producer of this graph_def.
    // Descriptions and Ops not used in graph_def are stripped out.
    OpList stripped_op_list = 2;

    // A serialized protobuf. Can be the time this meta graph is created, or
    // modified, or name of the model.
    google.protobuf.Any any_info = 3;

    // User supplied tag(s) on the meta_graph and included graph_def.
    //
    // MetaGraphDefs should be tagged with their capabilities or use-cases.
    // Examples: "train", "serve", "gpu", "tpu", etc.
    // These tags enable loaders to access the MetaGraph(s) appropriate for a
    // specific use-case or runtime environment.
    repeated string tags = 4;

    // The __version__ string of the tensorflow build used to write this graph.
    // This will be populated by the framework, which will overwrite any user
    // supplied value.
    string tensorflow_version = 5;

    // The __git_version__ string of the tensorflow build used to write this
    // graph. This will be populated by the framework, which will overwrite any
    // user supplied value.
    string tensorflow_git_version = 6;

    // A flag to denote whether default-valued attrs have been stripped from
    // the nodes in this graph_def.
    bool stripped_default_attrs = 7;
  }

其中的meta_graph_version(计算图的版本号)、tags(用户指定的一些标签)，如果没在saver中指定，都默认是空。stripped_op_list属性记录了计算图上使用的所有运算方法的信息。如果某个运算在计算图中出现多次，则其在stripped_op_list中也只会出现一次。stripped_op_list的类型是OpList其定义在tensorflow/core/framework/op_def.proto中，如下：

syntax = "proto3";

package tensorflow;
option cc_enable_arenas = true;
option java_outer_classname = "OpDefProtos";
option java_multiple_files = true;
option java_package = "org.tensorflow.framework";
option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework";
import "tensorflow/core/framework/attr_value.proto";
import "tensorflow/core/framework/types.proto";

// Defines an operation. A NodeDef in a GraphDef specifies an Op by
// using the "op" field which should match the name of a OpDef.
// LINT.IfChange
message OpDef {
  // Op names starting with an underscore are reserved for internal use.
  // Names should be CamelCase and match the regexp "[A-Z][a-zA-Z0-9_]*".
  string name = 1;

  // For describing inputs and outputs.
  message ArgDef {
    // Name for the input/output.  Should match the regexp "[a-z][a-z0-9_]*".
    string name = 1;

    // Human readable description.
    string description = 2;

    // Describes the type of one or more tensors that are accepted/produced
    // by this input/output arg.  The only legal combinations are:
    // * For a single tensor: either the "type" field is set or the
    //   "type_attr" field is set to the name of an attr with type "type".
    // * For a sequence of tensors with the same type: the "number_attr"
    //   field will be set to the name of an attr with type "int", and
    //   either the "type" or "type_attr" field will be set as for
    //   single tensors.
    // * For a sequence of tensors, the "type_list_attr" field will be set
    //   to the name of an attr with type "list(type)".
    DataType type = 3;
    string type_attr = 4;    // if specified, attr must have type "type"
    string number_attr = 5;  // if specified, attr must have type "int"
    // If specified, attr must have type "list(type)", and none of
    // type, type_attr, and number_attr may be specified.
    string type_list_attr = 6;

    // For inputs: if true, the inputs are required to be refs.
    //   By default, inputs can be either refs or non-refs.
    // For outputs: if true, outputs are refs, otherwise they are not.
    bool is_ref = 16;
  };

  // Description of the input(s).
  repeated ArgDef input_arg = 2;

  // Description of the output(s).
  repeated ArgDef output_arg = 3;

  // Description of the graph-construction-time configuration of this
  // Op.  That is to say, this describes the attr fields that will
  // be specified in the NodeDef.
  message AttrDef {
    // A descriptive name for the argument.  May be used, e.g. by the
    // Python client, as a keyword argument name, and so should match
    // the regexp "[a-z][a-z0-9_]+".
    string name = 1;

    // One of the type names from attr_value.proto ("string", "list(string)",
    // "int", etc.).
    string type = 2;

    // A reasonable default for this attribute if the user does not supply
    // a value.  If not specified, the user must supply a value.
    AttrValue default_value = 3;

    // Human-readable description.
    string description = 4;

    // TODO(josh11b): bool is_optional?

    // --- Constraints ---
    // These constraints are only in effect if specified.  Default is no
    // constraints.

    // For type == "int", this is a minimum value.  For "list(___)"
    // types, this is the minimum length.
    bool has_minimum = 5;
    int64 minimum = 6;

    // The set of allowed values.  Has type that is the "list" version
    // of the "type" field above (uses the "list" field of AttrValue).
    // If type == "type" or "list(type)" above, then the "type" field
    // of "allowed_values.list" has the set of allowed DataTypes.
    // If type == "string" or "list(string)", then the "s" field of
    // "allowed_values.list" has the set of allowed strings.
    AttrValue allowed_values = 7;
  }
  repeated AttrDef attr = 4;

  // Optional deprecation based on GraphDef versions.
  OpDeprecation deprecation = 8;

  // One-line human-readable description of what the Op does.
  string summary = 5;

  // Additional, longer human-readable description of what the Op does.
  string description = 6;

  // -------------------------------------------------------------------------
  // Which optimizations this operation can participate in.

  // True if the operation is commutative ("op(a,b) == op(b,a)" for all inputs)
  bool is_commutative = 18;

  // If is_aggregate is true, then this operation accepts N >= 2
  // inputs and produces 1 output all of the same type.  Should be
  // associative and commutative, and produce output with the same
  // shape as the input.  The optimizer may replace an aggregate op
  // taking input from multiple devices with a tree of aggregate ops
  // that aggregate locally within each device (and possibly within
  // groups of nearby devices) before communicating.
  // TODO(josh11b): Implement that optimization.
  bool is_aggregate = 16;  // for things like add

  // Other optimizations go here, like
  //   can_alias_input, rewrite_when_output_unused, partitioning_strategy, etc.

  // -------------------------------------------------------------------------
  // Optimization constraints.

  // Ops are marked as stateful if their behavior depends on some state beyond
  // their input tensors (e.g. variable reading op) or if they have
  // a side-effect (e.g. printing or asserting ops). Equivalently, stateless ops
  // must always produce the same output for the same input and have
  // no side-effects.
  //
  // By default Ops may be moved between devices.  Stateful ops should
  // either not be moved, or should only be moved if that state can also
  // be moved (e.g. via some sort of save / restore).
  // Stateful ops are guaranteed to never be optimized away by Common
  // Subexpression Elimination (CSE).
  bool is_stateful = 17;  // for things like variables, queue

  // -------------------------------------------------------------------------
  // Non-standard options.

  // By default, all inputs to an Op must be initialized Tensors.  Ops
  // that may initialize tensors for the first time should set this
  // field to true, to allow the Op to take an uninitialized Tensor as
  // input.
  bool allows_uninitialized_input = 19;  // for Assign, etc.
};
// LINT.ThenChange(
//     https://www.tensorflow.org/code/tensorflow/core/framework/op_def_util.cc)

// Information about version-dependent deprecation of an op
message OpDeprecation {
  // First GraphDef version at which the op is disallowed.
  int32 version = 1;

  // Explanation of why it was deprecated and what to use instead.
  string explanation = 2;
};

// A collection of OpDefs
message OpList {
  repeated OpDef op = 1;
};

例如，如下就是名为Add的运算。两个input_arg，一个output_arg，它们都有type_attr，且值均为T。所以在attr中，必须出现name是T的属性，及其allow_values。

    op {
      name: "Add"
      input_arg {
        name: "x"
        type_attr: "T"
      }
      input_arg {
        name: "y"
        type_attr: "T"
      }
      output_arg {
        name: "z"
        type_attr: "T"
      }
      attr {
        name: "T"
        type: "type"
        allowed_values {
          list {
            type: DT_BFLOAT16
            type: DT_HALF
            type: DT_FLOAT
            type: DT_DOUBLE
            type: DT_UINT8
            type: DT_INT8
            type: DT_INT16
            type: DT_INT32
            type: DT_INT64
            type: DT_COMPLEX64
            type: DT_COMPLEX128
            type: DT_STRING
          }
        }
      }
    }

另外，在meta_info_def中，还有如下记录生成当前计算图的tensorflow版本的属性：

  tensorflow_version: "1.9.0"
  tensorflow_git_version: "v1.9.0-0-g25c197e023"

graph_def

在tensorflow/core/framework/graph.proto中定义了GraphDef，用于记录计算图上的节点信息。每个节点对应一个运算。在meta_info_def中已包含了所有运算的信息，所以graph_def只关注运算的连接结构。GraphDef中的versions比较简单，主要存储tf的版本号，主要信息都在NodeDef类型的node中。

syntax = "proto3";

package tensorflow;
option cc_enable_arenas = true;
option java_outer_classname = "GraphProtos";
option java_multiple_files = true;
option java_package = "org.tensorflow.framework";
option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework";
import "tensorflow/core/framework/node_def.proto";
import "tensorflow/core/framework/function.proto";
import "tensorflow/core/framework/versions.proto";

// Represents the graph of operations
message GraphDef {
  repeated NodeDef node = 1;

  // Compatibility versions of the graph.  See core/public/version.h for version
  // history.  The GraphDef version is distinct from the TensorFlow version, and
  // each release of TensorFlow will support a range of GraphDef versions.
  VersionDef versions = 4;

  // Deprecated single version field; use versions above instead.  Since all
  // GraphDef changes before "versions" was introduced were forward
  // compatible, this field is entirely ignored.
  int32 version = 3 [deprecated = true];

  // EXPERIMENTAL. DO NOT USE OR DEPEND ON THIS YET.
  //
  // "library" provides user-defined functions.
  //
  // Naming:
  //   * library.function.name are in a flat namespace.
  //     NOTE: We may need to change it to be hierarchical to support
  //     different orgs. E.g.,
  //     { "/google/nn", { ... }},
  //     { "/google/vision", { ... }}
  //     { "/org_foo/module_bar", { ... }}
  //     map<string, FunctionDefLib> named_lib;
  //   * If node[i].op is the name of one function in "library",
  //     node[i] is deemed as a function call. Otherwise, node[i].op
  //     must be a primitive operation supported by the runtime.
  //
  //
  // Function call semantics:
  //
  //   * The callee may start execution as soon as some of its inputs
  //     are ready. The caller may want to use Tuple() mechanism to
  //     ensure all inputs are ready in the same time.
  //
  //   * The consumer of return values may start executing as soon as
  //     the return values the consumer depends on are ready.  The
  //     consumer may want to use Tuple() mechanism to ensure the
  //     consumer does not start until all return values of the callee
  //     function are ready.
  FunctionDefLibrary library = 2;
};

其中的NodeDef在tensorflow/core/framework/node_def.proto中定义如下：

syntax = "proto3";

package tensorflow;
option cc_enable_arenas = true;
option java_outer_classname = "NodeProto";
option java_multiple_files = true;
option java_package = "org.tensorflow.framework";
option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/framework";
import "tensorflow/core/framework/attr_value.proto";

message NodeDef {
  // The name given to this operator. Used for naming inputs,
  // logging, visualization, etc.  Unique within a single GraphDef.
  // Must match the regexp "[A-Za-z0-9.][A-Za-z0-9_./]*".
  string name = 1;

  // The operation name.  There may be custom parameters in attrs.
  // Op names starting with an underscore are reserved for internal use.
  string op = 2;

  // Each input is "node:src_output" with "node" being a string name and
  // "src_output" indicating which output tensor to use from "node". If
  // "src_output" is 0 the ":0" suffix can be omitted.  Regular inputs
  // may optionally be followed by control inputs that have the format
  // "^node".
  repeated string input = 3;

  // A (possibly partial) specification for the device on which this
  // node should be placed.
  // The expected syntax for this string is as follows:
  //
  // DEVICE_SPEC ::= PARTIAL_SPEC
  //
  // PARTIAL_SPEC ::= ("/" CONSTRAINT) *
  // CONSTRAINT ::= ("job:" JOB_NAME)
  //              | ("replica:" [1-9][0-9]*)
  //              | ("task:" [1-9][0-9]*)
  //              | ("device:" [A-Za-z]* ":" ([1-9][0-9]* | "*") )
  //
  // Valid values for this string include:
  // * "/job:worker/replica:0/task:1/device:GPU:3"  (full specification)
  // * "/job:worker/device:GPU:3"                   (partial specification)
  // * ""                                    (no specification)
  //
  // If the constraints do not resolve to a single device (or if this
  // field is empty or not present), the runtime will attempt to
  // choose a device automatically.
  string device = 4;

  // Operation-specific graph-construction-time configuration.
  // Note that this should include all attrs defined in the
  // corresponding OpDef, including those with a value matching
  // the default -- this allows the default to change and makes
  // NodeDefs easier to interpret on their own.  However, if
  // an attr with a default is not specified in this list, the
  // default will be used.
  // The "names" (keys) must match the regexp "[a-z][a-z0-9_]+" (and
  // one of the names from the corresponding OpDef's attr field).
  // The values must have a type matching the corresponding OpDef
  // attr's type field.
  // TODO(josh11b): Add some examples here showing best practices.
  map<string, AttrValue> attr = 5;
};

name是节点名称，是一个节点的唯一标识符。tf中可以通过节点名称来获取相应的节点。
op属性给出了该节点使用的tf运算方法的名称，通过此名称可以在计算图元图的meta_info_def中找到该运算的具体信息。
input属性中每个字符串的取值格式为node:src_output
- node部分给出一个节点的名称
- src_output部分表明这个输入是指定节点的第几个输出。src_output为0时可以省略，即node:0可以记为node。
device属性指定了处理这个运算的设备。设备可以是本地cpu/gpu，也可以是远程的cpu/gpu。当device为空时，tf在运行时会选一个最合适的设备来运行此运算。
attr指定了和当前运算相关的配置信息。

例如：

graph_def {
...
  node {
    name: "Variable_1"
    op: "VariableV2"
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
    attr {
      key: "container"
      value {
        s: ""
      }
    }
    attr {
      key: "dtype"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "shape"
      value {
        shape {
          dim {
            size: 1
          }
        }
      }
    }
    attr {
      key: "shared_name"
      value {
        s: ""
      }
    }
  }
...
  node {
    name: "add"
    op: "Add"
    input: "Variable/read"
    input: "Variable_1/read"
    attr {
      key: "T"
      value {
        type: DT_FLOAT
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
            dim {
              size: 1
            }
          }
        }
      }
    }
  }
...
  node {
    name: "save/control_dependency"
    op: "Identity"
    input: "save/Const"
    input: "^save/SaveV2"
    attr {
      key: "T"
      value {
        type: DT_STRING
      }
    }
    attr {
      key: "_class"
      value {
        list {
          s: "loc:@save/Const"
        }
      }
    }
    attr {
      key: "_output_shapes"
      value {
        list {
          shape {
          }
        }
      }
    }
  }
...
  versions {
    producer: 26
  }

主要有以下几种节点：

节点1：

变量定义的运算：名称为Variable_1，
运算方法名：VariableV2
与运算相关的属性，例如Variable_1中定义了dtype、shape等

节点2：

定义的运算：名称为add
运算方法名：Add
输入：Variable/read和Variable_1/read。因为Variable_1的值是Variable_1/read的第一个输出，所以:0可以省略

节点3：

名称：save/control_dependency
在系统完成模型持久化过程中自动生成的一个运算

最后，versions是生成文件时使用的tf版本号

saver_def

记录了持久化模型时需要用到的一些参数，例如保存到文件的文件名、保存操作和加载操作的名称、保存频率、清理历史记录等。在tensorflow/core/protobuf/saver.proto中定义如下：

syntax = "proto3";

package tensorflow;
option cc_enable_arenas = true;
option java_outer_classname = "SaverProtos";
option java_multiple_files = true;
option java_package = "org.tensorflow.util";
option go_package = "github.com/tensorflow/tensorflow/tensorflow/go/core/protobuf";

// Protocol buffer representing the configuration of a Saver.
message SaverDef {
  // The name of the tensor in which to specify the filename when saving or
  // restoring a model checkpoint.
  string filename_tensor_name = 1;

  // The operation to run when saving a model checkpoint.
  string save_tensor_name = 2;

  // The operation to run when restoring a model checkpoint.
  string restore_op_name = 3;

  // Maximum number of checkpoints to keep.  If 0, no checkpoints are deleted.
  int32 max_to_keep = 4;

  // Shard the save files, one per device that has Variable nodes.
  bool sharded = 5;

  // How often to keep an additional checkpoint. If not specified, only the last
  // "max_to_keep" checkpoints are kept; if specified, in addition to keeping
  // the last "max_to_keep" checkpoints, an additional checkpoint will be kept
  // for every n hours of training.
  float keep_checkpoint_every_n_hours = 6;

  // A version number that identifies a different on-disk checkpoint format.
  // Usually, each subclass of BaseSaverBuilder works with a particular
  // version/format.  However, it is possible that the same builder may be
  // upgraded to support a newer checkpoint format in the future.
  enum CheckpointFormatVersion {
    // Internal legacy format.
    LEGACY = 0;
    // Deprecated format: tf.Saver() which works with tensorflow::table::Table.
    V1 = 1;
    // Current format: more efficient.
    V2 = 2;
  }
  CheckpointFormatVersion version = 7;
}

例如：

saver_def {
  filename_tensor_name: "save/Const:0"
  save_tensor_name: "save/control_dependency:0"
  restore_op_name: "save/restore_all"
  max_to_keep: 5
  keep_checkpoint_every_n_hours: 10000.0
  version: V2
}

filename_tensor_name给出了保存文件名的张量名称，此张量是节点save/Const的第一个输出
save_tensor_name：给出了持久化模型的运算所对应的节点名称
restore_op_name：持久化模型对应的加载模型的运算名称
max_to_keep：设定tf.train.Saver类清理之前保存模型的策略。设为n时，第n+1次调用saver.save时，第一次保存的模型就会自动删掉
keep_checkpoint_every_n_hours：同样设定tf.train.Saver类清理之前保存模型的策略。设为n时，表示每n小时可以在max_to_keep的基础上多保存一个模型。

collection_def

在计算图（tf.Graph）中可以维护不同集合，而维护这些集合的底层实现就是collection_def这个属性。这是一个从集合名称到集合内容的映射，集合名称是字符串，集合内容是CollectionDef，定义在tensorflow/core/protobuf/meta_graph.proto中：

message CollectionDef {
  // NodeList is used for collecting nodes in graph. For example
  // collection_def {
  //   key: "summaries"
  //   value {
  //     node_list {
  //       value: "input_producer/ScalarSummary:0"
  //       value: "shuffle_batch/ScalarSummary:0"
  //       value: "ImageSummary:0"
  //     }
  //   }
  message NodeList {
    repeated string value = 1;
  }

  // BytesList is used for collecting strings and serialized protobufs. For
  // example:
  // collection_def {
  //   key: "trainable_variables"
  //   value {
  //     bytes_list {
  //       value: "\n\017conv1/weights:0\022\024conv1/weights/Assign
  //              \032\024conv1/weights/read:0"
  //       value: "\n\016conv1/biases:0\022\023conv1/biases/Assign\032
  //              \023conv1/biases/read:0"
  //     }
  //   }
  // }
  message BytesList {
    repeated bytes value = 1;
  }

  // Int64List is used for collecting int, int64 and long values.
  message Int64List {
    repeated int64 value = 1 [packed = true];
  }

  // FloatList is used for collecting float values.
  message FloatList {
    repeated float value = 1 [packed = true];
  }

  // AnyList is used for collecting Any protos.
  message AnyList {
    repeated google.protobuf.Any value = 1;
  }

  oneof kind {
    NodeList node_list = 1;
    BytesList bytes_list = 2;
    Int64List int64_list = 3;
    FloatList float_list = 4;
    AnyList any_list = 5;
  }
}

可见，计算图上主要维护4类不同的集合：

NodeList用于维护计算图上节点的集合
BytesList可以维护字符串或序列化之后的pb的集合
Int64List用于维护整数集合
FloatList用于维护实数集合

例如：

collection_def {
  key: "trainable_variables"
  value {
    bytes_list {
      value: "\n\nVariable:0\022\017Variable/Assign\032\017Variable/read:02\004v1:08\001"
      value: "\n\014Variable_1:0\022\021Variable_1/Assign\032\021Variable_1/read:02\004v2:08\001"
    }
  }
}
collection_def {
  key: "variables"
  value {
    bytes_list {
      value: "\n\nVariable:0\022\017Variable/Assign\032\017Variable/read:02\004v1:08\001"
      value: "\n\014Variable_1:0\022\021Variable_1/Assign\032\021Variable_1/read:02\004v2:08\001"
    }
  }
}

可见，维护了两个集合，一个是所有变量的集合『variables』，另一个是可训练变量的集合『trainable_variables』。

持久化得到以下5个文件：

demo/model
├── checkpoint
├── model.ckpt.data-00000-of-00001
├── model.ckpt.index
├── model.ckpt.meta
└── model.ckpt.meta.json

上面讲到的都是model.ckpt.meta的明文文件即model.ckpt.meta.json的内容，持久化了计算图的结构。

其中，model.ckpt.index和model.ckpt.data-xxxx-of-xxxx文件保存了变量的取值，其中的model.ckpt.data-xxxx-of-xxxx是用SSTable格式存储的，大致理解为一个kv列表。可以通过tf.train.NewCheckpointReader类来查看保存的变量：

import tensorflow as tf

ckpt_path = "./demo/model/model.ckpt"
reader = tf.train.NewCheckpointReader(ckpt_path)

global_variables = reader.get_variable_to_shape_map()

for variable_name in global_variables:
    print(variable_name)
    print(global_variables[variable_name])

print("Value for variable v1 is ", reader.get_tensor("v1"))

# 输出：
'''
v2
[1]
v1
[1]
Value for variable v1 is  [1.]
'''

而checkpoint文件维护了一个由tf.train.Saver类持久化的所有tf模型文件的文件名。当某个文件被删除时，此模型对应的文件名也会从checkpoint文件中删除。checkpoint文件的格式为CheckpointState，定义在tensorflow/python/training/checkpoint_state.proto中：

syntax = "proto3";

package tensorflow;
option cc_enable_arenas = true;

// Protocol buffer representing the checkpoint state.
message CheckpointState {
  // Path to the most-recent model checkpoint.
  string model_checkpoint_path = 1;

  // Paths to all not-yet-deleted model checkpoints, sorted from oldest to
  // newest.
  // Note that the value of model_checkpoint_path should be the last item in
  // this list.
  repeated string all_model_checkpoint_paths = 2;
  // Unix timestamps corresponding to all_model_checkpoint_paths, indicating
  // when each checkpoint was created.
  repeated double all_model_checkpoint_timestamps = 3;
  // Unix timestamp indicating the creation time for the last preserved
  // checkpoint.
  double last_preserved_timestamp = 4;
}

文件内容为：

model_checkpoint_path: "model.ckpt"
all_model_checkpoint_paths: "model.ckpt"

model_checkpoint_path属性保存了最新模型文件的文件名
all_model_checkpoint_paths列出了当前还没有被删除的所有模型文件的文件名

如果有多个checkpoint，则文件内容如下：

model_checkpoint_path: "model.ckpt-29001"
all_model_checkpoint_paths: "model.ckpt-25001"
all_model_checkpoint_paths: "model.ckpt-26001"
all_model_checkpoint_paths: "model.ckpt-27001"
all_model_checkpoint_paths: "model.ckpt-28001"
all_model_checkpoint_paths: "model.ckpt-29001"

tensorflow代码解析——概览

2018-04-07T00:00:00+00:00

简介
- 总体结构
- 代码结构
tf核心概念

参考：

简介

总体结构

从底向上分为设备管理和通信层、数据操作层、图计算层、API接口层、应用层。

底层设备通信层负责网络通信和设备管理。
- 设备管理可以实现TF设备异构的特性，支持CPU、GPU、Mobile等不同设备。
- 网络通信依赖gRPC通信协议实现不同设备间的数据传输和更新。
数据操作层是Tensor的OpKernels实现。这些OpKernels以Tensor为处理对象，依赖网络通信和设备内存分配，实现了各种Tensor操作或计算。Opkernels不仅包含MatMul等计算操作，还包含Queue等非计算操作
图计算层（Graph），包含本地计算流图和分布式计算流图的实现。Graph模块包含Graph的创建、编译、优化和执行等部分，Graph中每个节点都是OpKernels类型表示。
API接口层。Tensor C API是对TF功能模块的接口封装，便于其他语言平台调用。
应用层。不同编程语言在应用层通过API接口层调用TF核心功能实现相关实验和应用。

代码结构

以2018.09.23的master为基准:

tensorflow/core

其中，tensorflow/core目录包含了TF核心模块代码：

public: API接口头文件目录，用于外部接口调用的API定义，主要是session.h。
client: API接口实现文件目录。（目前已经没有这个目录了…）
platform: OS系统相关接口文件，如file system, env等。
protobuf: 均为.proto文件，用于数据传输时的结构序列化。（都是proto3的语法）
common_runtime: 公共运行库，包含session, executor, threadpool, rendezvous, memory管理, 设备分配算法等。
distributed_runtime: 分布式执行模块，如rpc session, rpc master, rpc worker, graph manager。
framework: 包含基础功能模块，如log, memory, tensor
graph: 计算流图相关操作，如construct, partition, optimize, execute等
kernels: 核心Op，如matmul, conv2d, argmax, batch_norm等
lib: 公共基础库，如gif、gtl(google模板库)、hash、histogram、jpeg、png、wav等。
ops: 基本ops运算(xxx_ops.cc)，ops梯度运算（xxx_grad.cc），io相关的ops（io_ops.cc），控制流和数据流*操作（control_flow_ops.cc和data_flow_ops.cc）

tensorflow/stream_executor

tensorflow/stream_executor目录是并行计算框架，由google stream executor团队开发。

tensorflow/contrib

tensorflow/contrib目录是contributor开发目录。

tensroflow/python

tensroflow/python目录是python API客户端脚本

third_party

eigen3：eigen矩阵运算库，tf基础ops调用
gpus: 封装了cuda/cudnn编程库

tf核心概念

tf的核心是围绕Graph展开的，简而言之，就是Tensor沿着Graph传递闭包完成Flow的过程。

Tensor

Matrix表示二维线性映射，Tensor表示多维线性映射。TF中Tensor的维数描述为阶，数值是0阶，向量是1阶，矩阵是2阶，以此类推，可以表示n阶高维数据。

tensor contraction

matrix的product和tensor的contract运算如下：

可见，一个4x2的A与一个2x1的B矩阵相乘，可以变成两个矩阵相加，每一个是一个1x1与一个4x1相乘，就是A矩阵的两列分别与B的两列分别相乘，再相加

contract是tensor的运算，python实现可以看：tensorflow/tensorflow/python/ops/math_ops.py，即tensordot（也称为张量收缩）对从a和b所指定的索引a_axes和b_axes的元素的乘积进行求和。a_axes和b_axes是两个数组，指定沿其收缩张量的那些轴对。对于所有range(0, len(a_axes))中的i，a的轴a_axes[i]必须与b的轴b_axes[i]具有相同的维度。列表a_axes和b_axes必须具有相同的长度，并由唯一的整数组成，用于为每个张量指定有效的坐标轴。

该操作对应于numpy.tensordot(a, b, axes)，numpy.tensordot文档。

示例1：当a和b是矩阵（2阶）时，axes = 1相当于矩阵乘法。
示例2：当a和b是矩阵（2阶）时，axes = [[1], [0]]相当于矩阵乘法。
示例3：假设$a_ {ijk}$和$b_ {lmn}$表示3阶的两个张量。那么，contract(a, b, [[0], [2]])是4阶张量$c_ {jklm}$，其条目对应于索引$(j,k,l,m)$由下式给出：

\[ c_{jklm} = \sum_i a_{ijk} b_{lmi} \]

可见，因为传入的是[[0],[2]]，所以ijk的第0维，即i，和lmn的第2维，即n，都变成了i，然后求和~

一般来说，order(c) = order(a) + order(b) - 2*len(axes[0])。

Tensor实现

Tensor在高维空间数学运算比Matrix计算复杂，计算量也非常大，加速张量并行运算是TF优先考虑的问题，如add, contract, slice, reshape, reduce, shuffle等运算。

TF中Tensor支持的数据类型有很多，如tf.float16, tf.float32, tf.float64, tf.uint8, tf.int8, tf.int16, tf.int32, tf.int64, tf.string, tf.bool, tf.complex64等，所有Tensor运算都使用*泛化的数据类型`*(可以重载*和+运算咯)表示。

Tensor定义和运算主要是调用Eigen矩阵计算库完成的。

Tensor的定义在tensorflow/core/framework/tensor.h中。

Tensor的两个主要的成员变量

TensorShape shape_;
TensorBuffer* buf_;

TensorShape在tensorflow/core/framework/tensor_shape.h中定义，基类是TensorShapeBase：

class TensorShape : public TensorShapeBase<TensorShape>

TensorShapeBase如下：

/// Represents the shape of a Tensor.
///
/// A tensor's shape is denoted by its number of dimensions and a size for each
/// dimension.  For example, a Tensor represented by a 3 x 4 matrix would have
/// a shape of 2-D, [3,4].
///
/// If you know the exact shape of your Tensor when you create the TensorShape
/// object, you can specify it then, or you can create a TensorShape with
/// zero dimensions and one element, and call AddDim() to add dimensions later.
class TensorShape : public TensorShapeBase<TensorShape> {
 public:
  using TensorShapeBase<TensorShape>::TensorShapeBase;

  /// Allow a TensorShape to be used as a PartialTensorShape without copying
  operator const PartialTensorShape&() const;  // NOLINT(runtime/explicit)

  /// Returns true if `*this` and `b` have the same sizes. Ignores
  /// dimension names.
  bool IsSameSize(const TensorShape& b) const;
  bool operator==(const TensorShape& b) const { return IsSameSize(b); }
  bool operator!=(const TensorShape& b) const { return !IsSameSize(b); }

  /// Fill `*dsizes` from `*this`.
  template <int NDIMS>
  Eigen::DSizes<Eigen::DenseIndex, NDIMS> AsEigenDSizes() const;

  /// Same as `AsEigenDSizes()` but allows for `NDIMS > dims()` -- in
  /// which case we pad the rest of the sizes with 1.
  template <int NDIMS>
  Eigen::DSizes<Eigen::DenseIndex, NDIMS> AsEigenDSizesWithPadding() const;

 private:
  // These CHECK fail to ease debugging.
  // REQUIRES: dims() == NDIMS
  void CheckDimsEqual(int NDIMS) const;
  // REQUIRES: dims() >= NDIMS
  void CheckDimsAtLeast(int NDIMS) const;
};

其中，TensorShapeBase是TensorShapeRep的子类

/// Base class for TensorShape and PartialTensorShape.
/// The class is templatized by either TensorShape or PartialTensorShape to
/// allow skipping known/unknown checks in the TensorShape case, but the
/// representation is shared exactly for fast conversion.
template <class Shape>
class TensorShapeBase : public TensorShapeRep

TensorBuffer是tensorflow/core/lib/core/refcount.h的RefCounted(引用计数器)的子类

class TensorBuffer : public core::RefCounted

Tensor的主要函数

返回Eigen::Tensor类型的主要函数：

  template <typename T>
  typename TTypes<T>::Vec vec() {
    return tensor<T, 1>();
  }
  // 其中，typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType>, Eigen::Aligned> Vec;

  template <typename T>
  typename TTypes<T>::Matrix matrix() {
    return tensor<T, 2>();
  }
  // 其中，typedef Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor, IndexType>, Eigen::Aligned> Matrix;

  template <typename T, size_t NDIMS>
  typename TTypes<T, NDIMS>::Tensor tensor();
  // 其中，typedef Eigen::TensorMap<Eigen::Tensor<T, NDIMS, Eigen::RowMajor, IndexType>, Eigen::Aligned> Tensor;

其中的TTypes定义在tensorflow/core/framework/tensor_types.h中，如下：

// Helper to define Tensor types given that the scalar is of type T.
template <typename T, int NDIMS = 1, typename IndexType = Eigen::DenseIndex>
struct TTypes {
  // Rank-<NDIMS> tensor of scalar type T.
  typedef Eigen::TensorMap<Eigen::Tensor<T, NDIMS, Eigen::RowMajor, IndexType>,
                           Eigen::Aligned>
      Tensor;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, NDIMS, Eigen::RowMajor, IndexType>, Eigen::Aligned>
      ConstTensor;

  // Unaligned Rank-<NDIMS> tensor of scalar type T.
  typedef Eigen::TensorMap<Eigen::Tensor<T, NDIMS, Eigen::RowMajor, IndexType> >
      UnalignedTensor;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, NDIMS, Eigen::RowMajor, IndexType> >
      UnalignedConstTensor;

  typedef Eigen::TensorMap<Eigen::Tensor<T, NDIMS, Eigen::RowMajor, int>,
                           Eigen::Aligned>
      Tensor32Bit;

  // Scalar tensor (implemented as a rank-0 tensor) of scalar type T.
  typedef Eigen::TensorMap<
      Eigen::TensorFixedSize<T, Eigen::Sizes<>, Eigen::RowMajor, IndexType>,
      Eigen::Aligned>
      Scalar;
  typedef Eigen::TensorMap<Eigen::TensorFixedSize<const T, Eigen::Sizes<>,
                                                  Eigen::RowMajor, IndexType>,
                           Eigen::Aligned>
      ConstScalar;

  // Unaligned Scalar tensor of scalar type T.
  typedef Eigen::TensorMap<
      Eigen::TensorFixedSize<T, Eigen::Sizes<>, Eigen::RowMajor, IndexType> >
      UnalignedScalar;
  typedef Eigen::TensorMap<Eigen::TensorFixedSize<const T, Eigen::Sizes<>,
                                                  Eigen::RowMajor, IndexType> >
      UnalignedConstScalar;

  // Rank-1 tensor (vector) of scalar type T.
  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType>,
                           Eigen::Aligned>
      Flat;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType>, Eigen::Aligned>
      ConstFlat;
  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType>,
                           Eigen::Aligned>
      Vec;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType>, Eigen::Aligned>
      ConstVec;

  // Unaligned Rank-1 tensor (vector) of scalar type T.
  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType> >
      UnalignedFlat;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType> >
      UnalignedConstFlat;
  typedef Eigen::TensorMap<Eigen::Tensor<T, 1, Eigen::RowMajor, IndexType> >
      UnalignedVec;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, 1, Eigen::RowMajor, IndexType> >
      UnalignedConstVec;

  // Rank-2 tensor (matrix) of scalar type T.
  typedef Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor, IndexType>,
                           Eigen::Aligned>
      Matrix;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, 2, Eigen::RowMajor, IndexType>, Eigen::Aligned>
      ConstMatrix;

  // Unaligned Rank-2 tensor (matrix) of scalar type T.
  typedef Eigen::TensorMap<Eigen::Tensor<T, 2, Eigen::RowMajor, IndexType> >
      UnalignedMatrix;
  typedef Eigen::TensorMap<
      Eigen::Tensor<const T, 2, Eigen::RowMajor, IndexType> >
      UnalignedConstMatrix;
};

用法如下：

    typedef float T;
    Tensor my_mat(...built with Shape{rows: 3, cols: 5}...);
    auto mat = my_mat.matrix<T>();    // 2D Eigen::Tensor, 3 x 5.
    auto mat = my_mat.tensor<T, 2>(); // 2D Eigen::Tensor, 3 x 5.
    auto vec = my_mat.vec<T>();       // CHECK fails as my_mat is 2D.
    auto vec = my_mat.tensor<T, 3>(); // CHECK fails as my_mat is 2D.
    auto mat = my_mat.matrix<int32>();// CHECK fails as type mismatch.

Eigen::Tensor

eigen源码：

https://bitbucket.org/eigen/eigen/src/8dd2d6552a87?at=default

git上的源码：

https://github.com/eigenteam/eigen-git-mirror

Eigen::Tensor不属于Eigen官方维护的程序，由贡献者提供文档和维护，所以Tensor定义在Eigen unsupported模块中(#include "third_party/eigen3/unsupported/Eigen/CXX11/Tensor")

参考http://eigen.tuxfamily.org/dox-devel/unsupported/classEigen_1_1Tensor.html

Tensor主要包含一个变量TensorStorage<Scalar, Dimensions, Options> m_storage，而TensorStorage里有两个变量m_data和m_dimensions，m_data保存了Tensor的数据块，T是泛化的数据类型，m_dimensions保存了Tensor的维度信息。

EIGEN_ALIGN_MAX T m_data[MinSize];
 FixedDimensions m_dimensions;

Eigen::Tensor的成员变量很简单，却支持非常多的基本运算，再借助Eigen的加速机制实现快速计算。Eigen::Tensor主要包含了

一元运算（Unary），如sqrt、square、exp、abs等。
二元运算（Binary），如add，sub，mul，div等
选择运算（Selection），即if / else条件运算
归纳运算（Reduce），如reduce_sum， reduce_mean等
几何运算（Geometry），如reshape，slice，shuffle，chip，reverse，pad，concatenate，extract_patches，extract_image_patches等
张量积（Contract）和卷积运算（Convolve）是重点运算，后续会详细讲解。

符号编程

编程模式通常分为命令式编程（imperative style programs）和符号式编程（symbolic style programs）。

命令式编程：容易理解和调试，命令语句基本没有优化，按原有逻辑执行。
符号式编程：涉及较多的嵌入和优化，不容易理解和调试，但运行速度有同比提升。

命令式编程明确输入变量，并根据程序逻辑逐步运算，这种模式非常在调试程序时进行单步跟踪，分析中间变量。

符号式编程将计算过程抽象为计算图，计算流图可以方便的描述计算过程，所有输入节点、运算节点、输出节点均符号化处理。

和目前的符号语言比起来，TF最大的特点是强化了数据流图，引入了mutation的概念。所谓mutation，就是可以在计算的过程中更改一个变量的值，而这个变量在计算的过程中会被带入到下一轮迭代里面去。mutation是机器学习优化算法几乎必须要引入的东西（虽然也可以通过immutable replacement来代替，但是会有效率的问题），这一点会导致最后的API设计和使用需要特别小心，把mutation引入到数据流图中会带来一些新的问题，比如，如何处理写与写之间的依赖。

梯度计算

梯度计算涉及每个计算节点，每个自定义的前向计算图都包含一个隐式的反向计算图。从数据流向上看，正向计算图是数据从输入节点到输出节点的流向过程，反向计算图是数据从输出节点到输入节点的流向过程。

可以参考tensorflow实战 chap1的自动求导部分

反向计算限制了符号编程中内存空间复用的优势，因为在正向计算中的计算数据在反向计算中也可能要用到。从这一点上讲，粗粒度的计算节点比细粒度的计算节点更有优势，而TF大部分为细粒度操作，虽然灵活性很强，但细粒度操作涉及到更多的优化方案，在工程实现上开销较大，不及粗粒度简单直接。在神经网络模型中，TF将逐步侧重粗粒度运算。

控制流

TF的计算图如同数据流一样，数据流向表示计算过程。数据流图可以很好的表达计算过程，为了扩展TF的表达能力，TF中引入控制流。编程语言中，if…else…是最常见的逻辑控制，在TF的数据流中也可以通过这种方式控制数据流向。接口函数如下，pred为判别表达式，fn1和fn2为运算表达式。当pred为true是，执行fn1操作；当pred为false时，执行fn2操作。

tf.cond(pred, fn1, fn2, name=None)

TF还可以协调多个数据流，在存在依赖节点的场景下非常有用，例如节点B要读取模型参数$\theta$更新后的值，而节点A负责更新参数$\theta$，则节点B必须等节点A完成后才能执行，否则读取的参数$\theta$为更新前的数值，这时需要一个运算控制器。接口函数如下，tf.control_dependencies函数可以控制多个数据流执行完成后才能执行接下来的操作，通常与tf.group函数结合使用。

tf.control_dependencies(control_inputs)

TF支持的控制算子有Switch、Merge、Enter、Leave和NextIteration等。

TF不仅支持逻辑控制，还支持循环控制。TF使用和MIT Token-Tagged machine（即Executing a program on the MIT tagged-token dataflow architecture.）相似的表示系统，将循环的每次迭代标记为一个tag，迭代的执行状态标记为一个frame，但迭代所需的数据准备好的时候，就可以开始计算，从而多个迭代可以同时执行。

自然语言处理中的自注意力机制（Self-Attention Mechanism）

2018-04-04T00:00:00+00:00

注意
attention的本质
自己的小结
multi-head attention
self-attention
对比rnn/cnn/transformer
- rnn
  - SRU
  - SRNN
- cnn
- transformer
机器翻译小综述
- 机器翻译的挑战
清华刘洋的talk——机器翻译的三大挑战
attention的其他奇怪应用

attention is all you need的解读可以参考

https://daiwk.github.io/posts/platform-tensor-to-tensor.html

各种attention model可以参考：

https://daiwk.github.io/posts/dl-attention-models.html

本文参考自然语言处理中的自注意力机制（Self-Attention Mechanism）

论文作者之一Lukasz Kaiser的ppt：https://daiwk.github.io/assets/attention-is-all-you-need-lkaiser.pdf

注意

https://www.jianshu.com/p/48e71b72ca67

Adam 优化器可以说是目前使用最广泛、收敛速度较快且收敛过程较稳定的优化器。Adam 的计算公式如图所示。可以看到公式中梯度的计算使用了动量原理，每一轮用于梯度下降的梯度是当前计算的真实梯度与上一轮用于梯度下降的梯度的加权和。这样动量的引入可以防止训练时产生震荡。Adam 优化器的学习率对于不同参数也是不同的，由该参数历史每一轮的真实梯度的大小决定。好处是对于 NLP 这种输入极度稀疏且输入特征极度不平衡（例如整个预料库中“我”这样的词经常出现，而“拉姆塞”这样的词只出现几次）的任务，学习率是自适应的，一些在一次训练 epoch 中只更新几次的 embedding，在训练后期还是会有较大的学习率。

NLP 输入稀疏的特点与 Adam 使用动量计算梯度的特点相结合就引入了麻烦。每一轮更新参数时，只有极少数 embedding 的梯度是非 0 的，大部分 embedding 的梯度是 0 即上图公式中的 gt 是 0。但是，计算了动量之后，这些原本梯度都应该是 0 的 embedding 有了非零梯度 mt 用于梯度下降更新。想象一个极端的例子，“拉姆塞”这个词在一个 epoch 中只在第一个 batch 出现了，于是第一个 batch 计算了“拉姆塞”这个 embedding 的真实梯度 g0 用于更新参数，在以后的每个 batch 中虽然“拉姆塞”这个词没有出现过，Adam 都会计算它的动量梯度 mt，并用于更新“拉姆塞”这个 embedding，实际上方向与 g0 完全相同，只是每一轮做一次 β1 倍的衰减。这样的做法就相当于对这些出现次数较少的低频词的 embedding，每次梯度下降的等效学习率是非常大的，容易引起类似过拟合的问题。

每轮迭代只更新这个 batch 中出现过的词的 embedding 即可。TensorFlow 中可以使用 tf.contrib.opt.LazyAdamOptimizer。

参考https://www.zhihu.com/question/265357659/answer/580469438

和图像等领域不同，对 NLU 之类的任务，每个 batch 采样到的词有限，每次更新对 Embedding 的梯度估计都是稀疏的。非 momentum-based 的 Optimizer 每步只会更新采样到的词，而对于 momentum-based 的 Optimizer，现在所有框架的实现都会用当前的 momentum 去更新所有的词，即使这些词在连续的几十步更新里都没有被采样到。这可能会使 Embedding 过拟合。

attention的本质

Attention函数的本质可以被描述为一个查询（query）与一系列（键key-值value）对一起映射成一个输出。分为以下3步：

将query和每个key进行相似度计算得到权重，常用的相似度函数有点积，拼接，感知机等
使用一个softmax(因为是一系列的k/v，所以类似多分类，要用softmax)函数对这些权重进行归一化
将权重和相应的键值value进行加权求和得到最后的Attention

\[ attention(Q,K,V)=softmax(\frac{QK^T}{\sqrt {d_k}})V \]

目前在NLP研究中，key和value常常都是同一个，即 key=value(如下例中的源语言的编码器输出)。

对比https://daiwk.github.io/posts/nlp-nmt.html#4-%E6%B3%A8%E6%84%8F%E5%8A%9B%E6%9C%BA%E5%88%B6以及https://daiwk.github.io/posts/platform-tensor-to-tensor.html#422-attention可以发现：

机器翻译里的源语言的编码器输出$h_j$就是$V$
机器翻译里的源语言的编码器输出$h_j$同样是$K$
机器翻译里的目标语言的隐层状态$z_i$就是$Q$
机器翻译里的目标语言和源语言的匹配程度$e_{ij}$就是$\frac{QK^T}{\sqrt {d_k}}$
机器翻译里的归一化后的目标语言和源语言的匹配程度$a_{ij}$就是$softmax(\frac{QK^T}{\sqrt {d_k}})$
机器翻译里的$c_i$就是最终的$attention(Q,K,V)$

所以说，机器翻译的attention，本质就是想给源语言的encoder输出的每一个元素$h_j$ (即V) 搞一个权重，然后加权求和。而这个权重是通$h_j$ 它自己 (即K=V) 与目标语言的隐层状态$z_i$ (即Q) 进行变换得到的。所以：

k=v=源语言的encoder输出，q=目标语言的隐层状态。

再理解回nmt里（不理那个$\sqrt{d_k}$）。假设emb是d维，那么 Q是mxd，K是nxd，i=1->m，j=1->n，$e_{ij}=QK^T$是一个m行目标语言，n列源语言的矩阵，那么$a_{ij}$是对$e_{ij}$求softmax，分母就是第i行每个元素(即这第i个目标语言的词，对应的所有源语言词)的exp之和，分子就是第i行第j列(第i个目标语言词对应的第j个源语言词)的exp，即$a_{ij}=\frac {exp(e_{ij})}{\sum _{k=1}^Texp(e_{ik})}$看分母，是固定i，遍历j，也就是固定第i行，求这行每一列的和。

再强调一次，一定要记得i、Q、m是目标语言的，j、K、n是源语言的，所以是$QK^T$，我们要拿attention来对源语言也就是V=K来做加权。做加权这步，就是一个mxn的矩阵，乘一个nxd的矩阵，得到最后mxd矩阵。就是第i行和nxd的一列对应相乘相加，得到一个元素，最后总共得到m个元素。相当于对于目标语言的第i个词来讲，他和源语言的每个词（共n个词）分别有个相关性（mxn矩阵的一行），然后作为这次输入的n个词的权重，求个和，当做这第i个目标语言的词的表示，即最终mxd的第i行的一个元素。而可以看到这个权重，对d维的emb的每一维的作用都是一样的（emb的第1维，即nxd的第1列和mxn的第i行相乘相加得到一个元素；emb的第2维，即nxd的第2列，和mxn的第i行相乘相加得到一个元素，这次运算和上一次运算，对于这一列的每一行来讲，它乘的mxn里的那一行是一样的，也就是说对一个给定的目标语言的词语，即mxn的第i行来讲，他对每一个源语言的词的影响权重在每一维源语言的emb（例如nxd的第1列和第2列）上都是一样的）。

另外，得到的context只是作为产出下一个目标语言词的输入之一，还有前一个目标语言的词，及前一个目标语言的隐层状态。

再来理解一下其中的softmax那步：

类比一个分类任务，m行n列，m个样本，n个类别，每一行就是对这个样本而言，他在这个分类的概率，所以分子是这个类别，分母是所有类别（这一行求和）

类似地，对于这个attention矩阵，m行n列，m个目标语言，n个源语言，一行就是一个目标语言的词，表示这个词和源语言每个词的相关程度，所以分母是所有源语言的词（这一行求和）。

自己的小结

某个时候整理了个ppt：

注意：输出的attention维度和Q一样，都是mxn

multi-head attention

Query，Key，Value最开始都是$d_{model}$维，各自通过h个线性变换(即每个$W^Q,W^K,W^V$)拆成h部分，每一部分的大小是$d_k$，$d_k$和$d_v$（$d_k=d_v=d_{model}/h$）。
然后这h部分，每部分各自的q/k/v做一个attention的操作得到对应的attention
最后把这h个attention给concat到一起

不同之处在于进行了h次计算而不仅仅算一次，论文中说到这样的好处是可以允许模型在不同的表示子空间里学习到相关的信息。

self-attention

Self-Attention即K=V=Q，例如输入一个句子，那么里面的每个词都要和该句子中的所有词进行Attention计算。目的是学习句子内部的词依赖关系，捕获句子的内部结构。

使用self-attention的原因：

每一层的复杂度：
- 如果输入序列n小于表示维度d的话，每一层的时间复杂度Self-Attention是比较有优势的。
- 当n比较大时，作者也给出了一种解决方案Self-Attention(restricted)即每个词不是和所有词计算Attention，而是只与限制的r个词去计算Attention。
是否可以并行: multi-head Attention和CNN一样不依赖于前一时刻的计算，可以很好的并行，优于 RNN。
长距离依赖: 由于Self-Attention是每个词和所有词都要计算Attention，所以不管他们中间有多长距离，最大的路径长度也都只是 1。可以捕获长距离依赖关系。

decoder中的masked att：

参考https://zhuanlan.zhihu.com/p/79872507

每个词只能看到他前面的词，后面的要mask掉

在gpt-2中，就是把要mask的乘以负无穷。qk如下：

乘以mask矩阵后如下：

计算softmax后如下：

对比rnn/cnn/transformer

当然，在讲t2t的时候，就讲到了https://daiwk.github.io/posts/platform-tensor-to-tensor.html#426-why-self-attention

不过，我们可以参考放弃幻想，全面拥抱Transformer：自然语言处理三大特征抽取器（CNN/RNN/TF）比较再来对比一下~

nlp问题的特点：

输入是一维线性序列
输入是不定长的
单词或子句的相对位置关系很重要

主要的nlp任务：

序列标注：句子中每一个单词要求模型根据上下文给出一个分类类别。如中文分词、词性标注、命名实体识别、语义角色标注。
分类任务：整个句子输出一个分类值。如文本分类。
句子关系推断：给定两个句子，判断这两个句子是否具备某种名义关系。例如entilment、QA、语义改写、自然语言推断
生成式任务：输出一段文本，生成另一段文本。如机器翻译、文本摘要、写诗造句、看图说话。

rnn

基本原理不再赘述，看看rnn并行化的两个主要套路

SRU

Simple Recurrent Units for Highly Parallelizable Recurrence

在nmt上，transformer+sru比单纯transformer的bleu提升约0.7个点。

SRU的核心思想就是仍然保留任意连续时间步（T-1和T）之间的隐层连接，然后在网络结构上做了一些改变，可以参考知乎的讨论：如何评价新提出的RNN变种SRU?

先看下原始的gru：https://daiwk.github.io/posts/nlp-nmt.html#12-gru

\[ \\ z_t=\sigma(W_zx_t+U_zh_{t-1}+b_z) \\ r_t=\sigma(W_rx_t+U_rh_{t-1}+b_r) \\ h_t=z_t \circ h_{t-1}+(1-z_t) \circ tanh(W_hx_t+ U_h(r_t \circ h_{t-1}) + b_h) \]

然后从知乎偷个图：

在gru的基础上进行修改，将各个时间步的gate和transformed input的计算只依赖于当前时间步的输入，然后在recurrent layers之间添加了skip connections（严格来说是highway connections）

所以，

各个时间步的transformed input、forget gate 以及reset gate的值可以并行处理，因为不依赖上一个时间步了。
还存在时间步依赖的计算也只是比较简单和快速的element-wise操作，它们还可以在dimension上进行并行。

因此这个RNN单元现在的计算瓶颈就在三个矩阵乘法了，最后将这三个矩阵乘法可以归并成一个矩阵乘法。

作者为了进一步的加速，将上面的各个时间步之间的element-wise的操作优化实现成了CUDA kernel functions。

SRNN

cnn

transformer

机器翻译小综述

参考神经网络机器翻译技术及应用（上）

机器翻译的挑战

漏译

翻译模型把原文句子整体读进去以后形成了一个向量，然后再对这个向量进行解码。翻译模型认为有些词不应该产生，从而漏掉了译文。

Addressing the Under-translation Problem from the Entropy Perspective这篇就发现漏译与词语的熵成正相关关系，这个词的熵越大，漏译的可能性越大。它所对应的目标语言词越多，概率越分散（熵越大），越有可能被漏译。

例如源语言的一个词s1对应3种不同的翻译，(s1,t1),(s1,t2),(s1,t3 t4)，它的熵就比较大。我们把所有对应的翻译统一替换为一个特殊词stoken4s1，以降低词语翻译的熵值。然后文章提出了pre-training, multitask learning, two-pass decoding三种方法，来改善翻译结果。

数据稀疏

相比于统计机器翻译，这个问题对神经网络翻译而言更严重。实验表明，神经网络对于数据量更敏感。

Multi-Task Learning for Multiple Language Translation在进行多语言翻译的时候，源语言共享编码器，在解码端，不同的语言，使用不同的解码器。这样在源语言端就会共享编码器的信息，从而缓解数据稀疏问题。

Phrase-Based & Neural Unsupervised Machine Translation是EMNLP’18的best paper，提出了一个统一的框架，通过两种单语言，来构建翻译系统。

首先构建一个词典，把这两种语言之间的词做一下对齐
然后为两个单语言分别训练一个语言模型
然后使用back translation，先基于词的翻译从语言a翻译成语言b，然后挑出得分高的译文，再翻译回去，再用源语言的语言模型来判别好不好。一轮轮地迭代，就可以得到比较好的翻译结果

引入知识

我们引入了几种知识，

短语表或者词表：如果发现『XXX』这个词没有被翻译出来，我们就去查这个词典，这个词典的内容是：『XXX: oo1 0.7 oo2:0.3』这样的，也就是XXX翻译成oo1和oo2的概率
语言模型：衡量目标语言的这个句子是不是流畅
长度奖励特征：奖励长句子，因为句子越长，可能漏掉的信息就越少。

但这样还可能有歧义问题，因为比如中巴关系，可以是中国和巴基斯坦，中国和巴西，中国和巴勒斯坦等的缩写，如果限定了『金砖框架』下的，那就只能是巴西了，所以这还是有挑战的。

可解释性

Visualizing and Understanding Neural Machine Translation

左边的例子，出现了一个UNK，它虽然没有被翻译出来，但是出现在正确的位置，占了一个位置。通过Attention对应关系，可以看到这个UNK对应到『债务国』。

右边例子是一个重复翻译的现象。神经网络机器翻译除了经常漏翻译之外，还会经常重复翻译。比如说出现了两个“history”。那么通过这个对应关系我们就可以看到，第6个位置上的“history”是重复出现的，它的出现不仅跟第一个位置“美国人”和第二个位置“历史”相关，还跟第5个位置“the”相关。因为产生了一个定冠词“the”，模型认为这个地方应该出现一个“history”。

语篇翻译

Modeling Coherence for Discourse Neural Machine Translation提出了一个两步解码的方法。在第一轮解码中单独生成每个句子的初步翻译结果，在第二轮解码中利用第一轮翻译的结果进行翻译内容润色，并且提出使用增强式学习模型来奖励模型产生更流畅的译文。

清华刘洋的talk——机器翻译的三大挑战

参考清华刘洋《基于深度学习的机器翻译》，突破知识整合、可解释和鲁棒性三大难关

知识整合

Prior Knowledge Integration for Neural Machine Translation using Posterior Regularization

在这项工作中，建议使用后验正则化来提供一个将先验知识整合到神经机器翻译中的通用框架。将先验知识来源表示为一个对数线性模型的特征，该模型指导神经翻译模型的学习过程。汉英翻译实验表明，该方法取得了显著的改进。

可解释/可视化

Visualizing and Understanding Neural Machine Translation

这项工作主要的贡献包括：

利用层级相关性传播算法可视化分析神经机器翻译；
能够计算任意隐状态和任意contextual words的相关性，同时不要求神经网络中的函数必须可求偏导，不同于之前只有encoder和decoder隐层之间的对应信息；
能够针对机器翻译中出错的例子，进行分析。

鲁棒性

输入中的小扰动会严重扭曲中间表示，从而影响神经机器翻译（NMT）模型的翻译质量。

attention的其他奇怪应用

机器翻译里，假设emb是d维，正常机器翻译里，源语言K=V是nxd，目标语言Q是mxd

softmax(QK^T)是mxn，第i行第j列是源语言的第j个词在所有源语言的词里，对第i个目标语言词的重要程度

假设有一个rank问题，m个队列，n个位置，每个队列有n条结果，每条结果是一个d维向量

Q是(mxd)xn，姑且把mxd这个向量看成一维的，即d=1，

K是nxn，表示每个位置间两两的关系

QK^T是(mxd)xn，第i行第j列是第j个位置在所有位置里，对第i个队列的重要程度

。。真绕

从我自己的角度，yy了一下：

m个队列，n个位置，每个队列有k条结果，每个结果是一个d维向量

Q: (mxd)xk，m行表示m个队列，k列表示k条结果

K: nxk，n行表示n个位置，k列表示k条结果，也就是每个位置与每一条结果间的权重

V: nxk，同K

softmax(QK^T)：(mxd)xn维，第i行第j列表示，第j个位置在所有位置里，对第i个队列的重要程度

softmax(QK^T)V：(mxd)xk维，

有点奇怪。。如果把k和n互换呢。。。

再想想。。

linux内核

2018-03-28T00:00:00+00:00

参考《Linux内核设计与实现（原书第3版）》

thrift

2018-03-28T00:00:00+00:00

https://github.com/apache/thrift

storm

2018-03-28T00:00:00+00:00

https://github.com/apache/storm

seastar

2018-03-28T00:00:00+00:00

Seastar 是一个开源，基于c++ 11/14 feature，支持高并发和低延迟的异步编程高性能库。参考：现代硬件上的高性能C++异步框架 - SeaStar

https://github.com/scylladb/seastar

protobufrpc

2018-03-28T00:00:00+00:00

参考http://www.codedump.info/?p=169

对于 service EchoService而言,会对应的生成两个类:

EchoService类
EchoService_Stub类

paddle fluid

2018-03-28T00:00:00+00:00

简介
核心概念
- 编译时概念
- 运行时概念
Tensor/LoD(Level-of-Detail)Tensor
demo

简介

参考https://daiwk.github.io/posts/platform-tensorflow-folding.html

先了解下eager execution的优点：

快速调试即刻的运行错误并通过 Python 工具进行整合
借助易于使用的 Python 控制流支持动态模型
为自定义和高阶梯度提供强大支持
适用于几乎所有可用的 TensorFlow 运算

fluid也有点类似，分为编译时和运行时。

编译时：

创建变量描述Variable
创建operators的描述OpDesc
创建operator的属性
推断变量的类型和形状，进行静态检查：InferShape
规划变量的内存复用
创建反向计算
添加优化相关的Operators
(可选)添加多卡/多机相关的Operator，生成在多卡/多机上运行的程序

运行时：

创建Executor
为将要执行的一段计算，在层级式的Scope空间中创建Scope
创建Block，依次执行Block

另外，fluid自己封装了各种switch/ifelse/while_op等。

核心概念

编译时概念

program就是一个nn的训练/预测任务，由多个可嵌套的Block组成，而每个Block中包含了Variable和Operator：

VarDesc + TensorDesc + OpDesc ==> BlockDesc ==> ProgramDesc

transpiler将一个ProgramDesc转成另一个ProgramDesc，有以下两种：

Memory optimization transpiler: 在原始ProgramDesc中插入FreeMemoryOps，在一次迭代结束前提前释放内存，使得能够维持较小的memory footprint
distributed training transpiler: 将原始ProgramDesc转化为对应的分布式版本，包括：
- trainer进程执行的ProgramDesc
- parameter server执行的ProgramDesc

WIP: 输入ProgramDesc，生成可以直接被gcc/nvcc/icc等编译的代码，编译得到可执行文件。

例如：

x = fluid.layers.data(name='x', shape=[13], dtype='float32')
y_predict = fluid.layers.fc(input=x, size=1, act=None)
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
cost = fluid.layers.square_error_cost(input=y_predict, label=y)
avg_cost = fluid.layers.mean(cost)
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
optimize_ops, params_grads = sgd_optimizer.minimize(avg_cost)
use_cuda = False
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
training_role = os.getenv("TRAINING_ROLE", "TRAINER")
if training_role == "PSERVER":
    place = fluid.CPUPlace()
exe = fluid.Executor(place)

这个时候可以打出来：

>>> print fluid.default_startup_program().to_string(True)
blocks {
  idx: 0
  parent_idx: -1
  vars {
    name: "learning_rate_0"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: 1
        }
      }
    }
    persistable: true
  }
  vars {
    name: "fc_0.b_0"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: 1
        }
      }
    }
    persistable: true
  }
  vars {
    name: "fc_0.w_0"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: 13
          dims: 1
        }
      }
    }
    persistable: true
  }
  ops {
    outputs {
      parameter: "Out"
      arguments: "learning_rate_0"
    }
    type: "fill_constant"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "op_role"
      type: INT
      i: 0
    }
    attrs {
      name: "force_cpu"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "value"
      type: FLOAT
      f: 0.0010000000475
    }
    attrs {
      name: "shape"
      type: INTS
      ints: 1
    }
    attrs {
      name: "dtype"
      type: INT
      i: 5
    }
  }
  ops {
    outputs {
      parameter: "Out"
      arguments: "fc_0.b_0"
    }
    type: "fill_constant"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "op_role"
      type: INT
      i: 0
    }
    attrs {
      name: "force_cpu"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "value"
      type: FLOAT
      f: 0.0
    }
    attrs {
      name: "shape"
      type: INTS
      ints: 1
    }
    attrs {
      name: "dtype"
      type: INT
      i: 5
    }
  }
  ops {
    outputs {
      parameter: "Out"
      arguments: "fc_0.w_0"
    }
    type: "uniform_random"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "op_role"
      type: INT
      i: 0
    }
    attrs {
      name: "dtype"
      type: INT
      i: 5
    }
    attrs {
      name: "seed"
      type: INT
      i: 0
    }
    attrs {
      name: "min"
      type: FLOAT
      f: -0.654653668404
    }
    attrs {
      name: "max"
      type: FLOAT
      f: 0.654653668404
    }
    attrs {
      name: "shape"
      type: INTS
      ints: 13
      ints: 1
    }
  }
}

再接下来，可以打出更多的信息(会发现多了梯度等)：

>>> print fluid.default_main_program().to_string(True)
...
        }
      }
    }
    persistable: true
  }
  vars {
    name: "fc_0.tmp_1"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: -1
          dims: 1
        }
        lod_level: 0
      }
    }
    persistable: false
  }
  vars {
    name: "square_error_cost_0.tmp_0"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: -1
          dims: 1
        }
        lod_level: 0
      }
    }
    persistable: false
  }
  vars {
    name: "learning_rate_0"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: 1
        }
      }
    }
    persistable: true
  }
  vars {
    name: "fc_0.tmp_0@GRAD"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: -1
          dims: 1
        }
      }
    }
  }
  vars {
    name: "fc_0.tmp_1@GRAD"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: -1
          dims: 1
        }
      }
    }
  }
  vars {
    name: "square_error_cost_0.tmp_1"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: -1
          dims: 1
        }
        lod_level: 0
      }
    }
    persistable: false
  }
  vars {
    name: "mean_0.tmp_0@GRAD"
    type {
      type: LOD_TENSOR
      lod_tensor {
        tensor {
          data_type: FP32
          dims: 1
        }
      }
    }
    persistable: true
  }
  ops {
    inputs {
      parameter: "X"
      arguments: "x"
    }
    inputs {
      parameter: "Y"
      arguments: "fc_0.w_0"
    }
    outputs {
      parameter: "Out"
      arguments: "fc_0.tmp_0"
    }
    type: "mul"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "op_role"
      type: INT
      i: 0
    }
    attrs {
      name: "y_num_col_dims"
      type: INT
      i: 1
    }
    attrs {
      name: "x_num_col_dims"
      type: INT
      i: 1
    }
  }
  ops {
    inputs {
      parameter: "X"
      arguments: "fc_0.tmp_0"
    }
    inputs {
      parameter: "Y"
      arguments: "fc_0.b_0"
    }
    outputs {
      parameter: "Out"
      arguments: "fc_0.tmp_1"
    }
    type: "elementwise_add"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "use_mkldnn"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "op_role"
      type: INT
      i: 0
    }
    attrs {
      name: "axis"
      type: INT
      i: 1
    }
  }
  ops {
    inputs {
      parameter: "X"
      arguments: "fc_0.tmp_1"
    }
    inputs {
      parameter: "Y"
      arguments: "y"
    }
    outputs {
      parameter: "Out"
      arguments: "square_error_cost_0.tmp_0"
    }
    type: "elementwise_sub"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "use_mkldnn"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "axis"
      type: INT
      i: -1
    }
    attrs {
      name: "op_role"
      type: INT
      i: 0
    }
  }
  ops {
    inputs {
      parameter: "X"
      arguments: "square_error_cost_0.tmp_0"
    }
    outputs {
      parameter: "Out"
      arguments: "square_error_cost_0.tmp_1"
    }
    type: "square"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "use_mkldnn"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "op_role"
      type: INT
      i: 0
    }
  }
  ops {
    inputs {
      parameter: "X"
      arguments: "square_error_cost_0.tmp_1"
    }
    outputs {
      parameter: "Out"
      arguments: "mean_0.tmp_0"
    }
    type: "mean"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "op_role"
      type: INT
      i: 256
    }
  }
  ops {
    outputs {
      parameter: "Out"
      arguments: "mean_0.tmp_0@GRAD"
    }
    type: "fill_constant"
    attrs {
      name: "op_role"
      type: INT
      i: 257
    }
    attrs {
      name: "value"
      type: FLOAT
      f: 1.0
    }
    attrs {
      name: "force_cpu"
      type: INT
      i: 0
    }
    attrs {
      name: "shape"
      type: INTS
      ints: 1
    }
    attrs {
      name: "dtype"
      type: INT
      i: 5
    }
  }
  ops {
    inputs {
      parameter: "Out@GRAD"
      arguments: "mean_0.tmp_0@GRAD"
    }
    inputs {
      parameter: "X"
      arguments: "square_error_cost_0.tmp_1"
    }
    outputs {
      parameter: "X@GRAD"
      arguments: "square_error_cost_0.tmp_1@GRAD"
    }
    type: "mean_grad"
    attrs {
      name: "op_role"
      type: INT
      i: 1
    }
  }
  ops {
    inputs {
      parameter: "Out"
      arguments: "square_error_cost_0.tmp_1"
    }
    inputs {
      parameter: "Out@GRAD"
      arguments: "square_error_cost_0.tmp_1@GRAD"
    }
    inputs {
      parameter: "X"
      arguments: "square_error_cost_0.tmp_0"
    }
    outputs {
      parameter: "X@GRAD"
      arguments: "square_error_cost_0.tmp_0@GRAD"
    }
    type: "square_grad"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "use_mkldnn"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "op_role"
      type: INT
      i: 1
    }
  }
  ops {
    inputs {
      parameter: "Out"
      arguments: "square_error_cost_0.tmp_0"
    }
    inputs {
      parameter: "Out@GRAD"
      arguments: "square_error_cost_0.tmp_0@GRAD"
    }
    inputs {
      parameter: "X"
      arguments: "fc_0.tmp_1"
    }
    inputs {
      parameter: "Y"
      arguments: "y"
    }
    outputs {
      parameter: "X@GRAD"
      arguments: "fc_0.tmp_1@GRAD"
    }
    outputs {
      parameter: "Y@GRAD"
    }
    type: "elementwise_sub_grad"
    attrs {
      name: "op_role_var"
      type: STRINGS
    }
    attrs {
      name: "use_mkldnn"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "axis"
      type: INT
      i: -1
    }
    attrs {
      name: "op_role"
      type: INT
      i: 1
    }
  }
  ops {
    inputs {
      parameter: "Out"
      arguments: "fc_0.tmp_1"
    }
    inputs {
      parameter: "Out@GRAD"
      arguments: "fc_0.tmp_1@GRAD"
    }
    inputs {
      parameter: "X"
      arguments: "fc_0.tmp_0"
    }
    inputs {
      parameter: "Y"
      arguments: "fc_0.b_0"
    }
    outputs {
      parameter: "X@GRAD"
      arguments: "fc_0.tmp_0@GRAD"
    }
    outputs {
      parameter: "Y@GRAD"
      arguments: "fc_0.b_0@GRAD"
    }
    type: "elementwise_add_grad"
    attrs {
      name: "op_role_var"
      type: STRINGS
      strings: "fc_0.b_0"
      strings: "fc_0.b_0@GRAD"
    }
    attrs {
      name: "use_mkldnn"
      type: BOOLEAN
      b: false
    }
    attrs {
      name: "op_role"
      type: INT
      i: 1
    }
    attrs {
      name: "axis"
      type: INT
      i: 1
    }
  }
  ops {
    inputs {
      parameter: "Out"
      arguments: "fc_0.tmp_0"
    }
    inputs {
      parameter: "Out@GRAD"
      arguments: "fc_0.tmp_0@GRAD"
    }
    inputs {
      parameter: "X"
      arguments: "x"
    }
    inputs {
      parameter: "Y"
      arguments: "fc_0.w_0"
    }
    outputs {
      parameter: "X@GRAD"
    }
    outputs {
      parameter: "Y@GRAD"
      arguments: "fc_0.w_0@GRAD"
    }
    type: "mul_grad"
    attrs {
      name: "op_role_var"
      type: STRINGS
      strings: "fc_0.w_0"
      strings: "fc_0.w_0@GRAD"
    }
    attrs {
      name: "op_role"
      type: INT
      i: 1
    }
    attrs {
      name: "y_num_col_dims"
      type: INT
      i: 1
    }
    attrs {
      name: "x_num_col_dims"
      type: INT
      i: 1
    }
  }
  ops {
    inputs {
      parameter: "Grad"
      arguments: "fc_0.b_0@GRAD"
    }
    inputs {
      parameter: "LearningRate"
      arguments: "learning_rate_0"
    }
    inputs {
      parameter: "Param"
      arguments: "fc_0.b_0"
    }
    outputs {
      parameter: "ParamOut"
      arguments: "fc_0.b_0"
    }
    type: "sgd"
    attrs {
      name: "op_role_var"
      type: STRINGS
      strings: "fc_0.b_0"
      strings: "fc_0.b_0@GRAD"
    }
    attrs {
      name: "op_role"
      type: INT
      i: 2
    }
  }
  ops {
    inputs {
      parameter: "Grad"
      arguments: "fc_0.w_0@GRAD"
    }
    inputs {
      parameter: "LearningRate"
      arguments: "learning_rate_0"
    }
    inputs {
      parameter: "Param"
      arguments: "fc_0.w_0"
    }
    outputs {
      parameter: "ParamOut"
      arguments: "fc_0.w_0"
    }
    type: "sgd"
    attrs {
      name: "op_role_var"
      type: STRINGS
      strings: "fc_0.w_0"
      strings: "fc_0.w_0@GRAD"
    }
    attrs {
      name: "op_role"
      type: INT
      i: 2
    }
  }
}

还可以用debugger模块：

>>> from paddle.fluid import debugger
>>> from paddle.fluid import framework
>>> print debugger.pprint_program_codes(framework.default_main_program())
// block-0  parent--1
// variables
Tensor x (tensor(type=float32, shape=[-1L, 13L]))
Tensor fc_0.w_0 (tensor(type=float32, shape=[13L, 1L]))
Tensor mean_0.tmp_0 (tensor(type=float32, shape=[1L]))
Tensor y (tensor(type=float32, shape=[-1L, 1L]))
Tensor fc_0.tmp_0 (tensor(type=float32, shape=[-1L, 1L]))
Tensor fc_0.b_0 (tensor(type=float32, shape=[1L]))
Tensor fc_0.tmp_1 (tensor(type=float32, shape=[-1L, 1L]))
Tensor square_error_cost_0.tmp_0 (tensor(type=float32, shape=[-1L, 1L]))
Tensor learning_rate_0 (tensor(type=float32, shape=[1L]))
Tensor square_error_cost_0.tmp_1 (tensor(type=float32, shape=[-1L, 1L]))

// operators
fc_0.tmp_0 = mul(X=x, Y=fc_0.w_0) [{op_role_var=[],op_role=0,y_num_col_dims=1,x_num_col_dims=1}]
fc_0.tmp_1 = elementwise_add(X=fc_0.tmp_0, Y=fc_0.b_0) [{op_role_var=[],use_mkldnn=False,op_role=0,axis=1}]
square_error_cost_0.tmp_0 = elementwise_sub(X=fc_0.tmp_1, Y=y) [{op_role_var=[],use_mkldnn=False,axis=-1,op_role=0}]
ymean_0.tmp_0 = mean(X=square_error_cost_0.tmp_1) [{op_role_var=[],op_role=256}]

运行时概念

数据相关：
- Tensor/LoDtensor/Variable
- Scope
计算相关：
- Block
- Kernel/OpWithKernel/OpWithoutKernel
执行相关：Executor

Tensor/LoD(Level-of-Detail)Tensor

Tensor是n维array的推广，LoDTensor是在Tensor基础上加了序列信息

Fluid中输入、输出以及所有可学习参数都用LodTensor表示

一个mini-batch的输入数据是一个LoDTensor:

rnn处理变长序列不需要padding
LoD可以理解为vector<vector<int>>
对于非序列数据，LoD信息为空

图中，

demo

定义以下训练流程：

def train_loop(main_program):
    """
    train_loop
    """
    train_reader = paddle.batch(
        paddle.reader.shuffle(
            cluster_data_reader(cluster_train_dir), buf_size = 500),
            batch_size = BATCH_SIZE)
    
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    exe.run(fluid.default_startup_program())

    batch_id = 0
    PASS_NUM = 100
    for pass_id in range(PASS_NUM):
        for data in train_reader():
            avg_loss_value, = exe.run(main_program,
                                      feed=feeder.feed(data),
                                      fetch_list=[avg_cost])
            print(avg_loss_value)
            visualdl.show_fluid_trend('epoch', \
                    pass_id, batch_id, '{\"avg_loss\":%d}' % (avg_loss_value[0]))
            batch_id += 1
            if avg_loss_value[0] < 10.0:
                if save_dirname is not None:
                    fluid.io.save_inference_model(save_dirname, ['x'],
                                                  [y_predict], exe)
                return
            if math.isnan(float(avg_loss_value)):
                sys.exit("got NaN loss, training failed.")
        visualdl.show_fluid_trend('batch', \
                pass_id, '{\"avg_loss\":%d}' % (avg_loss_value[0]))
        
    if save_dirname is not None:
        fluid.io.save_inference_model(save_dirname, ['x'], [y_predict], exe)    def train_loop(main_program):
    """
    train_loop
    """
    train_reader = paddle.batch(
        paddle.reader.shuffle(
            cluster_data_reader(cluster_train_dir), buf_size = 500),
            batch_size = BATCH_SIZE)
    
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
    exe.run(fluid.default_startup_program())

    batch_id = 0
    PASS_NUM = 100
    for pass_id in range(PASS_NUM):
        for data in train_reader():
            avg_loss_value, = exe.run(main_program,
                                      feed=feeder.feed(data),
                                      fetch_list=[avg_cost])
            print(avg_loss_value)
            visualdl.show_fluid_trend('epoch', \
                    pass_id, batch_id, '{\"avg_loss\":%d}' % (avg_loss_value[0]))
            batch_id += 1
            if avg_loss_value[0] < 10.0:
                if save_dirname is not None:
                    fluid.io.save_inference_model(save_dirname, ['x'],
                                                  [y_predict], exe)
                return
            if math.isnan(float(avg_loss_value)):
                sys.exit("got NaN loss, training failed.")
        visualdl.show_fluid_trend('batch', \
                pass_id, '{\"avg_loss\":%d}' % (avg_loss_value[0]))
        
    if save_dirname is not None:
        fluid.io.save_inference_model(save_dirname, ['x'], [y_predict], exe)

如果是local，直接调用上面的函数

train_loop(fluid.default_main_program())

如果是分布式：

port = os.getenv("PADDLE_PORT", "6174")
pserver_ips = os.getenv("PADDLE_PSERVERS")  # ip,ip...
eplist = []
for ip in pserver_ips.split(","):
    eplist.append(':'.join([ip, port]))
pserver_endpoints = ",".join(eplist)  # ip:port,ip:port...
trainers = int(os.getenv("PADDLE_TRAINERS_NUM", "0"))
current_endpoint = os.getenv("POD_IP") + ":" + port
trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
t = fluid.DistributeTranspiler()
t.transpile(
    optimize_ops,
    params_grads,
    trainer_id,
    pservers=pserver_endpoints,
    trainers=trainers)
if training_role == "PSERVER":
    pserver_prog = t.get_pserver_program(current_endpoint)
    pserver_startup = t.get_startup_program(current_endpoint,
                                            pserver_prog)
    exe.run(pserver_startup)
    exe.run(pserver_prog)
elif training_role == "TRAINER":
    train_loop(t.get_trainer_program())

完整的logistic regression的demo: https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/fluid/tests/book/test_fit_a_line.py

paddle fluid分布式cpu相关

2018-03-28T00:00:00+00:00

简介

简介

ERNIE2.0背后的神助攻：飞桨高性能分布式训练引擎

./paddle/fluid/framework/dist_multi_trainer.cc：入口
./paddle/fluid/framework/downpour_worker.cc：pull push sparse
./paddle/fluid/framework/pull_dense_worker.cc：pull，push dense
./paddle/fluid/framework/data_feed.cc：解析ins

nginx

2018-03-28T00:00:00+00:00

https://github.com/nginx/nginx

微服务

2018-03-28T00:00:00+00:00

从单体服务迁移成微服务
k8s+微服务

微服务是一种工程方法，聚焦在将应用拆解为具备良好接口设计的单一功能的模块集上。模块集可以独立部署，由掌管整个生命周期的小团队维护。

微服务最小化了人与人之间的沟通和协作，进而减小应用范围和变更的风险。

抽几个来讲一下：

单一功能：一个服务聚焦一个”类型的”功能上
良好接口设计：服务间的通信依赖接口，简单清晰的接口是基础
独立：服务具备独立运行工作的能力，包括流水线、监控、上线等
整个生命周期：团队负责从开发-测试-staging-部署-维护的整个阶段
语言无关：服务间通信使用语言无关的API，通常由RESTful的接口、RPC等实现
有限上下文：松耦合，服务单元不需要了解其他服务单元如何运作

随着时间演进，大型、复杂的单体应用逐步演化出多层架构（MVC等），但按照业务功能的分层仍然笨拙、复杂、难以控制。

从单体服务迁移成微服务

核心就是面向业务拆分服务

设计时考虑失败

熔断机制
- 设计初衷是保证一个服务故障不会影响整个系统
- 当某个服务调用失败比例提高，合理的使用其他方式提供服务
隔离
- 单个服务造成的负载问题不影响其他服务
- 设计服务的资源用量

去中心化数据管理

单体应用的事务管理更容易。相较ACID，微服务架构更偏重BASE

BASE
- BA：Basically Available，基本可用
- S：Soft state，无状态
- E：Eventual consistency，最终一致性。中间可以失败重试，但最终结果要保持一致。
尽可能的避免分布式事务，因为BASE还是会有各种坑
理想情况下每个微服务单元管理自己的数据

服务发现

微服务架构要求服务可靠和容错
云计算和容器化的微服务，服务配置动态化。新服务单元创建后，需要网络中的其他服务快速找到并相互调用
使用注册服务中心管理服务状态(例如使用zk，etcd等搞一个配置中心)
使用服务内通信设置，更少的依赖外部环境：IP\域名\hostname...

服务通信

API调用
- HTTP RESTful API
RPC
消息机制：mq，劣势是实时性，优势是可以延迟处理

k8s+微服务

SaaS的12要素

https://12factor.net/zh_cn/

基准代码：一分代码多处部署
依赖：显示声明依赖关系
配置：在环境中存储配置
后端服务：把后端服务当做附加资源
构建、发布、运行：严格分离构建和运行
进程：一个或多个无状态进程运行应用
端口绑定：通过端口绑定提供服务
并发：通过进程模型进行扩展
易处理：快速启动和优雅终止可最大化健壮性
开发与线上环境等价：尽可能的保持开发，预发布，线上环境相同
日志：把日志当作事件流
管理进程：后台管理任务当作一次性进程运行

Kubernetes的设计适合微服务

服务发现Service
服务编排与弹性伸缩
统一配置中心：对于配置中心，K8S 提供了 configMap，可以在容器启动的时候，将配置注入到环境变量或者 Volume 里面。但是唯一的缺点是，注入到环境变量中的配置不能动态改变了，好在 Volume 里面的可以，只要容器中的进程有 reload 机制，就可以实现配置的动态下发了。
统一日志与监控：统一日志和监控往往需要在 Node 上部署 Agent，来对日志和指标进行收集，当然每个 Node 上都有，daemonset 的设计，使得更容易实现
- Container Liveness
- Readness Probe
- Node-Problem-Detector
滚动更新

搞

设置账号密码

echo -n "root" > username
echo -n 'root123!' > password
kubectl create secret generic user-password --from-file=username --from-file=password

memcached

2018-03-28T00:00:00+00:00

https://github.com/memcached/memcached

linux内存管理

2018-03-28T00:00:00+00:00

参考http://lib.csdn.net/article/linux/33242

linux内核

2018-03-28T00:00:00+00:00

参考《linux内核设计与实现》

leveldb rocksdb anna等

2018-03-28T00:00:00+00:00

leveldb
rocksdb
ssd简介
Cassandra
anna

leveldb

memtable + wal文件 +l0-7

rocksdb

ssd简介

flash:写page 擦除block，512k一个block。擦除目前最好的是3w次

ssd中大多数厂商是通过一个映射表，把物理映射到逻辑上，将随机读改成顺序读

每个ssd会留出一块block做缓存，用户不可见。当用户区写满时，会把有用的数据移到这块block，然后移回去。如果失效数据很少，写放大很严重（目前写放大是10倍左右）

ssd写性能: 顺序500m/s，随机一般要/10 ssd读性能：约3G/s

xxxx存储系统针对ssd设计：有个全内存的index，是个hash，然后也有个磁盘的wal。内存里只记录偏移。设计上是顺序写

id是64int，其中前几位是标记offset，导致只有约16个bit可用==》最多只能用128g磁盘。但现在磁盘是800-1024t，所以要充分利用得部署多个引擎。但这样就变成了随机写

结合：单机引擎部分：用leveldb只做index，存储key+offset，所以不受限于内存，解决xxx的问题。

分布式：主从复制，写只写master，从只读

新硬件AEP：往内存口插

Cassandra

anna

秒杀Redis的KVS上云了！伯克利重磅开源Anna 1.0

berkely anna kv: 针对分布式的改造。

正常主-从group一般500个，但一开始hash要搞3w多个，方便扩容

节点没有主从概念，但每个slot有主从一致性：通过client端做一致性，很容易支持多种一致性（最终一致、强一致等）

kubernetes

2018-03-28T00:00:00+00:00

背景
- 物理机时代
- 虚拟机时代
- 前容器时代
- 后容器时代
- k8s起源
  - borg
  - omega
  - mesos
  - nomad
- CNCF基金会
- k8s现状
- 例子
架构&组件
基础概念&术语
inf k8s
k8s示例
- minikube
- katacoda
- 其他

中文网：https://www.kubernetes.org.cn

https://github.com/kubernetes/kubernetes

百度前员工刘杰写的《分布式系统原理介绍》【https://daiwk.github.io/assets/分布式系统原理介绍.pdf】。

参考http://kubernetes.kansea.com/docs/whatisk8s/

参考Borg, Omega, and Kubernetes Lessons learned from three container-management systems over a decade

参考Kubernetes 五周年回顾与展望

参考Docker 5年，架构演进之路

背景

物理机时代

虚拟机时代

openstack

前容器时代

docker，基于LXC为基础构建的容器引擎，通过namespace和cgroup实现资源隔离和调配。将os和应用捆绑，使得应用系统环境标准化、集装箱化。主要问题：缺乏完整的调度部署管理能力。

后容器时代

原生docker swarm
google的kubernetes(2015年)：容器集群管理系统。可以管理跨机器容器化。
apache的mesos。优势在于离线集群任务。

k8s起源

2004年google开始使用容器，06年cgroup 内部集群资源管理平台borg和omega k8s起源于borg，参考了omega的经验和教训。borg和omega的创始人都加入k8s。

https://daiwk.github.io/assets/Borg_Omega_Kubernetes.pdf

borg

https://daiwk.github.io/assets/Borg.pdf

omega

https://daiwk.github.io/assets/Omega.pdf

mesos

nomad

https://daiwk.github.io/assets/Nomad.pdf

CNCF基金会

Cloud Native Computing Foundation ==>生态绑定、法律保护、推广、培训等。

k8s现状

5w+commits，2.5w stars

例子

通过kubectl提交，应用描述文件（json/yaml）

一个app下可以有多个实例。

使用label和selector进行deployment和service的对应，nodeport虚拟端口nodeport，对外暴露的端口targetport

架构&组件

k8s & docker

k8s会调度相应的app到对应的docker host上去运行

k8s & Node

调度和pack各种xxx到不同的nodes上

架构

可以参考https://www.kubernetes.org.cn/kubernetes%E8%AE%BE%E8%AE%A1%E6%9E%B6%E6%9E%84

单集群可以一次5000台机器上线

有一个中心化的api server，然后把状态存储在etcd中主节点有scheduler和controller mgr，worker节点有kubelet和service proxy。

api server中有所有资源的增删改查的接口，还有authorization，可以按namespace来划分权限。

scheduler中把定义的pod按照策略调度到相应节点

controller manager和apiserver通信，获取集群的特定信息，然后做出响应的反馈动作。由多个controller组成

etcd是分布式k-v你在什么地方，所有集群数据存放在etcd中，实现组件的无状态化。可以通过watch的方式监听变化，并触发相应动作。

worker节点:

kubelet：是节点的agent，接收描述的manifest并处理
kubeproxy: 网络agent，部署在各个node，简单的tcp/udp转发，简单的round-robin负载均衡。

基础概念&术语

Pod

pod是若干相关容器的组合。pod包含的容器运行在同一台宿主机上，它们使用相同的pid/network/ipc/uts命名空间/ip地址和端口，相互之前能通过localhost来发现和通信，还可以共享一块存储volume空间。其实是容器的更高层次的抽象。

ReplicationSet

控制管理pod副本。确保任何时候k8s集群中有足够v几个的pod副本在运行。如果少于，会自动启动。

Label

区分pod/service/replication/controller的k/v对。每个api对象可以有多个label，但每个label的k只能对应一个v。

deployment

只描述集群的期望状态

rolling update

升级时，旧实例下一下，上一个新实例这样。但如果是大更新，只能停机更新，旧的全下了再上新的。参数： maxSurge:不容许实例减少，且集群资源充裕 maxUnavaliable:集群资源照张，可以先缩容，再更新

StatefulSet

部署带持久化数据的服务

identity严格区分, uniq ordinal value
index min会被选举为master
nfs是底层存储

搭建分布式db集群

storage class用于vpc申请
headless service用于维护db的endpoints
statefulset

daemonSet

每个host部署一个服务，也有rolling update

Jobs

parallelism：最大的共有并行数 completions: 完成了多少个job就算完成了

service

service是真实应用服务的抽象，定义了pod的逻辑集合和访问这个pod集合的策略。将代理pod对外表现为一个单一的访问接口，外部不需要了解后端pod是如何运行的。

实现原理：kube-proxy维护一个iptables，会去watch apiserver，然后更新这个table，有dns解析功能

headless service

不提供round-robin 显式返回所有endpoints 可以自定义策略（如选主）最佳实践：cacendera的去中心化选主

k8s service对外提供访问

nodeport
loadbalancer
- blvxxxxx: 类似bfe +ingress: 7层的routing，nginx的实现(可以访问内部节点，然后开个外网ip，让其他k8s也能访问它内部的节点)

DNS

skyDNS->KubeDNS。可以对特定的domain自定义上游nameserver。

优先级：

kubedns
特定domain的自定义上游namesever
默认的upstream nameserver

native network model

每个pod有一个ip，需要容器网络

Volumes

可以将存储在pod上进行挂载，可以直接挂载基于fuse共享存储NFS等。

inf k8s

微服务自动伸缩使用supervisor,如果主进程被Kill了，会把这个信号量传给每个子进程，避免孤儿进程节点亲和&应用亲和：例如混布cpu+gpu（后来，1.6的k8s原生支持gpu了）

k8s示例

minikube

使用minikube:

https://qii404.me/2018/01/06/minukube.html

katacoda

https://www.katacoda.com/

有状态的容器：例如

监控：普罗米修斯

其他

建一个k8s集群的时候，有n+3台机器做master，因为用的是etcd，选主至少要3台机器。

service如何访问到pods:

可以参考https://blog.csdn.net/yuanjunlai141/article/details/79487381

在宿主机创建iptables
xxx

kubernetes-container

2018-03-28T00:00:00+00:00

Namespace
- PID Namespace
- 与虚拟机的区别
Cgroups
rootfs文件系统

容器技术的核心功能，就是通过约束和修改进程的动态表现，从而为其创造一个『边界』。

Namespace：修改进程视图
Cgroups：制造约束

Namespace

可以参考https://coolshell.cn/articles/17010.html

参考05 | 白话容器基础（一）：从进程说开去

PID Namespace

进程：一个程序运行后的计算机执行环境（磁盘上的可执行文件、内存中的数据、寄存器中的值、堆栈中的指令、被打开的文件、各种设备的状态信息等）的总和。

docker run -it busybox /bin/sh

-it参数指的是，在启动容器后，分配一个文本输入/输出环境，即tty，与容器的标准输入相关联。

linux的Namespace机制，其实就是Linux新建进程的一个可选参数，在Linux系统中创建线程的系统调用是clone()，如：

int pid = clone(main_function, stack_size, SIGCHLD, NULL); 

这个系统调用会创建一个新进程，并返回其进程号pid（其中，SIGCHLD表示在一个进程终止或者停止时，将SIGCHLD信号发送给其父进程，按系统默认将忽略此信号，如果父进程希望被告知其子系统的这种状态，则应捕捉此信号）。可以指定CLONE_NEWPID参数，这样就会创建一个新的PID Namespace，clone出来的新进程将成为Namespace里的第一个进程。如：

int pid = clone(main_function, stack_size, CLONE_NEWPID | SIGCHLD, NULL); 

如果多次执行如上的clone()调用，就会创建多个PID Namespace，每个Namespace里的应用进程，都会认为自己是当前容器里的第1号进程，看不到宿主机里真正的进程空间，也看不到其他PID Namespace里的具体情况。

除了PID Namespace，Linux中还有Mount、UTS、IPC、Network和User这些Namespace。

与虚拟机的区别

下图左边是虚拟机的工作原理，Hypervisor是虚拟机最主要部分，通过硬件虚拟化功能，模拟出运行一个操作系统需要的各种硬件（CPU、内存、I/O设备等），然后在这些虚拟的硬件上安装了一个新的操作系统Guest OS。所以，这个Hypervisor负责创建虚拟机，会有额外资源消耗和占用，本身虚拟机还会占用内存，对宿主机操作系统的调用也要经过虚拟化软件的拦截和处理，对计算资源、网络和磁盘的I/O损耗也非常大。

右边的Docker在运行时，并没有一个真正的『docker容器』运行在宿主机中，只是一个正常的应用进程，只是在创建时，加上了各种Namespace参数。

『敏捷』和『高性能』是容器相对于虚拟机的最大优势，也是它能够在PaaS这种更细粒度的资源管理平台上大行其道的重要原因。

Cgroups

参考06 | 白话容器基础（二）：隔离与限制

Namespace的问题

但基于linux namespace的隔离机制有一个主要问题：隔离得不彻底，体现为以下两方面：

容器只是运行在宿主机上的一种特殊进程，多个容器之间用的还是同一个宿主机的操作系统内核

可以在容器中通过Mount Namespace单独挂载其他不同版本的操作系统文件，如CentOS或Ubuntu，但不能改变共享宿主机内核的事实。所以，要在Windows宿主机主运行Linux容器，或者在低版本的Linux宿主机上运行高版本的Linux容器，都是不行的（Docker on Mac或者windows，实际上都是基于虚拟化技术实现的，和这里要讲的linux容器不同）

Linux内核中，很多资源和对象是不能被Namespace化的，典型例子就是『时间』

例如，如果在容器中使用了settimeofday(可以设置系统的秒数，以及微秒数)修改了时间，那么宿主机的时间也会被修改。。。所以，在容器里部署应用时，『什么能做，什么不能做』，是用户必须考虑的。所以容器给应用暴露出的攻击面是很大的，尽管在实践中可以用Seccomp等技术，对容器内部发起的所有系统调用进行过滤和甄别以进行安全加固，但这加多了一层对系统调用的过滤，会拖累容器的性能。所以在生产环境中，不能把运行在物理机上的Linux容器直接暴露到公网上。

注：

seccomp 是 secure computing 的缩写，其是 Linux kernel 从2.6.23版本引入的一种简洁的 sandboxing 机制。在 Linux 系统里，大量的系统调用（system call）直接暴露给用户态程序。但是，并不是所有的系统调用都被需要，而且不安全的代码滥用系统调用会对系统造成安全威胁。seccomp安全机制能使一个进程进入到一种“安全”运行模式，该模式下的进程只能调用4种系统调用（system call），即 read(), write(), exit() 和 sigreturn()，否则进程便会被终止。

当然，后续讲的基于虚拟化或者独立内核技术的容器实现，可以较好地在隔离和性能间做平衡。

cgroups简介

可以参考https://coolshell.cn/articles/17049.html

Linux Cgroups是Linux内核中用来为进程设置资源限制的一个重要功能，可以限制一个进程能够使用的资源上限，包括CPU、内存、磁盘、网络带宽等。

如果是centos，先yum install libcgroup，然后service cgconfig start，可以发现

root@xx:ll /cgroup/
total 0
drwxr-xr-x 4 root root 0 Jul 19  2017 blkio
drwxr-xr-x 7 root root 0 Jul 19  2017 cpu
drwxr-xr-x 4 root root 0 Jul 19  2017 cpuacct
drwxr-xr-x 4 root root 0 Jul 19  2017 cpuset
drwxr-xr-x 4 root root 0 Jun 21 20:25 devices
drwxr-xr-x 5 root root 0 Jul 19  2017 freezer
drwxr-xr-x 5 root root 0 Jul 19  2017 memory
drwxr-xr-x 2 root root 0 Oct  8 20:34 net_cls

类似的目录，ubuntu是在/sys/fs/cgroup/目录下。例如，cpu目录下：

root@xx:ll /cgroup/cpu
total 0
drwxr-xr-x 2 root root 0 May 25 07:02 agent-webdir
-rw-r--r-- 1 root root 0 Jul 19  2017 cgroup.clone_children
--w--w--w- 1 root root 0 Jul 19  2017 cgroup.event_control
-r--r--r-- 1 root root 0 Jul 19  2017 cgroup.procs
-rw-r--r-- 1 root root 0 Jul 19  2017 cpu.cfs_period_us
-rw-r--r-- 1 root root 0 Jul 19  2017 cpu.cfs_quota_us
-rw-r--r-- 1 root root 0 Jul 19  2017 cpu.shares
-r--r--r-- 1 root root 0 Jul 19  2017 cpu.stat
drwxr-xr-x 7 root root 0 Jul 19  2017 idle
-rw-r--r-- 1 root root 0 Jul 19  2017 notify_on_release
drwxr-xr-x 7 root root 0 Jul 19  2017 offline
-rw-r--r-- 1 root root 0 Jul 19  2017 release_agent
drwxr-xr-x 2 root root 0 Oct  8 20:30 small
drwxr-xr-x 2 root root 0 Jul 19  2017 system
-rw-r--r-- 1 root root 0 Oct  8 20:06 tasks

cfs_quota和cfs_period是组合使用的参数，限制进程在长度为cfs_period的一段时间内，只能被分配到总量为cfs_quota的cpu时间。试着建一个文件夹，就会生成一堆文件，这个目录称为一个『控制组』：

root@xx:mkdir /cgroup/cpu/container
root@xx:ll /cgroup/cpu/container/  
total 0
-rw-r--r-- 1 root root 0 Oct  8 20:43 cgroup.clone_children
--w--w--w- 1 root root 0 Oct  8 20:43 cgroup.event_control
-r--r--r-- 1 root root 0 Oct  8 20:43 cgroup.procs
-rw-r--r-- 1 root root 0 Oct  8 20:43 cpu.cfs_period_us
-rw-r--r-- 1 root root 0 Oct  8 20:43 cpu.cfs_quota_us
-rw-r--r-- 1 root root 0 Oct  8 20:43 cpu.shares
-r--r--r-- 1 root root 0 Oct  8 20:43 cpu.stat
-rw-r--r-- 1 root root 0 Oct  8 20:43 notify_on_release
-rw-r--r-- 1 root root 0 Oct  8 20:43 tasks

可以看下默认值：

==> /cgroup/cpu/container/cpu.cfs_period_us <==
100000

==> /cgroup/cpu/container/cpu.cfs_quota_us <==
-1

文件/cgroup/cpu/container/cpu.cfs_quota_us的默认值是-1，如果改成20000（即20000us，也就是20ms），那么，在每100ms的时间内(/cgroup/cpu/container/cpu.cfs_period_us文件指定)，被这个控制组限制的进程只能用20%的CPU带宽。如何指定进程呢？把pid写到tasks文件里就行啦。

几个cgroups常用的子系统：

blkio：为块设备设定I/O限制，一般用于磁盘等设备
cpuset：为进程分配单独的CPU核和对应的内存节点
memory：为进程设定内存使用的限制

对于docker等linux容器项目来说，只需要在每个子系统下，为每个容器创建一个控制组（即创建一个新目录），然后在启动容器进程后，把这个进程的pid写入对应控制组的tasks文件中就行啦~

例如：

$ docker run -it --cpu-period=100000 --cpu-quota=20000 ubuntu /bin/bash

然后可以看到：

root@xx:docker ps
CONTAINER ID        IMAGE                                  COMMAND             CREATED             STATUS              PORTS                              NAMES
edc3dad98449        ubuntu                                 "/bin/bash"         14 minutes ago      Up 14 minutes                                          evil_shaw

然后我们拿containerid去找：

root@xx:ll /cgroup/cpu/docker/*edc3dad98449*
total 0
-rw-r--r-- 1 root root 0 Oct  8 20:59 cgroup.clone_children
--w--w--w- 1 root root 0 Oct  8 20:59 cgroup.event_control
-rw-r--r-- 1 root root 0 Oct  8 20:59 cgroup.procs
-rw-r--r-- 1 root root 0 Oct  8 20:59 cpu.cfs_period_us
-rw-r--r-- 1 root root 0 Oct  8 20:59 cpu.cfs_quota_us
-rw-r--r-- 1 root root 0 Oct  8 20:59 cpu.rt_period_us
-rw-r--r-- 1 root root 0 Oct  8 20:59 cpu.rt_runtime_us
-rw-r--r-- 1 root root 0 Oct  8 20:59 cpu.shares
-r--r--r-- 1 root root 0 Oct  8 20:59 cpu.stat
-rw-r--r-- 1 root root 0 Oct  8 20:59 notify_on_release
-rw-r--r-- 1 root root 0 Oct  8 20:59 tasks

进一步地，可以发现cfs_period_us和cfs_quota_us确实都设成了我们想要的值啦：

root@xx:head /cgroup/cpu/docker/*edc3dad98449*/*cpu*
==> /cgroup/cpu/docker/edc3dad98449c401fc53e684bb14242dcba2ccd5ac56024ed330aa54d5b3642d/cpu.cfs_period_us <==
100000

==> /cgroup/cpu/docker/edc3dad98449c401fc53e684bb14242dcba2ccd5ac56024ed330aa54d5b3642d/cpu.cfs_quota_us <==
20000

==> /cgroup/cpu/docker/edc3dad98449c401fc53e684bb14242dcba2ccd5ac56024ed330aa54d5b3642d/cpu.rt_period_us <==
1000000

==> /cgroup/cpu/docker/edc3dad98449c401fc53e684bb14242dcba2ccd5ac56024ed330aa54d5b3642d/cpu.rt_runtime_us <==
0

==> /cgroup/cpu/docker/edc3dad98449c401fc53e684bb14242dcba2ccd5ac56024ed330aa54d5b3642d/cpu.shares <==
1024

==> /cgroup/cpu/docker/edc3dad98449c401fc53e684bb14242dcba2ccd5ac56024ed330aa54d5b3642d/cpu.stat <==
nr_periods 5
nr_throttled 1
throttled_time 27232386

总之，容器是一个『单进程』模型。所以，在一个容器中，不能同时运行两个不同的应用，除非可以事先找到一个公共的pid=1来充当两个不同应用的父进程。所以很多人会用systemd或者supervisord等软件来代替应用本身作为容器的启动进程。当然，还有其他的解决方法，使容器和应用能同生命周期，因为如果『容器正常运行，但里面的应用已经挂了』这种情况出现，容器编排就很麻烦了。。

cgroups缺点

提及最多的是/proc文件系统的问题。/proc目录存储的是记录当前内核运行状态的一系列特殊文件，也是top命令查看系统信息的主要数据来源。所以，在容器中执行top命令，会发现显示的是宿主机的cpu和内存数据！因为/proc并不知道cgroups限制的存在。

解决方法：lxcfs

top是从/proc/stats目录下获取数据，所以道理上来讲，容器不挂载宿主机的该目录就可以了。lxcfs就是来实现这个功能的，做法是把宿主机的/var/lib/lxcfs/proc/memoinfo文件挂载到Docker容器的/proc/meminfo位置后。容器中进程读取相应文件内容时，LXCFS的FUSE实现会从容器对应的Cgroup中读取正确的内存限制。从而使得应用获得正确的资源约束设定。kubernetes环境下，也能用，以ds 方式运行 lxcfs ，自动给容器注入争取的 proc 信息。

详见https://blog.csdn.net/shida_csdn/article/details/79196258，从https://copr-be.cloud.fedoraproject.org/results/ganto/lxd/epel-7-x86_64/00486278-lxcfs/下载lxcfs-2.0.5-3.el7.centos.x86_64.rpm，然后(注意，要求GLIBC_2.17。。关于glibc的问题可以参考https://daiwk.github.io/posts/knowledge-gcc48.html)：

yum install lxcfs-2.0.5-3.el7.centos.x86_64.rpm

然后启动的时候加如下参数就行：

docker run -it -m 300m  \
      -v /var/lib/lxcfs/proc/cpuinfo:/proc/cpuinfo:rw \
      -v /var/lib/lxcfs/proc/diskstats:/proc/diskstats:rw \
      -v /var/lib/lxcfs/proc/meminfo:/proc/meminfo:rw \
      -v /var/lib/lxcfs/proc/stat:/proc/stat:rw \
      -v /var/lib/lxcfs/proc/swaps:/proc/swaps:rw \
      -v /var/lib/lxcfs/proc/uptime:/proc/uptime:rw \
	  ubuntu:14.04 /bin/bash

rootfs文件系统

参考07 | 白话容器基础（三）：深入理解容器镜像

Mount Namespace和其他Namespace的不同之处在于：它对容器进程视图的改变，一定要伴随着挂载操作(mount)才能生效。

xxx

Union Mount FS可以参考https://en.wikipedia.org/wiki/Union_mount

实现：

AU FS
Overlay FS
Devicemapper
btrfs

grpc

2018-03-28T00:00:00+00:00

安装
c++ tutorial
- 快速c++入门
- 进阶

https://github.com/grpc/grpc

安装

https://github.com/grpc/grpc/blob/master/INSTALL.md

git clone -b $(curl -L https://grpc.io/release) https://github.com/grpc/grpc
cd grpc
git submodule update --init
make
[sudo] make install

然后

c++ tutorial

快速c++入门

https://github.com/grpc/grpc/tree/master/examples/cpp

先安装protoc

cd third_party/protobuf/
make
make install

然后编译demo

cd examples/cpp/helloworld
make

启动server

./greeter_server
./greeter_async_server # 异步

启动client

greeter_client
greeter_async_client #异步
greeter_async_client2 #异步

进阶

https://github.com/grpc/grpc/blob/master/examples/cpp/cpptutorial.md

brpc-rdma

2018-03-28T00:00:00+00:00

brpc
rdma
- rdma vs tcp
- rdma实现
brpc-rdma
- 零拷贝
- 内存池

brpc

内部实现

无锁读写

bthread

iobuf

rdma

rdma vs tcp

rdma实现

brpc-rdma

零拷贝

内存池

baidurpc

2018-03-28T00:00:00+00:00

简介

https://github.com/brpc/brpc

简介

baidurpc的动机

现有rpc不好用的原因

不透明：没开源，所有有一点相关的问题都想找rpc团队跟进
难扩展：很难被使用超过2年
性能差：在机器较忙或者混部环境下波动很大

baidurpc的解决方法

/vars, /flags, /rpcz等http内置服务，方便快速排查问题
重视接口设计。支持了百度所有rpc协议和多种外部协议，共12种
充分考虑多线程，尽量规避全局竞争。较其他rpc大大提升了性能。

key components

rpc::socket

使fd ABA-free，且能原子地写入消息

这里的fd指的是socket

使fd ABA-free： linux管理fd时用的是32位的整数，但关掉之后就释放了，可能被另一个进程打开，而指向了另一个设备。所以多线程时，可能同一个整数被多个线程使用，用的时候可能fd已经被关掉或者被重复打开（ABA-连续看到两个值是a，无法判断是之前那个a，还是开始是a，后来变b，又变回a）
能原子地写入消息：在操作系统中，fd是可以原子地写入消息的，但这里的原子指的是byte。例如，有两个线程要往一个fd写消息，但一个消息的长度肯定不止一个byte，所以结果会是两个线程交错地写这个fd。

wait-free write

使每个线程同时能做有用的事，而不是因为锁被一个线程抢占了，其他线程就只能空等(one-free)，而如果用了锁，就两者都不能保证。每秒可以写入500w个16字节的消息。解决：使用一个64-bid的id。多线程的时候，不能传指针之类的，因为不知道什么时候就被free了，可能访问的是一个非法内存。所以用一个64位的id，并且被一个类似sharedptr的包住，保证不会在中间被析构，当有一个地方将其标记为失效时，其他用到的地方也都会原子地失效

bthread_id

ABA-free: 同上，是个64bit的id

其他rpc存在的问题：例1：当往一个连接开始写一个request之后，可能response在write这个函数完成之前就回来了。而如果write的时候会访问一个数据，而拿到response后也会访问同一个数据，那就会有问题例2：当超时时间设置得很短，线程还在写连接的时候，超时时间就到了，而连接里的东西不完整，可能别人会去读它。

checking every RPC call without global contention(??)

rpc::LoadBalance

详见https://github.com/brpc/brpc/blob/master/docs/cn/lalb.md#doublybuffereddata

例如，round-robin（rr）。

调度并发

例如对于rr算法而言，因为naming service对应的下游可能会变，所以每个线程在访问rr的这个列表时，常规的解决方法之一就是用读写锁。例如在查时，用的是读锁，而想要修改时，会用写锁。但在POSIX中，读写锁的性能会特别差。如果临界区不是特别大（例如rr其实临界区非常小），会发现直接用mutex反而比读写锁还要快…

brpc的解决方法：用一个特殊的双buffer读写锁，读时读前台的buffer，写时写后台的buffer，定时同步两个buffer（前后台切换）。但有一个限制就是前后台不能切换得太快，不然可能出现类似前面讲到的ABA的情况，可能一个线程正在读前台，但中间后台和前台切换了，然后又切换一次。所以会有一个切换频率，最低也要2s，一般是5-10s。但在loadbalance这个场景，这个等待时间是不可接受的。所以这里是一个特殊的双buffer读写锁，只需要和每一个前台线程抢一把thread-local锁就行了。

locality aware

最适合混部的分流算法。是一个动态的迭代型的算法，总是能选择期望延时最低的server。例如，优先把流量分给同机房的机器，只有当同机房的机器或者负载达到一定临界值，或者出现故障的时候，才会导流给邻近机房的机器。

consistent hashing

实现了多种一致性hash，便于各类caching使用。主要是两种：

基于memcached的
基于md5的

rpc::NamingService

统一形式： protocol://url
例如：bns://node, http://node, file://path, list://server1,server2,…, servername

rpc::Channel

与服务器通信

支持协议：

hulu-pbrpc,sofa-pbrpc,public/pbrpc,nova-pbrpc,ubrpc(idl/mcpack/compack)
http 1.1, hadoop-rpc, memcached

特性：

线程安全，都支持异步也就是说，不需要每个线程都建一个channel。很多开源的都是线程不安全的
超时，重试，backup request，取消
- 超时是严格的超时，只要超时就一定结束，结束就一定失败，错误码是timeout。而其他rpc，可能有很多种不同的超时。
- 重试只会发生在连接断开时，而不会在各种超时的时候去不断开连接继续重试（这种情况就是backup request了）
- backup request就是比如设置了5ms没回来，就再try一下，再等5ms
- 取消，可以随时取消。如果是异步调用，取消后仍然会调用done，返回的错误码是cancel
单连接，连接池，短连接，连接caching，连接认证
- 单连接，不管建立多少个channel，两点之前都只会建立一个连接。所以就会使用前面讲到的wait-free的fd的socket。
- 连接池，ub、http1.1（keep-alive）、public/pbrpc就是基于这种方式的，相当于一个池子里有n个连接，一个请求想发送时，就从这n个连接里拿一个来用，用完就放回池子里，并不需要大量地重新建立连接。但，如果在一个集群里，如果两两间要建立连接，而单点和单点之间假设要保持很多个连接，那fd、端口号可能就会被打爆了，所以就需要单连接的设计
- 短连接，用完就释放掉，适用于频率非常低的，比如一秒来一次的
- 连接caching，server端可以配一个参数，例如某个连接大于5s，没有任何东西写入，就把连接关掉。client端也有
- 连接认证，支持认证
ParallelChannel：更简单的并发访问方式。是一个combo-channel，可以加入一系列的子channel，每个Channel对应一个子分库，这样，对一个parallellchannel的访问，就会变成对这一系列子channel的并发访问（全异步）。可以parallelchannel套parallelchannel

channel的析构是不影响这次rpc_call的。所以如果是点对点的channel，那可以在栈上直接声明一个channel变量，然后去异步地rpc_call，再做别的。但如果是在bns上的channel，因为本身这个init是比较重量级的，就不太好这么用，最好还是用一个类成员变量之类的。

rpc::Channel xx;
xx.Init("10.1.1.1", "la", NULL);

rpc::Server

同端口多协议

hulu-pbrpc,sofa-pbrpc,public/pbrpc,nova-pbrpc,ubrpc(with adapter,将idl适配成pb，server中还是pb，但client可以仍然用idl)
http 1.1, hadoop-rpc, https

特性

高度并发：只要能并发就并发。除了从一个fd读数据之外，因为操作系统要求读一个fd只能是一个线程读，其实是一个线程不安全的设计。例如一个fd里传来了两个pb，如果pb很大，普通的rpc会等第一个parsefrom完再去解第二个，而brpc可以并发解析。
没有io线程和worker线程之分，首先，是没有io线程的，只有worker线程，其次，默认取cpu的核数，会在/flags里记录，可以通过内置的html页面去动态地修改
同进程内所有Server/Channel默认共享工作线程。为了提高线程的利用率

其中，SERVER_OWNS_SERVICE指的是server析构的时候，一起把service给干掉；反之，SERVER_DOESNT_OWN_SERVICE指的是service析构时，不把service干掉

rpc::Server xx;
xx.AddService(new MyService(), rpc::SERVER_OWNS_SERVICE);
xx.Start(8010, NULL);

内置服务

方便监控和调试

/status

因为同端口支持多协议，所以可以用同一个server端口在浏览器打开。可以看到支持的所有service,还有每个method的对应的指标，各种时间维度的流量、平响之类的

/connections

精确到微秒，有各种对端的ip之类的

/flags

进程内所有的gflags，有（R）的，就表示可以在浏览器里动态修改，改过的会高亮。如果一个gflag有检查函数，就会动态reload(gflag的特性)

/vars

所有用到bvar的都会显示在这里，bvar可以算各种cnt,max,min,90perlatency,80perlatency之类的，类似ubmonitor，但性能好很多，会定时写，noah会动态地读

/rpcz

会把进程内所有rpc_call列出来，会分配一个唯一的traceid，会有每一次rpc_call的详情

/pprof/profiler

支持远程做profiling，可以在线做cpu /heap profiling，

/pprof/heap

同上

baidurpc的性能

好于ub/hulu/sofa/thrift/zeromq…

why：

从sys_read开始就是并发的，只要cpu有富余，请求总会在O(1)时间内开始处理
wait-free write 写出总会在O(1)时间内返回，高吞吐，特别是包大的时候
高并发的loadbalancer（因为locality aware比较复杂，所以要求localbalancer不能全局加锁）
没有全局竞争的request tracking(不需要一个全局hash表来区分每次请求，有bthread-id就行了)
不区分io与worker，可以减少一次上下文切换
dedicated memory allocator: 专门写的针对多线程的内存分配，比tcmalloc更快

其他语言实现

python:
- 基于c++包装，通过动态pb互动
- 尽量规避GIL(GIL并不是Python的特性，它是在实现Python解析器(CPython)时所引入的一个概念。参考http://python.jobbole.com/81822/)
java：完全用java写的
其他脚本语言：推荐用http+json访问baidurpc，因为baidurpc默认开启http

bthread

M:N的线程库，同步的代码可以获得异步的性能，和pthread接口同构

butex使bthread阻塞函数可同时被bthread和pthread调用，分别阻塞bthread和pthread，相互可唤醒。mutex/semaphore/condition之类的，都是基于futex（POSIX最底层的）的，而butex就相当于futex。

超快的创建：每个rpc请求建一个bthread,请求结束，bthread就结束。如果一个channel里有3个请求，会用一个bthread读进来，然后建两个bthread去处理后面两个请求，读数据的那个bthread处理第一个请求

超快的scheduler

更好的cache locality: 允许新线程在当前cpu core上执行
减少全局竞争：取线程任务靠steal，而非pull

eventloop

从epoll-wait开始，后面的callback会等上面的结束了再执行，会进到epoll-wait状态，延时不可控，有的callback很慢，所以会等很久。

适用于高度定制的

ub_aserver用的就是eventloop，有n个eventloop。

eventloop+threadpool

io线程+worker线程

缺点：

io线程的竞争非常激烈
io线程到worker线程有拷贝的开销
epoll-control在linux中的实现，时间复杂度要O(n)

bthread

需要执行callback时，复用io线程

bvar

修改是thread-local的，写数据的时候并不急着读，所以写自己的thread-local就行，不需要全局竞争，只在需要读的时候汇总就行了

base

基于chromium【https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md】和百度的一些公共库写的

cv tips

2018-03-27T00:00:00+00:00

图片分类

提特征：

对空间建模
各像素当做bag of words
对图片做金字塔分割

处理特征：

pca 降维 bootstrap 增维

视频分类：提取视频内的interest point

特征：有区分性和鲁棒性，合适的特征是任务驱动的

普通的nn是不具备平移不变性的，而cnn可以，因为同一个卷积核在不同位置的权重是一样的

imgnet: top5:打5个标签有一个对就算对

vgg：不断用3*3的卷积核

inception: google系的，用各种不同大小的卷积核，然后再拼起来

分组卷积：嵌入式的地方常用，mobilenet，因为速度快。例如256层，变成8组，每组32层，在cpu上加速很快，在gpu一般

残差：2015年的paper，在所有网络都有提升

se-net：引入se-block，在所有网络都有提升==》浅层、中层、深层分别去做分类，然后把结果merge到一起

视频分类：先对每个图做光流，然后把rgb和光流图一起去做分类

用上lstm: 1.拿出最后一个隐状态的结果做分类 2.把每一个时间步的状态做pooling，再分类，会稍微好一点

attention : 每一帧做卷积再做softmax 得到一个一维的权重==》aaai 2018

做3d的卷积，直接输入32张图，32*3个channel，然后分块卷积，参数变大了

空间维度，先用一个cnn提取出1024维，t个时间步，看成1024个channel的图像，高1，宽是t，就变成了一个图像分类问题

与3d卷积相比，参数少很多

训练时会采样，例如只采样10帧（不用采太多），采一样多zhen，只要样本够多；测试可以所有帧

分类欠拟合：区分性不足，解决：把类别分细一点，类间不要有重合加batchnorm

过拟合：对于hardsample,不容易区分是哪一类，人工加入正确的样本

交叉熵等价mle 加入weightdecay等价于map

学习率优化(2个很有效的方法）：

cos annealing sgd+nestrov momentom

plateau anealing + rmsprop

图文相关性

百度去搜图搜出top10的提出来当做这个文本的表示

ocr：一般先做检测再做分类

tensorflow基础用法

2018-03-21T00:00:00+00:00

创建和操作张量
pandas
线性回归
重新训练

参考 https://developers.google.cn/machine-learning/crash-course/exercises

创建和操作张量

矢量加法

import tensorflow as tf
with tf.Graph().as_default():
  # Create a six-element vector (1-D tensor).
  primes = tf.constant([2, 3, 5, 7, 11, 13], dtype=tf.int32)

  # Create another six-element vector. Each element in the vector will be
  # initialized to 1. The first argument is the shape of the tensor (more
  # on shapes below).
  ones = tf.ones([6], dtype=tf.int32)

  # Add the two vectors. The resulting tensor is a six-element vector.
  just_beyond_primes = tf.add(primes, ones)

  # Create a session to run the default graph.
  with tf.Session() as sess:
    print just_beyond_primes.eval()
    #[ 3  4  6  8 12 14]

张量形状

with tf.Graph().as_default():
  # A scalar (0-D tensor).
  scalar = tf.zeros([])

  # A vector with 3 elements.
  vector = tf.zeros([3])

  # A matrix with 2 rows and 3 columns.
  matrix = tf.zeros([2, 3])

  with tf.Session() as sess:
    print 'scalar has shape', scalar.get_shape(), 'and value:\n', scalar.eval()
    # 0.0
    print 'vector has shape', vector.get_shape(), 'and value:\n', vector.eval()
    # [0. 0. 0.]
    print 'matrix has shape', matrix.get_shape(), 'and value:\n', matrix.eval()
    #[[0. 0. 0.]
    # [0. 0. 0.]]

广播

利用广播，元素级运算中的较小数组会增大到与较大数组具有相同的形状。

如果指令需要大小为 [6] 的张量，则大小为 [1] 或 [] 的张量可以作为运算数。
如果指令需要大小为 [4, 6] 的张量，则以下任何大小的张量都可以作为运算数。
- [1, 6]
- [6]
- []
如果指令需要大小为 [3, 5, 6] 的张量，则以下任何大小的张量都可以作为运算数。
- [1, 5, 6]
- [3, 1, 6]
- [3, 5, 1]
- [1, 1, 1]
- [5, 6]
- [1, 6]
- [6]
- [1]
- []

当张量被广播时，从概念上来说，系统会复制其条目（出于性能考虑，实际并不复制。广播专为实现性能优化而设计）。

with tf.Graph().as_default():
  # Create a six-element vector (1-D tensor).
  primes = tf.constant([2, 3, 5, 7, 11, 13], dtype=tf.int32)

  # Create a constant scalar with value 1.
  ones = tf.constant(1, dtype=tf.int32)

  # Add the two tensors. The resulting tensor is a six-element vector.
  just_beyond_primes = tf.add(primes, ones)

  with tf.Session() as sess:
    print just_beyond_primes.eval()

矩阵乘法

with tf.Graph().as_default():
  # Create a matrix (2-d tensor) with 3 rows and 4 columns.
  x = tf.constant([[5, 2, 4, 3], [5, 1, 6, -2], [-1, 3, -1, -2]],
                  dtype=tf.int32)

  # Create a matrix with 4 rows and 2 columns.
  y = tf.constant([[2, 2], [3, 5], [4, 5], [1, 6]], dtype=tf.int32)

  # Multiply `x` by `y`. 
  # The resulting matrix will have 3 rows and 2 columns.
  matrix_multiply_result = tf.matmul(x, y)

  with tf.Session() as sess:
    print matrix_multiply_result.eval()
    # [[35 58]
    #  [35 33]
    #  [ 1 -4]]

张量变形

with tf.Graph().as_default():
  # Create an 8x2 matrix (2-D tensor).
  matrix = tf.constant([[1,2], [3,4], [5,6], [7,8],
                        [9,10], [11,12], [13, 14], [15,16]], dtype=tf.int32)

  # Reshape the 8x2 matrix into a 2x8 matrix.
  reshaped_2x8_matrix = tf.reshape(matrix, (16,1))
  
  # Reshape the 8x2 matrix into a 4x4 matrix
  reshaped_4x4_matrix = tf.reshape(matrix, [4,4])

  with tf.Session() as sess:
    print "Original matrix (8x2):"
    print matrix.eval()
    print "Reshaped matrix (2x8):"
    print reshaped_2x8_matrix.eval()
    print "Reshaped matrix (4x4):"
    print reshaped_4x4_matrix.eval()

with tf.Graph().as_default():
  # Create an 8x2 matrix (2-D tensor).
  matrix = tf.constant([[1,2], [3,4], [5,6], [7,8],
                        [9,10], [11,12], [13, 14], [15,16]], dtype=tf.int32)

  # Reshape the 8x2 matrix into a 3-D 2x2x4 tensor.
  reshaped_2x2x4_tensor = tf.reshape(matrix, [2,2,4])
  
  # Reshape the 8x2 matrix into a 1-D 16-element tensor.
  one_dimensional_vector = tf.reshape(matrix, [16])

  with tf.Session() as sess:
    print "Original matrix (8x2):"
    print matrix.eval()
    print "Reshaped 3-D tensor (2x2x4):"
    print reshaped_2x2x4_tensor.eval()
    print "1-D vector:"
    print one_dimensional_vector.eval()

变量、初始化和赋值

创建变量时，可以明确设置一个初始值，也可以使用初始化程序（例如分布）:

g = tf.Graph()
with g.as_default():
  # Create a variable with the initial value 3.
  v = tf.Variable([3])

  # Create a variable of shape [1], with a random initial value,
  # sampled from a normal distribution with mean 1 and standard deviation 0.35.
  w = tf.Variable(tf.random_normal([1], mean=1.0, stddev=0.35))

TensorFlow 的一个特性是变量初始化不是自动进行的。例如，以下代码块会导致错误：

with g.as_default():
  with tf.Session() as sess:
    try:
      v.eval()
    except tf.errors.FailedPreconditionError as e:
      print "Caught expected error: ", e
      # Caught expected error:  Attempting to use uninitialized value Variable
	    #[[Node: _retval_Variable_0_0 = _Retval[T=DT_INT32, index=0, _device="/job:localhost/replica:0/task:0/device:CPU:0"](Variable)]]

最简单的方法，是调用global_variables_initializer，初始化后，变量的值保留在同一会话中（不过，当启动新会话时，需要重新初始化）

with g.as_default():
  with tf.Session() as sess:
    initialization = tf.global_variables_initializer()
    sess.run(initialization)
    # Now, variables can be accessed normally, and have values assigned to them.
    print v.eval()
    print w.eval()

要更改变量的值，使用assign指令。请注意，仅创建 assign 指令不会起到任何作用。和初始化一样，必须运行赋值指令才能更新变量值：

with g.as_default():
  with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    # This should print the variable's initial value.
    print v.eval()

    assignment = tf.assign(v, [7])
    # The variable has not been changed yet!
    print v.eval()

    # Execute the assignment op.
    sess.run(assignment)
    # Now the variable is updated.
    print v.eval()

练习：

创建一个骰子模拟，在模拟中生成一个 10x3 二维张量，其中：

列 1 和 2 均存储一个骰子的一次投掷值。
列 3 存储同一行中列 1 和 2 的值的总和。

例如，第一行中可能会包含以下值：

列 1 存储 4
列 2 存储 3
列 3 存储 7

with tf.Graph().as_default(), tf.Session() as sess:
  # Task 2: Simulate 10 throws of two dice. Store the results
  # in a 10x3 matrix.

  # We're going to place dice throws inside two separate
  # 10x1 matrices. We could have placed dice throws inside
  # a single 10x2 matrix, but adding different columns of
  # the same matrix is tricky. We also could have placed
  # dice throws inside two 1-D tensors (vectors); doing so
  # would require transposing the result.
  dice1 = tf.Variable(tf.random_uniform([10, 1],
                                        minval=1, maxval=7,
                                        dtype=tf.int32))
  dice2 = tf.Variable(tf.random_uniform([10, 1],
                                        minval=1, maxval=7,
                                        dtype=tf.int32))

  # We may add dice1 and dice2 since they share the same shape
  # and size.
  dice_sum = tf.add(dice1, dice2)

  # We've got three separate 10x1 matrices. To produce a single
  # 10x3 matrix, we'll concatenate them along dimension 1.
  resulting_matrix = tf.concat(
      values=[dice1, dice2, dice_sum], axis=1)

  # The variables haven't been initialized within the graph yet,
  # so let's remedy that.
  sess.run(tf.global_variables_initializer())

  print(resulting_matrix.eval())

pandas

pandas官网：http://pandas.pydata.org/pandas-docs/stable/index.html

基本概念

pandas 中的主要数据结构被实现为以下两类：

DataFrame，您可以将它想象成一个关系型数据表格，其中包含多个行和已命名的列。
Series，它是单一列。DataFrame 中包含一个或多个 Series，每个 Series 均有一个名称。

import pandas as pd

例如：

city_names = pd.Series(['San Francisco', 'San Jose', 'Sacramento'])
population = pd.Series([852469, 1015785, 485199])

pd.DataFrame({ 'City name': city_names, 'Population': population })

加载整个文件，并显示一些统计信息（如：count/mean/std/min/25%/50%/75%/max）：

california_housing_dataframe = pd.read_csv("https://storage.googleapis.com/mledu-datasets/california_housing_train.csv", sep=",")
california_housing_dataframe.describe()

显示前几条记录：

california_housing_dataframe.head()

绘制图表（某一列的值的分布）：

california_housing_dataframe.hist('housing_median_age')

访问数据

cities = pd.DataFrame({ 'City name': city_names, 'Population': population })
cities['City name'] # 直接访问某一列
cities['City name'][1] # 访问某一列的某一行
cities[0:2] # 整个表格的第0-1行的所有列的数据

pandas的索引和选择官方文档

操控数据

可以直接进行算术运算：

population / 1000.

也可以通过numpy的函数进行操作

import numpy as np
np.log(population)

也可以通过apply以及lambda进行操作：

population.apply(lambda val: val > 1000000)

dataframe的修改，可以直接操作：

cities['Area square miles'] = pd.Series([46.87, 176.53, 97.92])
cities['Population density'] = cities['Population'] / cities['Area square miles']

cities['Is wide and has saint name'] = (cities['Area square miles'] > 50) & cities['City name'].apply(lambda name: name.startswith('San'))

索引

Series 和 DataFrame 对象也定义了 index 属性，该属性会向每个 Series 项或 DataFrame 行赋一个标识符值。

默认情况下，在构造时，pandas 会赋可反映源数据顺序的索引值。索引值在创建后是稳定的；也就是说，它们不会因为数据重新排序而发生改变。

city_names.index # RangeIndex(start=0, stop=3, step=1)，city_names这一列有0,1,2总共3行
cities.index # RangeIndex(start=0, stop=3, step=1)，整个dataframe有0,1,2总共3行

调用 DataFrame.reindex 以手动重新排列各行的顺序。

cities.reindex([2, 0, 1])
#City name	Population	Area square miles	Population density	Is wide and has saint name
#2	Sacramento	485199	97.92	4955.055147	False
#0	San Francisco	852469	46.87	18187.945381	False
#1	San Jose	1015785	176.53	5754.177760	True

重建索引是一种随机排列 DataFrame 的绝佳方式。(参考https://blog.csdn.net/you_are_my_dream/article/details/70165384，np.random.permutation与np.random.shuffle有两处不同：如果传给permutation一个矩阵，它会返回一个洗牌后的矩阵副本；而shuffle只是对一个矩阵进行洗牌，无返回值。如果传入一个整数，它会返回一个洗牌后的arange。)

cities.reindex(np.random.permutation(cities.index))

注意：如果您的 reindex 输入数组包含原始 DataFrame 索引值中没有的值，reindex 会为此类“丢失的”索引添加新行，并在所有对应列中填充 NaN 值：

cities.reindex([0, 4, 5, 2])
#	City name	Population	Area square miles	Population density	Is wide and has saint name
#0	San Francisco	852469.0	46.87	18187.945381	False
#4	NaN	NaN	NaN	NaN	NaN
#5	NaN	NaN	NaN	NaN	NaN
#2	Sacramento	485199.0	97.92	4955.055147	False

线性回归

定义特征并配置特征列

在 TensorFlow 中，我们使用一种称为“特征列”的结构来表示特征的数据类型。特征列仅存储对特征数据的描述；不包含特征数据本身。

主要有两类数据：

分类数据：一种文字数据。
数值数据：一种数字（整数或浮点数）数据以及您希望视为数字的数据。有时您可能会希望将数值数据（例如邮政编码）视为分类数据。

# Define the input feature: total_rooms.
my_feature = california_housing_dataframe[["total_rooms"]]
​
# Configure a numeric feature column for total_rooms.
feature_columns = [tf.feature_column.numeric_column("total_rooms")]

定义目标:

targets = california_housing_dataframe["median_house_value"]

配置 LinearRegressor

使用```clip_gradients_by_norm``将梯度裁剪应用到我们的优化器。梯度裁剪可确保梯度大小在训练期间不会变得过大，梯度过大会导致梯度下降法失败。

# Use gradient descent as the optimizer for training the model.
my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.0000001)
my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)

# Configure the linear regression model with our feature columns and optimizer.
# Set a learning rate of 0.0000001 for Gradient Descent.
linear_regressor = tf.estimator.LinearRegressor(
    feature_columns=feature_columns,
    optimizer=my_optimizer
)

定义输入函数

将 Pandas 特征数据转换成 NumPy 数组字典，例如，本例中就是把pandas的一列”total_rooms”:[3.,20.,…,42.]变成一个字典{“total_rooms”:array([3.,20.,…42.])}

使用 TensorFlow Dataset API 根据我们的数据构建 Dataset 对象，并将数据拆分成大小为 batch_size 的多批数据，以按照指定周期数 (num_epochs) 进行重复。

如果 shuffle 设置为 True，则我们会对数据进行随机处理，以便数据在训练期间以随机方式传递到模型。buffer_size 参数会指定 shuffle 将从中随机抽样的数据集的大小(representing the number of elements from this dataset from which the new dataset will sample)。

def my_input_fn(features, targets, batch_size=1, shuffle=True, num_epochs=None):
    """Trains a linear regression model of one feature.
  
    Args:
      features: pandas DataFrame of features
      targets: pandas DataFrame of targets
      batch_size: Size of batches to be passed to the model
      shuffle: True or False. Whether to shuffle the data.
      num_epochs: Number of epochs for which data should be repeated. None = repeat indefinitely
    Returns:
      Tuple of (features, labels) for next data batch
    """
  
    # Convert pandas data into a dict of np arrays.
    features = {key:np.array(value) for key,value in dict(features).items()}                                           
 
    # Construct a dataset, and configure batching/repeating
    ds = Dataset.from_tensor_slices((features,targets)) # warning: 2GB limit
    ds = ds.batch(batch_size).repeat(num_epochs)
    
    # Shuffle the data, if specified
    if shuffle:
      ds = ds.shuffle(buffer_size=10000)
    
    # Return the next batch of data
    features, labels = ds.make_one_shot_iterator().get_next()
    return features, labels

训练模型

_ = linear_regressor.train(
    input_fn = lambda:my_input_fn(my_feature, targets),
    steps=100
)

评估模型

# Create an input function for predictions.
# Note: Since we're making just one prediction for each example, we don't 
# need to repeat or shuffle the data here.
prediction_input_fn =lambda: my_input_fn(my_feature, targets, num_epochs=1, shuffle=False)

# Call predict() on the linear_regressor to make predictions.
predictions = linear_regressor.predict(input_fn=prediction_input_fn)

# Format predictions as a NumPy array, so we can calculate error metrics.
predictions = np.array([item['predictions'][0] for item in predictions])

# Print Mean Squared Error and Root Mean Squared Error.
mean_squared_error = metrics.mean_squared_error(predictions, targets)
root_mean_squared_error = math.sqrt(mean_squared_error)
print "Mean Squared Error (on training data): %0.3f" % mean_squared_error
print "Root Mean Squared Error (on training data): %0.3f" % root_mean_squared_error

RMSE 的一个很好的特性是，它可以在与原目标相同的规模下解读。

min_house_value = california_housing_dataframe["median_house_value"].min()
max_house_value = california_housing_dataframe["median_house_value"].max()
min_max_difference = max_house_value - min_house_value

print "Min. Median House Value: %0.3f" % min_house_value
print "Max. Median House Value: %0.3f" % max_house_value
print "Difference between Min. and Max.: %0.3f" % min_max_difference
print "Root Mean Squared Error: %0.3f" % root_mean_squared_error

可以通过以下方法获得均匀分布的随机数据样本：

sample = california_housing_dataframe.sample(n=300)

重新训练

在 10 个等分的时间段内使用此函数，以便观察模型在每个时间段的改善情况。

对于每个时间段，我们都会计算训练损失并绘制相应图表。这可以帮助您判断模型收敛的时间，或者模型是否需要更多迭代。

此外，我们还会绘制模型随着时间的推移学习的特征权重和偏差项值的曲线图。您还可以通过这种方式查看模型的收敛效果。

def train_model(learning_rate, steps, batch_size, input_feature="total_rooms"):
  """Trains a linear regression model of one feature.
  
  Args:
    learning_rate: A `float`, the learning rate.
    steps: A non-zero `int`, the total number of training steps. A training step
      consists of a forward and backward pass using a single batch.
    batch_size: A non-zero `int`, the batch size.
    input_feature: A `string` specifying a column from `california_housing_dataframe`
      to use as input feature.
  """
  
  periods = 10
  steps_per_period = steps / periods

  my_feature = input_feature
  my_feature_data = california_housing_dataframe[[my_feature]]
  my_label = "median_house_value"
  targets = california_housing_dataframe[my_label]

  # Create feature columns
  feature_columns = [tf.feature_column.numeric_column(my_feature)]
  
  # Create input functions
  training_input_fn = lambda:my_input_fn(my_feature_data, targets, batch_size=batch_size)
  prediction_input_fn = lambda: my_input_fn(my_feature_data, targets, num_epochs=1, shuffle=False)
  
  # Create a linear regressor object.
  my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)
  my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)
  linear_regressor = tf.estimator.LinearRegressor(
      feature_columns=feature_columns,
      optimizer=my_optimizer
  )

  # Set up to plot the state of our model's line each period.
  plt.figure(figsize=(15, 6))
  plt.subplot(1, 2, 1)
  plt.title("Learned Line by Period")
  plt.ylabel(my_label)
  plt.xlabel(my_feature)
  sample = california_housing_dataframe.sample(n=300)
  plt.scatter(sample[my_feature], sample[my_label])
  colors = [cm.coolwarm(x) for x in np.linspace(-1, 1, periods)]

  # Train the model, but do so inside a loop so that we can periodically assess
  # loss metrics.
  print "Training model..."
  print "RMSE (on training data):"
  root_mean_squared_errors = []
  for period in range (0, periods):
    # Train the model, starting from the prior state.
    linear_regressor.train(
        input_fn=training_input_fn,
        steps=steps_per_period
    )
    # Take a break and compute predictions.
    predictions = linear_regressor.predict(input_fn=prediction_input_fn)
    predictions = np.array([item['predictions'][0] for item in predictions])
    
    # Compute loss.
    root_mean_squared_error = math.sqrt(
        metrics.mean_squared_error(predictions, targets))
    # Occasionally print the current loss.
    print "  period %02d : %0.2f" % (period, root_mean_squared_error)
    # Add the loss metrics from this period to our list.
    root_mean_squared_errors.append(root_mean_squared_error)
    # Finally, track the weights and biases over time.
    # Apply some math to ensure that the data and line are plotted neatly.
    y_extents = np.array([0, sample[my_label].max()])
    
    weight = linear_regressor.get_variable_value('linear/linear_model/%s/weights' % input_feature)[0]
    bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')

    x_extents = (y_extents - bias) / weight
    x_extents = np.maximum(np.minimum(x_extents,
                                      sample[my_feature].max()),
                           sample[my_feature].min())
    y_extents = weight * x_extents + bias
    plt.plot(x_extents, y_extents, color=colors[period]) 
  print "Model training finished."

  # Output a graph of loss metrics over periods.
  plt.subplot(1, 2, 2)
  plt.ylabel('RMSE')
  plt.xlabel('Periods')
  plt.title("Root Mean Squared Error vs. Periods")
  plt.tight_layout()
  plt.plot(root_mean_squared_errors)

  # Output a table with calibration data.
  calibration_data = pd.DataFrame()
  calibration_data["predictions"] = pd.Series(predictions)
  calibration_data["targets"] = pd.Series(targets)
  display.display(calibration_data.describe())

  print "Final RMSE (on training data): %0.2f" % root_mean_squared_error

train_model(
    learning_rate=0.00002,
    steps=500,
    batch_size=5
)

IndRNN

2018-03-21T00:00:00+00:00

简介

参考：学界 | 新型循环神经网络IndRNN：可构建更长更深的RNN（附GitHub实现）

代码：https://github.com/batzner/indrnn

简介

澳大利亚伍伦贡大学联合电子科技大学提出一种新型的循环神经网络IndRNN，不仅可以解决传统RNN所存在的梯度消失和梯度爆炸问题，还学习长期依赖关系；此外，借助relu等非饱和激活函数，训练之后IndRNN会变得非常鲁棒，并且通过堆叠多层IndRNN还可以构建比现有RNN更深的网络。实验结果表明，与传统的RNN和LSTM相比，使用IndRNN可以在各种任务中取得更好的结果。

deeplearning.ai笔记

2018-03-09T00:00:00+00:00

资料1
资料2：by mbadry1

资料1

参考这是一份优美的信息图，吴恩达点赞的deeplearning.ai课程总结

下载地址 https://daiwk.github.io/assets/deeplearning.ai-notes.pdf

资料2：by mbadry1

github地址：https://github.com/mbadry1/DeepLearning.ai-Summary

pdf打包下载地址(!!大赞!!)：

https://daiwk.github.io/assets/lecture_notes_dl.ai_by_mbadry1.tar.gz

机器学习速成课程

2018-03-01T00:00:00+00:00

参考学习了！谷歌今日上线基于TensorFlow的机器学习速成课程（中文版）

课程地址：https://developers.google.cn/machine-learning/crash-course/

机器学习从入门到放弃：机器学习- 从入门到放弃

百度云地址：https://pan.baidu.com/s/1tNXYQNadAsDGfPvuuj7_Tw

深入浅出强化学习-chap5 基于时间差分的强化学习方法

2018-02-19T00:00:00+00:00

1. 基于时间差分的强化学习方法
2. python和gym的实例

参考《深入浅出强化学习》

1. 基于时间差分的强化学习方法

sarsa和Qlearning的最大区别在于:

sarsa是用$\varepsilon -greedy$得到动作$a$回报$r$和下一个状态$s'$，并对$s'$也使用$\varepsilon -greedy$得到动作$a'$和状态行为值函数$Q(s',a')$，并计算TD目标$r+\gamma Q(s',a')$
Qlearning是用$\varepsilon -greedy$得到动作$a$回报$r$和下一个状态$s'$【这部分和sarsa一样】，然后计算TD目标$r+\gamma max_{a'}Q(s',a')$，可见这里不再是通过$\varepsilon-greedy$选出的$a'$来算的$Q(s',a')$，而是$max_{a'}Q(s',a')$，也就是强制选使Q最大的那个action带来的Q，而非随机策略。
注意，这里二者的$Q(s',a')$都是基于第一个$\varepsilon-greedy$得到的新状态$s'$来搞的。

2. python和gym的实例

https://github.com/daiwk/reinforcement-learning-code/blob/master/qlearning.py

代码如下：

import sys
import gym
import random
random.seed(0)
import time
import matplotlib.pyplot as plt

grid = gym.make('GridWorld-v0')
#grid=env.env                     #创建网格世界
states = grid.env.getStates()        #获得网格世界的状态空间
actions = grid.env.getAction()      #获得网格世界的动作空间
gamma = grid.env.getGamma()       #获得折扣因子
#计算当前策略和最优策略之间的差
best = dict() #储存最优行为值函数
def read_best():
    f = open("best_qfunc")
    for line in f:
        line = line.strip()
        if len(line) == 0: continue
        eles = line.split(":")
        best[eles[0]] = float(eles[1])
#计算值函数的误差
def compute_error(qfunc):
    sum1 = 0.0
    for key in qfunc:
        error = qfunc[key] -best[key]
        sum1 += error *error
    return sum1

#  贪婪策略
def greedy(qfunc, state):
    amax = 0
    key = "%d_%s" % (state, actions[0])
    qmax = qfunc[key]
    for i in range(len(actions)):  # 扫描动作空间得到最大动作值函数Q(s,a)
        key = "%d_%s" % (state, actions[i])
        q = qfunc[key]
        if qmax < q:
            qmax = q
            amax = i
    return actions[amax]


#######epsilon贪婪策略
def epsilon_greedy(qfunc, state, epsilon):
    amax = 0
    key = "%d_%s"%(state, actions[0])
    qmax = qfunc[key]
    for i in range(len(actions)):    #扫描动作空间得到最大动作值函数
        key = "%d_%s"%(state, actions[i])
        q = qfunc[key]
        if qmax < q:
            qmax = q
            amax = i
    #概率部分，除了max的为加上1-epsilon，其他的概率一样
    pro = [0.0 for i in range(len(actions))]
    pro[amax] += 1-epsilon
    for i in range(len(actions)):
        pro[i] += epsilon/len(actions)

    ##选择动作
    r = random.random()
    s = 0.0
    for i in range(len(actions)):
        s += pro[i]
        if s>= r: return actions[i]
    return actions[len(actions)-1]

def qlearning(num_iter1, alpha, epsilon):
    x = []
    y = []
    qfunc = dict()   #行为值函数为字典
    #初始化行为值函数为0
    for s in states:
        for a in actions:
            key = "%d_%s"%(s,a)
            qfunc[key] = 0.0
    for iter1 in range(num_iter1):
        x.append(iter1)
        y.append(compute_error(qfunc))

        #初始化初始状态
        s = grid.reset()
        a = actions[int(random.random()*len(actions))] # 应该改成epsilon-greedy?
        t = False
        count = 0
        while False == t and count <100:
            key = "%d_%s"%(s, a)
            #与环境进行一次交互，从环境中得到新的状态及回报
            s1, r, t1, i =grid.step(a)
            key1 = ""
            #s1处的最大动作
            a1 = greedy(qfunc, s1)
            key1 = "%d_%s"%(s1, a1) # 这个时候的qfunc[key1]就是max的
            #利用qlearning方法更新值函数，注意！！这里更新的是key，而不是key1
            qfunc[key] = qfunc[key] + alpha*(r + gamma * qfunc[key1]-qfunc[key])
            #转到下一个状态
            s = s1;
            a = epsilon_greedy(qfunc, s1, epsilon)
            count += 1
    plt.plot(x,y,"-.,",label ="q alpha=%2.1f epsilon=%2.1f"%(alpha,epsilon))
    return qfunc

主流程的代码在https://github.com/daiwk/reinforcement-learning-code/blob/master/learning_and_test.py中。

import sys
import gym
from qlearning import *
import time
from gym import wrappers
#main函数
if __name__ == "__main__":
   # grid = grid_mdp.Grid_Mdp()  # 创建网格世界
    #states = grid.getStates()  # 获得网格世界的状态空间
    #actions = grid.getAction()  # 获得网格世界的动作空间
    sleeptime=0.5
    terminate_states= grid.env.getTerminate_states()
    #读入最优值函数
    read_best()
#    plt.figure(figsize=(12,6))
    #训练
    qfunc = dict()
    qfunc = qlearning(num_iter1=500, alpha=0.2, epsilon=0.2)
    #画图
    plt.xlabel("number of iterations")
    plt.ylabel("square errors")
    plt.legend()
   # 显示误差图像
    plt.show()
    time.sleep(sleeptime)
    #学到的值函数
    for s in states:
        for a in actions:
            key = "%d_%s"%(s,a)
            print("the qfunc of key (%s) is %f" %(key, qfunc[key]) )
            qfunc[key]
    #学到的策略为：
    print("the learned policy is:")
    for i in range(len(states)):
        if states[i] in terminate_states:
            print("the state %d is terminate_states"%(states[i]))
        else:
            print("the policy of state %d is (%s)" % (states[i], greedy(qfunc, states[i])))
    # 设置系统初始状态
    s0 = 1
    grid.env.setAction(s0)
    # 对训练好的策略进行测试
    grid = wrappers.Monitor(grid, './robotfindgold', force=True)  # 记录回放动画
   #随机初始化，寻找金币的路径
    for i in range(20):
        #随机初始化
        s0 = grid.reset()
        grid.render()
        time.sleep(sleeptime)
        t = False
        count = 0
        #判断随机状态是否在终止状态中
        if s0 in terminate_states:
            print("reach the terminate state %d" % (s0))
        else:
            while False == t and count < 100:
                a1 = greedy(qfunc, s0)
                print(s0, a1)
                grid.render()
                time.sleep(sleeptime)
                key = "%d_%s" % (s0, a)
                # 与环境进行一次交互，从环境中得到新的状态及回报
                s1, r, t, i = grid.step(a1)
                if True == t:
                    #打印终止状态
                    print(s1)
                    grid.render()
                    time.sleep(sleeptime)
                    print("reach the terminate state %d" % (s1))
                # s1处的最大动作
                s0 = s1
                count += 1

深入浅出强化学习-chap3 基于模型的动态规划方法

2018-02-19T00:00:00+00:00

1. 基于模型的动态方法理论
2. 动态规划中的数学基础
- 2.1 线性方程组的迭代解法
- 2.2 压缩映射证明策略评估的收敛性
3. 基于gym的编程实例
4. 最优控制与强化学习比较

参考《深入浅出强化学习》

1. 基于模型的动态方法理论

一个完整的已知模型的马尔科夫决策过程可以用元组$S,A,P,r,\gamma$表示。$S$为状态集，$A$为动作集，$P$为转移概率【对应环境和智能体的模型】，$r$为回报函数，$\gamma$为折扣因子，用于计算累积回报$R=\sum_{t=0}^T\gamma ^tr_t$。若$T$为有限值，强化学习过程称为有限范围强化学习。若$T=\infty$，称为无限范围强化学习。下面以有限范围强化学习为例。

强化学习的目标是找到最优策略$\pi$，使得累积回报的期望最大。策略是状态到动作的映射$\pi:s\rightarrow a$，$\tau $表示从状态$s_t$到最终状态$s_T$的一个序列$\tau:s_t,s_{t+1},...,s_T$，目标函数是累积回报函数的期望$\int R(\tau)p_{\pi}(\tau)d\tau$。

所以强化学习的目标是：$\underset{\pi}{max}\int R(\tau)p_{\pi}(\tau)d\tau$，最终目标是找到最优策略$\pi ^*:s\rightarrow u^*$。这里的$u$指的是决策序列$u_0^*\rightarrow u_1^*\rightarrow ...u_T^*$，所以，广义上来讲，强化学习就是找到一个决策序列，使得目标函数最优。

强化学习的分类如下图所示：

根据转移概率$P$是否已知，可以分为基于模型的动态规划方法，和基于无模型的强化学习方法。

这两种方法都包括策略迭代算法、值迭代算法和策略搜索算法。而基于无模型的强化学习方法中，每类方法又分为online和offline。

1.1 动态规划

基于模型的强化学习可以用动态规划的思想来解决。“动态”，指序列和状态的变化;“规划”，指优化，如线性优化、二次优化或非线性优化。

利用动态规划可解决的问题需要满足两个条件：

整个优化问题可以分解为多个子优化问题。
子优化问题的解可以被存储和重复利用。

第二章说到，强化学习可以利用马尔科夫决策过程来描述，利用贝尔曼最优性原理得到贝尔曼最优化方程：

\[ \\\upsilon ^*(s)=\underset{a}{max}R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon ^*(s') \\q^*(s,a)=R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\underset{a}{max}q^*(s',a') \]

可见马尔科夫决策问题符合使用动态规划的两个条件，所以可以用动态规划来解决。

动态规划的核心是找到最优值函数。

由上一章可以得到如下状态值函数的计算方法：

\[ \upsilon_{\pi}(s)=\sum_{a\in A}\pi(a|s)(R^a_{s}+\gamma \sum_{s'\in S}P^a_{ss'}\upsilon_{\pi}(s')) \]

从上式中可见，状态s处的值函数$\upsilon_{\pi}(s)$可以用后继状态的值函数$\upsilon_{\pi}(s')$来表示，而后继状态的值函数是未知的，所以这就是bootstrap算法。

上式中，对于模型已知的强化学习算法，$P^a_{ss'}$、$\gamma$和$R^a_{s}$都是已知的，$\pi(a|s)$是要评估的策略，是指定的，也是已知的。所以未知数就是值函数，未知数的个数为状态的总数，用$|S|$表示。

下面介绍如何求解上述公式(其实就是关于值函数的线性方程组)

1.2 策略迭代算法

1.2.1 策略评估算法

使用高斯-赛德尔迭代算法：

\[ \upsilon_{k+1}(s)=\sum_{a\in A}\pi(a|s)(R^a_{s}+\gamma \sum_{s'\in S}P^a_{ss'}\upsilon _{k}(s')) \]

算法步骤如下：

输入：需要评估的策略$\pi$状态转移概率$P^a_{ss'}$回报函数$R^a_s$，折扣因子$\gamma$

初始化值函数：$\upsilon(s)=0$

repeat k=0,1,…

for s in S:

$\upsilon_{k+1}(s)=\sum _{a\in A}\pi(a|s)(R^a_{s}+\gamma \sum_{s'\in S}P^a_{ss'}\upsilon_k(s'))$

until $\upsilon_{k+1}=\upsilon_k$

输出：$\upsilon(s)$

注意：每次迭代都需要对状态集进行一次遍历，以评估每个状态的值函数。

1.2.2 贪婪策略

1.2.3 策略迭代算法

1.3 值函数迭代算法

输入：状态转移概率$P^a_{ss'}$，回报函数$R^a_{s}$，折扣因子$\gamma$，初始化值函数$\upsilon(s)=0$，初始化策略$\pi_0$

Repeat $l=0,1,...$

for every $s$ do

$\upsilon _{l+1}(s)=\underset{a}{max}R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon _l(s')$

Until $\upsilon _{l+1}=\upsilon _l$

输出：$\pi(s)=argmax_aR^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon _l(s')$

1.4 解决最优控制问题的三种算法

1.4.1 变分法原理

1.4.2 庞特里亚金最大值原理

1.4.3 动态规划方法

2. 动态规划中的数学基础

2.1 线性方程组的迭代解法

2.2 压缩映射证明策略评估的收敛性

3. 基于gym的编程实例

4. 最优控制与强化学习比较

TVM

2018-02-17T00:00:00+00:00

陈天奇等人提出TVM：深度学习自动优化代码生成器

陈天奇任CTO，TVM团队成立OctoML：让任何硬件都能部署机器学习模型

深入浅出强化学习-chap2 马尔科夫决策过程

2018-02-16T00:00:00+00:00

1. 马尔科夫决策过程理论
2. MDP中的概率学基础
- 2.1 期望与方差
  - 期望
  - 方差
- 2.2 随机策略
3. 基于gym的MDP实例

参考《深入浅出强化学习》

1. 马尔科夫决策过程理论

1.1 马尔科夫性

系统的下一个状态$s_{t+1}$仅与当前状态$s_t$有关，与之前的状态无关。

定义：状态$s_t$是马尔科夫的，当且仅当$P[s_{t+1}|s_t]=P[s_{t+1}|s_1,...,s_t]$。

随机过程就是随机变量序列。如果随机变量序列的每个状态都是马尔科夫的，那么此随机过程就是马尔科夫随机过程。

1.2 马尔科夫过程

马尔科夫过程是一个二元组$(S,P)$，且满足：$S$是有限状态集合，$P$是状态转移概率。状态转移概率矩阵如下：

\[ P=\begin{bmatrix} P_{11} & ... & P_{1n} \\ \vdots & \vdots & \vdots \\ P_{n1} & ... & P_{nn} \end{bmatrix} \]

由若干个状态组成的序列称为马尔科夫链。当给定状态转移概率时，从某个状态出发存在多条马尔科夫链。

1.3 马尔科夫决策过程

马尔科夫决策过程由元组$(S,A,P,R,\gamma)$描述，其中：

$S$为有限的状态集
$A$为有限的动作集
$P$为状态转移概率
$R$为回报函数
$\gamma$为折扣因子，用于计算累积回报

区别于马尔科夫过程，马尔科夫决策过程的态转移概率是包含动作的，即$P^a_{ss'}=P[S_{t+1}=s'|S_t=s,A_t=a]$。

强化学习的目标是给定一个马尔科夫决策过程，寻找最优策略。策略指的是，状态到动作的映射，用符号$\pi$表示，给定状态$s$时，动作集上的一个分布，即：

\[ \pi (a|s)=p[A_i=a|S_t=s] \]

含义是，策略$\pi$在每个状态$s$指定一个动作概率。如果给出的策略$\pi$是确定性的，那么策略$\pi$在每个状态$s$指定一个确定的动作。注，$\sum _{a\in A}\pi(s,a)=1$

概率在强化学习中的作用：

强化学习的策略往往是随机策略。可以将探索耦合到采样的过程中。探索，指机器人尝试其他动作以便找到更好的策略。
实际应用中，存在各种噪声，这些噪声大都服从正态分布，可以用概率的知识去掉噪声。

给定一个策略$\pi$时，可以计算累积回报：

\[ G_t=R_{t+1}+\gamma R_{t+2}+...=\sum _{k=0}^{\infty }\gamma ^kR_{i+k+1} \]

当给定策略$\pi$时，假设从状态$s_t$出发，可能有很多个状态序列，所以对应的$G_t$也有多个可能值。为了评价状态$s_t$的价值，需要一个确定的量来描述。而累积回报$G_t$是一个随机变量，不是确定值，但其期望是一个确定值，因此可以做为状态值函数的定义。

1.4 状态值函数与状态-行为值函数

当智能体采用策略$\pi$时，累积回报服从一个分布，累积回报在状态$s$处的期望值定义状态值函数：

\[ \upsilon _{\pi}(s)=E_{\pi}[\sum _{k=0}^{\infty }\gamma ^kR_{t+k+1}|S_t=s] \]

注：状态值函数是与策略$\pi$相对应的，因为策略$\pi$决定了累积回报$G$的状态分布。

状态-行为值函数为：

\[ q_{\pi}(s,a)=E_{\pi}[\sum _{k=0}^{\infty}\gamma ^kR_{t+k+1}|S_t=s,A_t=a] \]

1.5 状态值函数与状态-行为值函数的贝尔曼方程

贝尔曼方程（Bellman Equation）也被称作动态规划方程（Dynamic Programming Equation）。

状态值函数的贝尔曼方程：

\[ \begin{split} \\\upsilon(S_t)&=\upsilon(s)=E[G_t|S_t=s] \\&=E[R_{t+1}+\gamma R_{t+2}+...|S_t=s] \\&=E[R_{t+1}+\gamma (R_{t+2}+\gamma R_{t+3}+...)|S_t=s] \\&=E[R_{t+1}+\gamma G_{t+1}|S_t=s] \\&=E[R_{t+1}+\gamma \upsilon(S_{t+1})|S_t=s] \end{split} \]

最后一个等号的证明（书P23，有小改……）

\[ \begin{split} \\\upsilon(S_t)&=E_{S_t,S_{t+1},...}(R_{t+1}+\gamma G_{t+1}|S_t=s) \\&=E_{S_t}(R_{t+1})+\gamma E_{S_{t+1},...}(G_{t+1}) \\&=E_{S_t}(R_{t+1}+\gamma \upsilon(S_{t+1})) \\&=E(R_{t+1}+\gamma\upsilon(S_{t+1})) \end{split} \]

同理，状态-行为值函数的贝尔曼方程：

\[ q_{\pi}(s,a)=E_{\pi}[R_{t+1}+\gamma q(S_{t+1},A_{t+1})|S_t=s,A_t=a] \]

状态值函数与状态-行为值函数的关系：

\[ \upsilon_{\pi}(s)=\sum_{a\in A}\pi(a|s)q_{\pi}(s,a) \]

而(其中，$P^a_{ss'}$表示从状态$s$开始，采取行动$a$，移动到状态$s'$的概率)

\[ q_{\pi}(s,a)=R^a_{s}+\gamma \sum _{s'}P^a_{ss'}\upsilon _{\pi}(s') \]

因此，

\[ \upsilon_{\pi}(s)=\sum_{a\in A}\pi(a|s)(R^a_{s}+\gamma \sum_{s'\in S}P^a_{ss'}\upsilon_{\pi}(s')) \]

而

\[ \upsilon_{\pi}(s')=\sum _{a'\in A}\pi(a'|s')q_{\pi}(s',a') \]

所以，状态-行为值函数是：

\[ q_{\pi}(s,a)=R^a_{s}+\gamma \sum_{s'\in S}P^a_{ss'}\sum _{a'\in A}\pi(a'|s')q_{\pi}(s',a') \]

示例：

图中，空心圆圈中的数值为该状态下的值函数，实心圆圈表示状态-行为对。除了实心圆圈部分，其他状态转移$\pi(a|s)=0.5,\gamma =1$。$s_4$通过睡觉，可以到达$s_5$，而通过发表，可以到达$s_3$、$s_2$和$s_4$

\[ \begin{split} \\\upsilon (s_4)&=\pi(睡觉|s_4)R^{睡觉}_{s_4s_5}+\pi(发表|s_4)(R^{发表}_{s_4s_3}+\gamma (P^{发表}_{s_4s_2}\upsilon (s_2)+P^{发表}_{s_4s_3}\upsilon (s_3)+P^{发表}_{s_4s_4}\upsilon (s_4))) \\&=0.5*10+0.5*(1+1*(0.2*(-1.3)+0.4*2.7+0.4*7.4)) \\&=7.39 \end{split} \]

1.6 最优状态值函数与最优状态-行为值函数及其贝尔曼最优方程

每个策略对应一个状态值函数，最优策略对应着最优状态值函数。

定义：最优状态值函数$\upsilon ^*(s)$为在所有策略中值最大的值函数，即$\upsilon ^*(s)=\underset{\pi}{max}\upsilon_{\pi}(s)$。

最优状态-行为值函数$q^*(s,a)$为在所有策略中最大的状态-行为值函数，即$q^*(s,a)=\underset{\pi}{max}q_{\pi}(s,a)$。

从而，最优状态值函数的贝尔曼最优方程(与前面的$\upsilon _{\pi}(s)$的区别是，少乘了一个$\pi(a|s)$)：

\[ \upsilon ^*(s)=\underset{a}{max}R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\upsilon ^*(s') \]

最优状态-行为值函数的贝尔曼最优方程：

\[ q^*(s,a)=R^a_{s}+\gamma \sum _{s'\in S}P^a_{ss'}\underset{a'}{max}q^*(s',a') \]

若已各大最优状态-值函数，最优策略可以通过直接最大化$q^*(s,a)$来决定：

\[ \pi_*(a|s)=\left\{\begin{matrix} 1 &if\ a=\underset{a\in A}{argmax}q_*(s,a) \\ 0 & otherwise \end{matrix}\right. \]

1.7 强化学习形式化描述

定义一个离散时间有限范围的折扣马尔科夫决策过程$M=(S,A,P,r,\rho_0,\gamma,T)$，

$S$为状态集
$A$为动作集
$P:S\times A\times S\rightarrow R$为转移概率
$r:S\times A\rightarrow [-R_{max},R_{max}]$为立即回报函数
$\rho_0:S\rightarrow R$是初始状态分布
$\gamma \in [0,1]$是折扣因子
$T$为水平范围（即步数）

$\tau $为一个轨迹序列，$\tau =(s_0,a_0,s_1,a_1,...)$ $R=\sum _{t=0}^T\gamma ^tr_t$为累积回报。

强化学习的目标是找到最优策略$\pi$，使得该策略下的累积回报期望最大，即

\[ \underset{\pi}{max}\int R(\tau )p_{\pi}(\tau )d\tau \]

2. MDP中的概率学基础

2.1 期望与方差

期望

函数f(x)关于某分布P(x)的期望指，当x由分布P(x)产生，f作用于x时，f(x)的平均值。

离散型随机变量的期望：

\[ E_{x\sim P}[f(x)]=\sum _xP(x)f(x) \]

连续型随机变量的期望通过积分求得：

\[ E_{x\sim P}[f(x)]=\int p(x)f(x)dx \]

期望的运算是线性的：

\[ E_x(\alpha f(x)+\beta g(x))=\alpha E_x[f(x)]+\beta E_x[g(x)] \]

方差

方差衡量利用当前概率分布采样时，采样值差异的大小：

\[ Var(f(x))=E[(f(x)-E[f(x)])^2] \]

方差越小，不确定性越小。

2.2 随机策略

2.2.1 贪婪策略

\[ \pi_*(a|s)=\left\{\begin{matrix} 1 &if\ a=\underset{a\in A}{argmax}q_*(s,a) \\ 0 & otherwise \end{matrix}\right. \]

贪婪策略是一个确定性策略，只有动作值函数$q^*(s,a)$最大的动作时取概率1

2.2.2 `$\varepsilon -greedy$`策略

\[ \pi (a|s)=\left\{\begin{matrix} 1-\varepsilon + \frac{\varepsilon}{|A(s)|} &if\ a=\underset{a\in A}{argmax}q_*(s,a) \\ \frac{\varepsilon}{|A(s)|} & otherwise \end{matrix}\right. \] $\varepsilon -greedy$策略是强化学习最基本最常用的随机策略。该策略平衡了e&e，也就是利用(exploitation)和探索(exploration)，其中选取动作值函数最大的部分为利用，其他非最优动作仍然有概率的部分为探索部分。

也就是说，所有的$\pi(a|s)$都初始化为$\frac{\varepsilon}{|A(s)|}$，而如果正好这个a能取到$max_aQ(s,a)$，那么给他加上$(1-\varepsilon)$

2.2.3 高斯策略

一般的高斯策略都可以写成

\[ \pi_{\theta}=\mu_{\theta}+\varepsilon,\varepsilon \sim N(0,\sigma ^2) \]

其中$\mu_{\theta}$为确定性部分，$\varepsilon$为零均值的高斯随机噪声。这种策略也平衡了利用与探索，利用由确定性部分完成，探索由$\varepsilon$完成。

2.2.4 玻尔兹曼分布

对于动作空间是离散的，或者动作空间并不大的情况，可以采用玻尔兹曼分布(吉布斯分布)作为随机策略，即：

\[ \pi(a|s,\theta)=\frac{exp(Q(s,a,\theta))}{\sum_bexp(h(s,b,\theta))} \]

其中，$Q(s,a,\theta)$是动作值函数。动作值函数大的动作被选中的概率大，小的动作被选中的概率小。

类似softmax，可以参考多类分类下为什么用softmax而不是用其他归一化方法?。

3. 基于gym的MDP实例

详见书p29

https://github.com/daiwk/reinforcement-learning-code/blob/master/grid_mdp.py

Wasserstein自编码器

2018-02-16T00:00:00+00:00

ICLR 2018 | 谷歌大脑Wasserstein自编码器：新一代生成模型算法

变分自编码器（VAE）与生成对抗网络（GAN）是复杂分布上无监督学习主流的两类方法。近日，谷歌大脑 Ilya Tolstikhin 等人提出了又一种新思路：Wasserstein 自编码器，其不仅具有 VAE 的一些优点，更结合了 GAN 结构的特性，可以实现更好的性能。该研究的论文《Wasserstein Auto-Encoders》已被即将在 4 月 30 日于温哥华举行的 ICLR 2018 大会接收。

Zero to Hero：2017年机器之心AI高分概述文章全集

2018-02-16T00:00:00+00:00

Zero to Hero：2017年机器之心AI高分概述文章全集

深入浅出强化学习-chap1 绪论

2018-02-13T00:00:00+00:00

1. 强化学习可以解决什么问题
2. 强化学习如何解决问题
3. 强化学习算法分类及发展趋势
4. gym
5. 整体脉络

参考《深入浅出强化学习》

1. 强化学习可以解决什么问题

强化学习解决的是智能决策（即序贯决策）问题，也就是说需要连续不断地做出决策，才能实现最终目标。

2. 强化学习如何解决问题

监督学习解决的是智能感知的问题，学习的是输入长得像什么（特征），以及和它对应的是什么（标签）。需要的是多样化的标签数据。

强化学习不关心输入长什么样，只关心当前输入下应该采取什么动作，才能实现最终目标。需要智能体不断地与环境交互，不断尝试。需要的是带有回报的交互数据。

几个关键时间点：

1998年，Richard S. Sutton出版了《强化学习导论》第一版，总结了1998年以前强化学习的各种进展。关注和发展最多的是表格型强化学习算法。基于直接策略搜索的方法也被提出来了，例如1992年的Rinforce算法，直接对策略梯度进行估计。
2013年，deepmind提出了DQN(deep Q network)，将深度学习与强化学习结合形成深度强化学习。
2016、2017年，alphago连续两年击败围棋世界冠军。

3. 强化学习算法分类及发展趋势

根据强化学习是否依赖模型：

基于模型的强化学习：利用与环境交互得到的数据学习系统或者环境模型，再基于模型进行序贯决策。效率会比无模型的高
无模型的强化学习：直接利用与环境交互获得的数据改善自身的行为。有些根本无法建模的任务，只能利用无模型的强化学习算法，也更具有通用性。

根据策略的更新和学习方法：

基于值函数的强化学习：学习值函数，最终的策略根据值函数贪婪得到。任意状态下，值函数最大的动作就是当前最优策略。
基于直接策略搜索的强化学习：将策略参数化，学习实现目标的最优参数。
基于AC的方法：联合使用值函数和直接策略搜索。

根据环境返回的回报函数是否已知：

正向强化学习：回报函数是人为指定的
逆向强化学习：通过机器学习的方法由函数自己学出回报，因为很多时候回报无法人为指定，例如无人机的表演

其他强化学习：分层强化学习、元强化学习、多智能体强化学习、关系强化学习、迁移强化学习等。

强化学习的发展趋势：

强化学习和深度学习的结合会更加紧密

机器学习算法分为三大类：监督学习、无监督学习、强化学习。三类算法联合使用的效果更好，例如基于深度强化学习的对话生成等。

强化学习和专业知识的结合会更加紧密

对于不同领域，可以重塑回报函数，或者修改网络结构。代表作：NIPS2016的最佳论文：值迭代网络【Value Iteration Networks，github代码：https://github.com/TheAbhiKumar/tensorflow-value-iteration-networks】。

强化学习算法理论分析会更强，算法会更稳定和高效

代表作有：基于深度能量的策略方法、值函数与策略方法的等价性等。

强化学习与脑科学、认知神经科学、记忆的联系会更紧密

DeepMind和伦敦大学学院是这一流派的代表。

4. gym

以CartPoleEnv为例：

env = gym.make('CartPole-v0')
env.reset()
env.render()

CartPoleEnv的环境文件位于/gym/gym/envs/classic_control/cartpole.py 注册的代码在/gym/gym/envs/__init__.py中

reset()函数

智能体需要一次次尝试病积累经验，然后从经验中学到好的动作。每一次尝试称为一条轨迹，或者一个episode。每次尝试都需要达到终止状态，一次尝试结束后，就需要智能体重新初始化。

reset()是重新初始化函数。实现如下：

    def reset(self):
        self.state = self.np_random.uniform(low=-0.05, high=0.05, size=(4,))
        self.steps_beyond_done = None
        return np.array(self.state)

即，利用均匀随机分布初始化环境状态，然后设置当前步数为None，病返回环境的初始化状态。

render()函数

render()扮演图像引擎的角色。为了便于直观显示环境中物理的状态，需要除了物理引擎之外的图像引擎。源码如下:

注释参考：https://github.com/daiwk/reinforcement-learning-code/blob/master/cartpole_notes.py

        if self.viewer is None:
            from gym.envs.classic_control import rendering
            self.viewer = rendering.Viewer(screen_width, screen_height)
            # 创建台车
            l,r,t,b = -cartwidth/2, cartwidth/2, cartheight/2, -cartheight/2
            axleoffset =cartheight/4.0
            cart = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)]) ## 填充一个矩形
            #添加台车转换矩阵属性
            self.carttrans = rendering.Transform()
            cart.add_attr(self.carttrans)
            #加入几何体台车
            self.viewer.add_geom(cart)
            #创建摆杆
            l,r,t,b = -polewidth/2,polewidth/2,polelen-polewidth/2,-polewidth/2
            pole = rendering.FilledPolygon([(l,b), (l,t), (r,t), (r,b)])
            pole.set_color(.8,.6,.4)
            #添加摆杆转换矩阵属性
            self.poletrans = rendering.Transform(translation=(0, axleoffset))
            pole.add_attr(self.poletrans)
            pole.add_attr(self.carttrans)
            #加入几何体
            self.viewer.add_geom(pole)
            #创建摆杆和台车之间的连接
            self.axle = rendering.make_circle(polewidth/2)
            self.axle.add_attr(self.poletrans)
            self.axle.add_attr(self.carttrans)
            self.axle.set_color(.5,.5,.8)
            self.viewer.add_geom(self.axle)
            #创建台车来回滑动的轨道，即一条直线
            self.track = rendering.Line((0,carty), (screen_width,carty))
            self.track.set_color(0,0,0)
            self.viewer.add_geom(self.track)

        if self.state is None: return None

        x = self.state
        cartx = x[0]*scale+screen_width/2.0 # MIDDLE OF CART
        #设置平移属性
        self.carttrans.set_translation(cartx, carty)
        self.poletrans.set_rotation(-x[2])

        return self.viewer.render(return_rgb_array = mode=='rgb_array')

创建完cart的形状，给cart添加平移属性和旋转属性，将车的位移设置到cart的平移属性中，cart就会根据系统的状态变化左右移动。

step()函数

step()函数扮演物理引擎的角色。

输入：动作a
输出：下一步的状态、立即回报、是否终止、调试项。调试信息可能为空，但要填默认值{}。

描述了智能体与环境交互的所有信息。利用智能体的运动学模型和动力学模型计算下一步的状态和立即回报，并判断是否达到终止状态。

    def step(self, action):
        assert self.action_space.contains(action), "%r (%s) invalid"%(action, type(action))
        state = self.state
        x, x_dot, theta, theta_dot = state # 系统的当前状态
        force = self.force_mag if action==1 else -self.force_mag # 输入动作，即作用到车上的力
        costheta = math.cos(theta) # cos
        sintheta = math.sin(theta) # sin
        # 车摆的动力学方程式，即加速度与动作之间的关系
        temp = (force + self.polemass_length * theta_dot * theta_dot * sintheta) / self.total_mass
        thetaacc = (self.gravity * sintheta - costheta* temp) / (self.length * (4.0/3.0 - self.masspole * costheta * costheta / self.total_mass)) # 摆的角加速度
        xacc  = temp - self.polemass_length * thetaacc * costheta / self.total_mass # 小车的平移加速度
        x  = x + self.tau * x_dot
        x_dot = x_dot + self.tau * xacc
        theta = theta + self.tau * theta_dot
        theta_dot = theta_dot + self.tau * thetaacc # 积分球下一步的状态
        self.state = (x,x_dot,theta,theta_dot)
        done =  x < -self.x_threshold \
                or x > self.x_threshold \
                or theta < -self.theta_threshold_radians \
                or theta > self.theta_threshold_radians
        done = bool(done)

        if not done:
            reward = 1.0
        elif self.steps_beyond_done is None:
            # Pole just fell!
            self.steps_beyond_done = 0
            reward = 1.0
        else:
            if self.steps_beyond_done == 0:
                logger.warn("You are calling 'step()' even though this environment has already returned done = True. You should always call 'reset()' once you receive 'done = True' -- any further steps are undefined behavior.")
            self.steps_beyond_done += 1
            reward = 0.0

        return np.array(self.state), reward, done, {}

5. 整体脉络

强化学习的基本算法

第一部分强化学习基础

chap2 马尔科夫决策过程

强化学习解决的是序贯决策问题，一般的序贯决策问题可以用马尔科夫决策过程（MDP）的框架来表示。

chap3 基于动态规划的强化学习算法

对于模型已知的MDP问题，动态规划是一个不错的解。由此引出广义策略迭代的方法。而广义策略迭代的方法也适用于无模型的方法，是基于值函数强化学习的基本框架。因此有chap4的基于蒙特卡罗方法、chap5的基于时间查分方法、chap6的基于值函数逼近方法。

第二部分基于值函数的强化学习方法

chap4 基于蒙特卡罗的强化学习算法

无模型的强化学习算法，是整个强化学习算法的核心。基于值函数的强化学习算法的核心是计算值函数的期望。值函数是一个随机变量，其期望的计算可以通过蒙特卡罗方法得到。

chap5 基于时间差分的强化学习算法

基于蒙特卡罗的强化学习算法通过蒙特卡罗模拟计算期望，需要等每次试验结束后再对值函数进行估计，收敛速度漫。而时间差分的方法只需要一步便更新，效率高、收敛速度快。

chap6 基于值函数逼近的强化学习算法

chap4和chap5介绍的是表格型强化学习，即，状态空间和动作空间都是有限集，动作值函数可以用一个表格来描述，表格的索引分别为状态量和动作量。但当状态空间和动作空间都很大时，甚至两个空间都是连续空间时，这就无法用表格表示，可以用函数逼近理论对值函数进行逼近。本章介绍了DQN及其变种（Double DQN、Prioritized Replay DQN、Dueling DQN等）。

第三部分基于直接策略搜索的强化学习方法

chap7 策略梯度理论

区别于基于值函数的方法，强化学习的第二大类算法是直接策略搜索方法。就是将策略进行参数化，然后在参数空间直接搜索最优策略。直接策略搜索方法中，最直接最简单的方法是策略梯度方法。

chap8 TRPO

基于策略梯度方法最具挑战性的是更新步长的确定。TRPO方法通过理论分析得到单调非递减的策略更新方法.

chap9 确定性策略搜索

当动作空间维数很高时，智能体的探索效率会很低，利用确定性策略可以免除对动作空间的探索，提升算法的收敛速度。

chap10 引导策略搜索的强化学习算法

chap7（策略梯度）\8（TRPO）\9（确定性策略搜索）章讲的是无模型的直接策略搜索方法。而对于机器人等复杂系统，无模型的方法随机初始化很难找到成功的解，所以算法很难收敛。此时，可以利用传统控制器来引导策略进行搜索。

第四部分强化学习研究及前沿

chap11 逆向强化学习算法

很多实际问题，往往不知道回报函数，所以可以通过逆向强化学习来学习回报函数。

chap12 组合策略梯度和值函数方法

将策略梯度方法和值函数方法相组合。

chap13 值迭代网络

先介绍DQN，然后介绍值迭代网络。

chap14 PILCO方法及其扩展

PLICO(probalistic inference for learning control)是一种基于模型的强化学习算法，将模型误差纳入考虑范围内，一般只需要训练几次到几十次就可以成功实现对单摆等典型非线性系统的稳定性控制，而基于无模型的强化学习则需要训练上万次。

强化学习算法所用到的基础知识

第2章：概率学基础、随机策略。
第3章：模型已知时，值函数的求解可转化为线性方程组的求解。线性方程组的数值求解方法——高斯·赛尔德迭代法，并利用时变与泛函分析中的压缩映射证明了算法的收敛性。
第4章：值函数是累积回报的期望。统计学中利用采样数据可以用来计算期望：重要性采样、拒绝性采样、MCMC方法。
第8章：TRPO中，替代目标函数用了信息论的熵和相对熵的概念，同时TRPO的求解需要用到各种优化算法。
第10章：引导策略搜索强化学习的优化目标用到了KL散度和变分推理，及大型的并行优化算法，例如，LBFGS优化算法、ADMM方法（交替方向乘子法）

阿里巴巴的强化学习应用

2018-02-06T00:00:00+00:00

参考原文链接

转储

tensorflow项目架构模板+常用代码集

2018-02-06T00:00:00+00:00

tensorflow项目架构模板
tensorflow常用代码集
oo的dl代码
awesome tensorflow

tensorflow项目架构模板

参考快速开启你的第一个项目：TensorFlow项目架构模板

项目代码： https://github.com/Mrgemy95/Tensorflow-Project-Template

tensorflow常用代码集

参考https://github.com/taki0112/Tensorflow-Cookbook

oo的dl代码

编程进阶之路：用简单的面向对象编程提升深度学习原型

awesome tensorflow

https://github.com/jtoy/awesome-tensorflow

nested lstm

2018-02-04T00:00:00+00:00

参考学界 | Nested LSTM：一种能处理更长期信息的新型LSTM扩展

论文地址：

Nested LSTMs

虽然在层级记忆上已有一些研究，LSTM 及其变体仍旧是处理时序任务最流行的深度学习模型，例如字符级的语言建模。特别是默认的堆栈 LSTM 架构使用一系列 LSTM 一层层地堆叠在一起来处理数据，一层的输出成为下一层的输入。在此论文中，研究者们提出并探索了一种全新的嵌套 LSTM 架构（Nested LSTM，NLSTM)，并认为其有潜力直接取代堆栈 LSTM。

在 NLSTM 中，LSTM 的记忆单元可以访问内部记忆，使用标准的 LSTM 门选择性地进行读取、编写。相比于传统的堆栈 LSTM，这一关键特征使得模型能实现更有效的时间层级。在 NLSTM 中，(外部）记忆单元可自由选择读取、编写的相关长期信息到内部单元。相比之下，在堆栈 LSTM 中，高层级的激活（类似内部记忆）直接生成输出，因此必须包含所有的与当前预测相关的短期信息。换言之，堆栈 LSTM 与嵌套 LSTM 之间的主要不同是，NLSTM 可以选择性地访问内部记忆。这使得内部记忆可以免于记住、处理更长时间规模上的事件，即使这些事件与当前事件不相关。

在此论文中，作者们的可视化图证明了，相比于堆栈 LSTM 中的高层级记忆，NLSTM 的内部记忆确实能在更长的时间规模上操作。实验也表明，NLSTM 在多种任务上都超越了堆栈 LSTM。

直观上，LSTM 中的输出门会编码仍旧值得记忆的信息，这些记忆可能与当前的时间步并不相关。嵌套 LSTM 根据这一直观理解来创造一种记忆的时间层级。访问内部记忆以同样的方式被门控，以便于长期信息只有在情景相关的条件下才能选择性地访问。

计算(outer)memory cell不是$c_t^{outer}=f_t\odot c_{t-1}+i_t\odot g_t$，而是将concatenation $(f_t\odot c_{t-1}, i_t\odot g_t)$作为inner lstm(NLSTM)的memory cell的输入，并指定$c^{outer}_t=h^{inner}_t$。

对抗样本防御

2018-02-03T00:00:00+00:00

参考搞事！ICLR 2018七篇对抗样本防御论文被新研究攻破，Goodfellow论战

capsule

2018-02-02T00:00:00+00:00

1. cnn-challenges
2. equivariance
3. capsule
4. dynamic-routing
- 4.1 intuition
- 4.2 calculating-a-capsule-output
5. iterative-dynamic-routing
6. max-pooling-shortcoming
7. significant-of-routing-by-agreement-with-capsules
8. capsnet-architecture
9. loss-function-margin-loss
10. capsnet-model
11. what-capsule-is-learning
12. sarasra的代码
13. 源码解析

代码： https://github.com/Sarasra/models/tree/master/research/capsules

paper: Dynamic Routing Between Capsules

参考 Hinton胶囊网络代码正式开源，5天GitHub fork超1.4万

本文主要参考jhui的博客： https://jhui.github.io/2017/11/03/Dynamic-Routing-Between-Capsules/

1. cnn-challenges

神经元的激活水平通常被解释为检测特定特征的可能性【例如，如果图中蓝色的比例很高，可能某个神经元的激活值就特别大】。

CNN善于检测特征，却在探索特征（视角，大小，方位）之间的空间关系方面效果较差。(一个简单的CNN模型可以正确提取鼻子、眼睛和嘴巴的特征，但如果一张图里，鼻子和眼睛错位了，或者一只眼睛倾斜了一定的角度，那这张图仍然有可能错误地激活神经元导致认为这张图就是人脸)

假设每个神经元都包含特征的可能性和属性【这里就叫做胶囊(capsule)了，也就是说，里面包含的不是一个值(a single scaler value)，而是一个向量(vector)】。例如，神经元输出的是一个包含[可能性，方向，大小]的向量。利用这种空间信息，就可以检测鼻子、眼睛和耳朵特征之间的方向和大小的一致性。此时，上面那张图对于人脸检测的激活输出就会低很多。

2. equivariance

为了CNN能够处理不同的视角或变体，我们添加了更多的神经元和层。尽管如此，这种方法倾向于记忆数据集，而不是得出一个比较通用的解决方案，它需要大量的训练数据来覆盖不同的变体，并避免过拟合。MNIST数据集包含55,000个训练数据，也即每个数字都有5,500个样本。但是，儿童看过几次就能记住数字。现有的包括CNN在内的深度学习模式在利用数据方面效率十分低下。

胶囊网络不是训练来捕捉特定变体的特征，而是捕捉特征及其变体的可能性。所以胶囊的目的不仅在于检测特征，还在于训练模型来学习变体。

这样，相同的胶囊就可以检测不同方向的同一个物体类别。

Invariance对应特征检测，特征是不变的。例如，检测鼻子的神经元不管什么方向，都检测鼻子。但是，神经元空间定向的损失最终会损害这种invariance模型的有效性。
Equivariance对应变体检测，也即可以相互转换的对象（例如检测不同方向的人脸）。直观地说，胶囊网络检测到脸部旋转了20°，而不是实现与旋转了20°的变体相匹配的脸。通过强制模型学习胶囊中的特征变体，我们可以用较少的训练数据，更有效地推断可能的变体。此外，也可以更有效地防止对抗攻击。

3. capsule

胶囊是一组神经元，不仅捕捉特征的可能性，还捕捉具体特征的参数。

第一行表示神经元检测到数字“7”的概率。2-D胶囊是组合了2个神经元的网络。这个胶囊在检测数字“7”时输出2-D向量。

第二行中的第一个图像，它输出一个向量$v = (0, 0.9)$，向量的模是$\| v \| = \sqrt{ 0^2 + 0.9^2 } = 0.9$。

在第三行，旋转图像20°。胶囊将产生具有相同幅度但不同方向的矢量。这里，矢量的角度表示数字“7”的旋转角度。

最后，还可以添加2个神经元来捕捉大小和笔画的宽度(如下图)。

我们称胶囊的输出向量为活动向量(activity vector) ，其幅度(模)代表检测特征的概率，其方向代表其参数（属性）。

4. dynamic-routing

4.1 intuition

假设有3张类似但大小、方向不同的人脸图，嘴巴和眼睛的capsule分别记录了嘴巴和眼睛的水平方向的宽度（当然，也可以加上别的，例如高度、颜色等）。在dynamic routing中，将input capsules的vectors通过一个变换矩阵（transformation matrix）转换成一个vote，并且将相似vote的capsules分为同一组。这些votes最终成为parent capsule的output vector。

4.2 calculating-a-capsule-output

对于capsule网络，一个capsule的输入$u_i$和$v_j$都是向量。

我们将一个变换矩阵（transformation matrix）$W_{ij}$应用到前一层的输出$u_i$上，例如，使用一个$m\times k$的矩阵，将$k\times D$的$u_i$变成一个$m\times D$的$\hat u_{j|i}$。

然后计算$c_{ij}$和$\hat u_{j|i}$的加权和，得到$s_j$：

\[ \\ \hat u_{j|i}=W_{ij}u_i \\ s_j=\sum_i c_{ij}\hat u_{j|i} \]

其中，$c_{ij}$是迭代动态路由过程（iterative dynamic routing process）训练的耦合系数（coupling coefficients），而且$\sum_jc_{ij}=1$。

这里不适用ReLU，而使用一个挤压函数（squashing function），来缩短0和单位长度之间的向量：

\[ v_j=\frac{||s_j||^2}{1+||s_j||^2}\frac{s_j}{||s_j||} \]

挤压函数能够将短向量缩小到接近0，将长向量缩小为接近单位向量。因此，每个capsule的似然性在0到1之间。

\[ \\ v_j\approx ||s_j||s_j,\ for\ s_j\ is\ short \\ v_j\approx \frac{s_j}{||s_j||},\ for\ s_j\ is\ long \]

5. iterative-dynamic-routing

在深度学习中，我们使用反向传播来训练模型参数。转换矩阵$W_{ij}$在胶囊中仍然用反向传播训练。不过，耦合系数$c_{ij}$ 用新的迭代动态路由方法进行计算。

伪代码如下：

在深度学习中，我们使用反向传播来训练基于成本函数的模型参数。这些参数（权重）控制信号从一层到另一层的路由。如果两个神经元之间的权重为零，则神经元的激活不会传播到该神经元。

迭代动态路由提供了如何根据特征参数来路由信号的替代方案。通过利用特征参数，理论上，可以更好地将胶囊分组，形成一个高层次的结构。例如，胶囊层可能最终表现为探索“部分-整体”关系的分析树。例如，脸部由眼睛、鼻子和嘴组成。迭代动态路由利用变换矩阵、可能性和特征的性质，控制向上传播到上面胶囊的信号的多少。

6. max-pooling-shortcoming

7. significant-of-routing-by-agreement-with-capsules

8. capsnet-architecture

使用CapsNet进行mnist任务

每一层的说明(capsule层使用convolution kernel来explore locality information)：

Layer Name	Apply	Output shape
Image	Raw image array	28x28x1
ReLU Conv1	Convolution layer with 9x9 kernels output 256 channels, stride 1, no padding with ReLU	20x20x256
PrimaryCapsules	Convolution capsule layer with 9x9 kernel output 32x6x6 8-D capsule, stride 2, no padding	6x6x32x8
DigiCaps	Capsule output computed from a (16x8 matrix) between and ( from 1 to 32x6x6 and from 1 to 10).	10x16
FC1	Fully connected with ReLU	512
FC2	Fully connected with ReLU	1024
Output image	Fully connected with sigmoid	784(28x28)

9. loss-function-margin-loss

10. capsnet-model

10.1 primarycapsules

10.2 squash-function

10.3 digicaps-with-dynamic-routing

10.4 image-reconstruction

10.5 reconstruction-loss

11. what-capsule-is-learning

12. sarasra的代码

要求：tf/numpy/gpu

测试：

python layers_test.py

12.1 Quick mnist test results：

下载tfrecords，并解压到$DATA_DIR/

wget https://storage.googleapis.com/capsule_toronto/mnist_data.tar.gz

下载model checkpoint，并解压到$CKPT_DIR

wget https://storage.googleapis.com/capsule_toronto/mnist_checkpoints.tar.gz

测试

python experiment.py --data_dir=$DATA_DIR/mnist_data/ --train=false \
--summary_dir=/tmp/ --checkpoint=$CKPT_DIR/mnist_checkpoint/model.ckpt-1

12.2 Quick CIFAR10 ensemble test results

下载cifar10 binary version，并解压到$DATA_DIR/

wget  https://www.cs.toronto.edu/~kriz/cifar.html

下载cifar10 model checkpoints，并解压到$CKPT_DIR

wget https://storage.googleapis.com/capsule_toronto/cifar_checkpoints.tar.gz

测试

python experiment.py --data_dir=$DATA_DIR --train=false --dataset=cifar10 \
--hparams_override=num_prime_capsules=64,padding=SAME,leaky=true,remake=false \
--summary_dir=/tmp/ --checkpoint=$CKPT_DIR/cifar/cifar{}/model.ckpt-600000 \
--num_trials=7

12.3 训练

mnist

python experiment.py --data_dir=$DATA_DIR --dataset=cifar10 --max_steps=600000\
--hparams_override=num_prime_capsules=64,padding=SAME,leaky=true,remake=false \
--summary_dir=/tmp/

mnist baseline

python experiment.py --data_dir=$DATA_DIR/mnist_data/ --max_steps=300000\
--summary_dir=/tmp/attempt1/ --model=baseline

cifar

python experiment.py --ata_dir=$DATA_DIR/mnist_data/ --max_steps=300000\
--summary_dir=/tmp/attempt0/

12.4 训练+验证

训练时在验证集上验证：

--validate=true
需要两个gpu：一个训练；一个验证
如果两个job都在同一台机器，需要限制每个job的RAM大小，因为 TensorFlow will fill all your RAM for the session of your first job and your second job will fail

python experiment.py --data_dir=$DATA_DIR/mnist_data/ --max_steps=300000\
--summary_dir=/tmp/attempt0/ --train=false --validate=true

测试/训练 MultiMNIST:

--num_targets=2
--data_dir=$DATA_DIR/multitest_6shifted_mnist.tfrecords@10

生成multiMNIST/MNIST records的代码：

input_data/mnist/mnist_shift.py

generate multiMNIST test split的代码：

python mnist_shift.py --data_dir=$DATA_DIR/mnist_data/ --split=test --shift=6 
--pad=4 --num_pairs=1000 --max_shard=100000 --multi_targets=true

build expanded_mnist for affNIST generalizability：

--shift=6 --pad=6

13. 源码解析

参考Capsule官方代码开源之后，机器之心做了份核心代码解读

cv方面的paper

2018-01-31T00:00:00+00:00

2017年

2017年

参考 2017年度最值得读的AI论文 | CV篇 · 评选结果公布

Mask R-CNN

Image-to-Image Translation with Conditional Adversarial Networks

A-Fast-RCNN: Hard Positive Generation via Adversary for Object Detection

Bayesian GAN

Interpretable R-CNN

Towards Interpretable R-CNN by Unfolding Latent Structures

Learning Feature Pyramids for Human Pose Estimation

Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks

High-Resolution Image Synthesis and Semantic Manipulation with Conditional GANs

Triple Generative Adversarial Nets

Realtime Multi-Person 2D Pose Estimation using Part Affinity Fields

2017年度10大值得读的nlp方面的paper

2018-01-30T00:00:00+00:00

1. Attention Is All You Need
2. Reinforcement Learning for Relation Classification from Noisy Data
3. Convolutional Sequence to Sequence Learning
4. Zero-Shot Relation Extraction via Reading Comprehension
5. IRGAN: A Minimax Game for Unifying Generative and Discriminative Information Retrieval Models
6. Neural Relation Extraction with Selective Attention over Instances
7. Unsupervised Neural Machine Translation
8. Joint Extraction of Entities and Relations Based on a Novel Tagging Scheme
9. A Structured Self-attentive Sentence Embedding
10. Dialogue Learning With Human-In-The-Loop

参考 2017年度最值得读的AI论文 | NLP篇 · 评选结果公布

1. Attention Is All You Need

2. Reinforcement Learning for Relation Classification from Noisy Data

3. Convolutional Sequence to Sequence Learning

4. Zero-Shot Relation Extraction via Reading Comprehension

5. IRGAN: A Minimax Game for Unifying Generative and Discriminative Information Retrieval Models

6. Neural Relation Extraction with Selective Attention over Instances

7. Unsupervised Neural Machine Translation

8. Joint Extraction of Entities and Relations Based on a Novel Tagging Scheme

9. A Structured Self-attentive Sentence Embedding

10. Dialogue Learning With Human-In-The-Loop

pytorch一周年

2018-01-20T00:00:00+00:00

Community
Engineering

参考 PyTorch一周年战绩总结：是否比TensorFlow来势凶猛？

原文：http://pytorch.org/2018/01/19/a-year-in.html

Community

Research papers, packages and Github

人们一起创建了 torchtext、torchvision 和 torchaudio，以便利化平民化不同领域的研究。

首个 PyTorch 社区工具包（被命名为 Block）来自 Brandon Amo，有助于更轻松地处理块矩阵（block matrix）。来自 CMU 的 Locus 实验室后来继续公布 PyTorch 工具包及其大部分研究的实现。首个研究论文代码来自 Sergey Zagoruyko，论文名称为《Paying more attention to attention》。

cycle-GAN

来自 U.C.Berkeley 的 Jun-Yan Zhu、Taesung Park、Phillip Isola、Alyosha Efros 及团队发布了非常流行的 Cycle-GAN 和 pix2pix，用于图像转换。

torch版：https://github.com/junyanz/CycleGAN

pytorch版：https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix

论文链接：https://arxiv.org/abs/1703.10593

介绍：让莫奈画作变成照片：伯克利图像到图像翻译新研究

opennmt

哈佛大学NLP组开源神经机器翻译工具包OpenNMT：已达到生产可用水平

HarvardNLP 和 Systran 的研究者开始使用 PyTorch 开发和提升 OpenNMT，它最初开始于 Facebook Adam Lerer 的 [Lua]Torch 代码最初的再实现。

项目主页：http://opennmt.net/

pytorch版：https://github.com/OpenNMT/OpenNMT-py

tf版： https://github.com/OpenNMT/OpenNMT-tf

超分辨率

来自 Twitter 的 MagicPony 团队贡献了其超分辨率研究示例的 PyTorch 实现【直接集成进pytorch的examples中】https://github.com/pytorch/examples/tree/master/super_resolution

PyTorch-QRNN

Salesforce 发布了若干个工具包，包括其亮点成果 PyTorch-QRNN，这是一种新型 RNN，相比于 CuDNN 优化的标准 LSTM 可提速 2 到 17 倍。James Bradbury 及其团队是 PyTorch 社区中最活跃和最有吸引力的团队之一。

pytorch：https://github.com/salesforce/pytorch-qrnn

Pyro & ProbTorch

来自 Uber、Northeaster、Stanford 的研究者围绕着其工具包 Pyro 和 ProbTorch，形成了一个活跃的概率编程社区。他们正在积极开发 torch.distributions 核心工具包。该社区非常活跃，快速发展，我们联合 Fritz Obermeyer、Noah Goodman、Jan-Willem van de Meent、Brooks Paige、Dustin Tran 及其他 22 名参会者在 NIPS 2017 上举办了首次 PyTorch 概率编程会议，共同探讨如何使世界贝叶斯化。

pyro：

http://pyro.ai/

参考：Uber 与斯坦福大学开源深度概率编程语言 Pyro：基于 PyTorch

probtorch：

https://github.com/probtorch/probtorch

pix2pixHD, sentiment neuron & flownet2

英伟达研究者发布了三个高质量 repo，实现了 pix2pix-HD、Sentiment Neuron 和 FlowNet2。对 PyTorch 中不同数据并行模型的扩展性分析对整个社区都很有益。

pix2pix-HD：

https://github.com/NVIDIA/pix2pixHD

sentiment neuron: https://github.com/NVIDIA/sentiment-discovery

flownet2: https://github.com/NVIDIA/flownet2-pytorch

allenNLP

艾伦人工智能研究所发布 AllenNLP，包括多个 NLP 先进模型：标准 NLP 任务的参考实现和易用 web demo。

代码：https://github.com/allenai/allennlp

allenNLP: http://allennlp.org/

demo[包括machine-comprehension/textuale-ntailment/semantic-role-labeling/coreference-resolution/named-entity-recognitio]：http://demo.allennlp.org/machine-comprehension

DSB2017冠军

六月份，我们还首次取得了 Kaggle 竞赛冠军（团队 grt123）。他们获得了 2017 数据科学杯（关于肺癌检测）【DataScience Bowl 2017 on Lung Cancer detection】的冠军，后来公开了其 PyTorch 实现：

https://github.com/lfz/DSB2017

可视化

在可视化方面，Tzu-Wei Huang 实现了 TensorBoard-PyTorch 插件 https://github.com/lanpa/tensorboard-pytorch

Facebook AI Research 发布了与 PyTorch 兼容的 visdom 可视化包。

https://github.com/facebookresearch/visdom

Facebook AI Research

Facebook AI Research 发布了多个项目，如 ParlAI、fairseq-py、VoiceLoop 和 FaderNetworks，在多个领域中实现了先进的模型和接口数据集。由于空间有限，这里就不将优秀项目一一列出，详细列表可参阅：https://github.com/facebookresearch/。

ParlAI:

https://github.com/facebookresearch/ParlAI

fairseq-py: https://github.com/facebookresearch/fairseq-py

VoiceLoop:

https://github.com/facebookresearch/loop

FaderNetworks:

https://github.com/facebookresearch/FaderNetworks

Metrics

在 Github 上有 87769 行代码引入 Torch。
在 Github 上有 3983 个 repository 在名字或者描述中提到了 PyTorch。
PyTorch binary 下载量超过 50 万，具体数字是 651916。
在论坛上，有 5400 名用户发表了 21500 条讨论，涉及 5200 个主题。
自发布以来，在 Reddit 上的/r/machinelearning 主题中有 131 条讨论提到了 PyTorch。同期，TensorFlow 被提及的次数为 255。

pytorch v.s. tensorflow: PyTorch和TensorFlow到底哪个更好？看看一线开发者怎么说

TensorFlow开源一周年：这可能是一份最完整的盘点

Research Metrics

PyTorch 是一个专注于研究的框架。所以与衡量它的指标包括 PyTorch 在机器学习研究论文中的使用。

在 ICLR 2018 学术会议提交的论文中，有 87 篇提到了 PyTorch，相比之下 TensorFlow 228 篇，Keras 42 篇，Theano 和 Matlab 是 32 篇。
按照月度来看，arXiv 论文提到 PyTorch 框架的有 72 篇，TensorFlow 是 273 篇，Keras 100 篇，Caffe 94 篇，Theano 53 篇。

Courses, Tutorials and Books

Sasank Chilamkurthy 承担了改进教程的任务，教程详见：http://pytorch.org/tutorials/

Sean Robertson 和 Justin Johnson 编写了 NLP 领域的全新教程，还有通过示例学习的教程。

Yunjey Choi 写了用 30 行或者更少的代码部署大多数模型的教程。每个新教程都帮助用户用不同的学习方法更快地找到适合自己的学习路径。

https://github.com/yunjey/pytorch-tutorial

Goku Mohandas 和 Delip Rao 把正在写的书中的代码做了改变，使用了 PyTorch。

我们看到，一些大学的机器学习课程是使用 PyTorch 作为主要工具讲授的，例如哈佛 CS 287。为了更进一步方便大众学习，我们还看到三个在线课程使用 PyTorch 讲授。

https://harvard-ml-courses.github.io/cs287-web/

Fast.ai 的「Deep Learning for Coders」是个流行的在线课程。9 月份，Jeremy 和 Rachel 宣布下一个 fast.ai 的课程将几乎全部基于 PyTorch。

http://www.fast.ai/2017/09/08/introducing-pytorch-for-fastai/

Ritchie Ng，在清华、新加坡国立大学都学习过的研究者，推出了名为「Practical Deep Learning with PyTorch」的 Udemy 课程。

https://www.udemy.com/practical-deep-learning-with-pytorch/

来自香港科技大学的 Sung Kim 在 Yotube 上推出了面向普通观众的在线课程「PyTorch Zero to All」。

Engineering

Higher-order gradients

随着多篇关于实现梯度罚项的论文的发表，以及二阶梯度法的不断研究发展，高阶梯度成为必需的热门功能。去年 8 月，我们实现了一个通用接口，可使用 n 阶导数，加快支持高阶梯度函数的收敛，截至写作本文时，几乎所有 ops 都支持此界面。

Distributed PyTorch

去年 8 月，我们发布了一个小型分布式包，该包使用非常流行的 MPI 集合（MPI-collective）方法。它有多个后端，如 TCP、MPI、Gloo 和 NCCL2，以支持多种CPU/GPU集合操作和用例，这个包整合了 Infiniband 和 RoCE 等分布式技术。分布很难，我们在初始迭代时也有一些 bug。在后续版本中，我们作出了一些改进，使这个包更加稳定，性能也更强。

Closer to NumPy

用户最大的一个需求是他们熟悉的 NumPy 功能。Broadcasting 和 Advanced Indexing 等功能方便、简洁，节约用户的时间。我们实现了这些功能，开始使我们的 API 更接近 NumPy。随着时间的进展，我们希望在合适的地方越来越接近 NumPy 的 API。

Sparse Tensors

In March, we released a small package supporting sparse Tensors and in May we released CUDA support for the sparse package. The package is small and limited in functionality, and is used for implementing Sparse Embeddings and commonly used sparse paradigms in deep learning. This package is still small in scope and there’s demand to expand it — if you are interested in working on expanding the sparse package, reach out to us on our Discussion Boards

Performance

性能是一场仍在进行中的战斗，尤其对于想要最大化灵活性的动态框架 PyTorch 而言。去年，从核心 Tensor 库到神经网络算子，我们改善了 PyTorch 在 board 上的性能，能在 board 上更快的编写微优化。

我们添加了专门的 AVX 和 AVX2 内部函数，用于 Tensor 运算；
写更快的 GPU kernel，用于常用的工作负载，如级联和 Softmax；
为多个神经网络算子重写代码，如 nn.Embedding 和组卷积。

Reducing framework overhead by 10x across board

由于 PyTorch 是动态图框架，我们在训练循环的每次迭代时都要创建一个新图。因此，框架开销必须很低，或者工作负载必须足够大来隐藏框架开销。去年 8 月，DyNet 的作者（Graham Neubig 及其团队）展示了 DyNet 在一些小型 NLP 模型上的速度快于 PyTorch。这是很有意思的一个挑战，我们开始重写 PyTorch 内部构件，将框架开销从 10 微秒／算子降低到 1 微秒。

ATen

重新设计 PyTorch 内部构件的同时，我们也构建了 ATen C++11 库，该库现在主导 PyTorch 所有后端。ATen 具备一个类似 PyTorch Python API 的 API，使之成为便于 Tensor 计算的 C++库。ATen 可由 PyTorch 独立构建和使用。

https://github.com/pytorch/pytorch/tree/master/aten

Exporting models to production — ONNX Support and the JIT compiler

我们收到的一个普遍请求是将 PyTorch 模型输出到另一个框架。用户使用 PyTorch 进行快速研究，模型完成后，他们想将模型搭载到更大的项目中，而该项目只要求使用 C++。

因此我们构建了 tracer，可将 PyTorch 模型输出为中间表示。用户可使用后续的 tracer 更高效地运行当前的 PyTorch 模型，或将其转换成 ONNX 格式以输出至 Caffe2、MXNet、TensorFlow 等其他框架，或直接搭载至硬件加速库，如 CoreML 或 TensorRT。今年，我们将更多地利用 JIT 编译器提升性能。

SQuAD比赛算法综述

2018-01-14T00:00:00+00:00

1. SLQA
- 1.1 整体思路
- 1.2 SLQA架构
2. 相关模型
3. 小结
4. 参考文献
x. QANet
- x.1 cnn+self-attention
- x.2 利用机器翻译进行数据增强

参考机器阅读理解打破人类记录，解读阿里iDST SLQA技术

SQuAD 数据集是行业内公认的机器阅读理解标准水平测试，也是该领域顶级赛事，被誉为机器阅读理解界的 ImageNet（图像识别领域的顶级赛事）。

SQuAD 是由 Rajpurkar 等人[1]提出的一个最新的阅读理解数据集。该数据集包含 10 万个（问题，原文，答案）三元组，原文来自于 536 篇维基百科文章，而问题和答案的构建主要是通过众包的方式，让标注人员提出最多 5 个基于文章内容的问题并提供正确答案，且答案出现在原文中。SQuAD 和之前的完形填空类阅读理解数据集如 CNN/DM[2]，CBT[3]等最大的区别在于：SQuAD 中的答案不在是单个实体或单词，而可能是一段短语，这使得其答案更难预测。SQuAD 包含公开的训练集和开发集，以及一个隐藏的测试集，其采用了与 ImageNet 类似的封闭评测的方式，研究人员需提交算法到一个开放平台，并由 SQuAD 官方人员进行测试并公布结果。

机器阅读理解的评测维度分为 EM（Exact Match，精准匹配分数）和 F1（精确率和召回率的平均，模糊匹配分数）。

1. SLQA

本次阿里巴巴参与测评的系统名为 SLQA，Semantic Learning for Question Answering，是 iDST NLP 团队提出的「基于分层融合注意力机制」的深度神经网络系统。评测证明，相比传统方法，SLQA 的效果取得了显著的提升。

采用传统方法解决机器阅读理解问题，一般会将该过程分为以下几个步骤：

对问题、篇章分别进行词法、句法分析，针对分析结果进行特征提取：
基于特征采用诸如 LR、CRF 等模型进行答案边界预测；
采用梯度下降类算法在训练集上进行优化，拟合数据分布。

在此过程中，基础语言模型、依存分析等模块的准确率在一定程度上会影响训练效果，特征工程的优劣也同样左右着是否能训练得到可用的模型。

1.1 整体思路

人类在进行阅读理解时，常见思维顺序如下：

通读篇章，理解文章主题和大体内容；读题，了解提问内容及关注点。
带着问题找答案，将问题同篇章做关联，并结合篇章主题，理解问题重点。
定位可能的答案范围，并再次重点阅读附近文字。
为避免忘记问题，再次审题，并结合 3. 中重点区域进行答案圈选。
针对挑出的答案候选进行精筛，确定最正确的答案。

因此，构建模型的主要思想是在捕捉问题和文章中特定区域关联的同时，借助分层策略，逐步集中注意力，使答案边界清晰。

同时，为了避免过于关注细节，采用融合方式将全局信息加入注意力机制，进行适度纠正，确保关注点正确。这种逐步聚焦并兼顾全局的方式与其他参赛者已经公布的的做法不太相同，也是团队此次刷榜登顶的关键所在。

1.2 SLQA架构

目前业界主流的基于 End2End 学习的机器阅读理解模型主要为Encode-Interaction-Pointer框架。

SLQA 系统包含如下基本结构：Encoder Layer（文本表征），Attention Layer（注意力机制），Match Layer（问题篇章匹配）以及 Output Layer（答案预测）。

Encoder Layer: 用于表示学习，可以理解为语言模型层，用以将篇章及问题从离散字符转变为蕴含语义的表征向量。团队采用了多层双向 LSTM 并分别对篇章和问题进行主题和重点词关注。
Attention Layer: 得到有效的问题及篇章表征后，为表达依据问题定位答案过程，缩小备选答案查找范围，将搜索空间通过注意力机制约束，主要进行多层融合注意力表示，对问题和篇章进行相关性对齐（Align），并不断补充全局信息（Fusion），每一次对齐都基于下层信息并在此基础上更加细化（paragraph→sentence→phrase→word），采用的方式分别为 Co-Attention（篇章到问题，问题到篇章），Self-Attention（问题自身，篇章自身）。
Match Layer: 用于做融合信息后的问题和篇章匹配，团队采用双线性矩阵来学习经过多层信息过滤后的篇章和问题匹配参数，由于在前一阶段无关信息已经被过滤，最后的匹配可完成答案的定位工作。
Output Layer: 结合匹配信息对篇章中词汇进行标注，预测相应词汇是答案开始位置或结束位置的概率。之后，模型会抽取可能性最高的一段连续文本作为答案。

重点探索和研究的Layer是第三层（Hierarchical Attention Fusion Network）。

2. 相关模型

参考PaperWeekly 第38期 | SQuAD综述

2.1 基本模型

由于 SQuAD 的答案限定于来自原文，模型只需要判断原文中哪些词是答案即可，因此是一种抽取式的 QA 任务而不是生成式任务。

几乎所有做 SQuAD 的模型都可以概括为同一种框架：Embed 层，Encode 层，Interaction 层和 Answer 层。

Embed 层负责将原文和问题中的 tokens 映射为向量表示；
Encode 层主要使用 RNN 来对原文和问题进行编码，这样编码后每个 token 的向量表示就蕴含了上下文的语义信息；
Interaction 层是大多数研究工作聚焦的重点，该层主要负责捕捉问题和原文之间的交互关系，并输出编码了问题语义信息的原文表示，即 query-aware 的原文表示；
最后 Answer 层则基于 query-aware 的原文表示来预测答案范围。

2.2 Match-LSTM[4]

Match-LSTM 的 Answer 层包含了两种预测答案的模式，分别为 Sequence Model 和 Boundary Model。

Sequence Model 将答案看做是一个整数组成的序列，每个整数表示选中的 token 在原文中的位置，因此模型按顺序产生一系列条件概率，每个条件概率表示基于上轮预测的 token 产生的下个 token 的位置概率，最后答案总概率等于所有条件概率的乘积。
Boundary Model 简化了整个预测答案的过程，只预测答案开始和答案结束位置，相比于 Sequence Model 极大地缩小了搜索答案的空间，最后的实验也显示简化的 Boundary Model 相比于复杂的 Sequence Model 效果更好，因此 Boundary Model 也成为后来的模型用来预测答案范围的标配。

主要步骤如下：

Embed 层使用词向量表示原文和问题；
Encode 层使用单向 LSTM 编码原文和问题 embedding；
Interaction 层对原文中每个词，计算其关于问题的注意力分布，并使用该注意力分布汇总问题表示，将原文该词表示和对应问题表示输入另一个 LSTM 编码，得到该词的 query-aware 表示；
在反方向重复步骤 2，获得双向 query-aware 表示；
Answer 层基于双向 query-aware 表示使用 Sequence Model 或 Boundary Model 预测答案范围。

2.3 BiDAF[5]

相比于之前工作，BiDAF（Bi-Directional Attention Flow）最大的改进在于 Interaction 层中引入了双向注意力机制，即首先计算一个原文和问题的 Alignment matrix，然后基于该矩阵计算 Query2Context 和 Context2Query 两种注意力，并基于注意力计算 query-aware 的原文表示，接着使用双向 LSTM 进行语义信息的聚合。另外，其 Embed 层中混合了词级 embedding 和字符级 embedding，词级 embedding 使用预训练的词向量进行初始化，而字符级 embedding 使用 CNN 进一步编码，两种 embedding 共同经过 2 层 Highway Network 作为 Encode 层输入。最后，BiDAF 同样使用 Boundary Model 来预测答案开始和结束位置。

代码：https://github.com/allenai/bi-att-flow

2.4 Dynamic Coattention Network[6]

DCN 最大的特点在于 Answer 层，其 Answer 层使用了一种多轮迭代 pointing 机制，每轮迭代都会产生对答案开始和结束位置的预测，并基于这两个预测使用 LSTM 和 Highway Maxout Network 来更新下一轮的答案范围预测。而在 Interaction 层，DCN 使用和 BiDAF 类似的双向注意力机制计算 query-aware 的原文表示。

2.5 Multi-Perspective Matching[7]

Multi-Perspective Matching 在 Encode 层同样使用 char, word 两个 embedding，只不过 char embedding 使用 LSTM 进行编码。在 Encode 层之前，该模型使用一个过滤操作，作用是过滤掉那些和问题相关度低的原文词。该模型最大的特点在 Interaction 层，该层针对每个原文词使用一种 multi-perspective 的匹配函数计算其和问题的匹配向量，并使用 BiLSTM 来进一步聚合这些匹配向量。匹配的形式包括每个原文词和整个问题的表示匹配，每个原文词和每个问题词匹配后进行最大池化，和每个原文词和每个问题词匹配后进行平均池化。最后在 Answer 层，基于匹配向量聚合表示使用两个前馈网络来预测答案开始和结束位置。

2.6 FastQAExt[8]

FastQAExt 使用了一种轻量级的架构，其 Embed 层除了 word 和 char 两种 embeeding 作为输入以外，还额外使用了两个特征：

binary 特征表示原文词是否出现在问题中；
weighted 特征表示原文词对于问题中所有词的相似度。

并且这两个特征同样用在了问题词上。

在 Interaction 层，FastQAExt 使用了两种轻量级的信息 fusion 策略：

Intra-Fusion，即每个原文词和其他原文词计算相似度，并汇总得到原文总表示，接着将该原文词和对应原文总表示输入 Highway Networks 进行聚合，聚合后原文词表示进一步和上下文词表示进行类似的聚合；
Inter-Fusion，即对每个原文词计算和问题词的相似度，并汇总得到问题总表示，接着将该原文词和对应问题总表示输入 Highway Networks 进行聚合，得到 query-aware 原文表示。

此外，在 Answer 层，FastQAExt 首先计算了一个问题的总表示，接着将 query-aware 原文表示和问题总表示共同输入两个前馈网络产生答案开始和结束位置概率。在确定答案范围时，FastQAExt 使用了 Beam-search。

2.7 jNet[9]

jNet 的 baseline 模型和 BiDAF 类似，其在 Interaction 层除了对每个原文词计算一个对应的问题表示以外，还将 Alignment Matrix 按原文所在维度进行池化（最大池化和平均池化），池化后的值表示原文各词的重要程度，因此基于该值对原文表示进行过滤，剔除不重要的原文词。在 Answer 层，jNet 不仅先预测答案开始位置再预测答案结束位置，还反向地先预测答案结束位置再预测答案开始位置。最后对两方向概率求平均后作为总概率输出。

jNet 的最大创新在于对问题的理解和适应。为了在编码问题表示时考虑句法信息，jNet 使用 TreeLSTM 对问题进行编码，并将编码后表示作为 Interaction 层的输入。为了对不同问题进行适应，jNet 首先使用了问题类型的 embedding，将该 embeeding 作为 Interaction 层输入。

另外，jNet 定义了K 个 cluster 的中心向量，每个 cluster model 了一个特定的问题类型比如”when”,”where”等，接下来的适应算法分为两步：adapting 和 updating。

Adapting 指根据问题总表示和 K 个 cluster 的相似度来更新出一个新的问题表示，并输入 Interaction 层；
Updating 层旨在修改 K 个 cluster 的中心以令每个 cluster 可以 model 不同类型的问题。

2.8 Ruminating Reader[10]

Ruminating Reader 是 BiDAF 的改进和扩展，它将之前的单 Interaction 层扩展为了双 Interaction 层。

第一个 Interaction 层和 BiDAF 的 Interaction 层相同，输出 query-aware 的原文表示。query-aware 原文表示经过一个双向 LSTM 编码，其输出的最后一位隐层状态作为 query-aware 原文表示的总结。接着，该总结向量依次与各原文词表示和各问题词表示经过一个 Highway Network 处理，以将总结向量的信息重新融入原文和问题表示当中。
最后，基于更新后的原文和问题表示，使用第二个 Interaction 层来捕捉它们之间的交互，并生成新的 query-aware 的原文表示。Ruminating Reader 的 Embed 层，Encode 层和 Answer 层和 BiDAF 相同。

2.9 ReasoNet[11]

【使用强化学习进行训练】

和之前介绍的 Embed-Encode-Interaction-Answer 框架不同，ReasoNet 使用了 Memory Networks 的框架[12]。在使用 BiRNN 编码问题和原文后，问题的最后一位隐层状态初始化为一个中间状态 s，而原文和问题表示作为 Memory。接下来是一个多轮迭代的过程，在每一轮迭代中，中间状态 s 首先经过一个逻辑回归函数来输出一个 binary random variable t，t 为真，那么 ReasoNet 停止，并且用当前中间状态 s 输出到 Answer 模块产生对答案的预测；否则，中间状态 s 会和 Memory（原文和问题）中每一位表示计算注意力，并基于注意力求原文和问题的加权表示 x，x 和 s 共同作为一个 RNN 的输入，产生新的中间状态 s 并进入下一轮迭代。由于出现了 binary random variable，ReasoNet 使用了强化学习的方法进行训练。

2.10 r-net[13]

r-net 同样使用了双 Interaction 层架构，其第一 Interaction 层负责捕捉原文和问题之间的交互信息，而第二 Interaction 层负责捕捉原文内部各词之间的交互信息。具体来说，

在第一 Interaction 层，r-net 首先使用了类似于 Match-LSTM 的方法，即对原文中每个词，计算其关于问题的注意力分布，并使用该注意力分布汇总问题表示，将原文该词表示和对应问题表示输入 RNN 编码，得到该词的 query-aware 表示。不同的是，在原文词表示和对应问题表示输入 RNN 之前，r-net 使用了一个额外的门来过滤不重要的信息。
接着，在第二 Interaction 层，r-net 使用了同样的策略来将 query-aware 表示进一步和自身进行匹配，将回答答案所需的证据和问题信息进行语义上的融合，得到最终的原文表示。

在其他方面，r-net 的 Embed 层同样使用了 word 和 char 两种 embedding 以丰富输入特征。在 Answer 层，r-net 首先使用一个 attention-pooling 的问题向量作为一个 RNN 的初始状态，该 RNN 的状态和最终的原文表示共同输入一个 pointer networks 以产生答案开始概率，接着基于开始概率和原文表示产生另一个 attention-pooling 向量，该向量和 RNN 状态共同经过一次 RNN 更新后得到 RNN 的新状态，并基于新状态来预测答案结束概率。

2.11 Mnemonic Reader[14]

相比于之前的工作，Mnemonic Reader 同样使用了类似于 r-net 和 Ruminating Reader 的两层 Interaction 层设计。其中第一个 Interaction 层负责捕捉原文和问题之间的交互信息，第二 Interaction 层负责捕捉原文内部的长时依赖信息。不同于 r-net 的是，r-net 使用了单向注意力+门机制来编码这些交互信息，而 Mnemonic Reader 使用了双向注意力机制来编码交互信息，因此能够捕捉更加细粒度的语义信息。

在 Answer 层，我们使用对问题敏感的表示方法，具体来说，问题表示分为两种：显式的问题类型 embedding 和隐式的问题向量表示。

进一步地，我们使用了 Memory Network[12] 的框架来预测答案范围，将问题表示作为一个可更新的记忆向量，在每次预测答案概率后将候选答案信息更新至记忆向量中。该过程可以持续多轮，因此可以根据之前预测信息来不断修正当前预测，直到产生正确的答案范围。

3. 小结

大规模语料集的构建是推进机器阅读理解发展的重要前提。从 15 年提出的 CNN/DM 完形填空数据集，到近期的 SQuAD 数据集，再到之后的若干新数据集，每一个新数据集都提出了当前方法无法有效解决的新问题，从而促使研究人员不断探索新的模型，促进了该领域的发展。
针对抽取式阅读理解任务，可以看到有如下几个技术创新点:
- 建立在单向或双向注意力机制上的 Interaction 层对于模型理解原文和问题至关重要，而[10]，[13]和[14]中更复杂的双 Interaction 层设计无疑要优于之前的单 Interaction 层设计，原因是在问题-原文交互层之上的原文自交互层使得更多的语义信息能在原文中流动，因此在某种程度上部分解决了长文本中存在的长时依赖问题。
- 多轮推理机制如[6]，[11]和[14]对于回答复杂问题具备一定帮助，尤其是针对 SQuAD 中的答案不是一个单词而可能是一个短语的情况，多轮推理机制可以不断缩小预测范围，最终确定正确答案位置。
- 对问题敏感的问题表示方法[9]，[14]能够更好地 model 各类型问题，并根据问题类型聚焦于原文中的特定单词，比如 when 类问题更加聚焦于原文中的时间信息，而 where 类问题更关注空间信息。

4. 参考文献

[1] Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. Squad: 100,000+ questions for machine comprehension of text. In Proceedings of EMNLP.

[2] Karl Moritz Hermann, Tomas Kocisky, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, , and Phil Blunsom. 2015. Teaching ma- chines to read and comprehend. In Proceedings of NIPS.

[3] Felix Hill, Antoine Bordes, Sumit Chopra, and Jason Weston. 2016. The goldilocks principle: Reading childrens books with explicit memory representa- tions. In Proceedings of ICLR.

[4] Shuohang Wang and Jing Jiang. 2017. Machine comprehension using match-lstm and answer pointer. In Proceedings of ICLR.

[5] Minjoon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hananneh Hajishirzi. 2017. Bidirectional attention flow for machine comprehension. In Proceedings of ICLR.

[6] Caiming Xiong, Victor Zhong, and Richard Socher. 2017. Dynamic coattention networks for question answering. In Proceedings of ICLR.

[7] Zhiguo Wang, Haitao Mi, Wael Hamza, and Radu Florian. 2016. Multi-perspective context matching for machine comprehension. arXiv preprint arXiv:1612.04211 .

[8] Dirk Weissenborn, Georg Wiese, and Laura Seiffe. 2017. Fastqa: A simple and efficient neural architecture for question answering. arXiv preprint arXiv:1703.04816 .

[9] Junbei Zhang, Xiaodan Zhu, Qian Chen, Lirong Dai, Si Wei, and Hui Jiang. 2017. Exploring question understanding and adaptation in neural- network-based question answering. arXiv preprint arXiv:1703.04617 .

[10] Yichen Gong and Samuel R. Bowman. 2017. Ruminating reader: Reasoning with gated multi-hop attention. arXiv preprint arXiv:1704.07415 .

[11] Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. 2016. Reasonet: Learning to stop reading in machine comprehension. arXiv preprint arXiv:1609.05284 .

[12] Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. 2015. End-to-end memory networks. In Proceedings of NIPS.

[13] Microsoft Research Asia. 2017. R-NET: MACHINE READING COMPREHENSION WITH SELF-MATCHING NETWORKS. In Proceedings of ACL.

[14] Minghao Hu, Yuxing Peng, and Xipeng Qiu. 2017. Mnemonic Reader for Machine Comprehension. arXiv preprint arXiv:1705.02798 .

x. QANet

参考谷歌大脑团队和 CMU 联合推出的 QANet，发表在ICLR2018：

问答系统冠军之路：用 CNN 做问答任务的 QANet

QANet: Combining Local Convolution with Global Self-Attention for Reading Comprehension

给定一个包含 n 个单词的上下文片段 $C={c_1,c_2,...,c_n}$,我们考虑包含 m 个单词的查询语句 $Q={q_1,q_2,...,q_m}$,模型输出为一个包含 j 个单词的片段 C 中的答案区间 $S={c_i,c_{i+1},...,c_{i+j}}$。

QANet 包含五个主要的组成部分：

嵌入层（embedding layer）
嵌入编码层（embedding encoder layer）
语境-查询注意力层（context-query attention layer）
模型编码层（model encoder）
输出层（output layer）

x.1 cnn+self-attention

仅仅使用卷积（convolution）和自注意力机制（self-attention）构建了一个神经网络，使得模型的训练速率和推断速率大大加快，并且可以并行处理输入的单词。

卷积操作可以对局部相互作用建模（捕获文本的局部结构），而使用自注意力机制则可以对全局交互进行建模（学习每对单词之间的相互作用）。据作者们介绍，这也是领域内首次将卷积和自注意力机制相结合。由于卷积层和自注意力机制都没有消耗时间的递归操作，所以作者们不仅大胆地把模型深度增加到了问答任务中史无前例的超过 130 层，同时还在训练、推理中都有数倍的速度提升。（相较于基于 RNN 的模型，训练速度提升了3-13倍，推理速度提升了 4-9 倍）

左图为包含多个编码器模块的 QANet 整体架构。

右图为基本编码器模块单元，QANet 所使用的所有编码器都是按照这个模式构建的，仅仅修改模块中卷积层的数量。(其实前两步都是 attention is all you need里有的，第三步是加上的)

QANet 在每一层之间会使用LayerNorm和残差连接技术
将编码器结构内位置编码之后的每个子层（卷积、自注意力、前馈网络等）封装在残差模块内。
QANet 还共享了语境、问题、输出编码器之间的部分权重，以达到知识共享。

区别于一般的编码器-解码器结构中使用的 Attention model（输入和输出的内容不同），self attention 机制并不是输入和输出之间的 attention 机制，而是输入内部的单词或者输出内部单词之间的 attention 机制。Self-attention即K=V=Q，在 QANet 中，作者使得原文中每一对单词的相互作用都能够被刻画出来，捕获整篇文章的内部结构。

使用 self-attention 有以下好处：

在并行方面，self-attention 和 CNN一样不依赖于前一时刻的计算，可以很好的并行，优于RNN。
在长距离依赖上，由于 self-attention 是每个词和所有词都要计算 attention，所以不管他们中间有多长距离，最大的路径长度也都只是 1。可以高效捕获长距离依赖关系。

更多的知识，请移步：

x.2 利用机器翻译进行数据增强

使用数据增强技术对原始数据集进行了扩充，用更多数据训练了模型。

具体来说，他们把英文原文用现有的神经机器翻译器翻译成另一种语言（QANet 使用的是法语）之后再翻译回英语。这个过程相当于对样本进行了改写，这样使得训练样本的数量大大增加，句式更加丰富。

dl中的normalization

2018-01-12T00:00:00+00:00

batch normalization
layer normalization

batch normalization

Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift

参考http://blog.csdn.net/hjimce/article/details/50866313

主要有四个好处：

快速训练收敛的特性。可以选择比较大的初始学习率，让你的训练速度飙涨。以前还需要慢慢调整学习率，甚至在网络训练到一半的时候，还需要想着学习率进一步调小的比例选择多少比较合适。现在我们可以采用初始很大的学习率，然后学习率的衰减速度也很大，因为这个算法收敛很快。即使你选择了较小的学习率，也比以前的收敛速度快。
提高网络泛化能力的特性。不用去理会过拟合中drop out、L2正则项参数的选择问题。移除这两项了参数，或者可以选择更小的L2正则约束参数了。
本身就是一个归一化网络层。不需要使用使用局部响应归一化层（Alexnet网络用到的方法）。
可以把训练数据彻底打乱。防止每批训练的时候，某一个样本都经常被挑选到。

一般地，在神经网络训练开始前，都要对输入数据做一个归一化处理，原因如下：

神经网络学习过程本质就是为了学习数据分布，一旦训练数据与测试数据的分布不同，那么网络的泛化能力也大大降低
一旦每批训练数据的分布各不相同(batch 梯度下降)，那么网络就要在每次迭代都去学习适应不同的分布，这样将会大大降低网络的训练速度。

参考https://blog.csdn.net/qq_25737169/article/details/79048516

layer normalization

Layer Normalization

参考知乎的讨论：

https://www.zhihu.com/question/59728870

https://www.zhihu.com/question/48820040

参考：

https://skyhigh233.com/blog/2017/07/21/norm/

直观区别：

bn是“竖”着来的，对于某一个神经元，会拿整个batch所有样本的值来做归一化。
ln是“横”着来的，对一个样本，在不同的神经间做归一化。

好处：

它的training和inference没有区别，只需要对当前隐藏层计算mean和variance就行
不需要保存每层的moving average mean and variance
不受batch size的限制，可以通过online learning的方式一条一条地输入训练数据
LN可以方便的在RNN中使用
LN增加了gain和bias作为学习的参数，$\mu$和$\sigma$分别是该layer的隐层维度的均值和方差

LayerNorm是Batch Normalization的一个变体，BN针对一个minibatch的输入样本，计算均值和方差，基于计算的均值和方差来对某一层神经网络的输入X中每一个case进行归一化操作。但BN有两个明显不足：1、高度依赖于mini-batch的大小，实际使用中会对mini-Batch大小进行约束，不适合类似在线学习（mini-batch为1）情况；2、不适用于RNN网络中normalize操作：BN实际使用时需要计算并且保存某一层神经网络mini-batch的均值和方差等统计信息，对于对一个固定深度的前向神经网络（DNN，CNN）使用BN，很方便；但对于RNN来说，sequence的长度是不一致的，换句话说RNN的深度不是固定的，不同的time-step需要保存不同的statics特征，可能存在一个特殊sequence比其的sequence长很多，这样training时，计算很麻烦。但LN可以有效解决上面这两个问题。LN中同层神经元输入拥有相同的均值和方差，不同的输入样本有不同的均值和方差；而BN中则针对不同神经元输入计算均值和方差，同一个minibatch中的输入拥有相同的均值和方差。因此，LN不依赖于mini-batch的大小和输入sequence的深度，因此可以用于bath-size为1和RNN中对边长的输入sequence的normalize操作。参考深度学习加速器Layer Normalization-LN

基于深度学习的ctr预估模型集合（持续更新）

2018-01-12T00:00:00+00:00

FM
FFM
embedding + mlp
FNN, SNN
- FNN
- SNN
NFM
AFM
PNN
- IPNN
- OPNN
- PNN小结
CCPM
Wide & Deep
DeepFM
Deep & Cross
xDeepFM
DIN
DIEN
- 兴趣提取
- 兴趣演化
ESMM
TDM
DeepGBM
各种比赛
应用示例

参考：

深度学习在 CTR 中应用

ctr模型汇总

基于lr和gbdt的可以参考传统ctr预估模型

参考：从FM推演各深度CTR预估模型(附代码)

发现一个不错的合集。。https://www.jianshu.com/p/2b1246858e6f

FM

二阶多项式模型：

\[ \phi(x) = w_0+\sum _{i}w_ix_i+\sum_{i}\sum_{j<i}w_{ij}x_ix_j \]

多项式模型的问题在于二阶项的参数过多，假设特征个数为n，那么二阶项的参数数目为n(n+1)/2，参数太多，而却只有少数模式在样本中能找到，因此模型无法学出对应的权重。

FM模型：

\[ \hat{y} = w_0+\sum _{i=1}^nw_ix_i+\sum_{i=1}^{n-1}\sum_{j=i+1}^{n}\left \langle \mathbf{v}_i,\mathbf{v}_j \right \rangle x_ix_j \]

其中，

$w_0\in \mathbb{R}$
$\mathbf{w}\in \mathbb{R}^n$
$\mathbf{V}\in \mathbb{R}^{n\times k}$
$\hat{w_{ij}}=\mathbf{v}_i\mathbf{v}_j^T=\sum _{l=1}^kv_{il}v_{jl}$ 所以上式中的$\mathbf{v}_i$就表示$\mathbf{V}$这个矩阵的第i行（有k列），而$\left \langle \mathbf{v}_i,\mathbf{v}_j \right \rangle$就表示第i行和和j行这两个向量的内积（得到一个数），而得到的正好就是权重矩阵的第i行第j列的元素$\hat{w}_{ij}$，而$\hat{w}$这个矩阵是$(n-1)\times(n-1)$维的矩阵，刻画的是相邻两个x【$x_i$和$x_{i+1}$】之间的系数。因此，可以理解为，将这个$(n-1)\times(n-1)$维的矩阵用一个$n\times k$维的低秩矩阵来表示。

在计算特征组合的时候，会用如下一个小trick：

因为$(ax+by)^2=a^2x^2+b^2y^2+2axby$，所以，

\[ \sum ^n_{i=1}\sum ^n_{j=i+1}x_ix_j=\frac{1}{2}[(\sum ^n_{i=1}x_i)^2-\sum^n_{i=1}x_i^2] \]

考虑了v，其实就是：

\[ \sum xxv=\frac{1}{2}[\sum (xv)^2-\sum x^2v^2] \]

tf实现：

class FM(Model):
    def __init__(self, input_dim=None, output_dim=1, factor_order=10, init_path=None, opt_algo='gd', learning_rate=1e-2,
                 l2_w=0, l2_v=0, random_seed=None):
        Model.__init__(self)
        # 一次、二次交叉、偏置项
        init_vars = [('w', [input_dim, output_dim], 'xavier', dtype),
                     ('v', [input_dim, factor_order], 'xavier', dtype),
                     ('b', [output_dim], 'zero', dtype)]
        self.graph = tf.Graph()
        with self.graph.as_default():
            if random_seed is not None:
                tf.set_random_seed(random_seed)
            self.X = tf.sparse_placeholder(dtype)
            self.y = tf.placeholder(dtype)
            self.vars = init_var_map(init_vars, init_path)

            w = self.vars['w']
            v = self.vars['v']
            b = self.vars['b']

            # [(x1+x2+x3)^2 - (x1^2+x2^2+x3^2)]/2
            # 先计算所有的交叉项，再减去平方项(自己和自己相乘)
            X_square = tf.SparseTensor(self.X.indices, tf.square(self.X.values), tf.to_int64(tf.shape(self.X)))
            xv = tf.square(tf.sparse_tensor_dense_matmul(self.X, v))
            p = 0.5 * tf.reshape(
                tf.reduce_sum(xv - tf.sparse_tensor_dense_matmul(X_square, tf.square(v)), 1),
                [-1, output_dim])
            xw = tf.sparse_tensor_dense_matmul(self.X, w)
            logits = tf.reshape(xw + b + p, [-1])
            self.y_prob = tf.sigmoid(logits)

            self.loss = tf.reduce_mean(
                tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=self.y)) + \
                        l2_w * tf.nn.l2_loss(xw) + \
                        l2_v * tf.nn.l2_loss(xv)
            self.optimizer = get_optimizer(opt_algo, learning_rate, self.loss)

            #GPU设定
            config = tf.ConfigProto()
            config.gpu_options.allow_growth = True
            self.sess = tf.Session(config=config)
            # 图中所有variable初始化
            tf.global_variables_initializer().run(session=self.sess)

将FM的公式稍微变形，写成内积形式，可以发现：

\[ \hat{y} = w_0+\left \langle w,x \right \rangle + \left \langle xV,xV \right \rangle \]

发现，$xV$就是将离散稀疏特征$x$降维成一个低维稠密向量，所以其实就是一种embedding。

所以，其实FM就是：

先对离散特征进行embedding
然后对embedding后的向量进行内积来做二阶特征组合

FFM

Field-aware Factorization Machines for CTR Prediction

参考https://blog.csdn.net/john_xyz/article/details/78933253#field-aware-factorization-machinesffm

FFM把相同性质的特征归于同一个field。每一维特征$x_i$，针对其他特征的每一种field $f_j$，都会学习一个隐向量$V_{i,f_j}$。所以隐向量不仅与特征有关，也与field相关。假设有$n$个特征，$f$个field，那么FFM的二次项总共有$nf$个隐向量，而FM中，每一维特征的隐向量只有一个。公式如下：

\[ y=w_0+\sum^n_{i=1}w_ix_i+\sum^n_{i=1}\sum ^n_{j=i+1} \left \langle V_{i,f_j}, V_{j,f_i} \right \rangle x_i x_j \]

如果隐向量的长度是$k$，那么FFM的二次参数有$nfk$个，远多于FM的$nk$个，二次项并不能化简，所以时间复杂度是$O(kn^2)$。由于FFM中的latent vector只需要学习特定的field，所以通常要求$k_{FFM}<< k_{FM}$

FFM做召回可以参考：推荐系统召回四模型之二：沉重的FFM模型

主要思想就是把item侧的emb做一下转置，然后就可以各自concat，拼出user的大向量和item的大向量，然后做个内积就是了。要加一阶项或者user内部组合特征或者item内部组合特征，就往对应的大向量后面加，然后另一个大向量对应位置写1，再去搞内积就是了。

“微博在业务中的实践表明，如果采取FM召回模型，对于有些应用来说，一阶项对于最终效果有明显影响，所以在用FM/FFM做召回的时候，是需要将一阶项考虑进去的，这可能是个别一阶特征比较重要导致的。我们在Criteo数据集合的实验结果也证明：如果是FM模型，一阶项是有用的，去掉一阶项，只保留二阶项，AUC大约会掉1个绝对百分点，对于CTR来说，这个差距还是很明显的；而如果是采用DeepFM模型，则FM部分是否保留一阶项对最终结果没有什么影响，这说明DNN的隐层有效地将一阶项的作用吸收掉了。”

加场景特征C的时候，先在取用户特征U的时候算出每个域的<U,C>，记为score1。然后把C拼到U的长向量里去，I的长向量后面也拼上I给C准备的emb，然后内积算出score2，score1+score2就是了。

这样就可能出现向量太长的问题，所以需要提速：

方法1：U的emb切分成k段，I的emb也切分成k段，U的每一段去annoy找topk的I的那段出来，然后k个子集merge，有交集的item把k段的内积加起来，就是它的score

方案2：作者提出了一种奇怪的想法，当然得出的结果不是FFM，是变种的FM+FFM：比如I有3个域，U有两个域，那U有2组向量，每组向量里有3个向量，记为(U11,U12,U13), (U21,U22,U23)，同理，I有3组向量，每组向量有2个向量，记为(I11,I12), (I21,I22), (I31,I32)，然后U跨域相加，得到(U11+U21),(U12+U22),(U31+U23)，而I进行域内相加，得到(I11+I12), (I21+I22), (I31+I32)，然后U和I就可以做内积啦。。同理，也可以对I跨域相加，对U域内相加。。

embedding + mlp

是ctr预估的通用框架，各种field的特征进行emb，然后concat到一起，然后堆一堆mlp。

缺点：只学习高阶特征组合，对于低阶或者手动的特征组合不够兼容，而且参数较多，学习较困难

FNN, SNN

Deep Learning over Multi-field Categorical Data - A Case Study on User Response Prediction in Display Ads

这篇文章里提出了FNN和SNN。

FNN

将FM与MLP进行了结合。它有着十分显著的特点：

采用FM预训练得到的隐含层及其权重作为神经网络的第一层的初始值，之后再不断堆叠全连接层，最终输出预测的点击率。
可以将FNN理解成一种特殊的embedding+MLP，其要求第一层嵌入后的各领域特征维度一致，并且emb权重的初始化是FM预训练好的。
不是一个端到端的训练过程，有贪心预训练的思路。而且如果不考虑预训练过程，模型网络结构也没有考虑低阶特征组合。

tf代码：

class FNN(Model):
    def __init__(self, field_sizes=None, embed_size=10, layer_sizes=None, layer_acts=None, drop_out=None,
                 embed_l2=None, layer_l2=None, init_path=None, opt_algo='gd', learning_rate=1e-2, random_seed=None):
        Model.__init__(self)
        init_vars = []
        num_inputs = len(field_sizes)
        for i in range(num_inputs):
            init_vars.append(('embed_%d' % i, [field_sizes[i], embed_size], 'xavier', dtype))
        node_in = num_inputs * embed_size
        for i in range(len(layer_sizes)):
            init_vars.append(('w%d' % i, [node_in, layer_sizes[i]], 'xavier', dtype))
            init_vars.append(('b%d' % i, [layer_sizes[i]], 'zero', dtype))
            node_in = layer_sizes[i]
        self.graph = tf.Graph()
        with self.graph.as_default():
            if random_seed is not None:
                tf.set_random_seed(random_seed)
            self.X = [tf.sparse_placeholder(dtype) for i in range(num_inputs)]
            self.y = tf.placeholder(dtype)
            self.keep_prob_train = 1 - np.array(drop_out)
            self.keep_prob_test = np.ones_like(drop_out)
            self.layer_keeps = tf.placeholder(dtype)
            self.vars = init_var_map(init_vars, init_path)
            w0 = [self.vars['embed_%d' % i] for i in range(num_inputs)]
            xw = tf.concat([tf.sparse_tensor_dense_matmul(self.X[i], w0[i]) for i in range(num_inputs)], 1)
            l = xw

            #全连接部分
            for i in range(len(layer_sizes)):
                wi = self.vars['w%d' % i]
                bi = self.vars['b%d' % i]
                print(l.shape, wi.shape, bi.shape)
                l = tf.nn.dropout(
                    activate(
                        tf.matmul(l, wi) + bi,
                        layer_acts[i]),
                    self.layer_keeps[i])

            l = tf.squeeze(l)
            self.y_prob = tf.sigmoid(l)

            self.loss = tf.reduce_mean(
                tf.nn.sigmoid_cross_entropy_with_logits(logits=l, labels=self.y))
            if layer_l2 is not None:
                self.loss += embed_l2 * tf.nn.l2_loss(xw)
                for i in range(len(layer_sizes)):
                    wi = self.vars['w%d' % i]
                    self.loss += layer_l2[i] * tf.nn.l2_loss(wi)
            self.optimizer = get_optimizer(opt_algo, learning_rate, self.loss)

            config = tf.ConfigProto()
            config.gpu_options.allow_growth = True
            self.sess = tf.Session(config=config)
            tf.global_variables_initializer().run(session=self.sess)

SNN

和FNN的不同就是最底层的结构和预训练方式。其最底层是全连接的，用RBM和DAE预训练。预训练的时候，因为特征数量太多，为了减少计算量，每个field里值为0的特征抽取m个，没有抽中的特征在该次权重更新就会被完全忽略。

FNN比SNN-DAE和SNN-RBM好，两种SNN结果总是差不多，但都比LR和FM好。

文章还指出一点，钻石型网络结构比常数型结构好，常数型又比增加型，减少型结构好

NFM

Neural Factorization Machines for Sparse Predictive Analytics

NFM的基本特点：

利用二阶交互池化层（Bi-Interaction Pooling）对FM嵌入后的向量两两进行元素级别的乘法，形成同维度的向量求和后作为前馈神经网络的输入。
NFM与DeepFM的区别是没有单独的FM的浅层网络进行联合训练，而是将其整合后直接输出给前馈神经网络。
当MLP的全连接层都是恒等变换且最后一层参数全为1时，NFM就退化成了FM。可见，NFM是FM的推广，它推迟了FM的实现过程，并在其中加入了更多非线性运算。
NFM与FNN非常相似。它们的主要区别是NFM在embedding之后对特征进行了两两逐元素乘法。因为逐元素相乘的向量维数不变，之后对这些向量求和的维数仍然与embedding的维数一致。因此输入到MLP的参数比起直接concatenate的FNN更少。

tf实现：

def model_fn(features, labels, mode, params):
    """Bulid Model function f(x) for Estimator."""
    #------hyperparameters----
    field_size = params["field_size"]
    feature_size = params["feature_size"]
    embedding_size = params["embedding_size"]
    l2_reg = params["l2_reg"]
    learning_rate = params["learning_rate"]
    #optimizer = params["optimizer"]
    layers = map(int, params["deep_layers"].split(','))
    dropout = map(float, params["dropout"].split(','))

    #------bulid weights------
    Global_Bias = tf.get_variable(name='bias', shape=[1], initializer=tf.constant_initializer(0.0))
    Feat_Bias = tf.get_variable(name='linear', shape=[feature_size], initializer=tf.glorot_normal_initializer())
    Feat_Emb = tf.get_variable(name='emb', shape=[feature_size,embedding_size], initializer=tf.glorot_normal_initializer())

    #------build feaure-------
    feat_ids  = features['feat_ids']
    feat_ids = tf.reshape(feat_ids,shape=[-1,field_size])
    feat_vals = features['feat_vals']
    feat_vals = tf.reshape(feat_vals,shape=[-1,field_size])

    #------build f(x)------
    with tf.variable_scope("Linear-part"):
        feat_wgts = tf.nn.embedding_lookup(Feat_Bias, feat_ids)         # None * F * 1
        y_linear = tf.reduce_sum(tf.multiply(feat_wgts, feat_vals),1)

    with tf.variable_scope("BiInter-part"):
        embeddings = tf.nn.embedding_lookup(Feat_Emb, feat_ids)         # None * F * K
        feat_vals = tf.reshape(feat_vals, shape=[-1, field_size, 1])
        embeddings = tf.multiply(embeddings, feat_vals)                 # vij * xi
        sum_square_emb = tf.square(tf.reduce_sum(embeddings,1))
        square_sum_emb = tf.reduce_sum(tf.square(embeddings),1)
        deep_inputs = 0.5*tf.subtract(sum_square_emb, square_sum_emb)   # None * K

    with tf.variable_scope("Deep-part"):
        if mode == tf.estimator.ModeKeys.TRAIN:
            train_phase = True
        else:
            train_phase = False

        if mode == tf.estimator.ModeKeys.TRAIN:
            deep_inputs = tf.nn.dropout(deep_inputs, keep_prob=dropout[0])                      # None * K
        for i in range(len(layers)):
            deep_inputs = tf.contrib.layers.fully_connected(inputs=deep_inputs, num_outputs=layers[i], \
                weights_regularizer=tf.contrib.layers.l2_regularizer(l2_reg), scope='mlp%d' % i)

            if FLAGS.batch_norm:
                deep_inputs = batch_norm_layer(deep_inputs, train_phase=train_phase, scope_bn='bn_%d' %i)   #放在RELU之后 https://github.com/ducha-aiki/caffenet-benchmark/blob/master/batchnorm.md#bn----before-or-after-relu
            if mode == tf.estimator.ModeKeys.TRAIN:
                deep_inputs = tf.nn.dropout(deep_inputs, keep_prob=dropout[i])                              #Apply Dropout after all BN layers and set dropout=0.8(drop_ratio=0.2)
                #deep_inputs = tf.layers.dropout(inputs=deep_inputs, rate=dropout[i], training=mode == tf.estimator.ModeKeys.TRAIN)

        y_deep = tf.contrib.layers.fully_connected(inputs=deep_inputs, num_outputs=1, activation_fn=tf.identity, \
            weights_regularizer=tf.contrib.layers.l2_regularizer(l2_reg), scope='deep_out')
        y_d = tf.reshape(y_deep,shape=[-1])

    with tf.variable_scope("NFM-out"):
        #y_bias = Global_Bias * tf.ones_like(labels, dtype=tf.float32)  # None * 1  warning;这里不能用label，否则调用predict/export函数会出错，train/evaluate正常；初步判断estimator做了优化，用不到label时不传
        y_bias = Global_Bias * tf.ones_like(y_d, dtype=tf.float32)      # None * 1
        y = y_bias + y_linear + y_d
        pred = tf.sigmoid(y)

    predictions={"prob": pred}
    export_outputs = {tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: tf.estimator.export.PredictOutput(predictions)}
    # Provide an estimator spec for `ModeKeys.PREDICT`
    if mode == tf.estimator.ModeKeys.PREDICT:
        return tf.estimator.EstimatorSpec(
                mode=mode,
                predictions=predictions,
                export_outputs=export_outputs)

    #------bulid loss------
    loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=y, labels=labels)) + \
        l2_reg * tf.nn.l2_loss(Feat_Bias) + l2_reg * tf.nn.l2_loss(Feat_Emb)

    # Provide an estimator spec for `ModeKeys.EVAL`
    eval_metric_ops = {
        "auc": tf.metrics.auc(labels, pred)
    }
    if mode == tf.estimator.ModeKeys.EVAL:
        return tf.estimator.EstimatorSpec(
                mode=mode,
                predictions=predictions,
                loss=loss,
                eval_metric_ops=eval_metric_ops)

    #------bulid optimizer------
    if FLAGS.optimizer == 'Adam':
        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8)
    elif FLAGS.optimizer == 'Adagrad':
        optimizer = tf.train.AdagradOptimizer(learning_rate=learning_rate, initial_accumulator_value=1e-8)
    elif FLAGS.optimizer == 'Momentum':
        optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.95)
    elif FLAGS.optimizer == 'ftrl':
        optimizer = tf.train.FtrlOptimizer(learning_rate)

    train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())

    # Provide an estimator spec for `ModeKeys.TRAIN` modes
    if mode == tf.estimator.ModeKeys.TRAIN:
        return tf.estimator.EstimatorSpec(
                mode=mode,
                predictions=predictions,
                loss=loss,
                train_op=train_op)

AFM

Attentional Factorization Machines:Learning theWeight of Feature Interactions via Attention Networks

NFM的主要创新点是在FM过程中添加了逐元素相乘的运算来增加模型的复杂度。但没有在此基础上添加更复杂的运算过程，比如对加权求和。

AFM的特点是：

AFM与NFM都是致力于充分利用二阶特征组合的信息，对嵌入后的向量两两进行逐元素乘法，形成同维度的向量。而且AFM没有MLP部分。
AFM通过在逐元素乘法之后形成的向量进行加权求和，而且权重是基于网络自身来产生的。其方法是引入一个注意力子网络（Attention Net）。
当权重都相等时，AFM退化成无全连接层的NFM。
“注意力子网络”的主要操作是进行矩阵乘法，其最终输出结果为softmax，以保证各分量的权重本身是一个概率分布。

PNN

Product-based Neural Networks for User Response Prediction

首先对输入数据进行embedding处理，得到一个low-dimensional vector层
对该层的任意两个feature进行内积或是外积处理就得到上图的蓝色节点，
是把这些Feature直接和1相乘复制到上一层的Z中，
然后把Z和P接在一起就可以作为神经网络的输入层，
在此基础上我们就可以应用神经网络去模型了。

假设有N个field，每个field是M维的embedding。

IPNN

field之间使用内积。左边的z就是一个NxM维的，而对于p来讲，p是NxN的。所以对p来讲，使用矩阵分解来简化问题：

任意的 N×N 实对称矩阵都有 N 个线性无关的特征向量。并且这些特征向量都可以正交单位化而得到一组正交且模为1的向量。故实对称矩阵A可被分解成 $A=Q\Lambda Q^T$。其中，Q为正交矩阵，$\Lambda$为实对角矩阵。

由于weight matrix是一个对称方阵，所以，如果进行一阶低秩矩阵分解，那么可以分解为$W^n_p=\theta ^n(\theta ^n)^T$，$\theta ^N\in R^N$。

而如果进行K阶低秩矩阵分解，就有：

\[ W^n_p\odot p=\sum ^N_{i=1}\sum ^N_{j=1}\left \langle \theta ^i_n,\theta ^j_n \right \rangle \left \langle f_i,f_j \right \rangle \]

其中，$\theta ^i_n\in R^K$。

OPNN

和IPNN唯一不同的是构造交叉项的方式：

PNN小结

利用二阶向量积层（Pair-wisely Connected Product Layer）对FM嵌入后的向量两两进行向量积，形成的结果作为之后MLP的输入。PNN采用的向量积有内积与外积两种形式。
PNN中向量与常数1进行的乘法运算其实与FNN类似，不是PNN的主要创新点。
对于内积形式的PNN，因为两个向量相乘的结果为标量，可以直接把各个标量“拼接”成一个大向量，就可以作为MLP的输入了。
当MLP的全连接层都是恒等变换且最后一层参数全为1时，内积形式的PNN就退化成了FM。
对于外积形式的PNN，因为两个向量相乘相当于列向量与行向量进行矩阵相乘，得到的结果为一个矩阵。各个矩阵向之前内积形式的操作一样直接拼接起来维数太多，论文的简化方案是直接对各个矩阵进行求和，得到的新矩阵（可以理解成之后对其拉长成向量）就直接作为MLP的输入。
观察计算图发现外积形式的PNN与NFM很像，其实就是PNN把NFM的逐元素乘法换成了外积。

CCPM

CIKM2015的文章A Convolutional Click Prediction Model

为了充分利用历史的顺序点击的信息，可以有基于RNN的预测模型，把用户所浏览的历史记录作为序列，通过用户在不同的时间间隔内来划分用户的历史点击序列。然而在真实的场景下，用户对商品的兴趣会随时间而改变，RNN模型在此刻的场景下就受到限制。本文用cnn来解决。

在单条广告展示中（single ad impression），包括许多元素：element = (user, query, ad, impression time, site category, device type, etc)。用户是否点击一个广告与用户的历史ad impression有关。
一系列的ad impression组成sequential ad impression。

基于以上两种情况来预测点击概率。

ccpm包括convolutional layers和flexible p-max pooling layers两种layer：

Convolution Layer

每个样本有$n$个特征，对每个特征使用embeding得到定长为$d$的向量$e_i\in R^d$。构成矩阵$s\in R^{d\times n}$(一列是一个$d$维的向量$e_i$)：

\[ \begin{bmatrix} \vdots & \vdots &\vdots \\ e_1 & ... & e_n \\ \vdots & \vdots & \vdots \end{bmatrix} \]

然后就可以用cnn了：

搞一个$w\in R^{d\times \omega}$的权重矩阵进行卷积，卷积完得到的矩阵$r\in R^{d\times (n+\omega -1)}$。给定各矩阵的第$i$行：$w_i\in R^{\omega}$，和$s_i\in R^n$，还有$r_i\in R^{(n+\omega -1)}$。那么：

\[ r_i=w_i^Ts_{i,j-\omega +1:j} \]

其中$j=1,...,n+\omega -1$。将out-of-range的值$s_{i,k}$，即$k<1\ or\ k>n$全部置为0(即不要padding)。

解释一下下：$w\in R^{d\times \omega}$，所以，$w^T\in R^{\omega \times d}$，$w_i^T$就是这个矩阵的第$i$行这个长度为$d$的向量。$s_{i,j-\omega +1:j}$指的是$s$中的大小为$d\times \omega$的小矩阵的第$i$行（因为卷积是element-wise的乘积再相加，也就是两个相同维度的向量做内积，所以这里也是『行』！）,这行有$\omega$个元素（$j-(j-\omega+1)+1=\omega$），而start的范围是$1-w+1,...,n$，也就是$1-\omega+1\le j-\omega -1 \le n$，所以，$1\le j \le n+\omega -1$：

Flexible p-Max Pooling

由于输入的长度是可变的，为了降低这种影响，对应的池化层的参数应该也是灵活可变的。给定一个vector $r_i\in R^n$，所谓的p-max pooling就是取出一个sub-vector $s^p_i\in R^p$，取出原vector里最大的p个值。因为输入的instance是变长的，所以卷积层输出的长度也会随着变化，所以pooling层需要足够灵活地平滑地取出这p个数。因此，定义p为一个与输入数据长度及网络深度有关的参数：

\[ p_i=\left\{\begin{matrix} (1-(i/l)^{l-i})n, & i = 1,...,l-1 \\ 3, & i=l \end{matrix}\right. \]

其中，$l$代表卷积层的层数，$n$表示输入的长度（特征数），$p_i$表示第$i$个池化层的参数。例如，$n=18$，有3个卷积层，那么$p_1=16,p_2=6,p_3=3$。好处：

最后一个pooling层输出固定是3，不论输入长度怎么变化，都是固定的
这是一个power-exponential函数，与线性函数相比，一开始变化很慢，避免了一开始损失太多重要特征

我们看一下图像就一目了然了，假设有5层，我们看$n$前面的系数，也就是把层数$i$当成变量$x$。可以看到，一开始系数很接近1，所以变化很慢，后面就衰减得比较快，在5的时候衰减到0，所以我们要手动把最后一层设成一个固定的数：

feature maps

pooling完了后，接的是tanh。本文里把经过了卷积、pooling和tanh的结果叫1阶feature map。定义第$i$阶feature map为$F^i$。对于中间的某一层，里面其实有很多个feature map，完全可以并行计算。例如，定义$F^i_j$是$i$阶feature maps里的第$j$个feature map，是通过如下方式计算的：将distinct的权重矩阵$w^i_{j,k}$和低阶$i-1$的每个feature map $F^{i-1}_k$的卷积结果加起来：

\[ F^i_j=\sum ^{m_i}_{k=1}w^i_{j,k}* F^{i-1}_j \]

其中，$m_i$是第$i$阶的feature map数，$*$是卷积。类似地，$F^i_j$后面可以接pooling。最后接fc再接softmax得到最终输出。

ccpm小结

如上图，embed的维数$d=4$，有2个卷积层，每个卷积层分别生成了2个feature map。第一个卷积层的filter的宽度即$\omega _1=k_1=3$，也就是图中左边的蓝色部分，长度为3，第二个卷积层的filter的宽度即$w_2=k_2=2$，也就是图中中间的蓝色部分长度为2。这里把最后一个pooling层的$p_2$设成固定的2。

Wide & Deep

Wide & deep learning for recommender systems

LR 对于 DNN 模型的优势是对大规模稀疏特征的容纳能力，包括内存和计算量等方面，工业界都有非常成熟的优化方法；而 DNN 模型具有自己学习新特征的能力，一定程度上能够提升特征使用的效率，这使得 DNN 模型在同样规模特征的情况下，更有可能达到更好的学习效果。

模型结构如下：

模型左边的 Wide 部分，可以容纳大规模系数特征，并且对一些特定的信息（比如 ID）有一定的记忆能力；而模型右边的 Deep 部分，能够学习特征间的隐含关系，在相同数量的特征下有更好的学习和推导能力。

用于apps推荐：

wide侧：用户安装的app和浏览过的app的cross-product
deep侧：每个categorical产出一个32维的emb，然后concate到一起，再和连续值特征concate到一起得到一个约1200维的vec，再接3层fc和relu(1024->512->256)
wide和deep的输出加起来（如果是2分类问题，wide和deep的输出就都是一维，如果是n分类问题，那就是n维），加完的结果再丢给sigmoid或者softmax，去和label算交叉熵

用于ctr预估https://github.com/PaddlePaddle/models/tree/develop/ctr

特征的生成：https://github.com/PaddlePaddle/models/blob/develop/ctr/dataset.md

tf代码：

def get_model(model_type, model_dir):
    print("Model directory = %s" % model_dir)

    # 对checkpoint去做设定
    runconfig = tf.contrib.learn.RunConfig(
        save_checkpoints_secs=None,
        save_checkpoints_steps = 100,
    )

    m = None

    # 宽模型
    if model_type == 'WIDE':
        m = tf.contrib.learn.LinearClassifier(
            model_dir=model_dir, 
            feature_columns=wide_columns)

    # 深度模型
    if model_type == 'DEEP':
        m = tf.contrib.learn.DNNClassifier(
            model_dir=model_dir,
            feature_columns=deep_columns,
            hidden_units=[100, 50, 25])

    # 宽度深度模型
    if model_type == 'WIDE_AND_DEEP':
        m = tf.contrib.learn.DNNLinearCombinedClassifier(
            model_dir=model_dir,
            linear_feature_columns=wide_columns,
            dnn_feature_columns=deep_columns,
            dnn_hidden_units=[100, 70, 50, 25],
            config=runconfig)

    print('estimator built')

    return m

注意：wide deep在wide侧和deep侧用的是两个优化方法：

https://www.tensorflow.org/api_docs/python/tf/estimator/DNNLinearCombinedClassifier

linear_optimizer='Ftrl',
dnn_optimizer='Adagrad',

可以通过如下方式对不同参数指定不同的优化方法~

https://stackoverflow.com/questions/34945554/how-to-set-layer-wise-learning-rate-in-tensorflow

DeepFM

DeepFM: A Factorization-Machine based Neural Network for CTR Prediction

DeepFM和之前模型相比优势在于两点:

相对于Wide&Deep不再需要手工构建wide部分
另一个相对于FNN，FNN把FM的隐向量参数直接作为网络参数学习。而DeepFM将embedding层结果输入给FM和MLP，两者输出叠加，达到捕捉了低阶和高阶特征交叉的目的。

Deep & Cross

论文地址：deep & cross network for ad click predictions

参考：https://daiwk.github.io/posts/dl-deep-cross-network.html

DCN的特点如下：

Deep部分就是普通的MLP网络，主要是全连接。
与DeepFM类似，DCN是由embedding+MLP部分与cross部分进行联合训练的。Cross部分是对FM部分的推广。
可以证明，cross网络是FM的过程在高阶特征组合的推广。
只有两层，且第一层与最后一层权重参数相等时的Cross网络与简化版FM等价。
简化版的FM指的是，将拼接好的稠密向量作为输入向量，且不做领域方面的区分（但产生这些稠密向量的过程是考虑领域信息的，相对全特征维度的全连接层减少了大量参数，可以视作稀疏链接思想的体现）。而且之后进行embedding权重矩阵W只有一列——是退化成列向量的情形
与MLP网络相比，Cross部分在增加高阶特征组合的同时减少了参数的个数，并省去了非线性激活函数。

xDeepFM

参考KDD 2018 | 推荐系统特征构建新进展：极深因子分解机模型

还可以参考XDeepFM—-左边跟我撸个CIN，右边画一个DNN

xDeepFM: Combining Explicit and Implicit Feature Interactions for Recommender Systems

代码：https://github.com/Leavingseason/xDeepFM

传统的推荐系统中，高阶交叉特征通常是由工程师手工提取的，这种做法主要有三种缺点：

重要的特征都是与应用场景息息相关的，针对每一种应用场景，工程师们都需要首先花费大量时间和精力深入了解数据的规律之后才能设计、提取出高效的高阶交叉特征，因此人力成本高昂
原始数据中往往包含大量稀疏的特征，例如用户和物品的ID，交叉特征的维度空间是原始特征维度的乘积，因此很容易带来维度灾难的问题
人工提取的交叉特征无法泛化到未曾在训练样本中出现过的模式中。

目前大部分相关的研究工作是基于因子分解机的框架，利用多层全连接神经网络去自动学习特征间的高阶交互关系，例如FNN、PNN和DeepFM等。其缺点是模型学习出的是隐式的交互特征，其形式是未知的、不可控的；同时它们的特征交互是发生在元素级bit-wise而不是特征向量之间vector-wise，这一点违背了因子分解机的初衷。

同时以显式和隐式的方式自动学习高阶的特征交互，使特征交互发生在向量级，还兼具记忆与泛化的学习能力。

背景

FM将每个feature映射成一个D维的隐向量$v_i=[v_{i1},v_{i2},...,v_{iD}]$，然后将pairwise的特征交叉建模为隐向量的内积$f^{(2)}(i,j)=\left \langle v_i,v_j \right \rangle x_i x_j$，本文中将隐向量$v_i$的一个元素（例如$v_{i1}$）称作『bit』。。传统FM能扩展到任意高阶的特征交互，但同时对有用和无用的组合都建模了。而这些无用的组合可能会引入噪音并降低精度。

FNN（ Factorisation-machine supported Neural Network）在使用DNN之前，为field embedding使用pre-trained的FM。

PNN为embedding layer和DNN layer引入了product layer，从而不需要对pretrained FM的依赖。

FNN和PNN的缺点是，他们更多地关注高阶特征组合，而忽视了低阶的特征组合。

wide&deep和deepFM使用混合架构，在网络中有shallow part和deep part，保证memorization和generalization，从而克服了这个问题。

而并没有理论上的结论来证明，DNN能够支持的最高阶的特征交互到底有多少。而且，DNN是bit-wise的交互，与FM的vector-wise交互是不同的。

本文与DCN类似，但把cross network替换成了CIN。

预备知识

embedding

假设有m个field，每个field都从原始特征映射成了一个D维的embedding向量$e_i\in R^D$，那么embedding就是一个concat到一起的vector：

\[ e=[e_1,e_2,...,e_m] \]

如下图，就是D=4的embedding layer：

隐式的高阶特征交互

FNN，Deep crossing，wide&deep的deep部分都是直接用DNN来隐式地进行高阶特征交互。这里的交互是bit-wise的，也就是说，即使是同一个field里的feature，也会互相影响。

而PNN和DeepFM做的改进就是，加入了vector-wise的交互，区别如下：

PNN将product layer的输出直接做为DNN的输入
DeepFM将FM layer直接连到了output unit

显式的高阶特征交互

cross network使用如下公式进行高阶特征组合：

\[ x_k=x_0x^T_{k-1}w_k+b_k+x_{k-1} \]

其中，$w_k,x_k,b_k\in R^{m\times D}$，假设$d=m\times D$。可以通过证明发现，cross network其实是一种特殊的高阶特征交互，每一个hidden layer其实是$x_0$乘了一个scalar。。

证明：

k=1时，

\[ \begin{align*} x_1 &= x_0(x_0)^Tw_1+x_0 \\ &=x_0(x_0^Tw_1+1) \\ &=\alpha ^1x_0 \end{align*} \]

scalar$\alpha ^1$是$x_0$的一个线性变换($x_0$是dx1，所以$x_0^T$是1xd，而$w_1$是dx1，所以$x_0^Tw_1$是一个标量。。然后假设k=i成立，即$x_i=\alpha ^i x_0$。对于k=i+1，

\[ \begin{align*} x_{i+1} &= x_0(x_i)^Tw_{i+1}+x_i \\ &=x_0((\alpha ^ix_0)^Tw_1)+ \alpha ^ix_0 \\ &=\alpha ^{i+1}x_0 \end{align*} \]

其中$\alpha ^{i+1}=\alpha ^i(x^T_0w_{i+1}+1)$同样是一个scalar。。

当然了，这并不意味着$x_k$就是$x_0$的一个线性变换。$\alpha ^{i+1}$对$x_0$是敏感的。

因此，cross network有两个缺点：

每一层变成了$x_0$与一个标量相乘
高阶的特征交互变成了bit-wise，而不是FM所期待的vector-wise

CIN

假设总共有$m$个field，每个field的embedding是一个$D$维向量。

压缩交互网络（Compressed Interaction Network，简称CIN）隐向量是一个单元对象，因此我们将输入的原特征和神经网络中的隐层都分别组织成一个矩阵，记为$X^0$和$X^k$，CIN中每一层的神经元都是根据前一层的隐层以及原特征向量推算而来，其计算公式如下：

\[ X^k_{h,*}=\sum ^{H_{k-1}}_{i=1}\sum ^{m}_{j=1}W^{k,h}_{ij}(X^{k-1}_{i,*}\circ X^{0}_{j,*}) \]

其中，第k层隐层含有$H_k$条神经元向量。$\circ $是Hadamard product，即element-wise product，即，$\left \langle a_1,a_2,a_3\right \rangle\circ \left \langle b_1,b_2,b_3\right \rangle=\left \langle a_1b_1,a_2b_2,a_3b_3 \right \rangle$。

隐层的计算可以分成两个步骤：

根据前一层隐层的状态$X^k$和原特征矩阵$X^0$，计算出一个中间结果$Z^{k+1}$，它是一个三维的张量。注意图中的$\bigotimes $是outer product，其实就是矩阵乘法咯，也就是一个mx1和一个nx1的向量的外积是一个mxn的矩阵：

\[ u\bigotimes v=uv^T=\begin{bmatrix} u_1\\ u_2\\ u_3\\ u_4 \end{bmatrix}\begin{bmatrix} v_1 & v_2 & v_3 \end{bmatrix}=\begin{bmatrix} u_1v_1 & u_1v_2& u_1v_3 \\ u_2v_1 & u_2v_2 & u_2v_3\\ u_3v_1 & u_3v_2 & u_3v_3\\ u_4v_1 & u_4v_2 & u_4v_3 \end{bmatrix} \]

而图中的$D$维，其实就是左边的一行和右边的一行对应相乘，

接下来，如下图所示：

也就是说，这个时候把$Z^{k+1}$看成一个channel数是$D$的image，而把$W^{k,h}$看成一个$H^k*m$的卷积核（filter），这个卷积核大小和image一样，沿着embedding dimension($D$)进行slide，一个卷积核处理后就映射成一个1x1xD的向量。使用$H^{k+1}$个的卷积核，就生成一个$H^{k+1}*D$的矩阵。

可以复习一下卷积的那些公式：

大致逻辑https://github.com/Leavingseason/xDeepFM/blob/master/exdeepfm/src/CIN.py#L295：

                split_tensor = tf.split(hidden_nn_layers[-1], hparams.dim * [1], 2)
                dot_result_m = tf.matmul(split_tensor0, split_tensor, transpose_b=True)
                dot_result_o = tf.reshape(dot_result_m, shape=[hparams.dim, -1, field_nums[0]*field_nums[-1]])
                dot_result = tf.transpose(dot_result_o, perm=[1, 0, 2])

                filters = tf.get_variable(name="f_"+str(idx),
                                         shape=[1, field_nums[-1]*field_nums[0], layer_size],
                                         dtype=tf.float32)
                # dot_result = tf.transpose(dot_result, perm=[0, 2, 1])
                curr_out = tf.nn.conv1d(dot_result, filters=filters, stride=1, padding='VALID')

CIN的总体框架如下图：

最终学习出的特征交互的阶数是由网络的层数决定的，每一层隐层都通过一个pooling操作连接到输出层，从而保证了输出单元可以见到不同阶数的特征交互模式。

CIN的结构与RNN是很类似的，即每一层的状态是由前一层隐层的值与一个额外的输入数据计算所得。不同的是，

CIN中不同层的参数是不一样的，而在RNN中是相同的；
RNN中每次额外的输入数据是不一样的，而CIN中额外的输入数据是固定的，始终是$X^0$。

xDeepFM

CIN+DNN+linear

集成的CIN和DNN两个模块能够帮助模型同时以显式和隐式的方式学习高阶的特征交互，而集成的线性模块和深度神经模块也让模型兼具记忆与泛化的学习能力。值得一提的是，为了提高模型的通用性，xDeepFM中不同的模块共享相同的输入数据。而在具体的应用场景下，不同的模块也可以接入各自不同的输入数据，例如，线性模块中依旧可以接入很多根据先验知识提取的交叉特征来提高记忆能力，而在CIN或者DNN中，为了减少模型的计算复杂度，可以只导入一部分稀疏的特征子集。

一些基本知识可以参考：一镜到底：FM们的原理及在贝壳搜索的实践

DIN

Deep Interest Network for Click-Through Rate Prediction

以上神经网络对同领域离散特征的处理基本是将其嵌入后直接求和，这在一般情况下没太大问题。但其实可以做得更加精细。比如对于历史统计类特征。

以用户历史浏览的商户id为例，假设用户历史浏览了10个商户，这些商户id的常规处理方法是作为同一个领域的特征嵌入后直接求和得到一个嵌入向量。但这10个商户只有一两个商户与当前被预测的广告所在的商户相似，其他商户关系不大。增加这两个商户在求和过程中的权重，应该能够更好地提高模型的表现力。而增加求和权重的思路就是典型的注意力机制思路。DIN主要关注用户在同一领域的历史行为特征，如浏览了多个商家、多个商品等。DIN可以对这些特征分配不同的权重进行求和。

用户的每个领域的历史特征权重则由该历史特征及其对应备选广告特征通过一个子网络得到。即用户历史浏览的商户特征与当前浏览商户特征对应，历史浏览的商品特征与当前浏览商品特征对应。
权重子网络主要包括特征之间的元素级别的乘法、加法和全连接等操作。
AFM也引入了注意力机制。但是AFM是将注意力机制与FM同领域特征求和之后进行结合，DIN直接是将注意力机制与同领域特征求和之前进行结合。

DIEN

参考https://github.com/alibaba/x-deeplearning/wiki/%E7%94%A8%E6%88%B7%E5%85%B4%E8%B6%A3%E6%BC%94%E5%8C%96%E6%A8%A1%E5%9E%8B(DIEN)

这篇工作中我们提出用户的兴趣是一个抽象的概念，用户的历史行为只是抽象的兴趣的一个具体的体现。在DIEN中我们提出了兴趣抽取和兴趣演化两个模块共同组成的CTR预估模型。

兴趣提取

传统的算法直接将用户的历史行为当做用户的兴趣。同时整个建模过程中的监督信息全部集中于广告点击样本上。而单纯的广告点击样本只能体现用户在决策是否点击广告时的兴趣，很难建模好用户历史每个行为时刻的兴趣。

本文提出了auxiliary loss用于兴趣提取模块，约束模型在对用户每一个历史行为时刻的隐层表达能够推测出后续的行为，我们希望这样的隐层表达能更好的体现用户在每一个行为时刻的兴趣。

兴趣提取层部分我们主要采用GRU结构来对用户行为序列进行建模，获取得到用户在不同时刻的兴趣表达。同时我们在每个时间点约束当前兴趣表达可以预测下一个时刻的点击以及用户下时刻采样的不点击行为。我们将这样的约束方式作为模型的辅助loss的方式引入学习。通过加入辅助loss的方式不仅能够引入用户的反馈信息并且还能够帮助长序列的学习，降低梯度回传难度，同时还能够提供更多的语义信息帮助embedding部分的学习。

看着是不是有点晕，不急，我们来看上面那个图。。其实就是一个gru，然后比如说现在是时间步$t$，那么这个时刻的输出$h(t)$：

一方面需要和下一个时间步的输入的用户点击历史里的点击样本$e(t+1)$去算一个点击的loss
另一方面，需要和下一个时间步的输入的负采样样本$e'(t+1)$去算另一个不点击的loss

然后，每一个时间步的$h(t)$还要再和所有的目标广告去算attention，作为下面的AUGRU的输入。

兴趣演化

传统的RNN类似的方法只能建模一个单一的序列，然而在电商场景用户不同的兴趣其实有不同的演化过程。本文中提出了AUGRU（Activation Unit GRU），让GRU的update门和预估的商品相关。在建模用户的兴趣演化过程中，AUGRU会根据不同的预估目标商品构建不同的兴趣演化路径，推断出用户和此商品相关的兴趣。

用户的兴趣是多种多样的，其同时存在多个兴趣轨迹，我们在预测当前AD时，只需要关心和这个目标AD相关的兴趣的演化状态。在DIN算法里我们采用的是attention的方式得到用户和当前ad相关的兴趣状态，但是没有考虑到用户兴趣间的演化关系。所以我们在兴趣演化层部分首先将和当前ad相关的子兴趣提取出来，然后把这些子兴趣进行序列建模，从而能够获取得到和当前ad相关的兴趣演化信息。在这里我们将GRU结构进行了改进，将ad和兴趣的相关信息引入了门更新，实现了对不同的目标AD，用户都有一条独有的兴趣演化轨迹。

\[ \begin{matrix} r_t=\sigma(W^ri_t+U^rh_{t-1}+b^r) \\ u_t=\sigma(W^ui_t+U^uh_{t-1}+b^u) \\ u'_t=u_t*a_t \\ \hat{h_t}=tanh(W^hi_t+r_t\circ U^hh_{t-1}+b^h)\\ h_t=(1-u'_t)\circ h_{t-1}+u'_t\circ \hat{h_t} \end{matrix} \]

是不是有点晕。。没事，我们对比一下正常gru的公式。。https://daiwk.github.io/posts/nlp-nmt.html#12-gru

\[ \\ z_t=\sigma(W_zx_t+U_zh_{t-1}+b_z) \\ r_t=\sigma(W_rx_t+U_rh_{t-1}+b_r) \\ h_t=z_t \circ h_{t-1}+(1-z_t) \circ tanh(W_hx_t+ U_h(r_t \circ h_{t-1}) + b_h) \]

就会发现其实一毛一样。。只是把更新门多乘了一个attention权重而已。。。

$a_t$是ad和当前时间点兴趣(由兴趣提取层提取得到)的相关度权重

\[ a_i=\frac{exp(h_iWe_{ad})}{\sum^T_{i=0}exp(h_jWe_{ad})} \]

然后，将兴趣演化层的最后一个时刻的兴趣表达$h'(T)$作为用户兴趣，因为它捕捉了用户兴趣的演化信息，并且是和ad相关的子兴趣表达。最后将$h'(T)$和ad特征、上下文特征、用户静态信息特征一起拼接在一起，输出多层dnn进行预测。

代码实现：https://github.com/alibaba/x-deeplearning/blob/master/xdl-algorithm-solution/DIEN/script/model.py

其中augru的实现如下：

https://github.com/alibaba/x-deeplearning/blob/master/xdl-algorithm-solution/DIEN/script/utils.py#L139

ESMM

Entire Space Multi-Task Model: An Effective Approach for Estimating Post-Click Conversion Rate

传统CVR预估模型会有比较明显的样本选择偏差（sample selection bias）和训练数据过于稀疏（data sparsity ）的问题，而ESMM模型利用用户行为序列数据，在完整的样本数据空间同时学习点击率和转化率（post-view clickthrough&conversion rate，CTCVR），在一定程度上解决了这个问题。

定义：$pctcvr=pctr*pcvr$

主任务是pCVR。引入两个辅助任务，分别拟合pCTR和pCTCVR，把pCVR当做一个中间变量。

\[ L(\theta_{cvr},\theta_{ctr})=\sum ^N_{i=1}l(y_i,f(x_i;\theta_{ctr}))+\sum ^N_{i=1}l(y_i\&z_i,f(x_i;\theta_{ctr})\times f(x_i;\theta_{cvr})) \]

其中，$l$是交叉熵。可以参考https://github.com/alibaba/x-deeplearning/blob/master/xdl-algorithm-solution/ESMM/script/esmm.py#L269

实际操作中，由于pCTR通常很小，pCTCVR除这个很小的数，容易溢出。故ESMM采用了乘法的形式，避免了除法。且能够使pCVR的值在[0,1]区间。

ESMM模型是在整个样本空间建模，而不像传统CVR预估模型那样只在点击样本空间建模。

创新点其实是，一方面在特征间传统mtl的隐式共享，另一方面，在label间找到了显式的关联（在此模型中，就是连乘关系）

代码：https://github.com/alibaba/x-deeplearning/blob/master/xdl-algorithm-solution/ESMM/script/esmm.py#L228

TDM

严格来说，tdm是个召回模型，这里一起看一看

Learning Tree-based Deep Model for Recommender Systems

https://github.com/alibaba/x-deeplearning/wiki/%E6%B7%B1%E5%BA%A6%E6%A0%91%E5%8C%B9%E9%85%8D%E6%A8%A1%E5%9E%8B(TDM)

CIKM 2019 EComm AI：超大规模推荐之用户兴趣高效检索赛题解读及阿里深度树匹配技术实践

DeepGBM

KDD2019上，DeepGBM: A Deep Learning Framework Distilled by GBDT for Online Prediction Tasks

而目前广泛用于这些任务的机器学习模型都没有完美适配这两个重要的特性。常用的机器学习模型大致可分为三类：梯度提升树（GBDT）、神经网络（NN）和二者（GBDT+NN）结合的模型。其中 GBDT 可以很好地处理连续的数值特征，但很难处理好稀疏的类别特征，并且 GBDT 是利用全量数据学习的，很难高效地进行在线更新；而 NN（如Wide&Deep、DeepFM等）虽然可以用 embedding 技术处理好稀疏类别特征，且可以高效地在线更新，但其难以很好地处理数值特征；常见的 GBDT+NN 方法会单独使用 GBDT 再使用 NN，但同样由于 GBDT 的缘故，难以在线更新。

DeepGBM 主要包含两个子模块——面向类别特征的 CatNN 和面向数值特征的 GBDT2NN。CatNN 主要继承了 NN 中对类别特征友好的 Deep 模块和 FM 模块；GBDT2NN 是文章最主要的贡献之一，其基于 GBDT 进行知识蒸馏构造了一个 NN 模块，可以有效地处理类别特征并可以在线更新。综上，DeepGBM 既支持含有类别特征和数值特征的表格型数据输入，还能利用实时产生的数据进行学习和更新。

各种比赛

2019腾讯广告大赛：

冠军方案：https://zhuanlan.zhihu.com/p/72762888

https://zhuanlan.zhihu.com/p/73062485

初赛代码：https://github.com/guoday/Tencent2019_Preliminary_Rank1st

包括deepwalk/CIN/key-value memory network等

Key-Value Memory Networks for Directly Reading Documents

应用示例

从模型到部署，FPGA该怎样加速广告推荐算法

parameter server详解

2018-01-11T00:00:00+00:00

背景
发展历程
对比parameter server与通用分布式系统
parameter server的优势
parameter server系统架构
Implementation
Server Management
其他资料

Parameter Server 详解

参考论文： Scaling Distributed Machine Learning with the Parameter Server

背景

现实中，训练数据的数量可能达到1TB到1PB之间，而训练过程中的参数可能会达到$10^9$（十亿）到$10^{12}$（千亿）。而往往这些模型的参数需要被所有的worker节点频繁的访问，就有如下问题与挑战：

需要大量的网络带宽支持
很多机器学习算法都是连续型的，只有上一次迭代完成（各个worker都完成）之后，才能进行下一次迭代，这就导致了如果机器之间性能差距大（木桶理论），就会造成性能的极大损失；
在分布式中，容错能力是非常重要的。很多情况下，算法都是部署到云环境中的（这种环境下，机器是不可靠的，并且job也是有可能被抢占的）

发展历程

第一代 parameter server：缺少灵活性和性能 —— 仅使用memcached(key, value) 键值对存储作为同步机制。YahooLDA 通过改进这个机制，增加了一个专门的服务器，提供用户能够自定义的更新操作(set, get, update)。
第二代 parameter server：用bounded delay模型来改进YahooLDA，但是却进一步限制了worker线程模型。
第三代 parameter server 能够解决这些局限性。

对比parameter server与通用分布式系统

通用的分布式系统通常都是：每次迭代都强制同步，通常在几十个节点上，它们的性能可以表现的很好，但是在大规模集群中，这样的每次迭代强制同步的机制会因为木桶效应变得很慢。

Mahout 基于 Hadoop，MLI 基于 Spark，它们（Spark与MLI）采用的都是 Iterative MapReduce 的架构。它们能够保持迭代之间的状态，并且执行策略也更加优化了。但是，由于这两种方法都采用同步迭代的通信方式，使得它们很容易因为个别机器的低性能导致全局性能的降低。

为了解决这个问题，Graphlab 采用图形抽象的方式进行异步调度通信。但是它缺少了以 MapReduce 为基础架构的弹性扩展性，并且它使用粗粒度的snapshots来进行恢复，这两点都会阻碍到可扩展性。parameter server 正是吸取Graphlab异步机制的优势，并且解决了其在可扩展性方面的劣势。

parameter server的优势

Efficient communication 由于是异步的通信，因此，不需要停下来等一些机器执行完一个iteration（除非有必要），这大大减少了延时。为机器学习任务做了一些优化(后续会细讲)，能够大大减少网络流量和开销
Flexible consistency models 宽松的一致性要求进一步减少了同步的成本和延时。parameter server 允许算法设计者根据自身的情况来做算法收敛速度和系统性能之间的trade-off。
Elastic Scalability 使用了一个分布式hash表使得新的server节点可以随时动态的插入到集合中；因此，新增一个节点不需要重新运行系统。
Fault Tolerance and Durability 节点故障是不可避免的，特别是在大规模商用服务器集群中。从非灾难性机器故障中恢复，只需要1秒，而且不需要中断计算。Vector clocks保证了经历故障之后还是能运行良好
Ease of Use 全局共享的参数可以被表示成各种形式：vector，matrices 或者相应的sparse类型，这大大方便了机器学习算法的开发。并且提供的线性代数的数据类型都具有高性能的多线程库。

parameter server系统架构

总体架构

在parameter server中，每个 server 实际上都只负责分到的部分参数（servers共同维持一个全局的共享参数），而每个 work 也只分到部分数据和处理任务。

上图中，每个子节点都只维护自己分配到的参数（黑色），自己部分更新之后，将计算结果（例如，参数）传回到主节点，进行全局的更新（比如平均操作之类的），主节点再向子节点传送新的参数。

servers 与 workers 之间的通信如下：

server 节点：可以跟其他 server 节点通信，每个server负责自己分到的参数，server group 共同维持所有参数的更新。
server manager node：负责维护一些元数据的一致性，比如各个节点的状态，参数的分配情况等
worker 节点：worker之间没有通信，只跟自己对应的server进行通信。每个worker group有一个task scheduler，负责向worker分配任务，并且监控worker的运行情况。当有新的worker加入或者退出，task scheduler 负责重新分配任务。

(k,v), range push & pull

parameter server 中，参数都是可以被表示成(key, value)的集合，比如一个最小化损失函数的问题，key就是feature ID，而value就是它的权值。对于稀疏参数，不存在的key，就可以认为是0。

workers 跟 servers 之间通过 push 跟 pull 来通信。 worker 通过 push 将计算好的梯度发送到server，然后通过 pull 从server更新参数。 为了提高计算性能和带宽效率，parameter server 允许用户使用Range Push 跟 Range Pull操作。

range push/pull：发送和接收特定Range中的参数。

Asynchronous Tasks and Dependency

如果 iter1 需要在 iter0 computation，push 跟 pull 都完成后才能开始，那么就是Synchronous，反之就是Asynchronous.

Asynchronous Task：能够提高系统的效率（因为节省了很多等待的过程），但是，它的缺点就是容易降低算法的收敛速率。

系统性能和算法收敛速率的trade-off需要考虑的因素：

算法对于参数非一致性的敏感度；
训练数据特征之间的关联度；
硬盘的存储容量

考虑到用户使用的时候会有不同的情况，parameter server 为用户提供了多种任务依赖方式：

Sequential：这里其实是 synchronous task，任务之间是有顺序的，只有上一个任务完成，才能开始下一个任务；
Eventual：跟 sequential 相反，所有任务之间没有顺序，各自独立完成自己的任务，
Bounded Delay：这是sequential 跟 eventual 之间的trade-off，可以设置一个$\tau $作为最大的延时时间。也就是说，只有$>\tau $之前的任务都被完成了，才能开始一个新的任务。极端的情况：
$\tau = 0$情况就是 Sequential；
$\tau = \infty $情况就是 Eventual

一个bounded delay 的 PGD (proximal gradient descent)算法的系统运行流程：

如何选择$\tau $

Implementation

Vector Clock

parameter server 使用 vector clock 来记录每个节点中参数的时间戳，能够用来跟踪状态或避免数据的重复发送。但是，假设有n个节点，m个参数，那么vector clock的空间复杂度就是$O(n*m)$。当有几千个节点和几十亿的参数时，对于内存和带宽来说都是不可实现的。

parameter server 在push跟pull的时候，都是rang-based，这就带来了一个好处：这个range里面的参数共享的是同一个时间戳，这显然可以大大降低空间复杂度。

每次从一个range里再提取一个range，最多会生成3个新的 vector clocks（一分为三）。假设总共m个参数，$k$是算法中产生的所有的range，那么空间复杂度就变成了$O(k*m)$。

Messages

一条 message 包括：时间戳，len(range)对k-v：

\[ [vc(R), (k_1, v_1), . . . , (k_p, v_p)] k_j \in R \; \; and\;\; j \in \{1, . . . p\} \]

这是parameter server 中最基本的通信格式，不仅仅是共享的参数才有，task 的message也是这样的格式，只要把这里的(key, value) 改成 (task ID, 参数/返回值)。

由于机器学习问题通常都需要很高的网络带宽，因此信息的压缩是必须的。

key的压缩： 因为训练数据通常在分配之后都不会发生改变，因此
- worker没有必要每次都发送相同的key，只需要接收方在第一次接收的时候缓存起来就行了。
- 第二次，worker不再需要同时发送key和value，只需要发送value 和 key list的hash就行。这样瞬间减少了一半的通信量。
value的压缩： 假设参数是稀疏的，那么就会有大量的0存在。因此，为了进一步压缩，我们只需要发送非0值。parameter server使用Snappy快速压缩库来压缩数据、高效去除0值。【Snappy 是一个 C++ 的用来压缩和解压缩的开发包。其目标不是最大限度压缩或者兼容其他压缩格式，而是旨在提供高速压缩速度和合理的压缩率。 Snappy在 Google 内部被广泛的使用，从 BigTable 到 MapReduce 以及内部的 RPC 系统https://code.google.com/p/snappy/】

另外，key 的压缩和 value 的压缩可以同时进行。

另外，还有用户自定义过滤：对于机器学习优化问题比如梯度下降来说，并不是每次计算的梯度对于最终优化都是有价值的，用户可以通过自定义的规则过滤一些不必要的传送，再进一步压缩带宽cost：

发送很小的梯度值是低效的
更新接近最优情况的值是低效的因此，只在非最优的情况下发送，可通过KKT来判断

Consistent Hashing

parameter server 在数据一致性上，使用的是传统的一致性哈希算法，参数key与server node id被插入到一个hash ring中。在分布式系统中，动态增加和移除节点的同时还能保证系统存储与key分配的性能效率。

每个节点都复制了它逆时钟方向的k个节点中的key。图中，k=2，$S_1$复制了$S_2$和$S_3$内的key。

Replication and Consistency

两种方式保证slave跟master之间的数据一致性：

默认的复制方式: Chain replication (强一致性, 可靠)：

更新：只能发生在数据头节点,然后更新逐步后移，直到更新到达尾节点，并由尾节点向客户确认更新成功；
查询：为保证强一致性，客户查询只能在尾节点进行

Replication after Aggregation

两个worker 节点分别向server传送x和y。server 首先通过一定方式（如：$f(x+y)$ ）进行aggregate，然后再进行复制操作；当有n个worker的时候，复制只需要$k/n$的带宽。通常来说，k（复制次数）是一个很小的常数，而n的值大概是几百到几千；

Server Management

要想实现系统的容错以及动态的扩展系统规模，必须要求系统能够支持动态添加和移除节点。

当有一个 server节点添加进来时：

server manager 会对新的节点分配一些range 的key，这会造成其他server节点的key的变化；
新节点会获取数据做为训练用，另外会复制k份到slave。
server manager 将节点的变化情况广播出去。接收方可能会移除不再属于自己的数据，并且将未完成的任务提交给新来的节点

当有一个worker节点W添加进来时：

task scheduler 为W分配数据；
这个 worker 节点通过网络或者文件系统得到分配到的训练数据。接着，W会从服务器pull参数；
task scheduler 会广播节点的变化情况，可能会使一些节点释放一部分训练数据

其他资料

参数服务器——分布式机器学习的新杀器

解决大规模机器学习的策略和原则

一个利用参数服务器解决大规模在线学习的实例

irgan

2018-01-02T00:00:00+00:00

概览
- 观点3

SIGIR2017 满分论文：IRGAN | 每周一起读

IRGAN: A Minimax Game for Unifying Generative and Discriminative Information Retrieval Models

在现代信息检索领域一直是两大学派之争的局面。一方面，经典思维流派是假设在文档和信息需求（由查询可知）之间存在着一个独立的随机生成过程。另一方面，现代思维流派则充分利用机器学习的优势，将文档和搜索词联合考虑为特征，并从大量训练数据中预测其相关性或排序顺序标签。

本篇SIGIR2017的满分论文则首次提出将两方面流派的数据模型通过一种对抗训练的方式统一在一起，使得两方面的模型能够相互提高，最终使得检索到的文档更加精准。文章的实验分别在搜索、推荐系统以及问答系统三个应用场景中实现并验证了结果的有效性。

概览

IR 系统，从数据库中检索相似的信息，应对的是离散的数据，而GAN一般在连续情况下容易work。常用的SGD在这里并不 work，作者采用RL的policy gradient作为替代。 IRGAN将generative retrieval model和discriminative retrieval model分别作为GAN的 generator和discriminator（文章里对生成模型和判别模型的提法跟我们通常所说的刚好相反）。所以，IRGAN训练的结果是两个IR系统：一个是生成模型，一个是判别模型。作者开源了代码，做了一些实验实验：web search，item recommendation，question answering，实验结果表明，IRGAN打败了多种strong baselines，带来显著的性能提升。作者认为，这种性能提升得益于GAN的对抗训练机制。两类IR模型统一到GAN框架下，虽然它们的性能不同，但是跟没有采用对抗训练的模型相比，它们之中至少有一个能够得到显著的性能提升。

学习一下：https://www.cnblogs.com/liaohuiqiang/p/9694277.html

判别模型：挖掘标注与非标注的数据中的信息，用于指导训练拟合文档内在相关性分布生成模型；
生成模型：生成判别模型难以判别的例子；
经典相关性模型着重于，如何从查询生成(相关)文档；独立模型，每个token是独立从相关文档档中生成；统计语言模型一般是从文档中生成查询元素；在词嵌模型中，词从其上下文中生成；在推荐系统中，也有类似的方法，从 item 的上下文中生成 item；
模型扩展到 pointwise, pairwise, listwise, 其中 pointwise 基于人的判断来衡量相关性，pairwise 主要是在所有文档对中找出最相关的文档对，listwise 着重于返回最合理的相关性排序；
观察到的正例和未观察到的正例之间会存在内在联系，生成器需要基于判别器的信息来快速推动这些未观察到的正例；
与 conditional GAN 有些相似；
生成模型提供了一种新的负采样方式；
使用 IR 的奖励机制，是在传统模型中不可获取的；

观点3

不像传统的 GAN，用噪声信号作为输入做生成，然后判别，而是将 Query 做输入，直接利用 Generative 和 Discriminative IR Models 做 GAN；
将 RL 的 Policy Gradient 引入针对离散的输入变量；以上两个步骤使得 GAN 更具推广意义。

tagspace

2018-01-02T00:00:00+00:00

概述

概述

#TagSpace: Semantic Embeddings from Hashtags

https://research.fb.com/publications/tagspace-semantic-embeddings-from-hashtags/

假设一句话有l个词，总词典大小是N，那么大的emb矩阵就是Nxd，而对于这句话来讲，就是一个lxd的矩阵，然后用same padding，并用1D卷积，详细地说，就是先padding成一个(l+K-1)xd的矩阵，然后有H个Kxd的卷积核，这样得到的结果就是一个(l+K-1-K+1)x(d-d+1)xH=lx1xH=lxH的矩阵了，之所以叫same padding，就是因为一开始的第一维是l，最终的第一维仍是l。

对于maxpooling来说，输入是lxH，按照论文和图中的，应该是l个数取max，得到1xH，但下面的tf的实现，好像不是这样的呢。。。paddle的实现用的是https://daiwk.github.io/posts/nlp-nmt.html#8-%E5%85%B6%E4%BB%96这个的sequence_conv_pool函数，实现参考

参考tf代码https://github.com/flrngel/TagSpace-tensorflow/blob/master/model.py

      doc_embed = tflearn.embedding(doc, input_dim=N, output_dim=d)
      self.lt_embed = lt_embed = tf.Variable(tf.random_normal([tN, d], stddev=0.1)) # 在卷积这步这个变量没啥用

      net = tflearn.conv_1d(doc_embed, H, K, activation='tanh')# conv_1d默认是same padding，卷积核是Kxd，有H个卷积核，输出是(None,l,d)
      net = tflearn.max_pool_1d(net, K) # max_pool_1d默认也是same pooling，输出是(None,xxx,H)
      ## maybe上面那行应该改成tensorflow.keras.layers.GlobalMaxPooling1D(net)# 输出就是(None,H)啦?
      net = tflearn.tanh(net)
      self.logit = logit = tflearn.fully_connected(net, d, activation=None)

参考paddle代码：https://github.com/PaddlePaddle/models/blob/develop/fluid/PaddleRec/tagspace/net.py

    text_emb = nn.embedding(
            input=text, size=[vocab_text_size, emb_dim], param_attr="text_emb")
    pos_tag_emb = nn.embedding(
            input=pos_tag, size=[vocab_tag_size, emb_dim], param_attr="tag_emb")
    neg_tag_emb = nn.embedding(
            input=neg_tag, size=[vocab_tag_size, emb_dim], param_attr="tag_emb")

    conv_1d = fluid.nets.sequence_conv_pool(
            input=text_emb,
            num_filters=hid_dim,
            filter_size=win_size,
            act="tanh",
            pool_type="max",
            param_attr="cnn")
    text_hid = fluid.layers.fc(input=conv_1d, size=emb_dim, param_attr="text_hid")
    cos_pos = nn.cos_sim(pos_tag_emb, text_hid)

c++11新特性

2018-01-02T00:00:00+00:00

0. 简介
1. 核心语言的运行期表现强化
2. 核心语言构造期表现的加强
- 2.1 外部模板
3. 核心语言使用性的加强
4. 核心语言能力的提升
5. C++标准程序库的变更
X. 示例

参考： C++11新特性

英文维基百科: c++11 中文维基百科：c++11

0. 简介

C++11,之前被称作C++0x，即ISO/IEC 14882:2011，是目前的C++编程语言的正式标准。它取代第二版标准ISO/IEC 14882:2003(第一版ISO/IEC 14882:1998发布于1998年，第二版于2003年发布，分别通称C++98以及C++03，两者差异很小)。新的标准包含了几个核心语言增加的新特性，而且扩展C++标准程序库，并入了大部分的C++ Technical Report 1程序库(数学的特殊函数除外)。最新的消息被公布在 ISO C++ 委员会网站(英文)。 ISO／IEC JTC1/SC22/WG21 C++ 标准委员会计划在2010年8月之前完成对最终委员会草案的投票，以及于2011年3月召开的标准会议完成国际标准的最终草案。然而，WG21预期ISO将要花费六个月到一年的时间才能正式发布新的C++标准。为了能够如期完成，委员会决定致力于直至2006年为止的提案，忽略新的提案。最终,于2011年8月12日公布，并于2011年9月出版。2012年2月28日的国际标准草案(N3376)是最接近于现行标准的草案，差异仅有编辑上的修正。像C++这样的编程语言，通过一种演化的过程来发展其定义。这个过程不可避免地将引发与现有代码的兼容问题。不过根据Bjarne Stroustrup(C++的创始人,标准委员会的一员)表示，新的标准将几乎100%兼容现有标准。

1. 核心语言的运行期表现强化

提升某些性能表现，例如内存或是速度上的表现。

1.1 右值引用和move语义

在C++03及之前的标准中，临时对象(称为右值”R-values”，因为通常位于赋值运算符的右边)的值是不能改变的，和C语言一样, 且无法和 const T& 类型做出区分。尽管在某些情况下临时对象的确会被改变，甚至有时还被视为是一个有用的漏洞。C++11新增加了一个非常量引用(non-const reference)类型，称作右值引用(R-value reference)，标记为T &&。右值引用所引用的临时对象可以在该临时对象被初始化之后做修改，这是为了允许 move 语义。

C++03 性能上被长期诟病的问题之一，就是其耗时且不必要的深拷贝。深拷贝会隐式地发生在以传值的方式传递对象的时候。例如，std::vector内部封装了一个C风格的数组和其元素个数，如果创建或是从函数返回一个std::vector的临时对象，要将其保存起来只能通过生成新的std::vector对象并且把该临时对象所有的数据复制进去。该临时对象和其拥有的內存会被销毁。(为简单起见，这里忽略了编译器的返回值优化)

参考https://zh.cppreference.com/w/cpp/container/vector/vector

//移动构造函数。用移动语义构造拥有 other 内容的容器。分配器通过属于 other 的分配器移动构造获得。移动后，保证 other 为 empty() 。
vector( vector&& other ); //(C++11 起) (C++17 前)
vector( vector&& other ) noexcept; //(C++17 起)

// 有分配器扩展的移动构造函数。以 alloc 为新容器的分配器，从 other 移动内容；若 alloc != other.get_allocator() ，则它导致逐元素移动。（该情况下，移动后不保证 other 为空）
vector( vector&& other, const Allocator& alloc ); //(C++11 起)

在 C++11中，std::vector有一个“移动构造函数”，对某个vector的右值引用可以单纯地从右值复制其内部C风格数组的指针到新的vector中，然后将右值中的指针置空。因为这个临时对象不会再被使用,没代码会再访问这个空指针，而且因为这个临时对象的内部指针是NULL，所以当这个临时对象离开作用域时它的内存也不会被释放掉。所以,这个操作不仅没有代价高昂的深拷贝, 还是安全的,对用户不可见的!

这个操作不需要数组的复制，而且空的临时对象的析构也不会销毁内存。返回vector临时对象的函数只需要返回std::vector<T>&&。如果vector没有move 构造函数，那么就会调用常规拷贝构造函数。如果有，那么就会优先调用move构造函数，这能够避免大量的内存分配和内存拷贝操作。

右值引用不用对标准库之外的代码做任何改动就可以为已有代码带来性能上的提升. 返回值类型为std::vector<T>的函数返回了一个std::vector<T>类型的临时对象，为了使用移动构造不需要显示地将返回值类型改为std::vector<T>&&, 因为这样的临时对象会被自动当作右值引用。但是在c++03中, std::vector<T>没有移动构造函数, 带有const std::vector<T>&参数的拷贝构造会**被调用, 这会导致大量内存分配和拷贝动作.

出于安全考虑, 需要施加一些限制! 一个已命名的变量即使声明为右值,也不会被视为右值。想要获取一个右值，应该使用模板函数std::move<T>()。右值引用也可以在特定情况下被修改, 主要是为了与移动构造函数一起使用!

由于”右值引用”这个词的自然语义,以及对”左值引用”(常规引用)这个词的修正, 右值引用可以让开发者提供完美的函数转发! 与可变参数模板结合时, 这个能力让模板函数能够完美地将参数转发给带有这些参数的另一个函数。这对构造函数的参数转发最为有用，创建一个能够根据特定的参数自动调用适当的构造函数的工厂函数.（没太懂…）

例如：

#include <string>
#include <iostream>
#include <vector>
using namespace std;

int main()
{
    string st = "hahaha";
    cout << &st <<endl;
    vector<string> vc ;
    vc.emplace_back(move(st));
    cout<<vc[0]<<endl;
    cout << &st <<endl;
    cout << st.empty() << endl;
    cout << (st.begin() == st.end()) << endl;
    cout << st << "xx" <<endl;
    if(!st.empty())
        cout<<st<<endl;

    return 0;
}

// 输出：
// 0x7fffd13c0860
// hahaha
// 0x7fffd13c0860
// 1
// 1
// xx // ==>move 后变成了empty()，string的内容也清空了，而对于double/int等普通类型，好像没变。。

1.2 constexpr – 泛化的常量表示式

1.3 对POD定义的修正

2. 核心语言构造期表现的加强

2.1 外部模板

3. 核心语言使用性的加强

3.1 初始化列表

3.2 统一的初始化

3.3 类型推导

3.4 基于范围的for循环

3.5 Lambda函数与表示式

3.6 回返类型后置的函数声明

3.7 对象构造的改良

3.8 显式虚函数重载

3.9 空指针

3.10 强类型枚举

3.11 角括号

3.12 显式类型转换子

3.13 模板的别名

3.14 无限制的unions

4. 核心语言能力的提升

4.1 可变参数模板

在 C++11 之前, 不论是类模板或是函数模板，都只能按其被声明时所指定的样子，接受一组数目固定的模板参数。C++11 加入新的表示法，允许任意个数，任意类型的模板参数，不必在定义时将参数的个数固定。

先写：

template<typename... Values> class tuple;

然后，模板类 tuple 的对象，能接受不限个数的 typename 作为它的模板形参(如下面的int/vector<int>/map<std::string, std::vector<int>>>)。

class tuple<int, std::vector<int>, std::map<std::string, std::vector<int>>> someInstanceName;

实参的个数也可以是0,所以class tuple<> someInstanceName这样的定义也是可以的。

若不希望产生实参个数为 0 的变长参数模板，则可以采用以下的定义：

template<typename First, typename... Rest> class tuple;

举个例子：

template <typename OutputType, typename...Args>
class baseClass {
    virtual int32_t process(OutputType *, const Args* ...) = 0;
};

实现一个子类如下，这样是没有问题的

class derivedClass: public baseClass<int, string, bool> {
    int32_t process(int* a, const string* b, const bool* c) override {
        return 0;
    }
};

int main()
{
    derivedClass xxx;
    return 0;
}

但如果把其中的一个const xxx*的指针去掉，如：

class derivedClass: public baseClass<int, string, bool> { 
    int32_t process(int* a, const string b, const bool* c) override {
        return 0;
    }
};
int main()
{
    derivedClass xxx;
    return 0;
}

因为我们写了override标识，所以直接就报错了，一方面是这个函数并非是我们想要重载的基类的纯虚函数，另一方面没有重载纯虚函数的子类是无法被实例化的~

./tmplt.h:18:13: error: 'int32_t derivedClass::process(int*, std::string, const bool*)' marked override, but does not override
     int32_t process(int* a, const string b, const bool* c) override {
             ^
./main.cpp: In function 'int main()':
./main.cpp:31:18: error: cannot declare variable 'xxx' to be of abstract type 'derivedClass'
     derivedClass xxx;
                  ^
In file included from ./main.cpp:5:0:
./tmplt.h:17:7: note:   because the following virtual functions are pure within 'derivedClass':
 class derivedClass: baseClass<int, string, bool> {
       ^
./tmplt.h:14:21: note:  int32_t baseClass<OutputType, Args>::process(OutputType*, const Args* ...) [with OutputType = int; Args = {std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool}; int32_t = int]
     virtual int32_t process(OutputType *, const Args* ...) = 0;

而如果我们去掉override标识，报错就只剩没有实现纯虚函数的了，因为process函数被当做子类自己的新函数：

./main.cpp: In function 'int main()':
./main.cpp:31:18: error: cannot declare variable 'xxx' to be of abstract type 'derivedClass'
     derivedClass xxx;
                  ^
In file included from ./main.cpp:5:0:
./tmplt.h:15:7: note:   because the following virtual functions are pure within 'derivedClass':
 class derivedClass: baseClass<int, string, bool> {
       ^
./tmplt.h:12:21: note:  int32_t baseClass<OutputType, Args>::process(OutputType*, const Args* ...) [with OutputType = int; Args = {std::basic_string<char, std::char_traits<char>, std::allocator<char> >, bool}; int32_t = int]
     virtual int32_t process(OutputType *, const Args* ...) = 0;

另外，在这个子类里，这个process函数可以自由地声明成private/protected/public，都行~

4.2 新的字符串字面值

4.3 用户定义字面量

4.4 多任务内存模型

4.5 thread-local的存储期限

4.6 使用或禁用对象的默认函数

4.7 long long int类型

4.8 静态assertion

4.9 允许sizeof运算符作用在类别的数据成员上，无须明确的对象

4.10 垃圾回收机制

5. C++标准程序库的变更

5.1 标准库组件上的升级

5.2 线程支持

5.3 多元组类型

5.4 散列表

5.5 正则表达式

5.6 通用智能指针

5.7 可扩展的随机数功能

5.8 包装引用

5.9 多态函数对象包装器

5.10 用于元编程的类型属性

5.11 用于计算函数对象回返类型的统一方法

5.12 iota 函数

X. 示例

shuffle

如下：

#include <random>

bool score_cmp(const RidTmpInfoPtr& first, const RidTmpInfoPtr& second) {
    return first->score > second->score;
}

bool func() {
    auto result_end = result.begin();
    std::advance(result_end, video_rec_buf.tmp_result_len);

    auto generator = std::mt19937(std::random_device()());
    std::exponential_distribution<float> distribution;
    for (auto& item: result) {
        item->score = -distribution(generator) * exp(-item->res_score);
    }
    std::sort(result.begin(), result_end, score_cmp);
}

带权随机采样

参考https://stackoverflow.com/questions/1761626/weighted-random-numbers

参考http://c.biancheng.net/view/646.html

#include <iostream>
#include <random>
#include <iterator>
#include <vector>
#include <ctime>
#include <type_traits>
#include <cassert>

int main()
{

    std::vector<std::string> idx_lst = {"a1", "a2", "a3", "a4"};
    std::vector<float> weight_lst = {10000, 2003, 8899, 3344};
    std::discrete_distribution<> dist(weight_lst.begin(), weight_lst.end());
    std::mt19937 gen((unsigned int) std::time(NULL));
    for (int i = 0; i < 200;++i) {
        int idx = static_cast<int>(dist(gen));
        std::cout << idx_lst[idx] << std::endl;
    }
    return 0;

}

均匀随机采样

#include <iostream>
#include <random>
#include <iterator>
#include <vector>
#include <ctime>
#include <type_traits>
#include <cassert>

int main()
{
    std::uniform_int_distribution<long long> dist(0, 1000000000);
    std::mt19937 gen((unsigned int) std::time(NULL));
    for (int i = 0; i < 200;++i) {
        int idx = static_cast<int>(dist(gen));
        std::cout << idx << std::endl;
    }
    return 0;

}

在一个unorder_map里随机抽取元素

https://stackoverflow.com/questions/27024269/select-random-element-in-an-unordered-map

极慢。。。。。

std::unordered_map<std::string, Edge> edges;
auto random_it = std::next(std::begin(edges), rand_between(0, edges.size()));

返回的是随机一个非空的edge

更复杂一点：

#include <iostream>
#include <random>
#include <iterator>
#include <vector>
#include <ctime>
#include <type_traits>
#include <cassert>
#include <map>
#include <string>
#include <memory>
#include <unordered_map>


int main()
{
    std::unordered_map<uint64_t, std::string> x_map;
    std::shared_ptr<std::unordered_map<uint64_t, std::string> > ptr_x;
    for (int i = 0; i < 200;++i) {
        x_map.emplace(i, "aa");
    }
    ptr_x = std::make_shared<std::unordered_map<uint64_t, std::string> >(x_map);
    
    std::uniform_int_distribution<long long> dist(0, 199);
    std::mt19937 gen((unsigned int) std::time(NULL));
    for (int i = 0; i < 2000;++i) {
        int idx = static_cast<int>(dist(gen));
        std::cout << "idx" << idx << std::endl;
        auto it = std::next(ptr_x->begin(), idx);
        std::cout << it->first << std::endl;
    }
    return 0;

}

!!!快得多的方法：

建个list，size和map一样大，把map的key扔到这个list里去

然后随机一个index，取出这个list对应的元素，再去map里get

video caption

cortex

numnet plus

hichnet

youtube multitask

ngboost

MLIR

nlp+gnn

HGAT

m4

RSGAN

Animating Face using Disentangled Audio Representations

flowseq

MixHop

avm

Arror数据集+tf

情感计算

Recurrent Independent Mechanisms

deep image prior用于视频修复

tsm

TSM

加速

gan-tts

tensorflow 2.0

tf2.0教程

基础

模型

InterpretML

InterpretML

其他库

LIME

RSLIME

H2O

ACE(cv相关)

各种概率分布

量子计算相关

简介

量子霸权

强化学习+量子计算

one-shot模仿学习

gate decorator

可解释性CNN

gan剪枝

语音生成评价

rl for recommendation

drn

top-k off-policy

slateq

DEAR

dear模型结构

dear实验

The Lottery Ticket Hypothesis

SpeedTorch

可视化工具

netron

hypergraph相关

Listener-Decoder-Speller(LDS)

learn2learn

neural style transfer相关

美图的MML

概述

召回+排序

多目标

样本reweight

多目标模型

多模型

多个多目标模型

非独立同分布的机器学习方法

neural structured learning(NSL)

tf-gan

多gpu并行

autogan

mrqa

说话人分类模型

HSIC-bottleneck

CorrNet

concept activation vector(概念激活向量)

pytorch-kaldi

生成模型小结

SLATEQ