博海文思

奎因：《Y的悲剧》

Mon, 13 Dec 2021 00:00:00 +0800

奎因：《Y的悲剧》

这是我第一次看奎因的作品，有个有趣的发现，就是奎因竟然是两个人，而不是通常的一个人。埃勒里·奎因（Ellery Queen）是美国推理小说家曼弗雷德·班宁顿·李（Manfred Bennington Lee，1905—1971年）和弗雷德里克·丹奈（Frederic Dannay，1905—1982年）表兄弟二人使用的笔名，他们开创了合著推理小说的先例。
悲剧系列总共有《X的悲剧》、《Y的悲剧》、《Z的悲剧》和《哲瑞.雷恩的最后一案》，都是围绕着我们的大戏剧家、大侦探家哲瑞.雷恩的故事展开。艾勒里奎因被称为“逻辑之王”，而悲剧系列则在其中机具代表性。而在这一系列悲剧中，个人觉得，则数《Y的悲剧》故事最为逻辑缜密、案件最为令人捉摸不透以及结局最为出人意料。

Goodbye.

乙一：《夏天、烟火和我的尸体》&《优子》

Sun, 12 Dec 2021 00:00:00 +0800

乙一：《夏天、烟火和我的尸体》&《优子》

零零碎碎的终于读完了《夏天、烟火和我的尸体》。这部16岁的乙一的处女作，确实还是震撼到我了。区别于他的另一部小说集《ZOO》更加成熟诡谲的故事风格，这部作品的风格则稍显稚嫩，不过依旧架不住其奇异卓绝的文风，以及具有作者独特风格的让人不寒而栗的欧亨利式结尾，也已初见端倪。这部书给我的感觉，就像是在吃一个青涩的苹果，直到快吃完才发现，原来里面的心已经腐烂长蛆。要说作者心理没点扭曲的话，估计也写不出这样的作品。这本小说总共有两个短篇故事：《夏天、烟火和我的尸体》与《优子》。下面我想概述下对两篇短文的简单想法。
《夏天、烟火和我的尸体》所讲的故事，正如书开头讲的：九岁那年的夏天，我看着我的尸体漫山遍野奔跑。故事在一开始就已经挑明了凶手：弥生，帮凶：健，以及作为受害者的“我”：五月，杀人手法则是推下摔死，杀人动机：出于吃醋。之后便是一场惊心动魄的藏尸之旅。通常的侦探小说有三大要素：手法、凶手以及动机，而且会留一抛二，即留一个作为悬念最后揭晓，其他两个则在开头或中间告知读者。这篇小说（当然，这篇也不是推理小说）在一开始就同时抛出了三个要素。整篇的阅读点就在于转移抛尸地点的惊心动魄的过程，以及暗藏在主线下的支线故事，在整篇小说里埋藏的暗线，直到最后揭晓才恍然大悟“原来如此，怪不得”。最终的结尾也是充满了魔幻现实主义色彩，虽不及《小丑惊魂》的极限反转，但也同样别有余味。
比起第一篇故事，我个人更喜欢他的第二篇短文《优子》。这篇短文主要讲述了在政义家中帮佣的清音，认为主人公政义一直沉浸在丧妻之痛中，他所说的妻子——优子，在她看来只是一个等人身的日本玩偶。而在政义看来，优子只是生病了才整日卧床不起，不便见人。然而从门缝中窥见的那张惨白的脸，究竟是生病的优子的脸，还是被取名为优子的玩偶的脸呢？究竟谁在臆想，看到结局再回过头来，才发现作者早已在多处暗示，结合这些细节与结局，谜底昭然若揭。
乙一的作品风格大多如此，结局的反转总是让人觉得莫名其妙，摸不着头脑。最后再推荐一下他的另一部可能知名度更高的小说：《花与爱丽丝》，这部小说有岩井俊二导演的同名电影，也很不错，而且口味相比于他的大部分作品来说算轻的了。

Goodbye.

Joker 2019-You think my life is a joke, then call me Joker

Sun, 17 Nov 2019 00:00:00 +0800

Joker 2019-You think my life is a joke, then call me Joker

相信大多数人知道这部作品，是因为这部作品在今年的威尼斯电影节拿下了金狮奖，是首部在欧洲三大国际电影节（威尼斯国际电影节->金狮奖、戛纳国际电影节->金棕榈奖以及柏林国际电影节->金熊奖）上拿奖的漫改电影。虽然电影在正式上映后评论褒贬不一，但是并不妨碍这部电影在全球收割票房。作为一部成本只有5500万美元的R级片，能够斩获近10亿美元的票房（目前），再加上本部电影未在中国大陆上映，有这样的票房已然很可观。虽然这部电影在国外评论褒贬不一，但是在国内还是大受追捧的，有网友将其与漫威电影作比较，认为DC虽然票房收割能力不如漫威，但是在艺术创作上的造诣DC要更高，让漫威显得更像个“小丑”。在大家一片叫好声中，还是希望大家能够冷静下来，认真观看影片。个人认为，一部电影，不同的人看，有不同的优点和缺点，有自己的想法和思考，这样就足够了，未必要比出胜负。毕竟两者目标人群不同，观众的口味也不同，大家体会到的乐趣也会不同。

简介

电影《小丑》以同名DC漫画角色为基础，由华纳兄弟影业公司发行，计划于2019年10月4日上映。本片的故事将独立于DCEU之外，故事背景设置在20世纪80年代，讲述了一位生活陷入困境的脱口秀喜剧演员渐渐走向精神的崩溃，在哥谭市开始了疯狂的犯罪生涯，最终成为了蝙蝠侠的宿敌“小丑”的故事。

演员

一说起小丑，可能第一反应会联想到诺兰·克里斯托弗的《蝙蝠侠2：黑暗骑士》中扮演大反派小丑的希斯·莱杰。确实，希斯·莱杰版本的小丑，完美的演绎出了这个角色的病态、疯狂、神经质以及高智商。你永远捉摸不透他下一步要做什么，只能在他诡谲的“咯咯咯”笑声中瑟瑟发抖。你在他身上看不到任何一点怜悯、善良，你无法同情他，他的怪笑和行为只会让人畏惧和恐慌，或者是像得了斯德哥尔摩症候群一样的追崇和仰慕他。而对比之下，《Joker》中杰昆·菲尼克斯则演绎出了一个悲惨、无助、软弱和爱幻想的小丑。和希斯·莱杰的小丑相比，相似之处在于，两者的笑声都是那么诡异，只不过《Joker》中亚瑟（影片中男主名）的笑声只因为大脑损伤造成的无法控制的大笑，这也是让他被人当成异类的主要原因。菲尼克斯为了把小丑演活，私底下做了大量功课，调研了许多病态笑容背后的心理分析，阅读了不少社会恐怖的书籍。他表示，笑声是小丑必须展现的部分，每个人都在设想小丑的笑声应该是什么样。早在看剧本之前，导演就跟他描述了自己想要的笑声，“甚至是痛苦的，好像他身体的一部分要出来”。菲尼克斯花了数月时间研究如何去笑，并且常常会独自练习，在片场上也经常大笑。并且，杰昆为了演好小丑，疯狂瘦身，才得以有今天我们看到小丑骨瘦如柴的畸形形体。

同时令人感到不幸的是，希斯·莱杰为我们带来的小丑依然能够呈现在大家面前，而他自己却于2008年因为过量服用药品而死，再也无法在大荧幕上呈现出更多的角色。除此之外，杰昆·菲尼克斯的哥哥瑞凡·菲尼克斯因吸毒过量死亡。对于弟弟而言，哥哥瑞凡·菲尼克斯鼓励了并促进了自己成为演员，曾是自己人生道路上的引领者，他的死也深深影响了自己。同时，作为瑞凡·菲尼克斯的挚友基努·里维斯，也因好友的早逝而深受打击。（图为瑞凡·菲尼克斯和基努·里维斯）

除了主演之外，令我意外的是在影片中看到了两位熟面孔，一是在剧中扮演亚瑟母亲佩妮的弗兰西丝·康罗伊，我一看到他就想起《How I met your mother》（老爸老妈浪漫史）剧中Barney的母亲。而另一位就是在影片中扮演主持人莫瑞的罗伯特·德尼罗，相信对于喜欢硬汉电影的同学，这个名字是相当耳熟能详了，他曾参演过《教父2》的年轻版第一代教父维托·柯里昂、《出租车司机》里的暴力司机、《美国往事》的面条、《盗火线》的吉米、《好家伙》的麦考利…不过我在看完后查阅资料才发现这个角色是他演的，看来还是没有适应他演这么搞怪的角色。

故事

看完电影后，我的脑海中浮现出一部老电影：詹姆斯·斯图尔特的《What A Wonderful Life!!》（生活多美好）。只不过，《生活多美好》中主角虽然经历了一次次绝望，但是最终还是在大家的帮助下挺过难关，上帝也没有放弃他，让他自生自灭，而是在关键时候挺身而出拯救了他。相比之下，Joker就没有那么幸运了，每当他找到新的心里寄托的时候，只不过是在自己的幻想中找到慰藉，而现实总是给予他狠狠的一记耳光，一记足以击垮他自尊的大嘴巴子。

如果影片开头几个小混混不去抢走、破坏他的广告牌，或者被抢了广告牌后有路人能挺身而出；
如果心里咨询医生能够走心的和亚瑟交流，而不是为完成任务的“治疗”；
如果回来的公交车上小孩和小孩的母亲能够对亚瑟友好些；
如果邻居苏菲愿意和亚瑟做朋友；
如果蓝道没有给亚瑟枪，或者不出卖他而让他丢掉工作；
如果地铁上的华尔街“精英”三人组不欺凌别人和亚瑟；如果亚瑟母亲佩妮能早些和亚瑟坦诚他的身世和他的病因；
如果托马斯韦恩能够耐心听完亚瑟的话，并且作为一个城市的管理者给予他帮助的话；
如果莫瑞不在电视节目上公然嘲讽亚瑟的病和他的笑话；
如果……

也许只需要一个如果，亚瑟都能够找到一点活下去的希望。现实很残酷，而亚瑟依旧能够在美好的幻想中坚持下去（这就是所谓的精神胜利法吧），直到连续的重击下，亚瑟本身羸弱的身躯再也承受不住这种打击，最终连幻想都变成了“如何自杀”，并为此而狂喜——I just hope my death makes more cents than my life.（我只希望我的死比我的人生更有价值。）

亚瑟是Joker，但Joker不只是亚瑟。

观后感

之前看到一句话，大概是这么说的：“如何让一个不幸的人变成一个恶魔：把他推进哥谭市就好了”。确实，在影片中，从主角亚瑟的角度看，哥谭市是一个贫富差距极大、富人占据权力、财富以及道德制高点的人，而作为城市边缘人物，就只能够被那些高高在上的人支配。影片的男主作为城市边缘人物中最不幸的人之一，始终受到来自周围的人的否定，自己的梦想被人嘲笑，自己的尊严遭到践踏，自己的人格受到侮辱，自己的身躯被人殴打，最终让一个心存善念的人（从影片中没有杀唯一没有对他刻薄的侏儒可以看出）否定了整个世界，一步步踏入深渊，最后变成了大家眼中的样子，托马斯维恩眼中穷人的样子——Joker。所以在我看来，影片中的哥谭市本质上就是一具披着华丽外衣的丑陋身体。而如何将一个不幸的人彻底变成一个恶魔？那就一直否定他的一切就好了。当你否定他的一切时，他最终会否定整个世界，包括维持世界和人类社会的秩序，道德，是非，在不归路上越走越远。

上一次看完英雄（？）电影想要立马写影评，还是在看DC的《守望者》（当时还以为扎导这么厉害，没想到只是托了原著小说的福，硬是把一部100分的作品拍80分）的时候。并且我也很久没有这样很想一口气看完整部电影，即便是在大半夜很困的情况下，仍然坚持看完。而在看《守望者》的时候，也是差不多这样的想法。《小丑》这部电影，其实并不适合所有人观看，也不可能被大多数人接受（那样就危险啦），毕竟这部电影本身具有极强的煽动性，并且整部影片充斥着绝望，十分致郁。

我欣赏这部电影主要有两点原因，一是主角杰昆菲尼克斯的机具代入感的演技，二则是电影从底层人物（不再是蝙蝠侠视角）的视角去看哥谭市。剧情虽然相对没那么出彩，但是演员的精湛演技配合上极度负面的能量累积，让这部电影爆发出别样的魅力。甚至于在回顾《蝙蝠侠黑暗骑士》的时候，带着一种莫名的同情和理解的情绪，去看待希斯莱杰所扮演的Joker的种种行为。

最后，虽然和电影通篇的负能量不符，不过还是要说一句：正义永远会战胜邪恶！

References

《Tensorflow内核剖析》阅读笔记

Thu, 03 Jan 2019 00:00:00 +0800

《Tensorflow内核剖析》阅读笔记

这本书主要是讲解了Tensorflow的内核原理，其中包括Tensorflow中的graph构建机制、session构建与运行机制、分布式调度方式等方面。通读下来，个人觉得内容讲解的还比较浅显，里面的代码很多都是作者根据源码简化后的，所以阅读起来比较轻松，不算吃力。对于想要了解tensorflow工作机制以方便在自己构建模型的时候能够更加理解过程的同学，这是一本不错的书，不过如果想要深入理解源码或者优化源码，那么个人觉得该书只能作为一个开始。

下面我将根据章节来划分与梳理自己对于该书的阅读总结。

References

Tensorflow内核剖析

2018年总结

Mon, 31 Dec 2018 00:00:00 +0800

2018年年终总结

今年说来也算是比较具有转折性的一年，不过是因为2019年即将迎来毕业季，从年初小论文和毕业论文的准备工作，到暑期实习招聘，再到后来的秋招，以及年末的毕业论文完稿工作，都是毕业季前的常规步骤，所以在心态上也有一个比较合理的过渡过程，即从学校走向社会的准备。总的来说，这一年过得还算中规中矩，倒没有大起大落的感觉。

学习方面

由于之前基本在实习和做比赛，没有系统性的做过研究，因此年初开题定毕业论文方向的时候也比较匆忙，基本会去广泛调研各个方向，从事件抽取到情感因素导出，从流言识别到问答，最后在对机器阅读理解探索一番后才确定了这个大方向，过程可以说是相当草率。

之后三月开学到六月，基本都是在做机器阅读理解方面的工作，尝试一些自己的idea，并最终在CIKM上中了一篇short paper，深表欣慰。

九月开学后，也基本在忙秋招的事情，没有怎么认真的看书或者文章了。十月中旬之后准备出国开会的事宜，以及准备着手写中期和毕业论文，直到年末这段时间，算来还比较清闲了。

找工作方面

三月到五月除开科研的工作，其余时间一直是循环着准备笔试面试（看书、刷题）->笔试->面试的过程。由于之前自己也去实习过，所以自以为对这个过程还算“熟悉”，但是也正因为盲目自信，才导致错过了不少好的机会。期间面试了腾讯、美团、阿里、网易以及微软，其中腾讯因为部门不太中意所以就直接结束了，也错过了微信的面试。美团则是没有认真准备面试，部门也不fit，因此也没有过。阿里虽然认真准备了，不过投的IDST，最后一直没有给结果，所以就弃掉了。最后只拿了网易和微软，考虑到留北京准备秋招，遂去了微软。

吃了暑期实习的亏后，秋招基本还算比较顺利。秋招有幸拿了阿里小蜜、腾讯广点通、微软小冰以及滴滴的offer，最终综合考虑平台、方向、工作地点以及薪酬，选择了阿里。

生活方面

家中老人身体还算健康，二姐年初结婚，十一月生下了yoyo，我的外甥女。大姐的两个宝贝哆哆和汤圆也是快速的、健康的成长。还有三姐五月份怀孕了，估计19年初就能见面了，期待。

其他方面

从一月到六月，和海良师兄以及其他几位同学一块写了一本《智能问答和深度学习》的书籍，本意是想将自己之前了解到的这个方向的知识再丰富一下，也为新手入门提供一个较好的方式。书本十一月中下旬在京东上市，目前来看颇受好评，也算是对自己辛苦付出的一份回报了。通过自己写书了解到，想要写好一本书，确实要花费不少心血。这是我第一次参与撰写的书本，仍有一些缺憾，希望在下一本书，能够避免这些问题，并能够有更大突破。

还有，暑期做了两个NLP比赛，赚了点外快。研究生三年没和家里要过钱，也算是聊以慰藉了。

感觉长时间不运动，身体跨的比较厉害，还是要保持多运动，健康还是第一位的。

新年寄语

新的一年多注意自己的健康，加强锻炼（先从无到有吧）
时刻保持平静的心态，不要浮躁
多读书充实自己
时刻保持写代码的习惯，不然会生疏
注意作息，不要没事熬夜
先做到上面这些再说

拍拍贷-第三届魔镜杯比赛Rank1解决方案

Sat, 29 Sep 2018 00:00:00 +0800

拍拍贷-第三届魔镜杯比赛Rank1解决方案

附上答辩ppt。

References

答辩PPT

蚂蚁金服-金融智能NLP服务Rank2解决方案

Fri, 28 Sep 2018 00:00:00 +0800

蚂蚁金服-金融智能NLP服务Rank2解决方案

问题分析

给定两个短文本，通过算法计算两个问题的相似度，进而判定两个问题是否在语义上一致。数据集的大小如下。一般在检索中，我们更多的是去做词匹配（word match）相关的工作，而在这个任务中，我们的目的则是去做语义匹配（paraphrasing）。

该任务的指标为F1 score。

比赛阶段	训练集	测试集
初赛	10W+	1W
复赛	49W+	1W

特征提取

通常在做这类NLP问题的时候，会尝试如下一些特征。不过这些特征在此任务中并没有发挥比较好的作用。

字数差
词数差
重复词统计、比例
停用词统计、比例
编辑距离
tfidf向量（的比较）
降维的tfidf向量（的比较）
LDA向量（的比较）
句子embedding向量（的比较）
数据集的图特征（比如样本[q1, q2]可以看成两个节点和一条无向边）

预训练

在该任务中，我们尝试了两种预训练字/词向量。

Word2vec：基于gensim训练的词向量，语聊为训练集；
cw2vec：基于fasttext训练的词向量，语聊为训练集。该方法是讲每个字/词拆解成笔画顺序后进行训练，与英文单词由字母序列构成的思路类似，可作subword的训练。

该任务中，我们同时也考虑词序列、字序列、由字构成的词序列三种模型输入方式。比如：原句：怎么更改花呗手机号码字序列：[怎么更改花呗手机号码] 词序列：[怎么更改花呗手机号码] 字表示的词序列：[[怎么] [更改] [花呗] [手机] [号码]]

模型构建

在该任务中，我们使用了5种模型，其中我们设计的simpleNN单模型效果最佳。

基于RNN的向量距离比较模型simpleNN（最优模型）
CNN+RNN模型RCNN
RNN+Attention对齐的GRUNN
BIMPM
ESIM

simpleNN

三种输入源（词序列+由字构成的词序列、字序列、词序列+字序列）
两种不同来源的embedding（word2vec以及cw2vec）

RCNN

Bi-LSTM进行上下文编码
得到上下文编码序列后，利用Multi-scale的CNN进行ngram信息抓取

GRUNN

考虑浅层信息
考虑语义编码信息
考虑attention信息
考虑语义编码与attention的比较信息

BiMPM

全称Bilateral Multi-Perspective Matching
基于字/词粒度的比较
Context layer 使用LSTM+Highway完成encode工作
Matching layr 基于Attention原理产生8对matching向量

ESIM

全称Enhanced Sequential Inference Model
该模型比一般语言模型特有的Inference机制，利用两文本互为上下文推理
考虑原始词与attention表示的词的比较
选用了BiLSTM编码方式
采用退火训练方式防止过拟合（学习率随着迭代次数增多而下降）

Finetune

gensim/fasttext训练词向量；
模型使用non_trainable词向量进行训练；
将除了embedding的layer所有梯度进行clip与scale，同时用低学习率finetune词向量层。

模型融合

采用等权重加权的方式融合模型预测的prob；
训练样本足够多，使用stacking + lr模型敲定融合参数，并泛化防止过拟合；
模型训练时间不充分，需要人工监控每个模型输出的prob分布，通过等权加权的mean与std的方式分配权重，使得分配的权重加权后的mean和std与等权加权的尽量一致。

模型优缺点

优点

词向量预训练考虑中文特殊性：考虑中文词，采用了cw2vec；
模型大量使用shortcut设计防止过拟合：引入浅层语义，防止模型深度过深造成的过拟合
控制模型数量的情况下保证异构性足够大：让模型尝试从不同角度去看数据
融合方案针对评价指标设计，鲁棒性优秀：按照指标进行monitor与early stop

缺点

文本预处理可以更加完善，比如错别字修正以及简繁字转换
BiMPM及ESIM过拟合较严重，还有改进空间
对PAI平台的不熟悉，还有很多组件和模型未进行探索

可以尝试的提升点

使用更大的中文语料训练词向量
利用拼音的embedding辅助纠正错别字与繁体转简体
query的词法（词性与实体等）分析
尝试更多模型

参考文献

Paul Neculoiu, Maarten Versteegh, Mihai Rotaru: Learning Text Similarity with Siamese Recurrent Networks. Rep4NLP@ACL 2016: 148-157
B. Wang, L. Wang, et.al. Joint Learning of Siamese CNNs and Temporally Constrained Metrics for Tracklet Association
Qian Chen, Xiaodan Zhu, Zhen-Hua Ling, Si Wei, Hui Jiang, Diana Inkpen: Enhanced LSTM for Natural Language Inference. ACL (1) 2017
Sumit Chopra, Raia Hadsell, Yann LeCun: Learning a Similarity Metric Discriminatively, with Application to Face Verification. CVPR (1) 2005
Mohammad Norouzi, David J. Fleet, Ruslan Salakhutdinov: Hamming Distance Metric Learning. NIPS 2012
Zhiguo Wang, Wael Hamza, Radu Florian: Bilateral Multi-Perspective Matching for Natural Language Sentences. IJCAI 2017: 4144-4150

答辩PPT

PPT

社区问答之QA匹配问题探索

Thu, 26 Apr 2018 00:00:00 +0800

社区问答之QA匹配问题探索

问题描述

在网络社区中或一些检索任务中，给出一个问题q，如何找到与这个问题q最接近的答案a。在检索任务中，learning to ranking的方式一般可以分为如下三种：

pointwise：对每个$(Q,d_i)$对，输出得分。在只有两种状态的情况下，则是输出标签0或1，1代表相关，0代表无关
pairwise：对每个$(Q,d_i,d_j)$对，对$d_i$与$d_j$进行排序，判断其中哪个更贴近问题Q。在只有两种状态的情况下，则是每次输入$(Q,d_i,d_j)$，其中$d_i$与Q相关，$d_j$与Q无关
listwise：对所有文档D关于问题Q进行排序。在只有两种状态的情况下，也是希望将标签为1的排在前面，或者如果文档数固定，可以看出是一个n分类问题（多标签，因为可能会有多个相关文档）

数据介绍

此处我们尝试在WikiQA上进行实践。其余数据集如TrecQA或者InsuranceQA也是一样的。

WikiQA数据集中，我们使用”tsv”格式的文件，该文件内部包含7个：QuestionID、Question、DocumentID、DocumentTitle、SentenceID、Sentence、Label。构建数据时，我们只考虑问题与答案，不考虑标题。并且在测试的时候，我们需要去掉不包含标签为1的答案的问题（问题对应的答案标签全为0的需要去掉）。

评测指标

MRR（mean reciprocal rank）

这个指标只考虑与当前问题相关的所有答案中，rank最靠前的那个答案，数据集的MRR就是每个样本的该答案排序的倒数的和的均值。一般用于问题与答案是否匹配的二状态问题中。假设对于问题$q_1$答案排序为$a_1,a_2,a_3$，与问题$q_1$相关的答案为$a_3$；对于与问题$q_2$答案排序为$a_4,a_5,a_6,a_7$，与问题$q_2$相关的答案为$a_5$和$a_6$，那么$MRR=(1/3+1/2)/2=5/12$。MRR公式可以简单描述为：

\[MRR=\frac{\sum_{i=1}^{n}{\frac{1}{first\ match\ answer\ rank}}}{n}\]

MAP(mean average precision)

MAP也是衡量问题与答案是否匹配（二状态）的一个指标。与MRR不同的是，MAP考虑所有与问题相关的答案的排序。假设$q_1$对应相关的答案排名是1，3，6（共三个答案与问题$q_1$相关，其余答案不相关），那么对于$q_1$，可以算出它的average precision为$ap_1=(1/1+2/3+3/6)/3$；对于$q_2$，与之相关的答案排名是2，5，7，8（共五个答案与$q_2$相关，有一个没有被召回），那么对于$q_2$，$ap_2=(1/2+2/5+3/7+4/8+0)/5$，那么这个排序算法的MAP就是$MAP=(ap1+ap2)/2$，具体公式可以写成如下：

\[AP_j=average(\sum{\frac{order}{rank}})\\ MAP=\sum_j{AP_j}\]

NDCG(Normalized Discounted Cumulative Gain)

NDCG指标可以用于不同打分的答案，也就是不局限于二状态的情况。一个问题和不同答案的相关度可以用不同分数来表示。NDCG其实可以由DCG和iDCG得到。iDCG表示最理想排序情况下的DCG分数。假设我们只考虑n个文档排序中的前K个文档，那么：

\[DCG@K=\sum_{i=1}^{p}\frac{2^{rel_i}-1}{log_2(i+1)} \\ iDCG@K=\sum_{i=1}^{REL}\frac{2^{rel_i}-1}{log_2(i+1)} \\ NDCG@K=\frac{DCG_K}{iDCG_K}\]

其中，$rel_i$表示当前排序$i$的文档与问题的相关度，$REL$表示按照相关度排序的列表。假设对于一个问题Q，得到排序文档$D_1,D_2,D_3$，而每个文档与Q的相关度分别为3，4，2。那么我们可以计算：

\[DCG=\frac{2^3-1}{log_2(2)}+\frac{2^4-1}{log_2(3)}+\frac{2^2-1}{log2(4)} \\ iDCG=\frac{2^4-1}{log_2(2)}+\frac{2^3-1}{log_2(3)}+\frac{2^2-1}{log2(4)} \\ NDCG=\frac{DCG}{iDCG}\]

模型实现

Siamese-NN模型

class SiameseNN(object):
    def __init__(self, config):
        self.config = config
        # 输入
        self.add_placeholders()
        # [batch_size, sequence_size, embed_size]
        q_embed, a_embed = self.add_embeddings()
        with tf.variable_scope('siamese') as scope:
            self.q_trans = self.network(q_embed)
            scope.reuse_variables()
            self.a_trans = self.network(a_embed)
        # 损失和精确度
        self.total_loss = self.add_loss_op(self.q_trans, self.a_trans)
        # 训练节点
        self.train_op = self.add_train_op(self.total_loss)

    # 输入
    def add_placeholders(self):
        # 问题
        self.q = tf.placeholder(tf.int32,
                shape=[None, self.config.max_q_length],
                name='Question')
        # 回答
        self.a = tf.placeholder(tf.int32,
                shape=[None, self.config.max_a_length],
                name='Ans')
        self.y = tf.placeholder(tf.float32, shape=[None, ], name='label')
        # drop_out
        self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')
        self.batch_size = tf.shape(self.q)[0]

    # word embeddings
    def add_embeddings(self):
        with tf.variable_scope('embedding'):
            if self.config.embeddings is not None:
                embeddings = tf.Variable(self.config.embeddings, name="embeddings", trainable=False)
            else:
                embeddings = tf.get_variable('embeddings', shape=[self.config.vocab_size, self.config.embedding_size], initializer=tf.uniform_unit_scaling_initializer())
            q_embed = tf.nn.embedding_lookup(embeddings, self.q)
            a_embed = tf.nn.embedding_lookup(embeddings, self.a)
            q_embed = tf.nn.dropout(q_embed, keep_prob=self.keep_prob)
            a_embed = tf.nn.dropout(a_embed, keep_prob=self.keep_prob)
            return q_embed, a_embed

    def network(self, x):
        # (batch_size * max_len, embed_size)
        max_len = tf.shape(x)[1]
        x = tf.reshape(x, (-1, x.get_shape()[-1]))
        fc1 = self.fc_layer(x, self.config.hidden_size, "fc1")
        ac1 = tf.nn.relu(fc1)
        fc2 = self.fc_layer(ac1, self.config.hidden_size, "fc2")
        ac2 = tf.nn.relu(fc2)
        # (batch_size, max_len, embed_size)
        ac3 = tf.reshape(ac2, (self.batch_size, max_len, ac2.get_shape()[1]))
        # (batch_size, embed_size)
        ac3 = tf.reduce_mean(ac3, axis=1)
        fc3 = self.fc_layer(ac3, self.config.output_size, "fc3")
        return fc3

    def fc_layer(self, bottom, n_weight, name):
        assert len(bottom.get_shape()) == 2
        n_prev_weight = bottom.get_shape()[1]
        initer = tf.truncated_normal_initializer(stddev=0.01)
        W = tf.get_variable(name+'W', dtype=tf.float32, shape=[n_prev_weight, n_weight], initializer=initer)
        b = tf.get_variable(name+'b', dtype=tf.float32, initializer=tf.constant(0.01, shape=[n_weight], dtype=tf.float32))
        fc = tf.nn.bias_add(tf.matmul(bottom, W), b)
        return fc

    # 损失节点
    def add_loss_op(self, o1, o2):
        # 此处用cos距离
        norm_o1 = tf.nn.l2_normalize(o1, dim=1)
        norm_o2 = tf.nn.l2_normalize(o2, dim=1)
        self.q_a_cosine = tf.reduce_sum(tf.multiply(o1, o2), 1)

        loss = self.contrastive_loss(self.q_a_cosine, self.y)
        tf.add_to_collection('total_loss', loss)
        total_loss = tf.add_n(tf.get_collection('total_loss'))
        return total_loss

    def contrastive_loss(self, Ew, y):
        l_1 = self.config.pos_weight * tf.square(1 - Ew)
        l_0 = tf.square(tf.maximum(Ew, 0))
        loss = tf.reduce_mean(y * l_1 + (1 - y) * l_0)
        return loss

    # 训练节点
    def add_train_op(self, loss):
        with tf.name_scope('train_op'):
            # 记录训练步骤
            self.global_step = tf.Variable(0, name='global_step', trainable=False)
            opt = tf.train.AdamOptimizer(self.config.lr)
            train_op = opt.minimize(loss, self.global_step)
            return train_op

Siamese-CNN模型

class SiameseCNN(object):
    def __init__(self, config):
        self.config = config
        # 输入
        self.add_placeholders()
        # [batch_size, sequence_size, embed_size]
        q_embed, a_embed = self.add_embeddings()
        with tf.variable_scope('siamese') as scope:
            self.q_trans = self.network(q_embed, reuse=False)
            scope.reuse_variables()
            self.a_trans = self.network(a_embed, reuse=True)
        # 损失和精确度
        self.total_loss = self.add_loss_op(self.q_trans, self.a_trans)
        # 训练节点
        self.train_op = self.add_train_op(self.total_loss)

    # 输入
    def add_placeholders(self):
        # 问题
        self.q = tf.placeholder(tf.int32,
                shape=[None, self.config.max_q_length],
                name='Question')
        # 回答
        self.a = tf.placeholder(tf.int32,
                shape=[None, self.config.max_a_length],
                name='Ans')
        self.y = tf.placeholder(tf.float32, shape=[None, ], name='label')
        # drop_out
        self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')
        self.batch_size = tf.shape(self.q)[0]

    # word embeddings
    def add_embeddings(self):
        with tf.variable_scope('embedding'):
            if self.config.embeddings is not None:
                embeddings = tf.Variable(self.config.embeddings, name="embeddings", trainable=False)
            else:
                embeddings = tf.get_variable('embeddings', shape=[self.config.vocab_size, self.config.embedding_size], initializer=tf.uniform_unit_scaling_initializer())
            q_embed = tf.nn.embedding_lookup(embeddings, self.q)
            a_embed = tf.nn.embedding_lookup(embeddings, self.a)
            q_embed = tf.nn.dropout(q_embed, keep_prob=self.keep_prob)
            a_embed = tf.nn.dropout(a_embed, keep_prob=self.keep_prob)
            return q_embed, a_embed

    def network(self, x, reuse=False):
        # (batch_size, conv_size)
        conv1 = self.conv_layer(x, reuse=reuse)
        # (batch_size, hidden_size)
        fc1 = self.fc_layer(conv1, self.config.hidden_size, "fc1")
        ac1 = tf.nn.relu(fc1)
        # (batch_size, output_size)
        fc2 = self.fc_layer(ac1, self.config.output_size, "fc2")
        return fc2

    def fc_layer(self, bottom, n_weight, name):
        assert len(bottom.get_shape()) == 2
        n_prev_weight = bottom.get_shape()[1]
        initer = tf.truncated_normal_initializer(stddev=0.01)
        W = tf.get_variable(name+'W', dtype=tf.float32, shape=[n_prev_weight, n_weight], initializer=initer)
        b = tf.get_variable(name+'b', dtype=tf.float32, initializer=tf.constant(0.0, shape=[n_weight], dtype=tf.float32))
        fc = tf.nn.bias_add(tf.matmul(bottom, W), b)
        return fc

    def conv_layer(self, h, reuse=False):
        pool = list()
        max_len = h.get_shape()[1]
        h = tf.reshape(h, [-1, max_len, h.get_shape()[2], 1])
        for i, filter_size in enumerate(self.config.filter_sizes):
            with tf.variable_scope('filter{}'.format(filter_size)):
                conv1_W = tf.get_variable('conv_W', shape=[filter_size, self.config.embedding_size, 1, self.config.num_filters], initializer=tf.truncated_normal_initializer(.0, .01))
                conv1_b = tf.get_variable('conv_b', initializer=tf.constant(0.0, shape=[self.config.num_filters]))
                # pooling层的bias,Q和A分开
                pool_b = tf.get_variable('pool_b', initializer=tf.constant(0.0, shape=[self.config.num_filters]))
                # 卷积
                out = tf.nn.relu((tf.nn.conv2d(h, conv1_W, [1,1,1,1], padding='VALID')+conv1_b))
                # 池化
                out = tf.nn.max_pool(out, [1,max_len-filter_size+1,1,1], [1,1,1,1], padding='VALID')
                out = tf.nn.tanh(out+pool_b)
                pool.append(out)
                # 加入正则项
                if not reuse:
                    tf.add_to_collection('total_loss', 0.5 * self.config.l2_reg_lambda * tf.nn.l2_loss(conv1_W))

        total_channels = len(self.config.filter_sizes) * self.config.num_filters
        real_pool = tf.reshape(tf.concat(pool, 3), [self.batch_size, total_channels])
        return real_pool

    # 损失节点
    def add_loss_op(self, o1, o2):
        # 此处用cos距离
        norm_o1 = tf.nn.l2_normalize(o1, dim=1)
        norm_o2 = tf.nn.l2_normalize(o2, dim=1)
        self.q_a_cosine = tf.reduce_sum(tf.multiply(o1, o2), 1)

        loss = self.contrastive_loss(self.q_a_cosine, self.y)
        tf.add_to_collection('total_loss', loss)
        total_loss = tf.add_n(tf.get_collection('total_loss'))
        return total_loss

    def contrastive_loss(self, Ew, y):
        l_1 = self.config.pos_weight * tf.square(1 - Ew)
        l_0 = tf.square(tf.maximum(Ew, 0))
        loss = tf.reduce_mean(y * l_1 + (1 - y) * l_0)
        return loss

    # 训练节点
    def add_train_op(self, loss):
        with tf.name_scope('train_op'):
            # 记录训练步骤
            self.global_step = tf.Variable(0, name='global_step', trainable=False)
            opt = tf.train.AdamOptimizer(self.config.lr)
            train_op = opt.minimize(loss, self.global_step)
            return train_op

Siamese-RNN模型

class SiameseRNN(object):
    def __init__(self, config):
        self.config = config
        # 输入
        self.add_placeholders()
        # [batch_size, sequence_size, embed_size]
        q_embed, a_embed = self.add_embeddings()
        with tf.variable_scope('siamese') as scope:
            self.q_trans = self.network(q_embed)
            tf.get_variable_scope().reuse_variables()
            self.a_trans = self.network(a_embed)
        # 损失和精确度
        self.total_loss = self.add_loss_op(self.q_trans, self.a_trans)
        # 训练节点
        self.train_op = self.add_train_op(self.total_loss)

    # 输入
    def add_placeholders(self):
        # 问题
        self.q = tf.placeholder(tf.int32,
                shape=[None, self.config.max_q_length],
                name='Question')
        # 回答
        self.a = tf.placeholder(tf.int32,
                shape=[None, self.config.max_a_length],
                name='Ans')
        self.y = tf.placeholder(tf.float32, shape=[None, ], name='label')
        # drop_out
        self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')
        self.batch_size = tf.shape(self.q)[0]

    # word embeddings
    def add_embeddings(self):
        with tf.variable_scope('embedding'):
            if self.config.embeddings is not None:
                embeddings = tf.Variable(self.config.embeddings, name="embeddings", trainable=False)
            else:
                embeddings = tf.get_variable('embeddings', shape=[self.config.vocab_size, self.config.embedding_size], initializer=tf.uniform_unit_scaling_initializer())
            q_embed = tf.nn.embedding_lookup(embeddings, self.q)
            a_embed = tf.nn.embedding_lookup(embeddings, self.a)
            q_embed = tf.nn.dropout(q_embed, keep_prob=self.keep_prob)
            a_embed = tf.nn.dropout(a_embed, keep_prob=self.keep_prob)
            return q_embed, a_embed

    def network(self, x):
        sequence_length = x.get_shape()[1]
        # (batch_size, time_step, embed_size) -> (time_step, batch_size, embed_size)
        inputs = tf.transpose(x, [1, 0, 2])
        inputs = tf.reshape(inputs, [-1, self.config.embedding_size])
        inputs = tf.split(inputs, sequence_length, 0)
        # (batch_size, rnn_output_size)
        rnn1 = self.rnn_layer(inputs)
        # (batch_size, hidden_size)
        fc1 = self.fc_layer(rnn1, self.config.hidden_size, "fc1")
        ac1 = tf.nn.relu(fc1)
        # (batch_size, output_size)
        fc2 = self.fc_layer(ac1, self.config.output_size, "fc2")
        return fc2

    def fc_layer(self, bottom, n_weight, name):
        assert len(bottom.get_shape()) == 2
        n_prev_weight = bottom.get_shape()[1]
        initer = tf.truncated_normal_initializer(stddev=0.01)
        W = tf.get_variable(name+'W', dtype=tf.float32, shape=[n_prev_weight, n_weight], initializer=initer)
        b = tf.get_variable(name+'b', dtype=tf.float32, initializer=tf.constant(0.01, shape=[n_weight], dtype=tf.float32))
        fc = tf.nn.bias_add(tf.matmul(bottom, W), b)
        return fc

    def rnn_layer(self, h):
        if self.config.cell_type == 'lstm':
            birnn_fw, birnn_bw = self.bi_lstm(self.config.rnn_size, self.config.layer_size, self.config.keep_prob)
        else:
            birnn_fw, birnn_bw = self.bi_gru(self.config.rnn_size, self.config.layer_size, self.config.keep_prob)
        outputs_x1, _, _ = tf.contrib.rnn.static_bidirectional_rnn(birnn_fw, birnn_bw, h, dtype=tf.float32)
        # (time_step, batch_size, 2*rnn_size) -> (batch_size, 2*rnn_size)
        output_x1 = tf.reduce_mean(outputs_x1, 0)
        return output_x1

    def bi_lstm(self, rnn_size, layer_size, keep_prob):

        # forward rnn
        with tf.name_scope('fw_rnn'), tf.variable_scope('fw_rnn'):
            lstm_fw_cell_list = [tf.contrib.rnn.LSTMCell(rnn_size) for _ in xrange(layer_size)]
            lstm_fw_cell_m = tf.contrib.rnn.DropoutWrapper(tf.contrib.rnn.MultiRNNCell(lstm_fw_cell_list), output_keep_prob=keep_prob)

        # backward rnn
        with tf.name_scope('bw_rnn'), tf.variable_scope('bw_rnn'):
            lstm_bw_cell_list = [tf.contrib.rnn.LSTMCell(rnn_size) for _ in xrange(layer_size)]
            lstm_bw_cell_m = tf.contrib.rnn.DropoutWrapper(tf.contrib.rnn.MultiRNNCell(lstm_fw_cell_list), output_keep_prob=keep_prob)

        return lstm_fw_cell_m, lstm_bw_cell_m

    def bi_gru(self, rnn_size, layer_size, keep_prob):

        # forward rnn
        with tf.name_scope('fw_rnn'), tf.variable_scope('fw_rnn'):
            gru_fw_cell_list = [tf.contrib.rnn.GRUCell(rnn_size) for _ in xrange(layer_size)]
            gru_fw_cell_m = tf.contrib.rnn.DropoutWrapper(tf.contrib.rnn.MultiRNNCell(gru_fw_cell_list), output_keep_prob=keep_prob)

        # backward rnn
        with tf.name_scope('bw_rnn'), tf.variable_scope('bw_rnn'):
            gru_bw_cell_list = [tf.contrib.rnn.GRUCell(rnn_size) for _ in xrange(layer_size)]
            gru_bw_cell_m = tf.contrib.rnn.DropoutWrapper(tf.contrib.rnn.MultiRNNCell(gru_bw_cell_list), output_keep_prob=keep_prob)

        return gru_fw_cell_m, gru_bw_cell_m

    # 损失节点
    def add_loss_op(self, o1, o2):
        # 此处用cos距离
        norm_o1 = tf.nn.l2_normalize(o1, dim=1)
        norm_o2 = tf.nn.l2_normalize(o2, dim=1)
        self.q_a_cosine = tf.reduce_sum(tf.multiply(o1, o2), 1)

        loss = self.contrastive_loss(self.q_a_cosine, self.y)
        tf.add_to_collection('total_loss', loss)
        total_loss = tf.add_n(tf.get_collection('total_loss'))
        return total_loss

    def contrastive_loss(self, Ew, y):
        l_1 = self.config.pos_weight * tf.square(1 - Ew)
        l_0 = tf.square(tf.maximum(Ew, 0))
        loss = tf.reduce_mean(y * l_1 + (1 - y) * l_0)
        return loss

    # 训练节点
    def add_train_op(self, loss):
        with tf.name_scope('train_op'):
            # 记录训练步骤
            self.global_step = tf.Variable(0, name='global_step', trainable=False)
            opt = tf.train.AdamOptimizer(self.config.lr)
            train_op = opt.minimize(loss, self.global_step)
            return train_op

pairwise QACNN模型

class QACNN(object):
    """
    pairwise学习模型
    """
    def __init__(self, config):
        self.config = config
        # 输入
        self.add_placeholders()
        # [batch_size, sequence_size, embed_size]
        q_embed, aplus_embed, aminus_embed = self.add_embeddings()
        # [batch_size, sequence_size, hidden_size, 1]
        self.h_q, self.h_ap, self.h_am = self.add_hl(q_embed, aplus_embed, aminus_embed)
        # [batch_size, total_channels]
        real_pool_q, real_pool_ap, real_pool_am = self.add_model(q_embed, aplus_embed, aminus_embed)
        # [batch_size, 1]
        self.q_ap_cosine, self.q_am_cosine = self.calc_cosine(real_pool_q, real_pool_ap, real_pool_am)
        # 损失和精确度
        self.total_loss, self.loss, self.accu = self.add_loss_op(self.q_ap_cosine, self.q_am_cosine)
        # 训练节点
        self.train_op = self.add_train_op(self.total_loss)


    # 输入
    def add_placeholders(self):
        # 问题
        self.q = tf.placeholder(tf.int32,
                shape=[None, self.config.max_q_length],
                name='Question')
        # 正向回答
        self.aplus = tf.placeholder(tf.int32,
                shape=[None, self.config.max_a_length],
                name='PosAns')
        # 负向回答
        self.aminus = tf.placeholder(tf.int32,
                shape=[None, self.config.max_a_length],
                name='NegAns')
        # drop_out
        self.keep_prob = tf.placeholder(tf.float32, name='keep_prob')
        self.batch_size = tf.shape(self.q)[0]

    # word embeddings
    def add_embeddings(self):
        with tf.variable_scope('embedding'):
            if self.config.embeddings is not None:
                embeddings = tf.Variable(self.config.embeddings, name="embeddings", trainable=False)
            else:
                embeddings = tf.get_variable('embeddings', shape=[self.config.vocab_size, self.config.embedding_size], initializer=tf.uniform_unit_scaling_initializer())
            q_embed = tf.nn.embedding_lookup(embeddings, self.q)
            aplus_embed = tf.nn.embedding_lookup(embeddings, self.aplus)
            aminus_embed = tf.nn.embedding_lookup(embeddings, self.aminus)
            q_embed = tf.nn.dropout(q_embed, keep_prob=self.keep_prob)
            aplus_embed = tf.nn.dropout(aplus_embed, keep_prob=self.keep_prob)
            aminus_embed = tf.nn.dropout(aminus_embed, keep_prob=self.keep_prob)
            return q_embed, aplus_embed, aminus_embed

    # Hidden Layer
    def add_hl(self, q_embed, aplus_embed, aminus_embed):
        with tf.variable_scope('HL'):
            W = tf.get_variable('weights', shape=[self.config.embedding_size, self.config.hidden_size], initializer=tf.uniform_unit_scaling_initializer())
            b = tf.get_variable('biases', initializer=tf.constant(0.1, shape=[self.config.hidden_size]))
            h_q = tf.reshape(tf.nn.tanh(tf.matmul(tf.reshape(q_embed, [-1, self.config.embedding_size]), W)+b), [-1, self.config.max_q_length, self.config.hidden_size])
            h_ap = tf.reshape(tf.nn.tanh(tf.matmul(tf.reshape(aplus_embed, [-1, self.config.embedding_size]), W)+b), [-1, self.config.max_a_length, self.config.hidden_size])
            h_am = tf.reshape(tf.nn.tanh(tf.matmul(tf.reshape(aminus_embed, [-1, self.config.embedding_size]), W)+b), [-1, self.config.max_a_length, self.config.hidden_size])
            tf.add_to_collection('total_loss', 0.5*self.config.l2_reg_lambda*tf.nn.l2_loss(W))
            return h_q, h_ap, h_am

    # CNN层
    def add_model(self, h_q, h_ap, h_am):
        pool_q = list()
        pool_ap = list()
        pool_am = list()
        h_q = tf.reshape(h_q, [-1, self.config.max_q_length, self.config.embedding_size, 1])
        h_ap = tf.reshape(h_ap, [-1, self.config.max_a_length, self.config.embedding_size, 1])
        h_am = tf.reshape(h_am, [-1, self.config.max_a_length, self.config.embedding_size, 1])
        for i, filter_size in enumerate(self.config.filter_sizes):
            with tf.variable_scope('filter{}'.format(filter_size)):
                conv1_W = tf.get_variable('W_q', shape=[filter_size, self.config.embedding_size, 1, self.config.num_filters], initializer=tf.truncated_normal_initializer(.0, .1))
                conv2_W = tf.get_variable('W_a', shape=[filter_size, self.config.embedding_size, 1, self.config.num_filters], initializer=tf.truncated_normal_initializer(.0, .1))
                conv1_b = tf.get_variable('conv_qb', initializer=tf.constant(0.1, shape=[self.config.num_filters]))
                conv2_b = tf.get_variable('conv_ab', initializer=tf.constant(0.1, shape=[self.config.num_filters]))
                # pooling层的bias,Q和A分开
                pool_qb = tf.get_variable('pool_qb', initializer=tf.constant(0.1, shape=[self.config.num_filters]))
                pool_ab = tf.get_variable('pool_ab', initializer=tf.constant(0.1, shape=[self.config.num_filters]))
                # 卷积
                out_q = tf.nn.relu((tf.nn.conv2d(h_q, conv1_W, [1,1,1,1], padding='VALID')+conv1_b))
                # 池化
                out_q = tf.nn.max_pool(out_q, [1,self.config.max_q_length-filter_size+1,1,1], [1,1,1,1], padding='VALID')
                out_q = tf.nn.tanh(out_q+pool_qb)
                pool_q.append(out_q)

                out_ap = tf.nn.relu((tf.nn.conv2d(h_ap, conv2_W, [1,1,1,1], padding='VALID')+conv2_b))
                out_ap = tf.nn.max_pool(out_ap, [1,self.config.max_a_length-filter_size+1,1,1], [1,1,1,1], padding='VALID')
                out_ap = tf.nn.tanh(out_ap+pool_ab)
                pool_ap.append(out_ap)

                out_am = tf.nn.relu((tf.nn.conv2d(h_am, conv2_W, [1,1,1,1], padding='VALID')+conv2_b))
                out_am = tf.nn.max_pool(out_am, [1,self.config.max_a_length-filter_size+1,1,1], [1,1,1,1], padding='VALID')
                out_am = tf.nn.tanh(out_am+pool_ab)
                pool_am.append(out_am)

                # 加入正则项
                tf.add_to_collection('total_loss', 0.5*self.config.l2_reg_lambda*tf.nn.l2_loss(conv1_W))
                tf.add_to_collection('total_loss', 0.5*self.config.l2_reg_lambda*tf.nn.l2_loss(conv2_W))

        total_channels = len(self.config.filter_sizes)*self.config.num_filters
        real_pool_q = tf.reshape(tf.concat(pool_q, 3), [-1, total_channels])
        real_pool_ap = tf.reshape(tf.concat(pool_ap, 3), [-1, total_channels])
        real_pool_am = tf.reshape(tf.concat(pool_am, 3), [-1, total_channels])

        return real_pool_q, real_pool_ap, real_pool_am

    # 计算cosine
    def calc_cosine(self, real_pool_q, real_pool_ap, real_pool_am):
        normalized_q_h_pool = tf.nn.l2_normalize(real_pool_q, dim=1)
        normalized_pos_h_pool = tf.nn.l2_normalize(real_pool_ap, dim=1)
        normalized_neg_h_pool = tf.nn.l2_normalize(real_pool_am, dim=1)
        q_ap_cosine = tf.reduce_sum(tf.multiply(normalized_q_h_pool, normalized_pos_h_pool), 1)
        q_am_cosine = tf.reduce_sum(tf.multiply(normalized_q_h_pool, normalized_neg_h_pool), 1)

        return q_ap_cosine, q_am_cosine

    # 损失节点
    def add_loss_op(self, q_ap_cosine, q_am_cosine):
        original_loss = self.config.m - q_ap_cosine + q_am_cosine
        l = tf.maximum(tf.zeros_like(original_loss), original_loss)
        loss = tf.reduce_sum(l)
        tf.add_to_collection('total_loss', loss)
        total_loss = tf.add_n(tf.get_collection('total_loss'))
        accu = tf.reduce_mean(tf.cast(tf.equal(0., l), tf.float32))
        return total_loss, loss, accu

    # 训练节点
    def add_train_op(self, loss):
        with tf.name_scope('train_op'):
            # 记录训练步骤
            self.global_step = tf.Variable(0, name='global_step', trainable=False)
            opt = tf.train.AdamOptimizer(self.config.lr)
            train_op = opt.minimize(loss, self.global_step)
            return train_op

实验效果

符合预期，嘿嘿。

References

如何轻松搭建神经机器翻译模型

Wed, 18 Apr 2018 00:00:00 +0800

如何轻松搭建神经机器翻译模型

任务定义

给定一句英文，我们如何将它翻译成中文呢？在传统的统计方法中，我们需要对两种语言量身定制很多规则和模板。如果有一个模型，能够端到端的完成这个任务，那肯定能省不少劲的。而神经机器翻译模型恰好能够实现端到端的翻译任务，并且这个任务“天然”的符合seq2seq以及attention的框架。下面我们来简单介绍这个任务。

Simple Seq2Seq

Encoder：RNN模型
Decoder：Encoder最后一个timestep的输出作为Decoder第一个timestep的输入

Attention Seq2Seq

Encoder：RNN模型
Decoder：计算Encoder的每个timestep关于Decoder当前timestep的输入的attention值，作为真正的输入

模型实现

现在我们通过代码实现来解释如何实现一个NMT模型，并把模型放到web服务器上，以提供简单的翻译功能。在搭建模型的时候，我们需要注意模型的训练/评估与预测的方式是不同的：

训练/评估：decode的时候，每个decode的输入就是前一个timestep的真实输出(target)
预测：decode的时候，每个decode的输入是前一个timestep的预测输出(predict)

那么话不多说，让我们看看如何实现一个模型吧。

数据

我们使用的数据是中英翻译数据UM-Corpus。这个语料包含了来自多个领域的中英文对照。

指标

我们使用BLEU-4指标来表现模型的性能。指标代码采用如下：

def bleu(refs, hyps):
    """
    计算bleu-4
    """
    refs = [[[_ for _ in ref if _ > 0]] for ref in refs]
    hyps = [[_ for _ in hyp if _ > 0] for hyp in hyps]
    return nltk.translate.bleu_score.corpus_bleu(refs, hyps)

模型

preprocess

读取数据，并将中英文分开：

def data_preprocess():
	train_en_corpus = []
	train_ch_corpus = []
	test_en_corpus = []
	test_ch_corpus = []
	count = 0

	for dirname in ('Bilingual', 'Testing'):
		if dirname == 'Bilingual':
			sub_dir_names = ['Education', 'Laws', 'Microblog', 'News', 
								'Science', 'Spoken', 'Subtitles', 'Thesis']
			for filename in sub_dir_names:
				with open(os.path.join(raw_data_path, dirname, filename, ''.join(['Bi-', filename, '.txt']))) as fr:
					for i, line in enumerate(fr):
						line = line.strip().decode()
						count += 1
						if i % 2 == 0:
							train_en_corpus.append(line)
						else:
							train_ch_corpus.append(line)
					print('Finished {}'.format(count))
		else:
			with open(os.path.join(raw_data_path, dirname, 'Testing-Data.txt')) as fr:
				for i, line in enumerate(fr):
					line = line.strip().decode()
					count += 1
					if i % 2 == 0:
						test_en_corpus.append(line)
					else:
						test_ch_corpus.append(line)
				print('Finished {}'.format(count))
	train_en_corpus = '\n'.join(train_en_corpus)
	train_ch_corpus = '\n'.join(train_ch_corpus)
	test_en_corpus = '\n'.join(test_en_corpus)
	test_ch_corpus = '\n'.join(test_ch_corpus)
	return train_en_corpus, train_ch_corpus, test_en_corpus, test_ch_corpus

分词、构造中英文词典：

def segment(corpus, tokenizer, savepath=None):
	tokenized_corpus = []
	count = 0
	tokenized_corpus = ' '.join([_ for _ in tokenizer(corpus) if _.strip(' ')])
	tokenized_corpus = tokenized_corpus.split(' \n ')
	# for sentence in corpus:
	# 	count += 1
	# 	tokenized_corpus.append(' '.join(tokenizer(sentence)))
	# 	if count % 1000 == 0:
	# 		print('Finished cutting {}'.format(count))
	if savepath:
		with open(savepath, 'w') as fw:
			pkl.dump(tokenized_corpus, fw)
	return tokenized_corpus
	
train_en_corpus, train_ch_corpus, test_en_corpus, test_ch_corpus = data_preprocess()
train_en_corpus = segment(train_en_corpus, jieba.cut, 'data/preprocess/train_en_segment.pkl')
train_ch_corpus = segment(train_ch_corpus, lambda k: iter(k.strip()), 'data/preprocess/train_ch_segment.pkl')
test_en_corpus = segment(test_en_corpus, jieba.cut, 'data/preprocess/test_en_segment.pkl')
test_ch_corpus = segment(test_ch_corpus, lambda k: iter(k.strip()), 'data/preprocess/test_ch_segment.pkl')

def vocab(data, topK=None):
    word2id = Counter()
    for sentence in data:
        for word in sentence.split():
            word2id[word] += 1
    word2id = word2id.most_common()
    if topK:
        word2id = word2id[:topK]
    word2id, _ = zip(*word2id)
    word2id = {word : i + 4 for i, word in enumerate(word2id)}
    word2id['<PAD>'] = 0
    word2id['<UNK>'] = 1
    word2id['<S>'] = 2
    word2id['</S>'] = 3
    id2word = dict(zip(word2id.values(), word2id.keys()))
    return word2id, id2word

en_word2id, en_id2word = vocab(train_en_corpus)
ch_word2id, ch_id2word = vocab(train_ch_corpus)

把数据中的字/词转成对应id（此时的id是根据词频排序的，词频高的词id小）：

def transform(data, word2id):
    ret_data = []
    for sentence in data:
        ret_data.append([word2id.get(word, 1) for word in sentence.split()])
    return ret_data

train_en_corpus = transform(train_en_corpus, en_word2id)
train_ch_corpus = transform(train_ch_corpus, ch_word2id)

数据迭代

用于按batch读取数据。其中next_batch随机选取一个batch数据用于训练，而next则是按batch顺序读取整个数据，用于评估。

class Iterator(object):
    """
    数据迭代器
    """
    def __init__(self, x, y):
        self.x = np.asarray(x)
        self.y = np.asarray(y)
        self.sample_num = self.x.shape[0]

    def next_batch(self, batch_size):
        # produce X, Y_out, Y_in, X_len, Y_in_len, Y_out_len
        l = np.random.randint(0, self.sample_num - batch_size + 1)
        r = l + batch_size
        x_part = self.x[l:r]
        y_out_part = self.y[l:r]
        x_len = np.sum((x_part > 0), axis=1)
        y_in_part = np.concatenate((np.ones((batch_size, 1)) * 2, y_out_part[:,:-1]), axis=-1)
        max_y_dim = self.y.shape[1]
        y_out_len = np.sum((y_out_part > 0), axis=1) + 1
        y_out_len = np.min(np.concatenate([np.ones((batch_size, 1)) * max_y_dim, y_out_len.reshape(-1, 1)], axis=-1), axis=-1)
        y_in_len = np.sum((y_in_part > 0), axis=1) + 1
        y_in_len = np.min(np.concatenate([np.ones((batch_size, 1)) * max_y_dim, y_in_len.reshape(-1, 1)], axis=-1), axis=-1)
        x_len = x_len.astype(np.int32)
        y_in_part = y_in_part.astype(np.int32)
        y_in_len = y_in_len.astype(np.int32)
        y_out_len = y_out_len.astype(np.int32)
        return x_part, y_out_part, y_in_part, x_len, y_in_len, y_out_len

    def next(self, batch_size):
        l = 0
        while l < self.sample_num:
            r = min(l + batch_size, self.sample_num)
            batch_size = r - l
            x_part = self.x[l:r]
            y_out_part = self.y[l:r]
            x_len = np.sum((x_part > 0), axis=1)
            y_in_part = np.concatenate((np.ones((batch_size, 1)) * 2, y_out_part[:,:-1]), axis=-1)
            max_y_dim = self.y.shape[1]
            y_out_len = np.sum((y_out_part > 0), axis=1) + 1
            y_out_len = np.min(np.concatenate([np.ones((batch_size, 1)) * max_y_dim, y_out_len.reshape(-1, 1)], axis=-1), axis=-1)
            y_in_len = np.sum((y_in_part > 0), axis=1) + 1
            y_in_len = np.min(np.concatenate([np.ones((batch_size, 1)) * max_y_dim, y_in_len.reshape(-1, 1)], axis=-1), axis=-1)
            x_len = x_len.astype(np.int32)
            y_in_part = y_in_part.astype(np.int32)
            y_in_len = y_in_len.astype(np.int32)
            y_out_len = y_out_len.astype(np.int32)
            l += batch_size
            yield x_part, y_out_part, y_in_part, x_len, y_in_len, y_out_len

模型构造

class NMTModel(object):
    """
    带Attention的NMT模型
    """
    def __init__(self, 
                 src_max_vocab_size, 
                 tgt_max_vocab_size, 
                 embedding_size,
                 hidden_size,
                 src_max_seq_len,
                 tgt_max_seq_len,
                 tgt_start_id,
                 tgt_end_id,
                 max_gradient_norm=5,
                 maximum_iterations=None,
                 optimizer='adam',
                 ):
        self.initializer = tf.random_uniform_initializer(
        -0.05, 0.05)
        self.optimizer = optimizer
        # 源词表大小
        self.src_max_vocab_size = src_max_vocab_size
        # 目标词表大小
        self.tgt_max_vocab_size = tgt_max_vocab_size
        # 输入embedding大小（src与tgt的embedding_size可以不同）
        self.embedding_size = embedding_size
        # 隐层大小
        self.hidden_size = hidden_size
        # 源序列长度
        self.src_max_seq_len = src_max_seq_len
        # 目标序列长度
        self.tgt_max_seq_len = tgt_max_seq_len
        # 目标序列起始id（输入的初始id值）
        self.tgt_start_id = tgt_start_id
        # 目标的终结id（模型预测到该id后停止预测）
        self.tgt_end_id = tgt_end_id
        if maximum_iterations is None:
            self.maximum_iterations = self.tgt_max_seq_len
        else:
            self.maximum_iterations = maximum_iterations
        self.max_gradient_norm = max_gradient_norm
        self.add_placeholders()
        self.batch_size = tf.shape(self.X)[0]
        self.add_embeddings()
        self.encoder()
        self.decoder()
        self.add_loss()
        self.add_train_op()

    def add_placeholders(self):
        # X, Y_out, Y_in, X_len, Y_in_len, Y_out_len
        self.X = tf.placeholder(tf.int32, [None, None])
        self.Y_out = tf.placeholder(tf.int32, [None, None])
        self.Y_in = tf.placeholder(tf.int32, [None, None])
        self.X_len = tf.placeholder(tf.int32, [None, ])
        self.Y_in_len = tf.placeholder(tf.int32, [None, ])
        self.Y_out_len = tf.placeholder(tf.int32, [None, ])
        self.lr = tf.placeholder(tf.float32)
        self.dropout = tf.placeholder(tf.float32)

    def add_embeddings(self):
        with tf.variable_scope('embeddings', initializer=self.initializer):
            self.X_emb = tf.get_variable('X_emb', 
                shape=(self.src_max_vocab_size, self.embedding_size), 
                dtype=tf.float32)
            self.Y_emb = tf.get_variable('Y_emb', 
                shape=(self.tgt_max_vocab_size, self.embedding_size), 
                dtype=tf.float32)

            self.encoder_input = tf.nn.embedding_lookup(self.X_emb, self.X)
            self.decoder_input = tf.nn.embedding_lookup(self.Y_emb, self.Y_in)

    def encoder(self):
        with tf.variable_scope('encoder'):
            fw_encoder_cell = tf.contrib.rnn.GRUCell(self.hidden_size)
            fw_encoder_cell = tf.contrib.rnn.DropoutWrapper(fw_encoder_cell, input_keep_prob=1-self.dropout)
            bw_encoder_cell = tf.contrib.rnn.GRUCell(self.hidden_size)
            bw_encoder_cell = tf.contrib.rnn.DropoutWrapper(bw_encoder_cell, input_keep_prob=1-self.dropout)

            encoder_outputs, bi_last_state = tf.nn.bidirectional_dynamic_rnn(
                    fw_encoder_cell, bw_encoder_cell, self.encoder_input, 
                    self.X_len, dtype=tf.float32)
            self.encoder_outputs = tf.concat(encoder_outputs, axis=-1)
            self.encoder_last_state = bi_last_state


    def decoder(self):
        with tf.variable_scope('decoder'):
            decoder_cell = tf.contrib.rnn.GRUCell(self.hidden_size)
            decoder_cell = tf.contrib.rnn.DropoutWrapper(decoder_cell, input_keep_prob=1-self.dropout)
            attention_mechanism = tf.contrib.seq2seq.LuongAttention(
                                    self.hidden_size, self.encoder_outputs,
                                    memory_sequence_length=self.X_len)
            decoder_cell = tf.contrib.seq2seq.AttentionWrapper(
                                    decoder_cell, attention_mechanism,
                                    attention_layer_size=self.hidden_size)

            projection_layer = layers_core.Dense(
            self.tgt_max_vocab_size, use_bias=False)

        # 训练或评估的时候，decoder的output是真实的target，input是target右移一个词
        with tf.variable_scope('dynamic_decode'):
            # Helper
            helper = tf.contrib.seq2seq.TrainingHelper(
                self.decoder_input, tf.ones((self.batch_size, ), dtype=tf.int32) * self.tgt_max_seq_len, time_major=False)
            # Decoder
            decoder_initial_state = decoder_cell.zero_state(self.batch_size, dtype=tf.float32).clone(
                cell_state=self.encoder_last_state[0])
            decoder = tf.contrib.seq2seq.BasicDecoder(
                decoder_cell, helper, decoder_initial_state,
                output_layer=projection_layer)
            # Dynamic decoding
            outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(decoder)
            self.logits = outputs.rnn_output
            self.pred = tf.argmax(self.logits, axis=2)

        # 预测的时候，decoder的每个timestep的输入为前一个时刻的输出
        with tf.variable_scope('dynamic_decode', reuse=True):
            # Helper
            helper = tf.contrib.seq2seq.GreedyEmbeddingHelper(
                self.Y_emb,
                start_tokens=tf.fill([self.batch_size], self.tgt_start_id),
                end_token=self.tgt_end_id)
            decoder_initial_state = decoder_cell.zero_state(self.batch_size, dtype=tf.float32).clone(
                cell_state=self.encoder_last_state[0])
            # Decoder
            decoder = tf.contrib.seq2seq.BasicDecoder(
                decoder_cell, helper, decoder_initial_state,
                output_layer=projection_layer)
            # Dynamic decoding
            outputs, _, _ = tf.contrib.seq2seq.dynamic_decode(
                decoder, maximum_iterations=self.maximum_iterations)
            self.translations = outputs.sample_id

    def add_loss(self):
        target_weights = tf.sequence_mask(
                         self.Y_out_len, self.tgt_max_seq_len, dtype=self.logits.dtype)
        crossent = tf.nn.sparse_softmax_cross_entropy_with_logits(
                         labels=self.Y_out, logits=self.logits)
        self.loss_op = (tf.reduce_sum(crossent * target_weights) / tf.to_float(self.batch_size))

    def add_train_op(self):
        params = tf.trainable_variables()
        gradients = tf.gradients(self.loss_op, params)
        clipped_gradients, _ = tf.clip_by_global_norm(
            gradients, self.max_gradient_norm)
        # Optimization
        if self.optimizer == 'sgd':
            optimizer = tf.train.GradientDescentOptimizer(self.lr)
        elif self.optimizer == 'adadelta':
            optimizer = tf.train.AdaDeltaOptimizer(self.lr)
        else:
            optimizer = tf.train.AdamOptimizer(self.lr)
        self.global_step = tf.Variable(0, trainable=False, name='global_step')
        self.train_op = optimizer.apply_gradients(
            zip(clipped_gradients, params), global_step=self.global_step)

训练模型

def train():
    # load data and dictionary
    with open('data/preprocess/vocab_dict_and_corpus.pkl') as fr:
        en_word2id, en_id2word, ch_word2id, ch_id2word, \
        train_en_corpus, train_ch_corpus, test_en_corpus, test_ch_corpus = pkl.load(fr)

    train_en_corpus = padding(train_en_corpus, src_max_seq_len)
    train_ch_corpus = padding(train_ch_corpus, tgt_max_seq_len)

    # truncate the vocabrary
    # for the words exceeded te vocab size, we set it as 1(<UNK>)
    train_en_corpus[train_en_corpus >= src_max_vocab_size] = 1
    train_ch_corpus[train_ch_corpus >= tgt_max_vocab_size] = 1

    train_en_corpus, eval_en_corpus, train_ch_corpus, eval_ch_corpus = train_test_split(train_en_corpus, train_ch_corpus, test_size=0.2, )

    print('train size:{}, val size:{}'.format(train_en_corpus.shape, eval_en_corpus.shape))

    iter_num = train_en_corpus.shape[0] // batch_size + 1

    data_iterator = Iterator(train_en_corpus, train_ch_corpus)
    eval_data_iterator = Iterator(eval_en_corpus, eval_ch_corpus)
    now_lr = lr
    with tf.Session(config=cf) as sess:
        model = NMTModel(src_max_vocab_size=src_max_vocab_size, 
                         tgt_max_vocab_size=tgt_max_vocab_size, 
                         embedding_size=embedding_size,
                         hidden_size=hidden_size,
                         src_max_seq_len=src_max_seq_len,
                         tgt_max_seq_len=tgt_max_seq_len,
                         tgt_start_id=tgt_start_id,
                         tgt_end_id=tgt_end_id,
                         max_gradient_norm=max_gradient_norm,
                         maximum_iterations=maximum_iterations,
                         optimizer=optimizer)
        sess.run(tf.global_variables_initializer())
        saver = tf.train.Saver()
        for epoch in xrange(num_epochs):
            for iter_n in xrange(iter_num):
                X, Y_out, Y_in, X_len, Y_in_len, Y_out_len = data_iterator.next_batch(batch_size)
                # print(X.shape)
                # print(Y_out.shape)
                # print(Y_in.shape)
                # print(X_len.shape)
                # print(Y_in_len.shape)
                # print(Y_out_len.shape)
                loss, _, global_step = sess.run([model.loss_op, model.train_op, model.global_step], 
                    feed_dict={ model.X:X,
                                model.Y_out:Y_out,
                                model.Y_in:Y_in, 
                                model.X_len:X_len,
                                model.Y_in_len:Y_in_len,
                                model.Y_out_len:Y_out_len,
                                model.lr:now_lr,
                                model.dropout:dropout})
                if iter_n % 100 == 0:
                    print('iter:{}, train loss:{}'.format(iter_n, loss))
            if optimizer == 'sgd':
                now_lr = now_lr / 2
            evaluate(model, sess, eval_data_iterator)
            saver.save(sess,'model/my_model', global_step=global_step)

评估模型

def evaluate(model, sess, data_iterator):
    translations = []
    refs = []
    losses = []
    for X, Y_out, Y_in, X_len, Y_in_len, Y_out_len in data_iterator.next(batch_size):
        loss, translation = sess.run([model.loss_op, model.translations], 
                        feed_dict={ model.X:X,
                                    model.Y_in:Y_in,
                                    model.Y_out:Y_out,
                                    model.X_len:X_len,
                                    model.Y_in_len:Y_in_len,
                                    model.Y_out_len:Y_out_len,
                                    model.lr:lr,
                                    model.dropout:0.})
        translations.append(translation)
        refs.append(Y_out)
        losses.append(loss)
    translations = np.concatenate(translations, axis=0)
    refs = np.concatenate(refs, axis=0)
    bleu_score = bleu(refs, translations)
    print('bleu score:{}, loss:{}'.format(bleu_score, np.mean(loss)))

预测（可用于线上服务）

def predict(X):
    with open('data/preprocess/vocab_dict.pkl') as fr:
        en_word2id, en_id2word, ch_word2id, ch_id2word = pkl.load(fr)
    if type(X) == str:
        X = X
    elif type(x) == list or type(X) == tuple:
        X = '\n'.join(X)
    else:
        raise ValueError('You must ensure the `X` be string or list!')
    X = segment(X, jieba.cut)
    X = transform(X, en_word2id)
    X = padding(X, src_max_seq_len)
    X_len = np.sum((X > 0), axis=1)
    # X -> (src_max_seq_len, ) or (batch, sec_max_seq_len, )
    with tf.Session(config=cf) as sess:
        model = NMTModel(src_max_vocab_size=src_max_vocab_size, 
                             tgt_max_vocab_size=tgt_max_vocab_size, 
                             embedding_size=embedding_size,
                             hidden_size=hidden_size,
                             src_max_seq_len=src_max_seq_len,
                             tgt_max_seq_len=tgt_max_seq_len,
                             tgt_start_id=tgt_start_id,
                             tgt_end_id=tgt_end_id,
                             max_gradient_norm=max_gradient_norm,
                             maximum_iterations=maximum_iterations,
                             optimizer=optimizer)
        saver = tf.train.Saver()
        saver.restore(sess, tf.train.latest_checkpoint('model/'))
        translations = sess.run(model.translations, 
                            feed_dict={ model.X:X,
                                        model.Y_out:[[]],
                                        model.Y_in:[[]], 
                                        model.X_len:X_len,
                                        model.Y_in_len:[],
                                        model.Y_out_len:[],
                                        model.lr:lr,
                                        model.dropout:0.})
        translations = transform2word(translations, ch_id2word)
    return translations

完整工程代码

完整代码可以参考：nmt。

训练与评估结果

因为忘了加summary到Tensorboard上，所以最后自己根据log日志画图。从下图看，training loss也是波动下降到收敛，eval loss也趋于平稳，最后bleu值在0.17左右，最高达到0.173695055726（在最后一个epoch）。实验只训练了20轮，模型结构、参数也相对简单，所以最后分数不是很高，不过从线上效果来看还是“有模有样”的。

线上结果

网页页面显示如下：

可以看到，上面输入一个比较简单的英文句：

I would like to play with you.

对应的中文翻译可以得到：

我想跟你一起玩<PAD>

References

Group Normalization简介

Sat, 07 Apr 2018 00:00:00 +0800

Group Normalization简介

之前我已经在normalization上单独做了一章，分别概述了Batch Norm、Layer Norm、Weight Norm以及selu在加速网络收敛上的效果。不过，最先提出这个思路的是BN，之后的则是在其基础上进行改进（或者照瓢画葫芦再来一套？），因此此处我们也是直接将GN的效果有BN直接进行比较（作者在论文也是这么做的）。虽然normalization在NLP任务上并不如CV里常用，但是这种学习的思想还是直接去了解的（万一哪天normalization在某类NLP任务上搞了个大新闻，还是很excited的）。
对上一节有兴趣的读者可以参考：加速网络收敛——BN、LN、WN与selu

Group Normalization的原理

在我看来，GN有三个点起码比BN“好用”：

BN需要区分train和evaluate过程，而GN不用
BN对batch size敏感，而GN与batch size独立（包括loss与accuracy等），BN的性能会随着训练的batch size变小而集聚下降（让BN在某些受内存限制而需要输入小batch的任务上效果不好）
小batch size的时候，GN效果要比BN好（原因就是第二点）

而GN在速度上，通常比BN要慢，这是因为GN相对于BN来说，有额外的transpose与reshape操作，当层数加深的时候，训练速度也按比例下降。

从上图可以看到，其实各个方式只是在不同维度、粒度上进行变化。假设输入的shape为(N, C, H*W)，则有：

Batch Norm：在N维度做normalization，计算N*H*W维度的均值与标准差
Layer Norm：在C维度做normalization，计算C*H*W维度的均值与标准差
Instance Norm：计算每一个H*W的均值与标准差
Group Norm：在G维度做normalization，计算(C//G)*H*W维度的均值与标准差

可以看到，其实GN是LN与IN的折中方法。

代码实现

import tensorflow as tf

def group_norm(x, G=32):
    """
        x: [B, H, W, C]
        G: group numbers
    """

    epsilon = 1e-8
    with tf.variable_scope('gn'):
        # [B, H, W, C] -> [B, C, H, W]
        B, H, W, C = x.get_shape().as_list()
        x = tf.transpose(x, (0, 3, 1, 2))
        x = tf.reshape(x, (B, G, C // G, H, W))
        mean, var = tf.nn.moments(x, (2, 3, 4), keep_dims=True)
        x = (x - mean) / tf.sqrt(var + epsilon)
        gamma = tf.get_variable('gamma', (C, ), initializer=tf.constant_initializer(1.))
        beta = tf.get_variable('beta', (C, ), initializer=tf.constant_initializer(0.))
        x = tf.reshape(x, (B, C, H, W))
        gamma = tf.reshape(gamma, (1, C, 1, 1))
        beta = tf.reshape(beta, (1, C, 1, 1))
        x = gamma * x + beta
        x = tf.transpose(x, (0, 2, 3, 1))
        return x

if __name__ == '__main__':
    with tf.Session() as sess:
        feature_map = tf.random_normal(shape=(32, 7, 7, 64))
        feature_map_after_gn = group_norm(feature_map)

        sess.run(tf.initialize_all_variables())

        feature_map_out, feature_map_after_gn_out = \
                                sess.run([feature_map, feature_map_after_gn])
        print(feature_map_out)
        print(feature_map_after_gn_out)

实验效果

笔者尝试跑了下Reference里第二个repo，各个任务上的实验效果可以直接参看repo。有兴趣的同学也可以尝试跑一下。构建方法比较简单（如上实现过程），就不重复造轮子了。