「深度学习福利」大神带你进阶工程师,立即查看>>>
一.从贝叶斯公式开始
贝叶斯分类其实是利用用贝叶斯公式,算出每种情况下发生的概率,再取概率较大的一个分类作为结果。我们先来看看贝叶斯公式： P(A|B) = P(B|A) P(A) / P(B)
其中P(A|B)是指在事件B发生的情况下事件A发生的概率。
在贝叶斯定理中,每个名词都有约定俗成的名称： P(A|B)是已知B发生后A的条件概率,也由于得自B的取值而被称作A的后验概率。 P(A)是A的先验概率（或边缘概率）。之所以称为"先验"是因为它不考虑任何B方面的因素。 P(B|A)是已知A发生后B的条件概率,也由于得自A的取值而被称作B的后验概率。 P(B)是B的先验概率或边缘概率。
这里可以用一个例子来说明这个公式。
看一个简单的小例子来展示贝叶斯定理
病人的例子： 某个医院早上收了八个门诊病人,如下表。
症状 职业 疾病
打喷嚏 | 护士 | 感冒 | 打喷嚏 | 农夫 | 过敏 |
|---|
| 头痛 | 建筑工人 | 脑震荡 | | 头痛 | 建筑工人 | 感冒 | | 打喷嚏 | 建筑工人 | 过敏 | | 打喷嚏 | 教师 | 感冒
头痛 | 打喷嚏
教师 | 教师
脑震荡 | 过敏 |
现在又来了第九个病人,是一个打喷嚏的建筑工人。请问他患上感冒的概率有多大？
根据贝叶斯定理： P(A|B) = P(B|A) P(A) / P(B)
可得满足“打喷嚏”和“建筑工人”两个条件下,感冒的概率如下： P(感冒|打喷嚏x建筑工人) = P(打喷嚏x建筑工人|感冒) x P(感冒) / P(打喷嚏x建筑工人)
假定"打喷嚏"和"建筑工人"这两个特征是独立的（即这两个条件没有相关性,比如不存在说他是建筑工人他打喷嚏的概率比较大或者比较小这种关系）,因此,上面的等式就变成了。 P(感冒|打喷嚏x建筑工人) = P(打喷嚏|感冒) x P(建筑工人|感冒) x P(感冒) / P(打喷嚏) x P(建筑工人)
通过统计可得： P(感冒|打喷嚏x建筑工人) = (2/3) x (1/3) x (3/8) / (5/8) x (3/8) = (16/45)
通过贝叶斯公式算出了满足条件下感冒的概率,那么现在贝叶斯分类器如何实现呢？
接上面的例子,从上面我们得出了 P(感冒|打喷嚏x建筑工人) 的值,那么我们可以再算出 P(不感冒|打喷嚏x建筑工人) 的值,计算结果如下： P(不感冒|打喷嚏x建筑工人) = P(打喷嚏|不感冒) x P(建筑工人|不感冒) x P(不感冒) / P(打喷嚏) x P(建筑工人) = (3/5) x (2/5) x (5/8) / (5/8) x (3/8) = (16/25)
OK,现在我们知道来一个打喷嚏的建筑工人,他感冒的几率是P(感冒|打喷嚏x建筑工人)= (16/45)。不感冒的几率是P(不感冒|打喷嚏x建筑工人)= (16/45)。
通过对概率的比较,我们就可以将打喷嚏的建筑工人分类到“不感冒”人群中（不感冒的概率比较大） 。 这就是朴素贝叶斯分类器的最简单的应用了。当然你也看到了,贝叶斯分类器需要我们应用到统计所得的结果,这需要数据量比较大,大到能满足大数定理（大数定理这里就不多解释啦,自行百度即可）,以及样本数据足够客观。
接下来我们看一个实际的例子,是我在 github 上看到的一个项目例子,根据姓名来对性别进行分类。看上去觉得很不可思议吧,其实也是用了上述说的贝叶斯分类的方法。
二.贝叶斯分类器根据姓名判别男女 -python
项目github地址： https://github.com/observerss/ngender
先说一下主要思路,我们日常从一个人的名字中,基本上能大致判断这个名字的主人是男是女。比如 李大志 ,这个名字一听就很男性。为什么呢？因为 大 字和 志 字男性名字用得比较多。虽然机器一眼看不出来,但它可以通过统计信息来判断。如果有足够多的数据,我们就可以统计出 大 字和 志 字用作男性名字的比例,计算概率信息。然后就可以用这些概率,运用上述的贝叶斯公式来进行计算,判定性别。
代码其实不难,各个字的统计数据已经计算好,在项目中给出。我们只需要读取文件数据,存储到 python 的字典中,计算出概率,然后预测的时候进行计算即可。我们先看核心代码,稍后会有例子说明。
里面核心代码文件为：
这里主要讲一下核心代码的内容： https://github.com/observerss/ngender/blob/master/ngender/ngender.py class Guesser(object): //初始化函数,调用下面的_load_model()函数 def __init__(self): self._load_model() //初始化一些参数 def _load_model(self): self.male_total = 0 self.female_total = 0 self.freq = {} //这里加载charfreq.csv文件,这个文件存放的是一些汉字是男女的统计信息 with open(os.path.join(os.path.dirname(__file__), 'charfreq.csv'), 'rb') as f: # skip first line next(f) //将文件中的信息存储,累加,以便稍后计算概率 for line in f: line = line.decode('utf-8') char, male, female = line.split(',') char = py2compat(char) //计算男性总数 self.male_total += int(male) //计算女性总数 self.female_total += int(female) //一个汉字对应的那女数量 self.freq[char] = (int(female), int(male)) self.total = self.male_total + self.female_total //一个汉字是男女概率 for char in self.freq: female, male = self.freq[char] self.freq[char] = (1. * female / self.female_total, 1. * male / self.male_total) def guess(self, name): name = py2compat(name) //去掉姓氏 firstname = name[1:] //过滤掉不在这个unicode编码范围内的字符 for char in firstname: assert u'一' <= char <= u'龠', u'姓名必须为中文' //贝叶斯分类器,分别计算出男的概率和女的概率 pf = self.prob_for_gender(firstname, 0) pm = self.prob_for_gender(firstname, 1) //若名字为男的概率较大,则分类为男,反之则为女 if pm pf: return ('male', 1. * pm / (pm + pf)) elif pm < pf: return ('female', 1. * pf / (pm + pf)) else: return ('unknown', 0) //贝叶斯公式的应用 def prob_for_gender(self, firstname, gender=0): p = 1. * self.female_total / self.total \ if gender == 0 \ else 1. * self.male_total / self.total for char in firstname: p *= self.freq.get(char, (0, 0))[gender] return p guesser = Guesser()
上述代码还是比较简单的,首先在初始化的时候会调用 _load_model() 函数,这个函数完成的是一些概率计算工作,比如先将每个字对应是男是女的概率计算好存储在字典中。
然后在计算的时候,先过滤掉姓氏。然后分别计算出这个名字是男是女的概率,比如计算 P(男|李大志)和P(女|李大志),,对比哪个概率大一些,然后进行男女分类。
这里放上一个例子：判断 P(gender=男|name=本山) = P(name=本山|gender=男) * P(gender=男) / P(name=本山) = P(name has 本|gender=男) * P(name has 山|gender=男) * P(gender=男) / P(name=本山) 公式原理为贝叶斯公式,下面对公式中中各个项进行解答,首先明确我们已经统计得到P(gender=男),P(gender=女)的概率。
怎么算 P(name has 本|gender=男)? “本”在男性名字中出现的次数 / 男性字出现的总次数
怎么算 P(gender=男)? 男性名出现的次数 / 总次数
怎么算 P(name=本山)?
这个概率对男女来说都是一样的,所以没必要算出来,即我们只需要比较P(name=本山|gender=男) * P(gender=男)和P(name=本山|gender=女) * P(gender=女)两部分谁比较大即可做出判断。
以上就是贝叶斯分类器介绍的全部内容啦。
参考文章： http://www.ruanyifeng.com/blog/2013/12/naive_bayes_classifier.html 「深度学习福利」大神带你进阶工程师,立即查看>>>
1前言
只要精通一种有效的交易方法,你就可以在投机市场里生存了。该交易方法最好是机械的,避免让你在交易过程中去思考或猜测,你要做的只是等待入市信号,进场后就等待出场信号,根本不用去思考,这样可以把情绪因素减少到很低。
本文发布一个基于 CCI 的交易系统,该系统广泛运用于期货、外汇和股票交易,当然也包括数字货币。
2了解CCI
CCI 本身是动量指标的一种,这类指标的工作原理大致相同,即观察快线和慢线的变化。以MACD为例子,它就是通过来观测快速移动平均线与慢速移动平均线的来判断行情变化。CCI指标中,快线反映价格本身变化,慢线反映移动平均线,在CCI中我们所看到的是实际测量的价格与移动平均价格的偏差,正常的幅度是在-250到250之间。下面的图表可以说明这个情况：
如上图,14周期EMA线,用蓝色表示,14周期的CCI线,蜡烛图下面的部分。当价格加速突破EMA线,同时CCI也突破了零线。等价格巩固后EMA也同步追近,CCI也开始向零线回落。其后价格再度上杨,如果本次的幅度并不像前次那么大,CCI也没到达前面的高度。在这种情况下价格创新高,但是CCI却没有跟进,这种分化其实预示着上升动量在减弱,上涨可能就要结束了。
3策略优势
优势一：参数少,敏感低
核心参数只有3个,可优化空间很小,避免过度优化。且参数敏感度极低。
优势二：胜率高,可用于加仓模型
除了固定仓位外,还可以扩展为加仓版本,效果更佳。
优势三：高普适性
适应商品期货市场大多数品种。
4测试环境
(1)、测试品种：螺纹钢、橡胶、棉花、PTA、铁矿石、聚丙烯、棕榈油、塑料、焦炭、焦煤。
(2)、测试时间：2010年至今。
(3)、测试费用：手续费0元,开平仓各2跳滑点。
(4)、资金配比：每个品种各10万,固定1手（采用非复利方式）。
(5)、测试说明：K线走完发单。无任何未来函数、偷价、过度优化、跨周期调用、分段优化等行为。
5绩效展示
6策略核心源码展示
源码领取： 发明者量化 「深度学习福利」大神带你进阶工程师,立即查看>>> 11 月 23 日,由七牛云主办的主题为《 AI 产业技术的渗透与融合》的 NIUDAY 小牛汇共享日在北京举行。会上,邀请到了中国人工智能产业发展联盟、中国网、Blued、好未来以及环信等知名企业与专家进行了政策与技术的分享。
会上,中国互联网新闻中心（以下简称：中国网）与七牛云进行了战略合作签约,中国网副总编辑杨新华、七牛云执行副总裁杜江华出席了此次签约仪式。
（中国网副总编辑杨新华、七牛云执行副总裁杜江华现场签约）
AI 技术的发展浪潮不但影响了众多移动互联网企业,越来越多的传统媒体也纷纷加入到应用创新技术的队伍中。此次签约,双方将依托云计算和大数据中心,积极推进媒体融合升级转型,探索前沿技术在新媒体传播中的实践和应用,致力于打造多语种、多板块、多平台的智慧+全球融媒中心。
中国网是国务院新闻办公室领导,中国外文出版发行事业局管理的国家重点新闻网站。自 2000 年成立以来,陆续实现了用中、英、法、西、德、日、俄、阿、韩、世界语 10 个语种 11 个文版,24 小时对外发布信息,访问用户覆盖全球 200 多个国家和地区,成为中国进行国际传播、信息交流的重要窗口。
七牛云作为国内领先的以视觉智能和数据智能为核心的企业级云计算服务商,同时也是国内最有特色的智能视频云服务商,累计为 70 多万家企业提供服务,覆盖了国内 80% 网民。七牛云围绕富媒体场景推出了对象存储、融合 CDN 加速、容器云、大数据平台、深度学习平台等产品、并提供一站式智能视频云解决方案,为各行业及应用提供可持续发展的智能视频云生态,帮助企业快速上云,创造更广阔的商业价值。
此次合作,七牛云和中国网将围绕多语种智能编目检索、多板块云端采编发布、多平台全球汇聚分发构建新型融媒中心标准,共同应对跨语种智能应用、跨国家平台构建的全新挑战。
「深度学习福利」大神带你进阶工程师,立即查看>>>
人工智能之机器学习主要有三大类：1）分类；2）回归；3）聚类。今天我们重点探讨一下CART算法。
我们知道十大 机器学习 中决策树算法占有两席位置,即C4．5算法和CART算法,可见CART算法的重要性。下面重点介绍CART算法。
不同于ID3与C4．5,CART为一种二分决策树,是满二叉树。CART算法由Breiman等人在1984年提出,它采用与传统统计学完全不同的方式构建预测准则,它是以二叉树的形式给出,易于理解、使用和解释。由CART模型构建的预测树在很多情况下比常用的统计方法构建的代数学预测准则更加准确,且数据越复杂、变量越多,算法的优越性就越显著。
CART算法既可用于分类也可用于回归。CART算法被称为数据挖掘领域内里程碑式的算法。
** CART算法概念：**
CART（Classification andRegression Tree）分类回归树是一种决策树构建算法。CART是在给定输入随机变量X条件下输出随机变量Y的条件概率分布的学习方法。CART假设决策树是二叉树,内部结点特征的取值为“是”和“否”,左分支是取值为“是”的分支,右分支是取值为“否”的分支。这样的决策树等价于递归地二分每个特征,将输入空间即特征空间划分为有限个单元,并在这些单元上确定预测的概率分布,也就是在输入给定的条件下输出的条件概率分布。
CART算法既可以处理离散型问题,也可以处理连续型问题。这种算法在处理连续型问题时,主要通过使用二元切分来处理连续型变量,即特征值大于某个给定的值就走左子树,或者就走右子树。
** CART算法组成：**
** CART算法组成如下：**
1）决策树生成：基于训练数据集生成决策树,生成的决策树要尽量大；自上而下从根开始建立节点,在每个节点处要选择一个最好（不同算法使用不同指标来定义＂最好＂）的属性来分裂,使得子节点中的训练数据集尽量的纯。
2）决策树剪枝：用验证数据集对已生成的树进行剪枝并选择最优子树,这时损失函数最小作为剪枝的标准。这里用代价复杂度剪枝CCP（Cost－Complexity Pruning）。
决策树的生成就是通过递归地构建二叉决策树的过程,对回归树用平方误差最小化准则,对分类树用基尼指数最小化准则,进行特征选择,生成二叉树。 CART决策树生成：
** 1）回归树生成**
回归树采用均方误差作为损失函数,树生成时会递归的按最优特征与最优特征下的最优取值对空间进行划分,直到满足停止条件为止,停止条件可以人为设定,比如当切分后的损失减小值小于给定的阈值ε,则停止切分,生成叶节点。对于生成的回归树,每个叶节点的类别为落到该叶节点数据的标签的均值。
回归树为一棵二叉树,每次都是按特征下的某个取值进行划分,每一个内部节点都是做一个对应特征的判断,直至走到叶节点得到其类别,构建这棵树的难点在于如何选取最优的切分特征与切分特征对应的切分变量。
回归树与模型树既可以处理连续特征也可以处理离散特征。
回归树生成算法如下：
输入：训练数据集D＝｛（x1,y1）,（x2,y2）,…,（xN,yN）｝
输出：回归树T
1）求解选择切分特征j与切分特征取值s,j将训练集D划分为两部分,R1与R2,依照（j,s）切分后如下：
R1（j,s）＝｛xi｜xji≤s｝R2（j,s）＝｛xi｜xji＞s｝
c1＝1N1∑xi∈R1yi c2＝1N2∑xi∈R2yi
2）遍历所有可能的解（j,s）,找到最优的（j＊,s＊）,最优的解使得对应损失最小,按照最优特征（j＊,s＊）来切分即可。
Min｛∑（yi–c1）＾2＋∑（yi–c2）＾2｝
j,s xi∈R1 xi∈R2
3）递归调用1）和2）,直到满足停止条件。
4）返回决策树T。
回归树主要采用了分治策略,对于无法用唯一的全局线性回归来优化的目标进行分而治之,进而取得比较准确的结果,但分段取均值并不是一个明智的选择,可以考虑将叶节点设置为一个线性函数,这便是所谓的分段线性模型树。实验表明：模型树效果比回归树的效果要好一些。模型树只需在回归树的基础上稍加修改即可,对于分到叶节点的数据,采用线性回归的最小均方损失来计算该节点的损失。 2）分类树生成
分类树是CART中用来分类的,不同于ID3与C4．5,CART分类树采用基尼指数来选择最优的切分特征,而且每次都是二分。
基尼指数是一个类似与熵的概念,对于一个有K种状态对应的概率为p1,p2,…,pK的随机变量X,其基尼指数Gini定义如下：
Gini（X）＝∑pk（1？pk）＝1？∑kp2k
k k
在已知特征A条件下集合D的基尼指数：
Gini（D,A）＝（｜D1｜／｜D｜）＊Gini（D1）＋（｜D2｜／｜D｜）＊Gini（D2）
Gini（D,A）取值越大,样本的不确定性也越大,这一点与熵类似,所以选择特征A的标准是Gini（D,A）的取值越小越好。 「深度学习福利」大神带你进阶工程师,立即查看>>> 美国当地时间 2018 年 9 月 27 日,国内领先的人工智能驱动的教育科技公司「英语流利说」正式挂牌纽交所,以其独创的教育 3.0 模式,成为中国「AI+ 教育」第一股。
教育 3.0 时代的智能突破
移动互联网的发展,使得教育行业从线下传统课堂的「教育 1.0 」时代发展到了在线远程教育的「教育 2.0 」时代。虽然相比于传统的线下教育,在线教育突破了时间、地域的限制,满足了用户一切碎片化的学习需求,但同为以「真人教师」为核心的教育课堂,课程成本高企、学习效率难控、师资质量不均等问题依然存在。
以英语为例,国人学英语的热潮催生了很多英语线下、线上培训机构的出现,但即便花费高昂费用,由专业外教培训千百小时,仍有不少人不会进行英语对话。
人工智能技术的加速发展,将教育带到了「教育 3.0 」时代。针对当下英语教学中开口难、发音差、学习成本高等一系列难点,由普林斯顿大学博士王翌和胡哲人、林晖博士于 2012 年共同创立的全新的在线英语学习应用 -「英语流利说」横空出世,开创性地将自主研发的人工智能技术赋能教学赛道,为用户提供定制化、高效率的学习体验,突破传统教育瓶颈,揭开了「AI+ 教育」的新篇章。
人工智能代替真人教师
高质量的教学水平和实时的教学反馈是课堂效率提升的关键因素。学生与老师相隔屏幕两端必定会存在沟通反馈不足等问题。立足于移动端,「流利说」自主研发的人工智能英语老师,可 24 小时全勤在线,并同时服务上万学员。
「流利说」基于深度学习技术的语音识别和评分引擎,为每一位用户提供个性化、自适应的学习课程。AI 教师会根据单词的发音、声调和断句来评估用户的发音、词汇、语法、流畅性等,并实时给出相应的标注和评分。通过预测用户在不同设置下的表现,为每个用户创建学习计划,从而做到真正意义上的「因材施教」。AI 教师不仅可以帮助学生高效提升英语水平,而且价格也并不昂贵,每个人都可轻松拥有。
像游戏闯关一样练口语
口语练习毕竟是一门功课,用户很可能中途放弃退出。为了激励用户每日打卡,「流利说」增设了游戏闯关解锁和社交元素,难度由低到高持续进阶。除此之外,还覆盖了玩转职场、旅游出行、日常必备等多个主题对话场景,提升用户口语练习的兴趣。
在「AI+ 移动互联网」这样的先进教育模式下,「流利说」成为国内领先的英语学习 App 和活跃的语言学习社区,曾被苹果公司评为「App Store 精华」和「2013年度精选 App」,是 CB Insights「2018年世界最具潜力人工智能公司 100 强」榜单上唯一上榜的中国教育公司。
海量的教学数据安放云端
截至 2018 年 6 月 30 日,「流利说」已在全球积累拥有超过 8380 万注册用户,月活跃访问用户于升至 720 万,成为活跃的英语学习社区。包罗万象的口语训练素材每日更新,每支视频均配有 AI 老师对知识点的讲解,用户可以随时随地边看、边学、边说。
基于七牛云对象存储服务,「流利说」海量的音视频及图片素材安全稳定保存在云端且具有超高可用性。存储需求可弹性伸缩,便于「流利说」按需增加课程场景,提高业务的灵活性。「流利说」目前已覆盖全球 175 个国家,全国 384 个城市。七牛云融合 CDN 对数据网络加速进行优化,广阔的节点覆盖,为世界各地的英语学习用户提供稳定快速的网络访问质量。
谈到创立初心,「英语流利说」CEO 王翌曾说：「每一个人都有权利接受英语教育」。「AI+ 教育」的发展势头持续渐长,「英语流利说」作为业界先驱,探索出了英语教学的新模式,降低了传统教育对专业教师的依赖,利用人工智能技术,帮助用户个性、高效提升口语水平。七牛云作为国内领先的云服务厂商,自 2013 年起,就在对象存储及内容分发等技术层面,为「流利说」提供优质服务,保障其线上课程的顺利运作,助力其为用户打造极致流畅的英语学习体验。
「深度学习福利」大神带你进阶工程师,立即查看>>>
【一】声明
本文源自TensorFlow官方指导（https://tensorflow.google.cn/tutorials/sequences/text_generation）,增加了部分细节说明。
【二】综述
1. tf.keras与keras有如下三个较大的不同点
1）：opt必须是tf.train模块下的opt,不能是keras下的opt
2）：tf.keras模型默认的保存格式时check-point,不是h5.
3）: tf.keras进行模型训练、推理时,input_data可以直接传递tf.data.Dataset
2. TensorFlow的官方案例,是依据字符进行文本生成的,基本流程是,给定一个句子,预测其下一个字符。因此该模型不知道单词是怎么拼写的,不知道字成词,因为他是字符级的,它只知道预测下一个字符。因此,可能生成了不存在的单词或者词语。
3. 该模型只有三层（char-embedding、GRU、FC）,但参数巨大,训练十分缓慢（i7CPU训练一个epoch差不多半个小时）。而且这里,char-embedding是直接训练出来了,而不是通过fasttext或者gensim训练出来,然后在做fine-tuning的。
【三】代码如下： # -*- coding:utf-8 -*- import tensorflow as tf import numpy as np import os import time tf.enable_eager_execution() # 1. 数据下载 path = tf.keras.utils.get_file('shakespeare.txt', 'https://storage.googleapis.com/download.tensorflow.org/data/shakespeare.txt') #2. 数据预处理 with open(path) as f: # text 是个字符串 text = f.read() # 3. 将组成文本的字符全部提取出来,注意 vocab是个list vocab = sorted(set(text)) # 4. 创建text-->int的映射关系 char2idx = {u:i for i, u in enumerate(vocab)} idx2char = np.array(vocab) text_as_int = np.array([char2idx[c] for c in text]) # 5. 借用dataset的batch方法,将text划分为定长的句子 seq_length = 100 examples_per_epoch = len(text)//seq_length char_dataset = tf.data.Dataset.from_tensor_slices(text_as_int) # 这里batch_size 加1的原因在于,下面对inputs和labels的生成。labels比inputs多一个字符 sequences = char_dataset.batch(seq_length+1, drop_remainder=True) # 6. 将每个句子划分为inputs和labels。例如：hello,inputs = hell,label=ello def split_input_target(chunk): input_text = chunk[:-1] target_text = chunk[1:] return input_text, target_text dataset = sequences.map(split_input_target) # 7. 将句子划分为一个个batch BATCH_SIZE = 64 steps_per_epoch = examples_per_epoch//BATCH_SIZE BUFFER_SIZE = 10000 # drop_remainder 一般需要设置为true,表示当最后一组数据不够划分为一个batch时,将这组数据丢弃 dataset = dataset.shuffle(BUFFER_SIZE).batch(BATCH_SIZE, drop_remainder=True) # 8. 模型搭建 # Length of the vocabulary in chars vocab_size = len(vocab) # The embedding dimension embedding_dim = 256 # Number of RNN units rnn_units = 1024 model = tf.keras.Sequential() # 这里是字符embedding,所以是字符集大小*embedding_dim model.add(tf.keras.layers.Embedding(input_dim=vocab_size,output_dim=embedding_dim, batch_input_shape=[BATCH_SIZE,None])) model.add(tf.keras.layers.GRU(units=rnn_units, return_sequences=True, recurrent_initializer='glorot_uniform', stateful=True)) model.add(tf.keras.layers.Dense(units=vocab_size)) model.summary() # 9. 模型配置 # optimizer 必须为 tf.train 下的opt,不能是keras下的opt model.compile(optimizer=tf.train.AdamOptimizer(),loss=tf.losses.sparse_softmax_cross_entropy) # 10 .设置回调函数 checkpoint_dir = './training_checkpoints' checkpoint_prefix = os.path.join(checkpoint_dir, "ckpt_{epoch}") checkpoint_callback=tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_prefix, save_weights_only=True) tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir='./logs/') # 11. 训练模型,repeat() 表示dataset无限循环,不然这里数据可能不够30个epochs model.fit(dataset.repeat(),epochs=30, steps_per_epoch=steps_per_epoch, callbacks=[checkpoint_callback,tensorboard_callback]) # 12 .模型保存 # 保存为keras模型格式 model.save_weights(filepath='./models/gen_text_with_char_on_rnn.h5',save_format='h5') # 保存为TensorFlow的格式 model.save_weights(filepath='./models/gen_text_with_char_on_rnn_check_point') # 13. 模型生成文本 def generate_text(model, start_string): # Evaluation step (generating text using the learned model) # Number of characters to generate num_generate = 1000 # You can change the start string to experiment start_string = 'ROMEO' # Converting our start string to numbers (vectorizing) input_eval = [char2idx[s] for s in start_string] input_eval = tf.expand_dims(input_eval, 0) # Empty string to store our results text_generated = [] # Low temperatures results in more predictable text. # Higher temperatures results in more surprising text. # Experiment to find the best setting. temperature = 1.0 # Here batch size == 1 model.reset_states() for i in range(num_generate): predictions = model(input_eval) # remove the batch dimension predictions = tf.squeeze(predictions, 0) # using a multinomial distribution to predict the word returned by the model predictions = predictions / temperature predicted_id = tf.multinomial(predictions, num_samples=1)[-1, 0].numpy() # We pass the predicted word as the next input to the model # along with the previous hidden state input_eval = tf.expand_dims([predicted_id], 0) text_generated.append(idx2char[predicted_id]) return (start_string + ''.join(text_generated)) print(generate_text(model, start_string="ROMEO: "))
【四】总结
1. 关于tf.keras更多的内容,可以参考官方网站（https://tensorflow.google.cn/guide/keras）
2. 关于tf.dataset的更多内容,可以参考官方网站（https://tensorflow.google.cn/guide/datasets）和另外一篇博客（https://my.oschina.net/u/3800567/blog/1637798）
3. 可以完全使用tf.keras,不再使用keras。二者功能与接口一致,tf.keras提供了更多的对TensorFlow的支持 「深度学习福利」大神带你进阶工程师,立即查看>>>
为了将Kubeflow（ https://github.com/kubeflow/kubeflow ）/Kubernetes等镜像放到本地集群部署或者更新,需要一系列的操作。如果集群的多个节点同时访问外部镜像服务,将带来较大的并发网络流量,不仅速度慢、而且费用增加。因此我将其分为两个阶段来进行,第一阶段将镜像下载到本地,第二阶段各个节点从本地文件系统或镜像服务来获取镜像的拷贝。
1、从 gcr到本地存储
这一阶段其实也分为两个步骤。
首先,从能够访问到gcr的站点（ https://www.katacoda.com ）下载。如： echo "" echo "=================================================================" echo "pull kubeflow images for system from gcr.io and hub.docker.com..." echo "This tools created by openthings, NO WARANTY. 2018.07.10." echo "=================================================================" echo "" echo "1. centraldashboard" docker pull gcr.io/kubeflow-images-public/centraldashboard:v0.2.1 echo "" echo "2. jupyterhub-k8s" docker pull gcr.io/kubeflow/jupyterhub-k8s:v20180531-3bb991b1 echo "" echo "3. tf_operator" docker pull gcr.io/kubeflow-images-public/tf_operator:v0.2.0 echo "" echo "4. ambassador" docker pull quay.io/datawire/ambassador:0.30.1 echo "" echo "5. redis" docker pull redis:4.0.1 echo "" echo "6. seldonio/cluster-manager" docker pull seldonio/cluster-manager:0.1.6 echo "" echo "Finished." echo ""
然后将镜像推送到国内站点（如阿里云- http://registry.cn-hangzhou.aliyuncs.com ）。如 echo "" echo "=================================================================" echo "Push kubeflow images for system to aliyun.com ..." echo "This tools created by openthings, NO WARANTY. 2018.07.10." echo "=================================================================" MY_REGISTRY=registry.cn-hangzhou.aliyuncs.com/openthings echo "" echo "1. centraldashboard" docker tag gcr.io/kubeflow-images-public/centraldashboard:v0.2.1 ${MY_REGISTRY}/kubeflow-images-public-centraldashboard:v0.2.1 docker push ${MY_REGISTRY}/kubeflow-images-public-centraldashboard:v0.2.1 echo "" echo "2. jupyterhub-k8s" docker tag gcr.io/kubeflow/jupyterhub-k8s:v20180531-3bb991b1 ${MY_REGISTRY}/kubeflow-jupyterhub-k8s:v20180531-3bb991b1 docker push ${MY_REGISTRY}/kubeflow-jupyterhub-k8s:v20180531-3bb991b1 echo "" echo "3. tf_operator" docker tag gcr.io/kubeflow-images-public/tf_operator:v0.2.0 ${MY_REGISTRY}/kubeflow-images-public-tf_operator:v0.2.0 docker push ${MY_REGISTRY}/kubeflow-images-public-tf_operator:v0.2.0 echo "" echo "4. ambassador" docker tag quay.io/datawire/ambassador:0.30.1 ${MY_REGISTRY}/quay-io-datawire-ambassador:0.30.1 docker push ${MY_REGISTRY}/quay-io-datawire-ambassador:0.30.1 echo "" echo "5. redis" docker tag redis:4.0.1 ${MY_REGISTRY}/redis:4.0.1 docker push ${MY_REGISTRY}/redis:4.0.1 echo "" echo "6. seldonio/cluster-manager" docker tag seldonio/cluster-manager:0.1.6 ${MY_REGISTRY}/seldonio-cluster-manager:0.1.6 docker push ${MY_REGISTRY}/seldonio-cluster-manager:0.1.6 echo "" echo "Finished." echo ""
然后,可以从阿里云下载到本地,恢复为原始的名称： echo "" echo "=================================================================" echo "Pull kubeflow images for system from aliyun.com ..." echo "This tools created by openthings, NO WARANTY. 2018.11.28." echo "=================================================================" MY_REGISTRY=registry.cn-hangzhou.aliyuncs.com/openthings echo "" echo "1. centraldashboard" docker pull ${MY_REGISTRY}/kubeflow-images-public-centraldashboard:v0.2.1 docker tag ${MY_REGISTRY}/kubeflow-images-public-centraldashboard:v0.2.1 gcr.io/kubeflow-images-public/centraldashboard:v0.2.1 echo "" echo "2. jupyterhub-k8s" docker pull ${MY_REGISTRY}/kubeflow-jupyterhub-k8s:v20180531-3bb991b1 docker tag ${MY_REGISTRY}/kubeflow-jupyterhub-k8s:v20180531-3bb991b1 gcr.io/kubeflow/jupyterhub-k8s:v20180531-3bb991b1 echo "" echo "3. tf_operator" docker pull ${MY_REGISTRY}/kubeflow-images-public-tf_operator:v0.2.0 docker tag ${MY_REGISTRY}/kubeflow-images-public-tf_operator:v0.2.0 gcr.io/kubeflow-images-public/tf_operator:v0.2.0 echo "" echo "4. ambassador" docker pull ${MY_REGISTRY}/quay-io-datawire-ambassador:0.30.1 docker tag ${MY_REGISTRY}/quay-io-datawire-ambassador:0.30.1 quay.io/datawire/ambassador:0.30.1 echo "" echo "5. redis" docker pull ${MY_REGISTRY}/redis:4.0.1 docker tag ${MY_REGISTRY}/redis:4.0.1 redis:4.0.1 echo "" echo "6. seldonio/cluster-manager" docker pull ${MY_REGISTRY}/seldonio-cluster-manager:0.1.6 docker tag ${MY_REGISTRY}/seldonio-cluster-manager:0.1.6 seldonio/cluster-manager:0.1.6 echo "" echo "Finished." echo ""
从阿里云下载到本地后,可以推送到本地镜像服务（如Harbor）或者打包为*.tar文件。
2、从本地存储到集群部署
从本地Harbor中安装,使用docker tag将镜像改名后,就可以使用了。可以参考上面的从阿里云下载的方法。
打包为*.tar文件,参见： echo "===================================================================" echo "Save Kubeflow images to tar." echo "This tool created by https://my.oschina.net/u/2306127" echo "Please visit https://github.com/openthings/kubernetes-tools" echo "###################################################################" echo "Kubeflow 0.3.3 ML system images." echo "-------------------------------------------------------------------" echo "A1.>> centraldashboard" docker save gcr.io/kubeflow-images-public/centraldashboard:v0.2.1 -o A1-kubeflow-centraldashboard-v0.2.1.tar echo "" echo "A2.>> jupyterhub-k8s" docker save gcr.io/kubeflow/jupyterhub-k8s:v20180531-3bb991b1 -o A2-kubeflow-jupyterhub-k8s-v20180531-3bb991b1.tar echo "" echo "A3.>> tf_operator" docker save gcr.io/kubeflow-images-public/tf_operator:v0.2.0 -o A3-kubeflow-tf_operator-v0.2.0.tar echo "" echo "A4.>> ambassador" docker save quay.io/datawire/ambassador:0.30.1 -o A4-kubeflow-ambassador-0.30.1.tar echo "" echo "A5.>> redis" docker save redis:4.0.1 -o A5-kubeflow-redis-4.0.1.tar echo "" echo "A6.>> seldonio/cluster-manager" docker save seldonio/cluster-manager:0.1.6 -o A6-kubeflow-seldonio-cluster-manager-0.1.6.tar echo "" echo "==================================================================" echo "Kubeflow worker engine images......" echo "B1.>> Tensorflow notebook CPU" docker save gcr.io/kubeflow-images-public/tensorflow-1.12.0-notebook-cpu:v-base-76107ff-897 -o A6-kubeflow-tensorflow-1.12.0-notebook-cpu-v-base-76107ff-897.tar echo "" echo "B2.>> Tensorflow notebook GPU" docker save gcr.io/kubeflow-images-public/tensorflow-1.12.0-notebook-gpu:v-base-76107ff-897 -o A6-kubeflow-tensorflow-1.12.0-notebook-gpu-v-base-76107ff-897.tar echo "" echo "===================================================================" echo "Save Kubeflow images Finished." echo "This tool created by https://my.oschina.net/u/2306127" echo "Please visit https://github.com/openthings/kubernetes-tools" echo "===================================================================" echo ""
将所有的镜像压缩为一个zip包,然后上传到工作节点： echo "Uploading 10.1.1.202" sshpass -p xxxx scp kf-images-0.3.3.zip supermap@10.1.1.202:/home/supermap/ echo "Uploading 10.1.1.203" sshpass -p xxxx scp kf-images-0.3.3.zip supermap@10.1.1.203:/home/supermap/ echo "Uploading 10.1.1.142" sshpass -p xxxx scp kf-images-0.3.3.zip supermap@10.1.1.142:/home/supermap/ echo "Uploading 10.1.1.193" sshpass -p xxxx scp kf-images-0.3.3.zip supermap@10.1.1.193:/home/supermap/ echo "Uploading 10.1.1.234" sshpass -p xxxx scp kf-images-0.3.3.zip supermap@10.1.1.234:/home/supermap/ echo "Uploading 10.1.1.205" sshpass -p xxxx scp kf-images-0.3.3.zip supermap@10.1.1.205:/home/supermap/ echo "Uploading 10.1.1.112" sshpass -p xxxx scp kf-images-0.3.3.zip supermap@10.1.1.112:/home/supermap/ echo "Upload kf-images-0.3.3.zip Finished."
然后,在各个节点上恢复到Docker的原始镜像名称。如下： echo "===================================================================" echo "Load Kubeflow images from tar." echo "This tool created by https://my.oschina.net/u/2306127" echo "Please visit https://github.com/openthings/kubernetes-tools" echo "###################################################################" echo "Kubernetes core system images." echo "-------------------------------------------------------------------" echo "A1<< centraldashboard" sudo docker load -i A1-kubeflow-centraldashboard-v0.2.1.tar echo "" echo "A2<< jupyterhub-k8s" sudo docker load -i A2-kubeflow-jupyterhub-k8s-v20180531-3bb991b1.tar echo "" echo "A3<< tf_operator" sudo docker load -i A3-kubeflow-tf_operator-v0.2.0.tar echo "" echo "A4<< ambassador" sudo docker load -i A4-kubeflow-ambassador-0.30.1.tar echo "" echo "A5<< redis" sudo docker load -i A5-kubeflow-redis-4.0.1.tar echo "" echo "A6<< seldonio/cluster-manager" sudo docker load -i A6-kubeflow-seldonio-cluster-manager-0.1.6.tar echo "" echo "==================================================================" echo "Kubeflow worker engine images......" echo "B1<< Tensorflow notebook CPU" sudo docker load -i A6-kubeflow-tensorflow-1.12.0-notebook-cpu-v-base-76107ff-897.tar echo "" echo "B2<< Tensorflow notebook GPU" sudo docker load -i A6-kubeflow-tensorflow-1.12.0-notebook-gpu-v-base-76107ff-897.tar echo "" echo "===================================================================" echo "Load Kubeflow images Finished." echo "This tool created by https://my.oschina.net/u/2306127" echo "Please visit https://github.com/openthings/kubernetes-tools" echo "==================================================================="
在每一个节点执行上面的脚本,也可以使用 ansible来远程批量执行。 ansible all -i hosts_ansible -m shell -a "unzip -u /home/supermap/kf-images-0.3.3.zip && cd /home/supermap/kf-images-0.3.3 && ./kf-images-load.sh" --ask-sudo-pass --become --become-method=sudo
上面的hosts_ansible为ansible的hosts列表文件（请参考 Ansible快速开始-指挥集群 ）。
上面的这个过程也适用于Kubernetes本身镜像的下载和更新。更多参考： Kubeflow镜像的快速下载（V0.3.3） Kubernetes 1.12.3快速升级
查看镜像是否有新的版本： https://console.cloud.google.com/gcr/images/kubeflow-images-public 「深度学习福利」大神带你进阶工程师,立即查看>>>
目标检测时需要对训练数据进行标注,标注工具为labelImg,其在Mac下的安装教程如下： # Install PyQt4, it must be this version brew install cartr/qt4/pyqt brew install libxml2 pip install labelImg # Run labelImg
其它版本的安装参考： http://tzutalin.github.io/labelImg/ 。
Github地址： https://github.com/tzutalin/labelImg 。
作者：SnailTyan 「深度学习福利」大神带你进阶工程师,立即查看>>>
Kubeflow是一个面向Kubernetes集群运行的机器学习框架。要想使用得先想办法把镜像搬到自己的环境里来。
目前版本0.3.3的容器镜像已经搬回来,可以使用下面的脚本来从Aliyun的镜像服务站下载： Kubeflow系统容器镜像（0.3.3）： echo "" echo "=================================================================" echo "Pull kubeflow images for system from aliyun.com ..." echo "This tools created by openthings, NO WARANTY. 2018.11.28." echo "=================================================================" MY_REGISTRY=registry.cn-hangzhou.aliyuncs.com/openthings echo "" echo "1. centraldashboard" docker pull ${MY_REGISTRY}/kubeflow-images-public-centraldashboard:v0.2.1 docker tag ${MY_REGISTRY}/kubeflow-images-public-centraldashboard:v0.2.1 gcr.io/kubeflow-images-public/centraldashboard:v0.2.1 echo "" echo "2. jupyterhub-k8s" docker pull ${MY_REGISTRY}/kubeflow-jupyterhub-k8s:v20180531-3bb991b1 docker tag ${MY_REGISTRY}/kubeflow-jupyterhub-k8s:v20180531-3bb991b1 gcr.io/kubeflow/jupyterhub-k8s:v20180531-3bb991b1 echo "" echo "3. tf_operator" docker pull ${MY_REGISTRY}/kubeflow-images-public-tf_operator:v0.2.0 docker tag ${MY_REGISTRY}/kubeflow-images-public-tf_operator:v0.2.0 gcr.io/kubeflow-images-public/tf_operator:v0.2.0 echo "" echo "4. ambassador" docker pull ${MY_REGISTRY}/quay-io-datawire-ambassador:0.30.1 docker tag ${MY_REGISTRY}/quay-io-datawire-ambassador:0.30.1 quay.io/datawire/ambassador:0.30.1 echo "" echo "5. redis" docker pull ${MY_REGISTRY}/redis:4.0.1 docker tag ${MY_REGISTRY}/redis:4.0.1 redis:4.0.1 echo "" echo "6. seldonio/cluster-manager" docker pull ${MY_REGISTRY}/seldonio-cluster-manager:0.1.6 docker tag ${MY_REGISTRY}/seldonio-cluster-manager:0.1.6 seldonio/cluster-manager:0.1.6 echo "" echo "Finished." echo "" TensorFlow机器学习引擎容器镜像（1.12.0）： ## 添加Tag for registry.cn-hangzhou.aliyuncs.com/openthings MY_REGISTRY=registry.cn-hangzhou.aliyuncs.com/openthings MY_IMAGE_CPU=tensorflow-1.12.0-notebook-cpu:v-base-76107ff-897 MY_IMAGE_GPU=tensorflow-1.12.0-notebook-gpu:v-base-76107ff-897 ## Push镜像 ## Tag to original docker iamges name. echo "" echo "1. tensorflow-1.12.0-notebook-cpu" echo "PULL: ${MY_REGISTRY}/kubeflow-images-public-${MY_IMAGE_CPU}" docker pull ${MY_REGISTRY}/kubeflow-images-public-${MY_IMAGE_CPU} docker tag ${MY_REGISTRY}/kubeflow-images-public-${MY_IMAGE_CPU} gcr.io/kubeflow-images-public/${MY_IMAGE_CPU} echo "" echo "2. tensorflow-1.12.0-notebook-gpu" echo "PULL: ${MY_REGISTRY}/kubeflow-images-public-${MY_IMAGE_GPU}" docker pull ${MY_REGISTRY}/kubeflow-images-public-${MY_IMAGE_GPU} docker tag ${MY_REGISTRY}/kubeflow-images-public-${MY_IMAGE_GPU} gcr.io/kubeflow-images-public/${MY_IMAGE_GPU} echo "" echo "FINISHED." echo "" 如果想自己学习当一回搬运工,请参考： 源码脚本,参见： https://github.com/openthings/kubernetes-tools/kubeflow 完整过程,参见： KubeFlow等镜像部署到本地集群的流程
更多的参考： Kubeflow-机器学习工作流框架 Kubeflow 使用指南 Kubeflow 快速入门 Kubeflow 入门——为 Kubernetes 打造的组件化、可移植、可扩展的机器学习堆栈 PyTorch支持Kubernetes集群 为JupyterHub自定义Notebook Images 基于Kubernetes的机器学习系统 Kubernetes集成TensorFlow服务 Spark机器学习工具链-MLflow简介 「深度学习福利」大神带你进阶工程师,立即查看>>>
摘要： 用机器学习来把股价走势安排的明明白白！
机器学习和深度学习已经在金融机构中找到了自己的位置,因为它们能够以高精度预测时间序列数据,并且工程师们仍在继续研究以使模型更好。这篇文章是我使用机器学习来预测股票价格的入门项目。
它基于我的项目 AlphaAI ,这是一个 堆叠的神经网络架构 ,可以预测各个公司的股票价格。该项目是2018年iNTUtion的 决赛项目 之一。
工作流程
该项目的工作流程基本上是以下步骤：
1.获取股票价格数据；
2.使用小波变换去噪数据；
3.使用 Stacked Autoencoders 提取特征；
4.使用特征训练 LSTM ；
5.测试预测准确性的模型；
在这篇文章中,我将详细介绍每个步骤以及为什么做出某些决定。
1.数据采集
pandas_datareader 是 借助雅虎财经的API,它可以很容易获得股票价格数据,只需使用以下命令即可完成： stock_data = pdr.get_data_yahoo(self.ticker, self.start, self.end)
2.数据去噪
由于股票市场动态的复杂性,股票价格数据通常充满了可能分散机器学习算法分散趋势和结构的噪声。因此,删除一些噪声是符合我们的诉求,同时也可以保留数据中的趋势和结构。起初,我想使用傅里叶变换（不熟悉的人应该 阅读这篇文章 ）,但我认为小波变换可能是保留数据时间因素的更好选择,而不是仅产生基于频率的输出。
小波变换
小波变换与傅立叶变换密切相关,只是用于变换的函数是不同的,并且这种变换发生的方式也略有不同。
过程如下：
1.使用小波变换来变换数据；
2.消除超过完全标准偏差的系数（在所有系数中）；
3.反变换新系数以获得去噪数据；
以下是小波变换如何对时间序列数据进行去噪的示例：
如你所见,在去噪版本中不存在初始信号中存在的随机噪声,这正是我们要查看的股票价格数据。
这是去噪数据的代码： x = np.array(self.stock_data.iloc[i: i + 11, j]) (ca, cd) = pywt.dwt(x, "haar") cat = pywt.threshold(ca, np.std(ca), mode="soft") cdt = pywt.threshold(cd, np.std(cd), mode="soft") tx = pywt.idwt(cat, cdt, "haar")
该库 pywt 非常适合小波变换,这也极大地减轻了我的负担。
3.提取特征
在大多数机器学习环境中,提取特征需要专家领域知识,这是我没有的奢侈品。我或许可以尝试使用某种形式的技术指标,如平均线或平均收敛差异（MACD）或动量指标,但我觉得盲目地使用它可能不是最优的。
但是,通过使用堆叠自动编码器或其他机器学习算法（如受限的Boltzmann机器）,可以实现自动特征提取。由于编码的可解释性与限制Boltzmann机器的概率相比,我选择使用堆叠自动编码器。
堆叠式自动编码器
从本质上讲,堆叠式自动编码器非常适合压缩数据并再次复制数据。我们感兴趣的是压缩部分,因为它意味着重现数据所需的信息以某种方式以压缩形式编码。这表明这些压缩数据在某种程度上可能是我们试图从中提取特征的数据的特征。以下是堆叠自动编码器的网络结构：
输入数据被压缩成所需的许多神经元,并且网络被迫使用自动编码器重建初始数据。这会强制模型提取数据的关键元素,我们可以将其解释为要素。需要注意的一点是,由于没有输入输出对,这个模型实际上属于无监督学习,但输入和输出其实都是相同的。
我们可以使用 keras 构建这样的模型。 class AutoEncoder: def __init__(self, encoding_dim): self.encoding_dim = encoding_dim def build_train_model(self, input_shape, encoded1_shape, encoded2_shape, decoded1_shape, decoded2_shape): input_data = Input(shape=(1, input_shape)) encoded1 = Dense(encoded1_shape, activation="relu", activity_regularizer=regularizers.l2(0))(input_data) encoded2 = Dense(encoded2_shape, activation="relu", activity_regularizer=regularizers.l2(0))(encoded1) encoded3 = Dense(self.encoding_dim, activation="relu", activity_regularizer=regularizers.l2(0))(encoded2) decoded1 = Dense(decoded1_shape, activation="relu", activity_regularizer=regularizers.l2(0))(encoded3) decoded2 = Dense(decoded2_shape, activation="relu", activity_regularizer=regularizers.l2(0))(decoded1) decoded = Dense(input_shape, activation="sigmoid", activity_regularizer=regularizers.l2(0))(decoded2) autoencoder = Model(inputs=input_data, outputs=decoded) encoder = Model(input_data, encoded3) # Now train the model using data we already preprocessed autoencoder.compile(loss="mean_squared_error", optimizer="adam") train = pd.read_csv("preprocessing/rbm_train.csv", index_col=0) ntrain = np.array(train) train_data = np.reshape(ntrain, (len(ntrain), 1, input_shape)) # print(train_data) # autoencoder.summary() autoencoder.fit(train_data, train_data, epochs=1000)
我使用从2000年到2008年的去噪股票价格数据训练了自动编码器。经过1000个epoch的训练后,RMSE降至0.9左右。然后,我使用该模型将剩余的股票价格数据编码为特征。
4. LSTM模型
LSTM模型不需要介绍,因为它在预测时间序列中变得非常普遍和流行。它从细胞状态的存在中获得了卓越的预测能力,使其能够理解和学习数据的长期趋势。这对我们的股票价格数据尤为重要,下面我将讨论我认为重要的设计选择的某些方面。
优化器
所使用的优化器类型可以极大地影响算法收敛到最小值的速度。此外,重要的是存在一些随机性概念,以避免陷入局部最小值且未达到全局最小值。这其中有一些很棒的算法,但我选择使用Adam优化器。Adam优化器成功的结合了另外两个优化器的优势：ADAgrad和RMSprop。
ADAgrad优化器基本上对每个参数和每个时间步使用不同的学习速率。ADAgrad背后的问题是：不常见的参数必须具有较大的学习率,而频繁的参数必须具有较小的学习率。换句话说,ADAgrad的随机梯度下降更新成为：
其中 。
基于已经为每个参数计算的过去梯度来计算学习速率。因此,
其中G是过去梯度平方和的矩阵,这种优化的问题是随着迭代次数的增加,学习率开始迅速消失。
RMSprop考虑通过仅使用一定数量的先前梯度来固定递减的学习速率。更新成为
其中
既然我们已经理解了这两个优化器是如何工作的,那么我们可以研究一下Adam的工作方式。
自适应矩估计（Adam）是另一种通过考虑过去平方梯度的指数衰减平均值来计算每个参数的自适应学习率的方法。这可以表示为
v和m可以分别被认为是梯度的第一和第二时刻的估计,因此得到自适应矩估计的名称。当这是第一次使用时,研究人员观察到存在0的固有偏差,他们通过使用以下估计来反驳这一点：
这导致我们进入最终的梯度更新规则
这是我使用的优化器,其好处总结如下：
1. 每个参数和每次迭代的学习率都不同；
2. 与ADAgrad一样,学习并没有减少；
3. 梯度更新使用权重分布矩阵。
正则化
训练模型的另一个重要方面是确保权重不会太大并关注一个数据点,或者称为过度拟合。所以我们应该对大权重设置惩罚（大的程度取决于所使用的常规者的类型）。我选择使用Tikhonov正则化,可以将其视为以下最小化问题：
函数空间在再生核Hilbert空间（RKHS）中确保了规范的概念存在。这允许我们将规范的概念编码到我们的正则化器中。
Dropout
一种新的防止过度拟合的方法,具体用在当一些神经元突然不起作用时会发生什么。这迫使模型不要过度依赖任何神经元组,而是考虑所有这些神经元。dropout已经发现它们可以使神经元更加健壮,从而使它们能够预测趋势,而无需关注任何一个神经元。以下是使用dropout的结果：
5.模型实施
上述所有分析都可以在keras及其功能API轻松地实现。这是模型的代码（查看整个代码,查看我的GitHub： AlphaAI ） class NeuralNetwork: def __init__(self, input_shape, stock_or_return): self.input_shape = input_shape self.stock_or_return = stock_or_return def make_train_model(self): input_data = kl.Input(shape=(1, self.input_shape)) lstm = kl.LSTM(5, input_shape=(1, self.input_shape), return_sequences=True, activity_regularizer=regularizers.l2(0.003), recurrent_regularizer=regularizers.l2(0), dropout=0.2, recurrent_dropout=0.2)(input_data) perc = kl.Dense(5, activation="sigmoid", activity_regularizer=regularizers.l2(0.005))(lstm) lstm2 = kl.LSTM(2, activity_regularizer=regularizers.l2(0.01), recurrent_regularizer=regularizers.l2(0.001), dropout=0.2, recurrent_dropout=0.2)(perc) out = kl.Dense(1, activation="sigmoid", activity_regularizer=regularizers.l2(0.001))(lstm2) model = Model(input_data, out) model.compile(optimizer="adam", loss="mean_squared_error", metrics=["mse"]) # load data train = np.reshape(np.array(pd.read_csv("features/autoencoded_train_data.csv", index_col=0)), (len(np.array(pd.read_csv("features/autoencoded_train_data.csv"))), 1, self.input_shape)) train_y = np.array(pd.read_csv("features/autoencoded_train_y.csv", index_col=0)) # train_stock = np.array(pd.read_csv("train_stock.csv")) # train model model.fit(train, train_y, epochs=2000)
结果
这些是我对各公司的预测结果。
对于雪佛龙来说,MSE是2.11
对于埃克森美孚,MSE为0.0945
很明显,使用这种神经网络架构的结果令人印象深刻,并且如果实施到策略中可以是有利可图的。
在线学习
除了从历史数据中学习模型之外,我还想让模型实时学习,甚至从预测中学习。因此,我已经使它成为一个学习和预测的在线模型。换句话说,它可以学习历史数据,预测明天的价格,另外当实际价格已知时,它也会学习使用它。所以模型总是在改进。
除了使用实际价格来改善之外,我还考虑制作一个二级模型,该模型使用关于公司的新闻和Twitter的情绪值。我将首先概述如何获取这些数据。
Twitter数据
除了股票价格数据,我还想尝试一些自然语言处理。因此,我尝试深入研究使用来自Twitter和新闻的情绪数据来改进股票预测。
第一个斗争就是免费获取推文,因为获取整个实时数据的Twitter API已经被禁止。但是,我找到了一个允许我在过去10天内获取推文的API,然后我可以实现某种形式的NLP来从推文中提取情绪数据。这不是最佳的,但对我的在线学习模型仍然有用。
新闻数据
与Twitter类似,获取新闻数据非常困难。我尝试分析彭博文章的网址,但实现从2000年手动报废网站几乎是不可能的。因此,我选择了具有相当强大的抓取模型的Aylien API。
这些新闻文章被删除的条件是他们只包括股票和财经新闻,过滤到前150个Alexa网站,并且使用指数加权移动平均线平均情绪分数,以考虑最近的新闻而不是旧的新闻。
在线模型
鉴于我的情绪分数,我使用额外的神经网络层来更正我的预测误差。但是,在本文发布时,结果不可用,因为生成一个数据点需要一天的时间。
结论
神经网络非常善于预测时间序列数据,当与情感数据结合时,可以真正建立一个实用的模型。虽然这里的结果令人印象深刻,但我仍然想方设法改进它,也许实际上可以从中制定完整的交易策略。目前,我正在研究使用强化学习来开发一个使用预测模型结果的交易代理。
原文链接 「深度学习福利」大神带你进阶工程师,立即查看>>>
本文整理自知乎上的一个问答,分享给正在学习自然然语言处理的朋友们！
一、自然语言处理是什么？
自然语言处理说白了,就是让机器去帮助我们完成一些语言层面的事情,典型的比如：情感分析、文本摘要、自动问答等等。我们日常场景中比较常见到的类似Siri、微软小冰之类的,这些的基础都是自然语言处理,另外还有一些语音处理,这就暂且不表了。总之,你看到的机器与人利用语言交互,用机器模拟人脑阅读,对话,评论等等这些的基础都是自然语言处理的范畴之内。
二、自然语言处理怎么学？
自然语言处理的实际入门步骤来说,假如单单从应用来说,我觉得还是直接先从简单的应用搞起更好一点,上来就是理论的话可能对一些人还是比较枯燥,我认为一个好的过程是：实践-理论-实践,先由实践搞起,加深兴趣,然后理论研究,深化理解,最后继续实践,知行合一。闲言少叙,下面说下自己的入门步骤：
1、分词
针对中文而言(当然假如你处理英文,可直接跳过这一步),首先就是分词的问题,因为中文相对于英文,并不是空格分隔的,另外进行自然语言处理的相关实践,也不大可能直接一长段文本进行操作,所以分词还是首当其中的。分词的原理暂且不说(比如CRF、霍夫曼等等,有兴趣可自己去了解),这里主要推荐一下常用到(Java)的几个分词工具：
（1）、 HanLP 是一个中文自然语言处理的基础包,它囊括了包含分词在内的几乎所有的自然语言处理涉及的基础操作,同时工具包来说,分为data版和ptotable版,对于一般的分词而言,protable完全就可以满足要求。另外还有一些其他的操作,例如词性识别,也是实际应用中比较多的。当然其他的类似关键词提取,情感识别做个参考也就好了,实际还是要自己优化；
（2）、 LTP 是哈工大的一个分词组件,相较于HanLP而言,其包含的依存句法分析以及语义依存分析的方法,对于我们基于文本进行更高级一点的操作(比如提取句子的主语、谓语；行动关系等,另外基于此进行分词优化实践也有一定的提升),可以说是比较方便的；但是与此同时,LTP提供分词的方式是利用http接口的方式,这就让它在实际的应用中有那么一点落后,虽然它也提供了自搭服务的方式,但也逃不出请求接口。最后的最后,貌似现在已经和讯飞合作了,开放接口都需要申请,而且还不一定能用。。允悲。
（3）、jieba 说起分词,就不得不提jieba,包括最基础的python版本,然后还有衍生出来的java版、C#版等等,实际使用起来也是比较方便,当然对于java版而言,它没有词性的功能,这也是我在实际应用中使用表少的一个原因吧。
另外,分词工具还有ansj、StanfordNLP中工具等等,用的不多也就不瞎说了。
2、关键词提取
对于中文文本而言,分词完毕,接下来我们要做的事情,大致逃不出那么几件：关键词提取、句子相似性、文本摘要等,这其中一个比较典型的应用就是关键词提取。相应的实践方式主要有以下几种：
（1）、TF-IDF 是关键词提取一个可以说是首先想到的解决方案,它说自己第二,没人敢说第一。当然它的理论也是比较好理解的,归结起来一句话：在一篇文本中那些不常出现（此处指的文本集）的词在当前文本中大量出现,那它就是关键词；TF、IDF也相应的就是两个概念,想看理论,查查便知；具体到应用层级来说,对于大量文本,语料比较丰富的场景下,这种方式提取关键词来说,确实也是比较方便和准确的,但在语料不足的情况下,可能也就just soso了。但是思想是最重要的,这也是我们入门的基础。
（2）、TextRank 是基于Google的PageRank的一个应用于文本的一个关键词提取算法,基于词语窗口的思想,利用相互投票的方式,提取文本关键词。TextRank有一个最大的好处就是不依赖额外文本,针对单篇文本,处理得当也就可以提取出看的过去的关键词,简单实用。关于其优化方式,比如改变词语网络窗口的大小,分词的预过滤,词性权重投票等等,都是一个不错的方向,效果也还算显著。其对应的实现都有开源的版本,GitHub上动动手就有了。
（3）、LDA 从严谨的角度而言,它并不是一个提取关键词的方式,但是对于我们预先有一定分类的文本而言,利用LDA提取文本的中心词,或者说针对类别的关键词,某些情况下效果也是不错的。具体到实现上,Java开源的有JGIbbLDA、当然python的scikit-learn,以及Spark Mllib中都包含了对应的LDA版本,可以一试。
具体到实际的使用场景,对于有大量语料,首推TF-IDF；对于单篇文本,当然还是TextRank；对于类别文本,LDA也不失为一种选择。总之,看你实际应用需求。
3、词向量
从关键词提取直接跳转到词向量,感觉是一个比较大的跳跃,但实际而言,词向量是我们后续进行机器学习或者深度学习的处理,因为机器处理的始终还是二进制,你不可能改变计算机底层的实现（当然说的是现在,没准后来有人就真成了呢,我们当那是一个美好的愿景吧）。词向量说白了,就是用向量的形式表示词,这就牵涉到一个问题了,我们怎么把一个中文词语转化成一个向量呢。这里主要有以下几种方式：
（1）、词袋模型,顾名思义就是把所有的词都放进一个袋子里,然后指定每个词的位置。所以这样生成的向量,就是长度等同于单词总数,尽在词对应的位置置1,其他位置均为0。这样你也应该能想到,实际应用而言,不太现实。
（2）、HashTF,对应词袋模型的困境,人们首先想到的就是怎么缩小向量的维度,同时表示相同的单词呢,HashTF的基本思想也就是为了解决这个问题,利用Hash的思想,将大量的单词映射到一个小维度向量中,来解读维度爆炸的问题,当然有利有弊,仍然不能很好的解决词语映射的问题。
（3）、Word2Vec是工业上比较常用的一个词向量模型工具,也是实际应用中采用的。其思想包括CBOW和Skip-Gram,基本思想都是词语和词语周围单词间的一个共现关系,它在一定程度上考虑了语境和语义的影响,是一个可以实际使用的工具。
概括来说,在我们后期利用机器学习或者深度学习处理问题的时候,词向量是我们必不可少的一步,word2vec也是我们可以考虑的一个比较不错的选择。
4、文本分类
文本分类是一个比较大的概念,具体到应用,其中包括了情感识别、敏感识别等,具体到实现方式,包括二类分类、多类别分类、多标签分类等。就是为了把一组文本按照指定要求利用机器进行区分。具体到实现算法而言,不胜枚举。。Spark Mllib中包含了大量的分类算法,可以进行实践,这也是入门的一种比较快速的方式,先会后懂然后深入。
5、自动问答
自动问答是一个比较热的概念,也是一个应用比较广泛的自然语言处理案例,当前业界最高水平R-Net已经可以达到80%多的准确率,已经是一个比较了不起的成就了,但是实际操作起来,也还是有一定难度,我也在不断摸索,暂时不瞎说了。
三、自然语言处理的深入
谈到自然语言处理的深入,这个可以做的就比较多了,上面列举的各个方面都与比较大的优化空间。但总体而言,最大的几个问题在于分词、词向量的转化以及文本特征的提取,这也是一定程序上困扰我们继续提高的几大阻碍。拿分词来说,无论是基于词典和算法的分词还是目前基于深度学习的分词方式,都只能说一定程度上进行分词实现,想要达到人脑的分词效果,实际上还是前路漫漫；词向量的转化在一定程序上也依赖于大量的语料,而我们也不可能在训练模型时囊括所有的词语,所有的语境,所有的文本,这些也都是不现实的,只能说时优化算法或者选择一种更好的方式；文本特征的提取也是一个我们在后期进行学习过程中一个绕不过去的坎。总而言之,自然语言处理说简单也简单,说难也难,就看你想要达到什么样的高度。
作者：郑海伦
「深度学习福利」大神带你进阶工程师,立即查看>>>
作为博客文章的处女秀,我将简要介绍一下我的研究领域。从现在起,我将之命名为“人体运动轨迹的人工智能动画模拟”（Physically-Based Animation ,下文简称PBA）。
译注：
这篇文章最早是在Media看到的,文中,作者将这一方法命名为Physically-Based Animation,但稍后却不知为何删除了Media上的文章,于是我们找到了作者的博客,在上面找到了这篇文章,但在博客中,这一方法被描述为Procedural Animation,即程序性动画。我个人较愿意以最新的名称来命名这一动画,因为Physically,既可以理解为物理反馈式的,也可以理解为人体的,因此更符合目前的研究方向和案例。
一、关于我的一点介绍
我是芬兰Aalto University计算机科学系的博士生。我目前的研究重点是为物理模拟角色在多智能体条件下的表现开发高效的,创造性的运动人工智能模拟技术。我的研究的最终目标是填补深度强化学习和在线最优化求解之间的空白。 译注： 多智能体（multi-agent）,是多个Agent组成的集合,其多个Agent成员之间相互协调,相互服务,共同完成一个任务,鸟群、鱼群、兽群和菌落都可以被看成是多智能体系统。（http://t.cn/E2oDTFg） 在线最优化求解：利用已有的样本数据训练的过程往往转换成一个最优化求解的过程。当我们面对高维高数据量的时候,批量处理的方式就显得笨重和不够高效,因此需要有在线处理的方法（Online）来解决相同的问题。（http://t.cn/E2oDuZf） 累积奖励：强化学习作为一种机器学习方法,是通过Agent与环境交互和获得反馈来形成学习过程,当Agent做出了正确的步骤,积累奖励增加,错误则扣减。最著名的例子就是AlphaGo,以往的学习方法依赖大量的棋谱,而强化学习是通过对弈中的成败来形成奖惩来让机器变得更“聪明”。 二、强化学习与PBA 「深度学习福利」大神带你进阶工程师,立即查看>>>
锅炉故障预测
预警准确率95%以上
利用算法模型进行制程能力的
综合分析与评估优化
提升定标效率
时间降低30%
构建垃圾焚烧发电工艺的优化算法模型
综合考虑环保和设备负荷因素
推荐最优工艺参数组合
优化人工操作,提高燃烧效率 「深度学习福利」大神带你进阶工程师,立即查看>>>
摘要： 本文介绍了创建神经网络时使用的多种优化器,并讲述了如何使用优化器让训练网络更快。
通过使用Numpy来创建神经网络,让我意识到有哪些因素影响着神经网络的性能。架构、超参数值、参数初始化,仅是其中的一部分,而这次我们将致力于对学习过程的速度有巨大影响的决策,以及所获得的预测的准确性—对优化策略的选择。我们会研究很多流行的优化器,研究它们的工作原理,并进行对比。
你在 GitHub 上可以找到所有代码： 机器学习算法的优化
优化是搜索用于最小化或最大化函数参数的过程。当我们训练机器学习模型的时候,通常使用间接优化。我们选择某种度量,如精确度或回调,来指示模型如何很好地解决给定问题。然而,我们正在优化一个不同的代价函数 J(θ) ,并且希望把它最小化以提高我们关心的度量。当然,代价函数的选择通常与我们要解决的具体问题有关。本质上,它表明了我们离理想的解决方案有多远。
陷阱
结果证明,通常要找到最小的非凸代价函数并不容易,我们必须使用先进的优化策略来找到它们。如果你已经学过了微分,就一定知道局部最小值的概念,这些是我们的优化器可能陷入的最大陷阱。对于那些还没有接触过这个数学概念的人,我只能说这些是在给定的区域内函数取最小值的点,如上图左侧所示。
克服所谓的鞍点（saddle points）通常被认为更具有挑战性。这些是稳定状态,其中代价函数的值几乎是不变的。这种情况显示在上图的右侧。在这些点上,梯度几乎在所有方向上都被归零,使得无法逃离。
有时候,特别是在多层网络的情况下,我们可能必须处理代价函数中非常陡峭的区域。在这些地方,梯度的值急剧地增加,引起梯度爆炸,这会致使采取一些极大的步骤长度,并经常破坏之前的整个优化工作。然而,通过梯度裁剪,就是定义允许的最大梯度值,就可以很容易地避免这个问题。 梯度下降法（Gradient descent）
在我们了解更好的算法之前,先看看一些基本的策略方法。可能一个最简单的方法就是简单地沿着与梯度相反的方向移动,这个方法可以用下面的等式来表示：
其中,α是一个称为学习率的超参数,它会转换为我们将在每次迭代中采取的步骤长度。它的值在一定程度上表示了一种折中选择,是学习的速度和可以获得结果的准确性之间的。选择太小的步骤长度会导致我们冗长的计算和执行更多的迭代。另一方面,无论如何,选择过大的步骤长度可以有效地阻止我们找到最小值。在图2中表示了这种情况,我们可以看到,在随后的迭代中,如何振动,而不能保持稳定。在此期间,定义了适当步骤的模型几乎立即就被发现了。
图 2. 对于小学习率和大学习率的值的梯度下降行为的可视化。
此外,这个算法容易受到前面描述的鞍点问题的影响。由于在随后的迭代过程中执行校正的大小与计算的梯度成正比,我们将无法摆脱平稳期。
最后,为了达到这一目的,该算法是无效的,它要求在每次迭代中使用整个训练集。这意味着,在每一个时期,我们必须查看所有的例子,以便执行下一步的优化。当训练集包含数千个例子的时候,这可能不是问题,但是正如我在之前提到的,当有数百万条记录可供使用时,神经网络工作的效果最好,但在这种情况下,很难想象在每次迭代中我们都使用整个集合,这会浪费时间和计算机资源。 小批量梯度下降法（Mini-bach Gradient descent）
图 3. 梯度下降与小批量梯度下降的比较
让我们来解决上节中提到的最后一个问题——低效。虽然向量化允许我们可以加速计算,但是要一次性处理太多的训练实例,并且当数据集具有数百万条记录时,整个处理过程仍然需要很长时间才能完成。让我们试着使用一个相当简单的解决方法,将整个数据集分成更小的部分,在随后的迭代中进行训练。假设左边的图形表示我们想要优化的代价函数。可以看到,由于我们需要处理的数据量要小得多,新算法就会使得决策更快。让我们来看下比较模型移动中的对比。梯度下降会采取罕见的、相对大的步骤,几乎没有噪音。另一方面,批量梯度下降更频繁地执行步骤,但是由于被分析的数据集中可能存在多样性,则会有更多的噪音。甚至在一次迭代中,我们会朝着与预期相反的方向移动。然而,平均而言,我们会朝着最小值的方向移动。
图 4. 将数据集成批拆分
那么按照什么尺寸拆呢？在深度学习中的通常情况下,答案是不确定的,取决于具体情况。如果整个数据集就是一批,那么我们基本上就是处理一个普通的梯度下降。另一方面,如果大小是1,那么在每次迭代中,我们只使用数据集中的一个实例,因此失去了向量化的好处。这种方法有时是合理的,被称为随机梯度下降。在实际环境中,我们通常会选择从64到512个例子的范围里选择一个中间值。 指数加权平均法（ exponentially weighted averges ,EWA）
这一思想被广泛应用于统计学、经济学、深度学习等领域。许多高级的神经网络优化算法使用了这个思想,因为它允许我们持续优化,即使在给定点所计算的梯度是零的情况下。让我们来了解一下这个算法,我们将使用最大的一家科技公司的股票作为例子。
图 5. 可视化地显示给不同的β值计算指数加权平均数
EWA实质上是对许多得到的值计算平均数,以便不受局部波动的影响而关注整体趋势。EWA的值是使用上面的递推公式计算的,其中β是用于控制要计算平均值的数的范围。在随后的迭代中,我们考虑了1 /（1 -β）的例子。对于较大的β值,得到的曲线更平滑,因为我们平均了许多记录。另一方面,曲线越来越向右移动,因为当我们把很长一段时间内的值进行平均的时候,EWA对新的趋势适应的比较慢。这在图5中可以看到,其中我们说明了股票在收盘时的实际价格,显示了给不同的β参数计算的指数加权平均值。 动量梯度下降法（Gradient descent with momentum）
该方法利用指数加权平均法来避免代价函数的梯度接近于零的点。简单来说就是,我们允许算法获得动量,因此即使局部梯度为零,我们仍然可以依靠之前计算的值向前移动。由于这个原因,它一直是一个比纯梯度下降更好的选择。
通常我们给网络的每一层使用反向传播来计算 dW 和 db 的值。这次,我们首先计算 VdW 和 Vdb 的中间值,而不是直接使用计算出来的梯度来更新神经网络参数的值,这些值实际上是关于单个参数的代价函数导数的EWA。最后,我们将在梯度下降中使用 VdW 和 Vdb 。整个过程可用上述方程表示。值得注意的是,这种方法的实现需要在迭代之间存储EWA的值。
图 6. 动量梯度下降法
现在我们尝试开发一个关于EWA影响模型行为的直觉能力。再次想象上面的轮廓象征着我们优化的代价函数。上图显示标准梯度下降和动量梯度下降的比较。我们可以看到,代价函数图表的形状推动一种非常缓慢的优化方法。正如股票市场价格的例子一样,使用指数加权平均法允许我们关注主要的趋势而不是噪声。指示最小值的分量被扩大,并且承担波动的分量被慢慢消除。更重要的是,如果我们在后续的更新中获得的梯度指向一个相似的方向,那么学习率将会提高。这将导致更快的收敛和减少振荡。然而,这种方法有一个缺点—当你接近最小值的时候,动量值会增大,并且可能变得相当大,以至于算法不能在正确的地方停止。 RMSProp 算法
另一种提高梯度下降性能的方法是使用RMSProp方法—均方根传播（Root Mean Squared Propagation）。它是有适应能力的,允许为模型每个参数的学习率单个调整。随后的参数值是基于之前为特定参数计算的梯度值。
使用图6的例子和上面的方程,让我们考虑这个方法背后的逻辑。根据名称,在每次迭代中,我们计算相应参数的代价函数导数的每个元素的平方。此外,我们使用EWA来计算在最近迭代中获得的值的平均数。最后,在更新网络参数值之前,将相应的梯度分量除以平方和的平方根。这意味着对于梯度大的参数,学习率降低得更快；反之,对于梯度小的参数,学习率降低得则更慢。以这种方式,我们的算法会减少波动,并防止噪音影响信号。为了避免零作除数（数值稳定性）,我们要向分母添加一个非常小的值,在公式中标记为ɛ。
在写本文的时候,我对所分析优化器的质量飞跃感到非常惊讶。第一个是当我看到标准梯度下降和小批量梯度下降之间的训练时间上的差异时；第二,比较RMSprop与迄今为止我们看到的一切。然而,这种方法有其缺点。随着上述方程的分母在每次迭代中增大,学习率会越来越小。因此,这可能会导致模型完全停止运行。
图 7. 优化器比较 Adam
最后,让我说一下Adam（自适应矩估计）。这是一种算法,和RMSProp一样,在大量的应用中效果不错。它利用了RMSProp的最大优点,将应用与动量优化的思想结合起来。结果就会得到一种允许快速且有效的优化策略。上图显示了讨论过的优化器如何处理函数复杂部分的优化。可以看到Adam在这种情况下做得很好。
遗憾的是,随着我们的方法有效性的提高,计算的复杂度也增大了。以上我写了十个矩阵方程来描述优化过程的单次迭代。对于那些不太熟悉数学的人,别担心,没有新的东西,这些是之前为动量和RMSProp 优化器所写的方程。我们将简单地使用这两种想法。 总结
我希望能以一种由浅入深的方式来解释这些复杂的问题。本文的相关工作使我能够理解选择正确的优化器是多么的重要。对这些算法的理解会让我们有意识地使用它们,了解个体超参数的变化如何影响整个模型的性能。
原文链接 「深度学习福利」大神带你进阶工程师,立即查看>>>
摘要： 本文讲述了热图、二维密度图、蜘蛛图、树形图这四种Python数据可视化方法。
数据可视化是任何数据科学或机器学习项目的一个重要组成部分。人们常常会从探索数据分析（EDA）开始,来深入了解数据,并且创建可视化确实有助于让问题更清晰和更容易理解,尤其是对于那些较大的高维度数据集。在项目结束的时候,能够以清晰的、简洁的和令人信服的方式呈现最终结果,这是非常重要的,让你的用户能够理解和明白。
你可能已经看过了我之前的文章《5种快速和简单的Python数据可视化方法（含代码）》（ 5 Quick and Easy Data Visualizations in Python with Code ）,其中介绍了5种基本可视化方法：散点图、线图、柱状图、条形图和箱形图。这五个是简单而强大的可视化方法,你绝对可以通过这些方法从数据集中得到巨大的收获。在本文中,将介绍另外4个数据可视化方法,但稍微复杂一些,你可以在看完上一篇文章介绍的基本方法之后再用。 热图（ Heat Map ）
热图是数据的矩阵表示方式,其中每个矩阵的值用一种颜色来表示。不同的颜色代表不同的级别,矩阵指数将两个对比的列或特征连接在一起。热图可以很好地显示出多个特征变量之间的关系,因为可以直接把一个级别看作一种颜色。还可以通过观察热图中的一些点来查看每个关系是如何与数据集中的其它关系进行比较的。这些颜色的确提供了简单的表示方式,因为这是非常直观的。
现在来看下代码：与matplotlib库相比,seaborn库可用于更高级的图表,通常也需要更多的组件,如更多的颜色、图形或者变量。Matplotlib库用于显示图表,numpy用于生成数据,而pandas用于控制。绘图只是调用一个简单的seaborn函数,如果你发现了一些在视觉上很特别的东西,通过这个函数,还可以设置颜色映射。 # Importing libs importseaborn as sns import pandas aspd importnumpyasnp importmatplotlib . pyplotasplt # Create a random dataset data = pd . DataFrame ( np . random . random ( ( 10 , 6 ) ) , columns = [ "Iron Man" , "CaptainAmerica" , "BlackWidow" , "Thor" , "Hulk" , "Hawkeye" ] ) print ( data ) # Plot the heatmap heatmap_plot = sns . heatmap ( data , center = 0 , cmap = 'gist_ncar' ) plt . show ( ) 二维密度图（ 2D Density Plot ）
二维密度图是一维版本的简单扩展,能够看到关于2个变量的概率分布。让我们看看下面的二维密度图,右边的刻度用颜色表示每一点的概率。最高的概率,看下数据集,似乎大约是0.5的大小和1.4-ish的速度。正如你所看到的,二维密度图对于快速确定数据对于两个变量最集中的区域非常地显著,而不是像一维密度图那样只集中一个变量。当你有两个对输出结果非常重要的变量,并且希望了解它们如何一起对输出结果分布起作用的时候,二维密度图尤其适合。
Seaborn的代码超级简单,我们将通过创建一个偏态分布介绍它。如果你发现某些颜色和阴影在视觉上更特别,那么大多数的可选参数都是为了看起来更清晰。 蜘蛛图（ Spider Plot ）
蜘蛛图是显示一对多关系最好的方法之一。也就是说,你可以绘制并查看区别于单个变量或类别的多个变量的值。在蜘蛛图中,一个变量相对于另一个变量的特性是显而易见的,因为面积和长度在一些方向上变化了。如果你希望了解几个类别关于这些变量是如何叠加起来的,可以并排绘制一下。在下图中,很容易比较三个电影角色的不同属性,并了解他们的优势所在！
这次我们将能够直接使用matplotlib来创建可视化,而不是用seaborn。需要计算每个属性所在的角度,因为我们希望它们沿圆周被平均地分隔开。我们将在每个计算的角度放置标签,然后把值绘制成一个点,该点到中心的距离取决于它的值或是级别。最后,为了清晰起见,我们将使用半透明的颜色填充由连接各属性点的线所包含的区域。
# Import libs import pandas aspd importseabornassns importnumpyasnp importmatplotlib . pyplotasplt # Get the data df = pd . read_csv ( "avengers_data.csv" ) print ( df ) """ # Name Attack Defense Speed Range Health 0 1 Iron Man 83 80 75 70 70 1 2 Captain America 60 62 63 80 80 2 3 Thor 80 82 83 100 100 3 3 Hulk 80 100 67 44 92 4 4 Black Widow 52 43 60 50 65 5 5 Hawkeye 58 64 58 80 65 """ # Get the data for Iron Man labels = np . array ( [ "Attack" , "Defense" , "Speed" , "Range" , "Health" ] ) stats = df . loc [ 0 , labels ] . values # Make some calculations for the plot angles = np . linspace ( 0 , 2 * np . pi , len ( labels ) , endpoint = False ) stats = np . concatenate ( ( stats , [ stats [ 0 ] ] ) ) angles = np . concatenate ( ( angles , [ angles [ 0 ] ] ) ) # Plot stuff fig = plt . figure ( ) ax = fig . add_subplot ( 111 , polar = True ) ax . plot ( angles , stats , 'o-' , linewidth = 2 ) ax . fill ( angles , stats , alpha = 0.25 ) ax . set_thetagrids ( angles * 180 / np . pi , labels ) ax . set_title ( [ df . loc [ 0 , "Name" ] ] ) ax . grid ( True ) plt . show ( ) 树形图 （ Tree Diagram ）
我们从小学就开始使用树形图了,树形图既自然又直观,还易于解释。直接连接的节点关系密切,而与有多个连接的节点差别很大。在下图中,我已经根据统计绘制了一小部分来自Kaggle的 Pokemon with stats 数据集：
HP、攻击、防御、特殊攻击、特殊防御、速度
因此,与stats wise最匹配的Pokemon将紧密连接在一起。例如,我们看到,在顶部,Arbok和Fearow是直接连接的,而且,如果我们查看数据,Arbok总共有438个,而Fearow有442个,非常接近。但是一旦我们移动到Raticate,我们得到的总数是413,这与Arbok和Fearow的差别很大,这就是它们被分开的原因。当我们移动树的时候,基于相似性,Pokemon被分的组越来越多。在绿色组中的Pokemon相互之间比红色组中的更相似,即使没有直接的绿色连接。
对于树形图,我们实际上要使用Scipy的。在查看了数据集之后,我们将去掉字符串类型的列。我们这么做只是为了要得到正确的可视化结果,但在实践中,最好是把这些字符串转换成分类变量,为了得到更好的结果和进行比较,我们还设置了数据帧索引,以便能够适当地用它作为引用每个节点的列。最后,在Scipy中计算和绘制树形图是非常简单的事了。 # Import libs import pandas aspd frommatplotlibimportpyplotasplt fromscipy . clusterimport hierarchy importnumpyasnp # Read in the dataset # Drop any fields that are strings # Only get the first 40 because this dataset is big df = pd . read_csv ( 'Pokemon.csv' ) df = df . set_index ( 'Name' ) del df . index . name df = df . drop ( [ "Type 1" , "Type 2" , "Legendary" ] , axis = 1 ) df = df . head ( n = 40 ) # Calculate the distance between each sample Z = hierarchy . linkage ( df , 'ward' ) # Orientation our tree hierarchy . dendrogram ( Z , orientation = "left" , labels = df . index ) plt . show ( ) 推荐阅读
为了了解更多的关于数据可视化方面的知识,我建议大家学习这本书 — Data Visualisation Book ,它提供了关于何时、何地、以及为什么使用各个类型的可视化方法的全面而直观的讲解。
原文链接 「深度学习福利」大神带你进阶工程师,立即查看>>>
本文主要参考：https://github.com/zhedongzheng/finch 完成。与原代码的区别在于没有使用 tf.estimator,以及数据预处理方面做了部分修改（使用于dataset） # -*- coding:utf-8 -*- from collections import Counter import tensorflow as tf import numpy as np import re PARAMS = { 'min_freq': 5, 'window_size': 3, 'n_sampled': 100, 'embed_dim': 200, } def preprocess_text(text): # 1. 将数据中的换行符替换为空格 text = text.replace('\n', ' ') # 2. 将数据中的空白字符替换为空格,并转化为全小写 text = re.sub('\s+', ' ', text).strip().lower() # 3. 以空格为分隔符,类似于简单的分词 words = text.split() # 4. 统计词频 word2freq = Counter(words) # 5. 去掉低频词 words = [word for word in words if word2freq[word] > PARAMS['min_freq']] print("Total words:", len(words)) # 6. 去重 _words = set(words) PARAMS['word2idx'] = {c: i for i, c in enumerate(_words)} PARAMS['idx2word'] = {i: c for i, c in enumerate(_words)} PARAMS['vocab_size'] = len(PARAMS['idx2word']) print('Vocabulary size:', PARAMS['vocab_size']) indexed = [PARAMS['word2idx'][w] for w in words] # 7. 将高频词去掉 indexed = filter_high_freq(indexed) print("Word preprocessing completed ...") return indexed def filter_high_freq(int_words, t=1e-5, threshold=0.8): int_word_counts = Counter(int_words) total_count = len(int_words) # 1. 计算词的概率,c/all word_freqs = {w: c / total_count for w, c in int_word_counts.items()} # 2. 计算词的丢弃概率,词频越高,丢弃概率越高。例如: 'the' 出现词频很高,但携带的信息少,需要去除 prob_drop = {w: 1 - np.sqrt(t / word_freqs[w]) for w in int_word_counts} # 3. 高于阈值的丢弃掉 train_words = [w for w in int_words if prob_drop[w] < threshold] return train_words def make_data(int_words): x, y = [], [] for i in range(PARAMS['window_size'], len(int_words) - PARAMS['window_size']): # 1. 生成一个词的上下文 inputs = get_x(int_words, i) # 2. 将一个词的所有上下文作为一个整体,添加到x中 # x = [['a','b','d',e'],['b','c','e','f'] x.append(inputs) # 3. 将每个label作为一个子list,添加到y中 #y = [['c'],['d']] # 4. 即每条数据为context:word y.append([int_words[i]]) return np.array(x), np.array(y) def get_x(words, idx): left = idx - PARAMS['window_size'] right = idx + PARAMS['window_size'] return words[left: idx] + words[idx + 1: right + 1] # 1. 预处理数据 with open(r'E:\nlp_data\ptb_train.txt') as f: x_train, y_train = make_data(preprocess_text(f.read())) # 2. 将数据封装为dataset # 这里一条数据是多少呢？ # 一条数据,x = 6个词,y=1个词,x_train[i],y_train[i] # 原因在于 make_data 中的 x.append(inputs) 和 y.append([int_words[i]]) dataset = tf.data.Dataset.from_tensor_slices(tensors=(x_train,y_train)) dataset = dataset.batch(batch_size=100).repeat(5) iter = dataset.make_one_shot_iterator() next_data = iter.get_next() # 3. CBOW模型搭建 # 这里填写 shape = (None,6) 和 shape=(None,1) # 原因在于 make_data 中的 x.append(inputs) 和 y.append([int_words[i]]) # window_size = 3,则context大小为6 # None 为100,原因在于 dataset.batch(batch_size=100) x = tf.placeholder(shape=(None,6),dtype=tf.int32) y_= tf.placeholder(shape=(None,1),dtype=tf.int32) E = tf.get_variable(name="E",shape=(PARAMS['vocab_size'],PARAMS['embed_dim'])) embedding = tf.nn.embedding_lookup(params=E,ids=x) embedding = tf.reduce_mean(embedding,axis=[1]) W = tf.get_variable(name="w",shape=(PARAMS['vocab_size'],PARAMS['embed_dim']),dtype=tf.float32) b = tf.get_variable(name="b",shape=(PARAMS['vocab_size']),dtype=tf.float32) loss_op = tf.reduce_mean(tf.nn.sampled_softmax_loss( weights=W, biases=b, labels=y_, inputs=embedding, num_sampled=PARAMS['n_sampled'], num_classes=PARAMS['vocab_size'])) opt = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(loss=loss_op) init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) try: while True: inputs,labels = session.run(next_data) session.run(fetches=opt,feed_dict={x:inputs,y_:labels}) except tf.errors.OutOfRangeError: print("train complete")
「深度学习福利」大神带你进阶工程师,立即查看>>>
你已经知道如何对二维图像做卷积了,现在看看如何执行卷积不仅仅在二维图像上,而是三维立体上。
我们从一个例子开始,假如说你不仅想检测灰度图像的特征,也想检测RGB彩色图像的特征。彩色图像如果是6×6×3,这里的3指的是三个颜色通道,你可以把它想象成三个6×6图像的堆叠。为了检测图像的边缘或者其他的特征,不是把它跟原来的3×3的过滤器做卷积,而是跟一个三维的过滤器,它的维度是3×3×3,这样这个过滤器也有三层,对应红绿、蓝三个通道。
给这些起个名字（原图像）,这里的第一个6代表图像高度,第二个6代表宽度,这个3代表通道的数目。同样你的过滤器也有一个高,宽和通道数,并且图像的通道数必须和过滤器的通道数匹配,所以这两个数（紫色方框标记的两个数）必须相等。下个幻灯片里,我们就会知道这个卷积操作是如何进行的了,这个的输出会是一个4×4的图像,注意是4×4×1,最后一个数不是3了。
我们研究下这背后的细节,首先先换一张好看的图片。这个是6×6×3的图像,这个是3×3×3的过滤器,最后一个数字通道数必须和过滤器中的通道数相匹配。为了简化这个3×3×3过滤器的图像,我们不把它画成3个矩阵的堆叠,而画成这样,一个三维的立方体。
为了计算这个卷积操作的输出,你要做的就是把这个3×3×3的过滤器先放到最左上角的位置,这个3×3×3的过滤器有27个数,27个参数就是3的立方。依次取这27个数,然后乘以相应的红绿蓝通道中的数字。先取红色通道的前9个数字,然后是绿色通道,然后再是蓝色通道,乘以左边黄色立方体覆盖的对应的27个数,然后把这些数都加起来,就得到了输出的第一个数字。
如果要计算下一个输出,你把这个立方体滑动一个单位,再与这27个数相乘,把它们都加起来,就得到了下一个输出,以此类推。
那么,这个能干什么呢？举个例子,这个过滤器是3×3×3的,如果你想检测图像红色通道的边缘,那么你可以将第一个过滤器设为,和之前一样,而绿色通道全为0,,蓝色也全为0,。如果你把这三个堆叠在一起形成一个3×3×3的过滤器,那么这就是一个检测垂直边界的过滤器,但只对红色通道有用。
或者如果你不关心垂直边界在哪个颜色通道里,那么你可以用一个这样的过滤器,,,,所有三个通道都是这样。所以通过设置第二个过滤器参数,你就有了一个边界检测器,3×3×3的边界检测器,用来检测任意颜色通道里的边界。参数的选择不同,你就可以得到不同的特征检测器,所有的都是3×3×3的过滤器。
按照计算机视觉的惯例,当你的输入有特定的高宽和通道数时,你的过滤器可以有不同的高,不同的宽,但是必须一样的通道数。理论上,我们的过滤器只关注红色通道,或者只关注绿色或者蓝色通道也是可行的。
再注意一下这个卷积立方体,一个6×6×6的输入图像卷积上一个3×3×3的过滤器,得到一个4×4的二维输出。
现在你已经了解了如何对立方体卷积,还有最后一个概念,对建立卷积神经网络至关重要。就是,如果我们不仅仅想要检测垂直边缘怎么办？如果我们同时检测垂直边缘和水平边缘,还有45°倾斜的边缘,还有70°倾斜的边缘怎么做？换句话说,如果你想同时用多个过滤器怎么办？
这是我们上一张幻灯片的图片,我们让这个6×6×3的图像和这个3×3×3的过滤器卷积,得到4×4的输出。（第一个）这可能是一个垂直边界检测器或者是学习检测其他的特征。第二个过滤器可以用橘色来表示,它可以是一个水平边缘检测器。
所以和第一个过滤器卷积,可以得到第一个4×4的输出,然后卷积第二个过滤器,得到一个不同的4×4的输出。我们做完卷积,然后把这两个4×4的输出,取第一个把它放到前面,然后取第二个过滤器输出,我把它画在这,放到后面。所以把这两个输出堆叠在一起,这样你就都得到了一个4×4×2的输出立方体,你可以把这个立方体当成,重新画在这,就是一个这样的盒子,所以这就是一个4×4×2的输出立方体。它用6×6×3的图像,然后卷积上这两个不同的3×3的过滤器,得到两个4×4的输出,它们堆叠在一起,形成一个4×4×2的立方体,这里的2的来源于我们用了两个不同的过滤器。
我们总结一下维度,如果你有一个（通道数）的输入图像,在这个例子中就是6×6×3,这里的就是通道数目,然后卷积上一个,这个例子中是3×3×3,按照惯例,这个（前一个nc）和这个（后一个nc）必须数值相同。然后你就得到了（n-f + 1）*（n-f+1）*nc,这里其实就是下一层的通道数,它就是你用的过滤器的个数,在我们的例子中,那就是4×4×2。我写下这个假设时,用的步幅为1,并且没有padding。如果你用了不同的步幅或者padding,那么这个数值会变化,正如前面的视频演示的那样。
这个对立方体卷积的概念真的很有用,你现在可以用它的一小部分直接在三个通道的RGB图像上进行操作。更重要的是,你可以检测两个特征,比如垂直和水平边缘或者10个或者128个或者几百个不同的特征,并且输出的通道数会等于你要检测的特征数。
对于这里的符号,我一直用通道数（nc）来表示最后一个维度,在文献里大家也把它叫做3维立方体的深度。这两个术语,即通道或者深度,经常被用在文献中。但我觉得深度容易让人混淆,因为你通常也会说神经网络的深度。所以,在这些视频里我会用通道这个术语来表示过滤器的第三个维度的大小。
所以你已经知道怎么对立方体做卷积了,你已经准备好了实现卷积神经其中一层了,在下个视频里让我们看看是怎么做的。
---------------------
作者：洪流之源
来源：CSDN
原文：https://blog.csdn.net/weicao1990/article/details/80283443
版权声明：本文为博主原创文章,转载请附上博文链接！ 「深度学习福利」大神带你进阶工程师,立即查看>>>
梯度下降算法 https://www.jianshu.com/p/c7e642877b0e
极大似然估计详解： https://blog.csdn.net/class_brick/article/details/79724660 https://blog.csdn.net/zengxiantao1994/article/details/72787849
SVM https://blog.csdn.net/crcr/article/details/60346084 PCA https://blog.csdn.net/hustqb/article/details/78394058 「深度学习福利」大神带你进阶工程师,立即查看>>>
2015年,阿里云宣布正式推出RDS for PostgreSQL服务,届时,阿里云成为国内首家同时支持MySQL、SQL Server 和PostgreSQL关系型数据库的云计算服务商。
用户在云上就能享受PostgreSQL引擎带来的对SQL标准和NoSQL的高度兼容、强大的处理复杂查询能力、以及丰富的插件支持等特性,同时还能大幅节省运维成本和硬件投入。
转眼到现在,已经是阿里云支持 PostgreSQL的第四年。
阿里云云数据库RDS for PostgreSQL成为了一款兼具轻松处理空间信息、强大NoSQL兼容、支持全文搜索、支持OSS云存储扩展、支持数据仓库数据共享等诸多功能于一身的实用数据库,无论是在OSS存储空间扩展以节省存储成本,还是整合JSON、GIS、IP网络类型处理的IoT业务上都有不俗的表现。
近日,阿里云重磅发布PostgreSQL 10 高可用本地SSD盘版,相比原 9.4 版本又新增了JSONB、BRIN索引、GROUPING SETS/CUBE/ROLLUP、UPSERT等多项功能。
PostgreSQL 10 高可用版支持并行顺序扫描、联合和聚合,新版本同时支持词组的全文检索提高处理性能。避免“二次冻结”过期数据实现减少对大表的自动清理数据的影响。
PostgreSQL在拥有一系列优势的同时,对用户来说也存在痛点,比如在管理上存在一定的复杂度。如果没有专业的运维知识,普通开发者很难独立完成PostgreSQL的管理工作（如备份恢复、高可用、性能优化、监控、容量扩展、版本升级等）。而阿里云RDS for PostgreSQL可帮助缺少运维经验的管理者,轻松完成这些任务。
了解更多关于阿里云云数据库RDS PostgreSQL高可用版请戳链接： https://www.aliyun.com/product/rds/postgresql?tlog=out_app_feature20181119
原文链接 「深度学习福利」大神带你进阶工程师,立即查看>>>
摘要： 相信很多朋友都会玩国际象棋,那么有尝试过构建一个国际象棋引擎吗,一起来玩玩看吧！
来源： Pexels
我不擅长国际象棋。
我父亲在我年幼的时候教过我,但我猜他是那些一直让他们的孩子获胜的爸爸之一。为了弥补世界上最受欢迎的游戏之一的技能的缺乏,我做了任何数据科学爱好者会做的事情:建立一个人工智能来击败我无法击败的人。遗憾的是,它不如AlphaZero（甚至普通玩家）好。但我想看看国际象棋引擎在没有强化学习的情况下如何做,以及学习如何将深度学习模型部署到网络上。
比赛在这里!
获取数据
FICS 拥有一个包含3亿场比赛,个人走法,结果以及所涉玩家评级的数据库。我下载了所有在2012年的比赛,其中至少有一名玩家超过2000 ELO。这总计约97000场比赛,有730万个走子。胜利分配是：43000次白方胜利,40000次黑方胜利和14000次平局。
极小极大算法
了解如何做一个深度学习象棋AI,我必须首先了解传统象棋AI程序。来自于极小极大算法。Minimax是“最小化最大损失”的缩写,是博弈论中决定零和博弈应如何进行的概念。
Minimax通常用于两个玩家,其中一个玩家是最大化者,另一个玩家是最小化者。机器人或使用此算法获胜的人假设他们是最大化者,而对手是最小化者。该算法还要求有一个棋盘评估函数,来衡量谁赢谁输。该数字介于-∞和∞之间。最大化者希望最大化此值,而最小化者希望最小化此值。这意味着当你,最大化者,有两个走法可以选择的时候,你将选择一个给你更高评估的那个,而最小化者将做相反的选择。这个游戏假设两个玩家都发挥最佳状态并且没有人犯任何错误。
来源： GlobalSoftwareSupport
以上面的GIF为例。你,最大化者（圆圈）有三个你可以选择的走法（从顶部开始）。你直接选择的走法取决于你的对手（方块）在走子后将选择的走法。但是你的对手直接选择的走法取决于你走子后选择的走法,依此类推,直到游戏结束。玩到游戏结束会占用大量的计算资源和时间,所以在上面的例子中,选择一个深度,2。如果最小化者（最左边的方块）选择左移,你有1和-1可供选择。你选择1,因为它会给你最高分。如果最小化者选择正确的走法,则选择0,因为它更高。现在是最小化者的回合,他们选择0因为这更低。这个游戏继续进行,一直进行到所有的走子都完成或你的思维时间耗尽。对于我的国际象棋引擎来说,假设白方是最大化者,而黑方是最小化者。如果引擎是白方,则算法决定哪个分支将给出最高的最低分数,假设人们在每次走子时选择最低分数,反之亦然。为了获得更好的性能,该算法还可以与另一种算法结合使用： alpha-beta剪枝 。 Alpha-beta剪枝截止系统适用于决定是否应该搜索下一个分支。
深度学习架构
我的研究始于 Erik Bernhardsson关于国际象棋深度学习的优秀文章 。他讲述了他如何采用传统方法制作AI下棋并将其转换为使用神经网络作为引擎。
第一步是将棋盘转换为输入层的数字形式。我借用了Erik Bernhardsson的编码策略,其中棋盘是一个热编码,每一个方块中都有一个棋子。这总计为768个元素数组（8 x 8 x 12,因为有12种棋子）。
Bernhardsson选择将输出图层设为1表示白方胜利,-1表示黑方胜利,0表示平局。他认为游戏中的每个板位置都与结果有关。如果黑方赢了,每个棋的位置都被训练成“支持黑方”,如果白方赢了,则“支持白方棋”。这允许网络返回介于-1和1之间的值,这将告诉你该位置是否更有可能导致白赢或黑赢。
我想用稍微不同的评估函数来解决这个问题。网络是否能够看到不是白方还是黑方获胜,而是能够看到哪个走子将导致胜利？首先,我尝试将768元素的棋盘表示放入输出,其中一个位置是输入,下一个位置是输出。当然,这没有用,因为这把它变成了一个多分类问题。这导致引擎适当地选择合法走子时出现太多的错误,因为输出层中的所有768个元素可以是1或0。因此,我查阅了Barak Oshri和Nishith Khandwala的斯坦福大学论文 《利用卷积神经网络预测国际象棋中的运动》 ,了解他们如何解决这个问题。他们训练了7个神经网络,其中1个网络是棋子选择器网络。这个网络决定哪一个方格最有可能被移动。其他六个网络专门针对每一个棋子类型,并决定将一个特定的棋子移动到哪里。如果棋子选择器选择了一个带有兵的方格,那么只有棋子神经网络会响应最有可能移动到的方格。
我从他们的想法中借鉴了两个卷积神经网络。第一个,从网络移动,将被训练成采用768元素数组表示并输出专业棋手移动的方格（在方块0和方块63之间）。 第二个网络：移动到网络,将做同样的事情,除了输出层将是专业棋手移动到的地方。我没有考虑谁赢了,因为我认为训练数据中的所有移动都是相对最优的,无论最终结果如何。
我选择的架构是两个128卷积层,带有2x2滤波器,后面是两个1024神经元完全连接层。我没有应用任何池,因为池提供位置不变性。图片左上角的猫就像图片右下角的猫一样。然而,对于国际象棋,,棋子国王的值是完全不同于车兵。隐藏图层的激活功能是RELU,而我将softmax应用到最后一层,因此我基本上得到一个概率分布,其中所有方格的概率总和加起来达到100％。
我的训练数据是训练集的600万个位置,其余130万个位置用于验证集。在训练结束时,我从网络上获得了34.8％的验证准确率,并且在转移到网络时获得了27.7％的验证准确率。这并不意味着70％的时间它没有学习合法的走子,这只意味着AI没有像验证数据中的专业玩家那样做出相同的举动。相比之下,Oshri和Khandwala的网络平均验证准确率为37％。
将深度学习与Minimax结合起来
因为现在这是一个分类问题,其中输出可以是64个类之一,这就留下了很大的错误空间。关于训练数据（来自高级别玩家的比赛）的一个警告是,优秀的棋手很少会玩到“将军”。他们知道什么时候输了,通常没有必要跟进整场比赛。这种缺乏平衡的数据使得网络在最终游戏结束时非常混乱。它会选择车来移动,并试图沿对角线移动。如果失败,网络甚至会试图指挥对手的棋子（厚颜无耻！）。
为了解决这个问题,我命令输出的概率。然后,我使用python-chess库获取给定位置的所有合法走子的列表,并选择具有最高结果概率的合法走子。最后,我应用了一个带有惩罚的预测分数方程式,用于选择较不可能的走子：400（选择的走子指数之和）。名单上的合法走子越远,其预测得分就越低。例如,如果从网络移动的第一个索引（索引0）与移动到网络的第一个索引相结合是合法的,那么预测分数是400（0 + 0）,这是最高可能分数：400。
在与材料分数结合使用数字后,我选择了400作为最大预测分数。材料分数是一个数字,可以判断所做的走子是否会捕获一个棋子。根据捕获的棋子,走子的整体得分将得到提升。我选择的材料价值如下：
兵:10,马:500,象:500,车:900,后:5000,王:50000。
这特别有助于残局。在将杀走子将是第二个最可能的合法行动且预测得分较低的情况下,国王的物质价值将超过它。兵的分数如此之低,因为网络在早期比赛中考虑得足够充分,所以如果它是战略举措,它将会采用兵。
然后我将这些分数结合起来,以返回给定任何潜在走子的棋盘的评估。我通过深度为3的minimax算法（使用alpha-beta修剪）提供了这个,并得到了一个可以将杀的可运行国际象棋引擎！
使用Flask和Heroku进行部署
我在Youtube上使用了 Bluefever Software的指南 ,展示了如何通过向flask服务器发出AJAX请求来制作javascript国际象棋UI并通过它来路由我的引擎。 我使用Heroku将python脚本部署到Web并将其连接到我的自定义域： Sayonb.com 。
结论
虽然引擎的性能没有我希望的那么好,但是我学到了很多关于AI的基础知识,将机器学习模型部署到web上,以及为什么AlphaZero不使用卷积神经网络来玩游戏!
可以通过以下方式进行改进： 1.通过使用bigram模型LSTM将从网络移动和移动到网络中的时间序列组合在一起。 这可能有助于将移出和移动到决策中,因为每个目前都是独立接近的。 2.通过添加夺取的棋子的位置来改进棋子的赋值（夺取棋盘中心的兵比它在边缘时夺取更有利）。 3.在使用神经网络预测分数和子力分值之间切换,而不是在每个节点使用两者。这可以允许更高的极小极大算法搜索深度。 4.考虑边缘情况,例如：减少孤立自己的兵的可能性,增加马靠近棋盘中心的可能性。
查看代码,或者在 GitHub repo 用自己的训练数据自己训练一个新网络！
原文链接 「深度学习福利」大神带你进阶工程师,立即查看>>>
中文主要有 ：NLTK,FoolNLTK,HanLP（java版本）,pyhanlp（python版本）,Ansj,THULAC,结巴分词,FNLP,哈工大LTP,中科院ICTCLAS分词,GATE,SnowNLP,东北大学NiuTrans,NLPIR,；
英文主要有 ：NLTK,Genism,TextBlob,Stanford NLP,Spacy。英文的开源NLP工具主要参见StackoverFlow-java or python for nlp
相关问题&文章：
（1）如何用 Python 中的 NLTK 对中文进行分析和处理？ 这个问题下的回答也详说了其他的语音处理包
（2）中文分词项目总结
详细介绍
HanLP ：HanLP是由一系列模型与算法组成的Java工具包,目标是普及自然语言处理在生产环境中的应用。HanLP具备功能完善、性能高效、架构清晰、语料时新、可自定义的特点。
开发语言：Java
网址：hankcs/HanLP
开发机构：大快搜索
协议：Apache-2.0
功能：非常多,主要有中文分词,词性标注,命名实体识别,关键词提取,自动摘要,短语提取,拼音转换,简繁转换,文本推荐,依存句法分析,文本分类：情感分析,word2vec,语料库工具
活跃度：github star 超过4千5,近期（201711）仍在保持更新
Ansj中文分词 ：一个基于n-Gram+CRF+HMM的中文分词的java实现.
开发语言：Java
网址：NLPchina/ansj_seg
协议：Apache License 2.0
功能：中文分词. 中文姓名识别 . 用户自定义词典,关键字提取,自动摘要,关键字标记
性能：分词速度达到每秒钟大约200万字左右（mac air下测试）,准确率能达到96%以上
活跃度：github star 数量超过3500,近期（2017.11）仍在保持更新
THULAC ：一个高效的中文词法分析工具包,具有中文分词和词性标注功能。
开发语言：
网址：THULAC：一个高效的中文词法分析工具包
开发机构：清华大学自然语言处理与社会人文计算实验室
协议：研究目的免费开放源代码,商用目的需洽谈许可证
功能：中文分词和词性标注
感谢石墨用户 @hain 的补充
Synonyms : 中文近义词工具包
开发语言：Python
网址：https://github.com/huyingxi/Synonyms
开发机构：个人
协议：MIT
功能：获取近义词集合,句子相似度计算
性能：见网站
活跃度：～1k Star
结巴分词： Python中文分词组件
开发语言：Python
网址：fxsjy/jieba
开发机构：
协议：MIT授权协议
功能：中文分词
FNLP ：FNLP主要是为中文自然语言处理而开发的工具包,也包含为实现这些任务的机器学习算法和数据集。
开发语言：
网址： FudanNLP/fnlp
开发机构：复旦
协议：LGPL3.0许可证。
功能：信息检索： 文本分类 新闻聚类；中文处理： 中文分词 词性标注 实体名识别 关键词抽取 依存句法分析 时间短语识别；结构化学习： 在线学习 层次分类 聚类
Genism ：Gensim is a Python library for topic modelling, document indexing and similarity retrieval with large corpora. Target audience is the natural language processing (NLP) and information retrieval (IR) community.
开发语言：Python
网址：RaRe-Technologies/gensim
协议：LGPL-2.1 license
活跃度：github star数超过五千,近期（201711）仍在更新
TextBlob ：Simple, Pythonic, text processing--Sentiment analysis, part-of-speech tagging, noun phrase extraction, translation, and more.
开发语言：Python
网址：sloria/TextBlob
功能：情感分析、词性标注、翻译等
活跃度：github star 超过4千,近期（201711）仍在更新
Spacy ：spaCy is a library for advanced Natural Language Processing in Python and Cython. It's built on the very latest research, and was designed from day one to be used in real products. spaCy comes with pre-trained statistical models and word vectors, and currently supports tokenization for 20+ languages. It features the fastest syntactic parser in the world, convolutional neural network models for tagging, parsing and named entity recognition and easy deep learning integration. It's commercial open-source software, released under the MIT license.
开发语言：python
协议：MIT协议
功能： 功能很多,如tagging, parsing and named entity recognition等
性能：功能强大,支持二十多种语言（然而目前还不支持中文,可以阅读官方文档了解更多信息https://spacy.io/usage/）,号称是工业级强度的Python NLP工具包,区别于学术性质更浓的Python NLTK
活跃度：star 超过7千,近期（201711）仍非常活跃
作者：鉴津Jackie
「深度学习福利」大神带你进阶工程师,立即查看>>>
【一】keras模型搭建整体流程
keras支持两种方式搭建模型,一种是使用Sequential方式进行模型搭建,一种是使用函数式API进行模型搭建,整体流程如下图：
【二】keras主要模块介绍
1. 数据预处理
2. NLP相关的主要layer
3. 其他模块
4. 其他
1. kears支持自定义layer,可以参考：https://keras.io/zh/layers/writing-your-own-keras-layers/
2. TensorFlow 最新的版本（如1.12）,支持keras。即通过tf.keras方式使用。使用方式和keras基本一致（后续会介绍tf.keras）
3. 使用keras搭建模型快速,方便。相对于纯tf代码搭建模型,简单了很多,影藏了很多细节（如：感知不到Graph、placeholder、variable、session等）
,就很简单的模型搭建,概念上,就是model与layer。如果tf的源码设计上,从上到下依次为：model--->layer---->op,则感觉清晰好多。 「深度学习福利」大神带你进阶工程师,立即查看>>> static std::string base64Decode(const char* Data, int DataByte) { //解码表 const char DecodeTable[] = { 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, 62, // '+' 0, 0, 0, 63, // '/' 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, // '0'-'9' 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // 'A'-'Z' 0, 0, 0, 0, 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 'a'-'z' }; std::string strDecode; int nValue; int i = 0; while (i < DataByte) { if (*Data != '\r' && *Data != '\n') { nValue = DecodeTable[*Data++] << 18; nValue += DecodeTable[*Data++] << 12; strDecode += (nValue & 0x00FF0000) >> 16; if (*Data != '=') { nValue += DecodeTable[*Data++] << 6; strDecode += (nValue & 0x0000FF00) >> 8; if (*Data != '=') { nValue += DecodeTable[*Data++]; strDecode += nValue & 0x000000FF; } } i += 4; } else { Data++; i++; } } return strDecode; } static std::string base64Encode(const unsigned char* Data, int DataByte) { //编码表 const char EncodeTable[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; //返回值 std::string strEncode; unsigned char Tmp[4] = { 0 }; int LineLength = 0; for (int i = 0; i < (int)(DataByte / 3); i++) { Tmp[1] = *Data++; Tmp[2] = *Data++; Tmp[3] = *Data++; strEncode += EncodeTable[Tmp[1] >> 2]; strEncode += EncodeTable[((Tmp[1] << 4) | (Tmp[2] >> 4)) & 0x3F]; strEncode += EncodeTable[((Tmp[2] << 2) | (Tmp[3] >> 6)) & 0x3F]; strEncode += EncodeTable[Tmp[3] & 0x3F]; if (LineLength += 4, LineLength == 76) { strEncode += "\r\n"; LineLength = 0; } } //对剩余数据进行编码 int Mod = DataByte % 3; if (Mod == 1) { Tmp[1] = *Data++; strEncode += EncodeTable[(Tmp[1] & 0xFC) >> 2]; strEncode += EncodeTable[((Tmp[1] & 0x03) << 4)]; strEncode += "=="; } else if (Mod == 2) { Tmp[1] = *Data++; Tmp[2] = *Data++; strEncode += EncodeTable[(Tmp[1] & 0xFC) >> 2]; strEncode += EncodeTable[((Tmp[1] & 0x03) << 4) | ((Tmp[2] & 0xF0) >> 4)]; strEncode += EncodeTable[((Tmp[2] & 0x0F) << 2)]; strEncode += "="; } return strEncode; } //imgType 包括png bmp jpg jpeg等opencv能够进行编码解码的文件 static std::string Mat2Base64(const cv::Mat &img, std::string imgType) { //Mat转base64 std::string img_data; std::vector vecImg; std::vector vecCompression_params; vecCompression_params.push_back(CV_IMWRITE_JPEG_QUALITY); vecCompression_params.push_back(90); imgType = "." + imgType; cv::imencode(imgType, img, vecImg, vecCompression_params); img_data = base64Encode(vecImg.data(), vecImg.size()); return img_data; } static cv::Mat Base2Mat(std::string &base64_data) { cv::Mat img; std::string s_mat; s_mat = base64Decode(base64_data.data(), base64_data.size()); std::vector base64_img(s_mat.begin(), s_mat.end()); img = cv::imdecode(base64_img, CV_LOAD_IMAGE_COLOR); return img; }
PS:不得不吐槽一句这年头WebSocket转MAT这么复杂,C++后端都隐藏实力去了吗？ 图像Base64编码更多查看 「深度学习福利」大神带你进阶工程师,立即查看>>>
欢迎大家前往 腾讯云+社区 ,获取更多腾讯海量技术实践干货哦~ 本文由 brzhang 发表
数据清洗
首先,为何需要对数据进行清洗
数据清洗的工作绝壁是非常枯燥的,做数据研究的的人绝对无法避开这个环节,其根本原因是因为我们从各种渠道拿到的数据可能会出现：
1、不合理的数据,你比如,样本中有些人的年龄超过了120岁,楼层的高度达到了1000层,以及其他的一些非常不合理的场景。
2、错误的类型,你比如,样例中,几乎所有的数据都是整形,然而,有一些是字符串类型,如果不进行处理,将这些数据直接喂给算法,一般情况下是要崩溃的。
3、计算机对于处理字符串类型比较吃力,有时候,需要我们将他转化为数字类型,这样就设计到一个映射关系,比如,样例性别,【男,女】,我们可以转化为1,2,房屋的类型【单间,一房一厅,二房一厅,三房一厅,商铺】可以对应的枚举出来,比如我在处理房屋朝向上的示例 #提取房屋的朝向 def parse_orientation(row): if '朝西南' in row: return 1 elif '朝东北' in row: return 2 elif '朝东' in row: return 3 elif '朝南' in row: return 4 elif '朝西北' in row: return 5 elif '朝北' in row: return 6 elif '朝东南' in row: return 7 elif '朝南北' in row: return 8 elif '朝西' in row: return 9 else: return 10
等等等等,我想说的是绝对还有很多你意想不到的场景,需要你耐心的打磨数据,将搜集到的原始数据,清洗成为可用的数据。
数据清洗需要掌握哪些黑科技
通常我们拿到的数据数据都可以简化为表格模型,无用你是xsl也好,csv亦或json数组也好,都可以利用pandas来读取,读取之后,接下来的工作基本上就是借助在pandas的一些api来做数据清洗工作了,如下,我读取了一份房价信息的数据表,这份数据当然是我自己根据上一篇文章,利用scrapy做了一个爬虫爬取的咯。
jupyter笔记
为了让我们能够更好的玩数据清洗,我也不吝啬的贡献出了一份非常全面的pandas的操作 Cheatsheet 一份,以及后面你一定会用到一个万能的 CheatSheet 。
来来,简单的了解一下pandas的一些常用的api了,举例就用：
示例数据一行
1、取子集常用操作
取子集
其中,loc是支持按照列名字符串的方式来取子集,iloc支持的是使用数组索引（从0开始）的方式来取子集,通常,逗号前面是行相关的一些条件限制,逗号右边则是列相关的限制。比如,我取得
我就取前两列
2、处理空白数据行
处理空白数据
这种就很简单愉快了,一个api就可以删除或者填充有空白数据的样本了。
这个就不演示了,因为我是爬虫爬取数据,所以在爬取的过程中,我已经对数据进行了一些基础的处理,程序控制不可能出现空白数据了,所以,我也是建议,自己写爬虫去获取数据,这些减轻数据清洗环节的压力。
3、apply系列
apply其实有比较多兄弟,比如applymap,map,他们的能力各有不同,总的来说就是apply()是一种让函数作用于列或者行操作,applymap()是一种让函数作用于DataFrame每一个元素的操作,而map是一种让函数作用于Series每一个元素的操作,如下所示,我这里对ege列进行处理了一了,将数字和文本归一化为数字。
apply示例
实际上,这个操作完全可用map来做： df['ege'] = df['ege'].map(parse_house_age) df.head(5)
结果完全一样,因为我们只取了一列。
数据清洗比较高级的方式,使用各种图表
1、使用散点图
房屋总面积对应总价图
2、房价热力值图：
房价区间热力图
图描述了房间分布区间,可以清洗看出一些问题。
3、频率直方图帮助我们迅速找到一些特例独行的猪,因为他出现的次数少嘛,不得不让人怀疑这种数据的真实性。
利用直方图快速找出毛刺点
ok,总的来说,这个过程需要开动自己的脑经,把你拿到的原始数据,慢慢慢慢的,变成可以给你下面算法需要的数据。 相关阅读 【每日课程推荐】机器学习实战！快速入门在线广告业务及CTR相应知识
此文已由作者授权腾讯云+社区发布,更多原文请 点击
搜索关注公众号「云加社区」,第一时间获取技术干货,关注后回复1024 送你一份技术课程大礼包！ 「深度学习福利」大神带你进阶工程师,立即查看>>>
前言
“ I’m sorry. I can’t do that, Dave.” 这是经典科幻电影《2001: A Space Odyssey》里HAL 9000机器人说的一句话,浓缩了人类对终极人工智能的憧憬。让机器学会说这样简单一句话,需要机器具备情感认知、自我认识以及对世界的认识,来辅助机器处理接收到的各种信息,了解信息背后的意思,从而生成自己的决策。而这些认知模块的基础,都需要机器具备知识学习组织推理的能力,知识图谱就是为实现这些目标而生。
今年5月,美团NLP中心开始构建大规模的餐饮娱乐知识图谱——美团大脑,它将充分挖掘关联各个场景数据,用AI技术让机器“阅读”用户评论数据,理解用户在菜品、价格、服务、环境等方面的喜好,挖掘人、店、商品、标签之间的知识关联,从而构建出一个“知识大脑”。美团大脑已经在公司多个业务中初步落地,例如智能搜索推荐、智能金融、智能商户运营等。
此前,《 美团大脑：知识图谱的建模方法及其应用 》一文,介绍了知识图谱的分类及其具体应用,尤其是常识性知识图谱及百科全书式知识图谱分别是如何使用的。之后我们收到非常多的反馈,希望能进一步了解“美团大脑”的细节。为了让大家更系统地了解美团大脑,NLP中心会在接下来一段时间,陆续分享一系列技术文章,包括知识图谱相关的技术,美团大脑背后的算法能力,千亿级别图引擎建设以及不同应用场景的业务效果等等,本文是美团大脑系列的第一篇文章。
迈向认知智能 海量数据和大规模分布式计算力,催生了以深度学习为代表的第三次（1993-目前）人工智能高潮。Web 2.0产生的海量数据给机器学习和深度学习技术提供了大量标注数据,而GPU和云计算的发展为深度学习的复杂数值计算提供了必要算力条件。深度学习技术在语音、图像领域均取得了突破性的进展,这表示学习技术成果使得机器首次在感知能力上达到甚至超越了人类的水平,人工智能已经进入感知智能阶段。
然而,随着深度学习被广泛应用,其局限性也愈发明显。 缺乏可解释性 ：神经网络端到端学习的“黑箱”特性使得很多模型不具有可解释性,导致很多需要人去参与决策,在这些应用场景中机器结果无法完全置信而需要谨慎的使用,比如医学的疾病诊断、金融的智能投顾等等。这些场景属于低容错高风险场景,必须需要显示的证据去支持模型结果,从而辅助人去做决策。 常识（Common Sense）缺失 ：人的日常活动需要大量的常识背景知识支持,数据驱动的机器学习和深度学习,它们学习到的是样本空间的特征、表征,而大量的背景常识是隐式且模糊的,很难在样本数据中进行体现。比如下雨要打伞,但打伞不一定都是下雨天。这些特征数据背后的关联逻辑隐藏在我们的文化背景中。 缺乏语义理解 。模型并不理解数据中的语义知识,缺乏推理和抽象能力,对于未见数据模型泛化能力差。 依赖大量样本数据 ：机器学习和深度学习需要大量标注样本数据去训练模型,而数据标注的成本很高,很多场景缺乏标注数据来进行冷启动。
图1 数据知识驱动AI能力对比
从人工智能整体发展来说,综上的局限性也是机器从感知智能向认知智能的迁跃的过程中必须解决的问题。认知智能需要机器具备推理和抽象能力,需要模型能够利用先验知识,总结出人可理解、模型可复用的知识。机器计算能力整体上需要从数据计算转向知识计算,知识图谱就显得必不可少。知识图谱可以组织现实世界中的知识,描述客观概念、实体、关系。这种基于符号语义的计算模型,一方面可以促成人和机器的有效沟通,另一方面可以为深度学习模型提供先验知识,将机器学习结果转化为可复用的符号知识累积起来。
知识究竟是什么呢？知识就是有结构的信息。人从数据中提取有效信息,从信息中提炼有用知识,信息组织成了结构就有了知识。知识工程,作为代表人工智能发展的主要研究领域之一,就是机器仿照人处理信息积累知识运用知识的过程。而知识图谱就是知识工程这一领域数十年来的代表性研究方向。在数据还是稀有资源的早期,知识图谱的研究重点偏向语义模型和逻辑推理,知识建模多是自顶向下的设计模式,语义模型非常复杂。其中典型工作,是在1956年人工智能学科奠基之会——达特茅斯会议上公布的“逻辑理论家”(Logic Theorist)定理证明程序,该程序可以证明《数学原理》中的部分定理。伴随着Web带来前所未有的数据之后,知识图谱技术的重心从严谨语义模型转向海量事实实例构建,图谱中知识被组织成<主,谓,宾>三元组的形式,来表征客观世界中的实体和实体之间的关系。比如像名人的维基百科词条页面中,Infobox卡片都会描述该名人的国籍信息,其结构就是<人,国籍,国家>这样的三元组。
图2 互联网公司知识图谱布局
目前,知识图谱已被广泛应用在问答、搜索、推荐等系统,已涉及金融、医疗、电商等商业领域,图谱技术成为“兵家必争”之地。微软于2010年开始构建Satori知识图谱来增强Bing搜索；Google在2012年提出 Knowledge Graph概念,用图谱来增强自己的搜索引擎；2013年Facebook发布Open Graph应用于社交网络智能搜索；2015年阿里巴巴开始构建自己的电商领域知识图谱；2016年Amazon也开始构建知识图谱。
图3 美团大脑
2018年5月,美团点评NLP中心开始构建大规模的餐饮娱乐知识图谱——美团大脑。美团点评作为中国最大的在线本地生活服务平台,覆盖了餐饮娱乐领域的众多生活场景,连接了数亿用户和数千万商户,积累了宝贵的业务数据,蕴含着丰富的日常生活相关知识。在建的美团大脑知识图谱目前有数十类概念,数十亿实体和数百亿三元组,美团大脑的知识关联数量预计在未来一年内将上涨到数千亿的规模。
美团大脑将充分挖掘关联各个场景数据,用AI技术让机器“阅读”用户评论和行为数据,理解用户在菜品、价格、服务、环境等方面的喜好,构建人、店、商品、场景之间的知识关联,从而形成一个“知识大脑”。相比于深度学习的“黑盒子”,知识图谱具有很强的可解释性,在美团跨场景的多个业务中应用性非常强,目前已经在搜索、金融等场景中初步验证了知识图谱的有效性。近年来,深度学习和知识图谱技术都有很大的发展,并且存在一种互相融合的趋势,在美团大脑知识构建过程中,我们也会使用深度学习技术,把数据背后的知识挖掘出来,从而赋能业务,实现智能化的本地生活服务,帮助每个人“Eat Better, Live Better”。
知识图谱技术链
图4 知识图谱技术链
知识图谱的源数据来自多个维度。通常来说,结构化数据处理简单、准确率高,其自有的数据结构设计,对数据模型的构建也有一定指导意义,是初期构建图谱的首要选择。世界知名的高质量的大规模开放知识库如Wikidata、DBPedia、Yago是构建通用领域多语言知识图谱的首选,国内有OpenKG提供了诸多中文知识库的Dump文件或API。工业界往往基于自有的海量结构化数据,进行图谱的设计与构建,并同时利用实体识别、关系抽取等方式处理非结构化数据,增加更多丰富的信息。
知识图谱通常以实体为节点形成一个大的网络,图谱的Schema相当于数据模型,描述了领域下包含的类型（Type）,与类型下描述实体的属性（Property）,Property中实体与实体之间的关系为边（Relation）,实体自带信息为属性（Attribute）。除此之外Schema也会描述它们的约束关系。
美团大脑围绕用户打造吃喝玩乐全方面的知识图谱,从实际业务需求出发,在现有数据表之上抽象出数据模型,以商户、商品、用户等为主要实体,其基本信息作为属性,商户与商品、与用户的关联为边,将多领域的信息关联起来,同时利用评论数据、互联网数据等,结合知识获取方法,填充图谱信息,从而提供更加多元化的知识。
知识获取
知识获取是指从不同来源、不同结构数据中,抽取相关实体、属性、关系、事件等知识。从数据结构划分可以分为结构化数据、半结构化数据和纯文本数据。结构化数据指的关系型数据库表示和存储的的二维形式数据,这类数据可以直接通过Schema融合、实体对齐等技术将数据提取到知识图谱中。半结构化数据主要指有相关标记用来分隔语义元素,但又不存在数据库形式的强定义数据,如网页中的表格数据、维基百科中的Infobox等等。这类数据通过爬虫、网页解析等技术可以将其转换为结构化数据。现实中结构化、半结构化数据都比较有限,大量的知识往往存在于文本中,这也和人获取知识的方式一致。对应纯文本数据获取知识,主要包括实体识别、实体分类、关系抽取、实体链接等技术。
实体作为知识图谱的核心单位,从文本中抽取实体是知识获取的一个关键技术。文本中识别实体,一般可以作为一个序列标注问题来进行解决。传统的实体识别方法以统计模型如HMM、CRF等为主导,随着深度学习的兴起,BiLSTM+CRF[1]模型备受青睐,该模型避免了传统CRF的特征模版构建工作,同时双向LSTM能更好地利用前后的语义信息,能够明显提高识别效果。在美团点评-美食图谱子领域的建设中,每个店家下的推荐菜（简称店菜）是图谱中的重要实体之一,评论中用户对店菜的评价,能很好地反映用户偏好与店菜的实际特征,利用知识获取方法,从评论中提取出店菜实体、用户对店菜的评价内容与评价情感,对补充实体信息、分析用户偏好、指导店家进行改善有着非常重要的意义。
图5 BiLSTM+CRF模型
实体分类则是对抽取出的实体进行归类。当从文本中发现一个新的实体,给实体相应的Type是实体概念化的基本目标。比如用该实体的上下文特征与其他Type下的实体特征进行对比,将新实体归入最相似的Type中。此外,在Schema不完善的情况下,对大量实体进行聚类,进而抽象出每个簇对应的Type,是自底向上构建图谱的一个常用方法,在补充Type层的同时,也顺便完成了实体归类。
关系抽取,是从文本中自动抽取实体与实体之间的特定的语义关系,以补充图谱中缺失的关系,例如,从“干酪鱼原来是奶酪做的”中抽取出<干酪鱼,食材,奶酪>。关系抽取可以通过定义规则模版来获取,如匹配某种表达句式、利用文法语义特征等,但规则类方法消耗大量人力,杂质较多。基于Bootstrap Learning的方法利用少量种子实例或模版抽取新的关系,再利用新的结果生成更多模版,如此迭代,KnowItAll[2]、TextRunner[3]基于这类思想；远程监督（Distant Supervision）方法[4]把现有的三元组信息作为种子,在文本中匹配同时含有主语和宾语的信息,作为关系的标注数据。这两种方法解决了人力耗费问题,但准确率还有待提高。近期的深度学习方法则基于联合模型思想,利用神经网络的端对端模型,同时实现实体识别和关系抽取[5][6],从而避免前期实体识别的结果对关系抽取造成的误差累积影响。
知识校验
知识校验贯穿整个知识图谱的构建过程。在初期的Schema设计过程中,需要严格定义Type下的Property,Property关联的是属性信息还是实体,以及实体所属的Type等等。Schema若不够规范,会导致错误传达到数据层且不易纠错。在数据层,通过源数据获取或者通过算法抽取的知识或多或少都包含着杂质,可以在Schema层面上,添加人工校验方法与验证约束规则,保证导入数据的规范性,比如对于<店A,包含,店菜B>关系,严格要求主语A的Type是POI,宾语B的Type是Dish。而对于实体间关系的准确性,如上下位关系是否正确、实例的类型是否正确,实例之间的关系是否准确等,可以利用实体的信息与图谱中的结构化信息计算一个关系的置信度,或看作关系对错与否的二分类问题,比如<店A, 适合, 情侣约会>,对于“情侣约会”标签,利用店A的信息去计算一个权重会使得数据更有说服力。此外,如果涉及到其他来源的数据,在数据融合的同时进行交叉验证,保留验证通过的知识。当图谱数据初步成型,在知识应用过程中,通过模型结果倒推出的错误,也有助于净化图谱中的杂质,比如知识推理时出现的矛盾,必然存在知识有误的情况。
知识融合
知识融合主要解决多源异构数据整合问题,即从不同来源、不同结构但表达统一实体或概念的数据融合为一个实体或概念。融入来自多源数据的知识,必然会涉及知识融合工作,实体融合主要涉及Schema融合、实体对齐、实体链接等技术。
Schema是知识图谱的模型,其融合等价于Type层的合并和Property的合并。在特定领域的图谱中,Type与Property数量有限,可以通过人工进行合并。对于实例的对齐,可以看作一个寻找Top匹配的实例的排序问题,或者是否匹配的二分类问题,其特征可以基于实体属性信息、Schema结构化信息、语义信息等来获取。
实体对齐是多源数据融合中的重要过程。当数据来自于不同的知识库体系,需要分辨其描述的是同一个实体,将相关信息融合,最终生成该知识库中唯一的实体。这通常是一个求最相似问题或判断两个实体是否是同一个的二分类问题,实体名称、实体携带属性以及其结构化信息,都可以作为有用特征。同时,通过Type或规则限制,缩小匹配的实体范围。
一旦图谱构建完成,如何从文本中准确匹配上图谱中相应的实体,进而延伸出相关的背景知识,则是一个实体链接问题。实体链接[7] 主要依赖于实体Entity与所有Mention（文本文档中实体的目标文本）的一个多对多的映射关系表, 如 “小龙虾”这个Mention在图谱中实际对应的实体Entity可能是“麻辣小龙虾”的菜,也可能是“十三香小龙虾”的菜。对于从文本中识别出的Mention,利用上下文等信息,对其候选Entity进行排序,找出最可能的Entity。实体链接可以正确地定位用户所提实体,理解用户真实的表达意图,从而进一步挖掘用户行为,了解用户偏好。
图6 实体链接（Entity Linking）
美团大脑也参考并融入了多源的数据信息,知识融合是构建图谱的一个重要步骤。以美食领域子图谱为例,该图谱是由结构化数据和文本挖掘出来的知识融合而成,首要任务是将图谱中已构建的菜品通过菜名、口味、食材等方面的相似度将菜品与文本挖掘出来的菜品知识进行关联,其次还要对无法关联的菜品知识聚类抽象成一个菜品实体。知识的融合很大程度上增加了菜品的数量,丰富了菜品信息,同时为实体链接的映射关系表提供了候选对,有助于我们在搜索过程中,支持更多维度（如口味、食材）的查询。
知识表示
知识表示是对知识数据的一种描述和约定,目的是让计算机可以像人一样去理解知识,从而可以让计算机进一步的推理、计算。大多数知识图谱是以符号化的方法表示,其中RDF是最常用的符号语义表示模型,其一条边对于一个三元组<主语Subject,谓语Predicate,宾语Object>,表达一个客观事实,该方法直观易懂,具备可解释性,支持推理。
而随着深度学习的发展,基于向量表示的Embedding算法逐渐兴起,其为每个实体与关系训练一个可表征的向量,该方法易于进行算法学习,可表征隐形知识并进一步发掘隐形知识。常用的Embedding模型有Word2Vec与Trans系列[8][9],将会在之后的系列文章里进一步讲解。美团大脑参考Freebase的建模思想,以< Subject,Predicate,Object>的三元组形式将海量知识存储在分布式数据仓库中,并以CVT(Compound Value Type)设计承载多元数据,即抽象一个CVT的实例来携带多元信息,图为一个知识表示的例子。与此同时,美团大脑基于上亿节点计算Graph Embedding的表征,并将结果应用到搜索领域中。
图7 美团大脑知识表示
知识推理
基于知识图谱的推理工作,旨在依据现有的知识信息推导出新知识,包括实体关系、属性等,或者识别出错误关系。可以分为基于符号的推理与基于统计的推理,前者一般根据经典逻辑创建新的实体关系的规则,或者判断现有关系的矛盾之处,后者则是通过统计规律从图谱中学到新的实体关系。
利用实体之间的关系可以推导出一些场景,辅助进行决策判断。美团大脑金融子图谱利用用户行为、用户关系、地理位置去挖掘金融领域诈骗团伙。团伙通常会存在较多关联及相似特性,图谱中的关系可以帮助人工识别出多层、多维度关联的欺诈团伙,再利用规则等方式,识别出批量具有相似行为的客户,辅助人工优化调查,同时可以优化策略。
图8 知识推理在金融场景应用
知识赋能
知识图谱含有丰富的语义信息,对文本有基于语义的更为深入的理解,在推荐、搜索、问答等领域能提供更加直接与精确的查询结果,使得服务更加智能化。
个性化推荐通过实体与实体之间的关系,利用用户感兴趣的实体,进一步扩展用户偏好的相似的实体,提供可解释性的推荐内容。一方面,图谱提供了实体在多个维度的特征信息,另一方面,表示学习向量带有一定的语义信息,使得寻找推荐实体更接近目标实体或更偏向用户喜好。
语义搜索,是指搜索引擎对Query的处理不再拘泥于字面本身,而是抽象出其中的实体、查询意图,通过知识图谱直接提供用户需要的答案,而不只是提供网页排序结果,更精准的满足用户的需求。当前Google、百度、神马搜索都已经将基于知识图谱的语义搜索融入到搜索引擎中,对于一些知识性内容的查找,能智能地直接显示结果信息。
美团大脑的业务应用
依托深度学习模型,美团大脑充分挖掘、关联美团点评各个业务场景公开数据（如用户评价、菜品、标签等）,正在构建餐饮娱乐“知识大脑”,并且已经开始在美团不同业务中进行落地,利用人工智能技术全面提升用户的生活体验。
智能搜索：帮助用户做决策
知识图谱可以从多维度精准地刻画商家,已经在美食搜索和旅游搜索中应用,为用户搜索出更适合Ta的店。基于知识图谱的搜索结果,不仅具有精准性,还具有多样性,例如：当用户在美食类目下搜索关键词“鱼”,通过图谱可以认知到用户的搜索词是“鱼”这种“食材”。因此搜索的结果不仅有“糖醋鱼”、“清蒸鱼”这样的精准结果,还有“赛螃蟹”这样以鱼肉作为主食材的菜品,大大增加了搜索结果的多样性,提升用户的搜索体验。并且对于每一个推荐的商家,能够基于知识图谱找到用户最关心的因素,从而生成“千人千面”的推荐理由,例如在浏览到大董烤鸭店的时候,偏好“无肉不欢”的用户A看到的推荐理由是“大董的烤鸭名不虚传”,而偏好“环境优雅”的用户B,看到的推荐理由就是“环境小资,有舞台表演”,不仅让搜索结果更具有解释性,同时也能吸引不同偏好的用户进入商家。
图9 知识图谱在点评搜索中应用
对于场景化搜索,知识图谱也具有很强的优势,以七夕节为例,通过知识图谱中的七夕特色化标签,如约会圣地、环境私密、菜品新颖、音乐餐厅、别墅餐厅等等,结合商家评论中的细粒度情感分析,为美团搜索提供了更多适合情侣过七夕节的商户数据,用于七夕场景化搜索的结果召回与展示,极大的提升了用户体验和用户点击转化。
在NLP中心以及大众点评搜索智能中心两个团队的紧密合作下,依赖知识图谱技术和深度学习技术对搜索架构进行了整体的升级。经过5个月时间,点评搜索核心指标在高位基础上,仍然有非常明显的提升。
ToB商户赋能：商业大脑指导店老板决策
美团大脑正在应用于SaaS收银系统专业版,通过机器智能阅读每个商家的每一条评论,可以充分理解每个用户对于商家的感受,针对每个商家将大量的用户评价进行归纳总结,从而可以发现商家在市场上的竞争优势/劣势、用户对于商家的总体印象趋势、商家的菜品的受欢迎程度变化。进一步,通过细粒度用户评论全方位分析,可以细致刻画商家服务现状,以及对商家提供前瞻性经营方向。这些智能经营建议将通过美团SaaS收银系统专业版定期触达到各个商家,智能化指导商家精准优化经营模式。
传统给店老板提供商业分析服务中主要聚焦于单店的现金流、客源分析。美团大脑充分挖掘了商户及顾客之间的关联关系,可以提供围绕商户到顾客,商户到所在商圈的更多维度商业分析,在商户营业前、营业中以及将来经营方向,均可以提供细粒度运营指导。
在商家服务能力分析上,通过图谱中关于商家评论所挖掘的主观、客观标签,例如“服务热情”、“上菜快”、“停车免费”等等,同时结合用户在这些标签所在维度上的Aspect细粒度情感分析,告诉商家在哪些方面做的不错,是目前的竞争优势；在哪些方面做的还不够,需要尽快改进。因而可以更准确地指导商家进行经营活动。更加智能的是,美团大脑还可以推理出顾客对商家的认可程度,是高于还是低于其所在商圈的平均情感值,让店老板一目了然地了解自己的实际竞争力。
在消费用户群体分析上,美团大脑不仅能够告诉店老板来消费的顾客的年龄层、性别分布,还可以推理出顾客的消费水平,对于就餐环境的偏好,适合他们的推荐菜,让店老板有针对性的调整价格、更新菜品、优化就餐环境。
金融风险管理和反欺诈：从用户行为建立征信体系
知识图谱的推理能力和可解释性,在金融场景中具有天然的优势,NLP中心和美团金融共建的金融好用户扩散以及用户反欺诈,就是利用知识图谱中的社区发现、标签传播等方法来对用户进行风险管理,能够更准确的识别逾期客户以及用户的不良行为,从而大大提升信用风险管理能力。
在反欺诈场景中,知识图谱已经帮助金融团队在案件调查中发现并确认多个欺诈案件。由于团伙通常会存在较多关联及相似特性,关系图可以帮助识别出多层、多维度关联的欺诈团伙,能通过用户和用户、用户和设备、设备和设备之间四度、五度甚至更深度的关联关系,发现共用设备、共用Wi-Fi来识别欺诈团伙,还可在已有的反欺诈规则上进行推理预测可疑设备、可疑用户来进行预警,从而成为案件调查的有力助手。
未来的挑战
知识图谱建设过程是美团第一次摸索基于图的构建/挖掘/存储/应用过程,也遇到了很多挑战,主要的挑战和应对思路如下：
（1）数据生成与导入 难点：Schema构建和更新；数据源多,数据不一致问题；数据质检。 应对思路：通过针对不同的数据进行特定清洗,元数据约束校验、业务逻辑正确性校验等,设置了严格的数据接入和更新规范。
（2）知识挖掘 难点：知识的融合、表征、推理和验证。 应对思路：通过借鉴文本中的词向量表征,为知识建立统一的语义空间表征,使得语义可计算,基于深度学习和知识表示的算法进行推理。
（3）百亿图存储及查询引擎 难点：数据的存储、查询和同步,数据量极大,没有成熟开源引擎直接使用。 应对思路：构建分层增量系统,实时增量、离线增量、全量图三层Merge查询,减少图更新影响范围。同时建设完整的容灾容错、灰度、子图回滚机制。基于LBS等业务特点合理切分子图View,构建分布式图查询索引层。
（4）知识图谱应用挑战 难点：算法设计,系统实现难和实时应用。 应对思路：知识图谱的应用算法则需要有效融合数据驱动和知识引导,才能提升算法效果和提供更好的解释性,属于研究前沿领域。百亿甚至千亿关系规模下,需要设计和实现分布式的图应用算法,这对算法和系统都有重大的挑战。
总而言之,为打造越来越强大的美团大脑,NLP中心一方面利用业界前沿的算法模型来挖掘关联以及应用知识,另一方面,也在逐步建立国内领先的商业化分布式图引擎系统,支撑千亿级别知识图谱的实时图查询、图推理和图计算。在未来的系列文章中,NLP中心将一一揭秘这背后的创新性技术,敬请期待。
参考文献
[1] Huang, Zhiheng, Wei Xu, and Kai Yu. "Bidirectional LSTM-CRF models for sequence tagging." arXiv preprint arXiv:1508.01991 (2015). [2] Etzioni, Oren, et al. "Unsupervised named-entity extraction from the web: An experimental study." Artificial intelligence165.1 (2005): 91-134. [3] Banko, Michele, et al. "Open information extraction from the web." IJCAI. Vol. 7. 2007. [4] Mintz, Mike, et al. "Distant supervision for relation extraction without labeled data." Proceedings of the Joint Conference of the 47th Annual Meeting of the ACL and the 4th International Joint Conference on Natural Language Processing of the AFNLP: Volume 2-Volume 2. Association for Computational Linguistics, 2009. [5] Zheng, Suncong, et al. "Joint entity and relation extraction based on a hybrid neural network." Neurocomputing 257 (2017): 59-66. [6] Zheng, Suncong, et al. "Joint extraction of entities and relations based on a novel tagging scheme." arXiv preprint arXiv:1706.05075 (2017). [7] Shen, Wei, Jianyong Wang, and Jiawei Han. "Entity linking with a knowledge base: Issues, techniques, and solutions." IEEE Transactions on Knowledge and Data Engineering 27.2 (2015): 443-460. [8] Bordes, Antoine, et al. "Translating embeddings for modeling multi-relational data." Advances in neural information processing systems. 2013. [9] Wang, Zhen, et al. "Knowledge Graph Embedding by Translating on Hyperplanes." AAAI. Vol. 14. 2014.
作者简介
仲远,博士,美团AI平台部NLP中心负责人,点评搜索智能中心负责人。在国际顶级学术会议发表论文30余篇,获得ICDE 2015最佳论文奖,并是ACL 2016 Tutorial “Understanding Short Texts”主讲人,出版学术专著3部,获得美国专利5项。此前,博士曾担任微软亚洲研究院主管研究员,以及美国Facebook公司Research Scientist。曾负责微软研究院知识图谱、对话机器人项目和Facebook产品级NLP Service。
富峥,博士,美团AI平台NLP中心研究员,目前主要负责美团大脑项目。在此之前,博士在微软亚洲研究院社会计算组担任研究员,并在相关领域的顶级会议和期刊上发表30余篇论文,曾获ICDM2013最佳论文大奖,出版学术专著1部。 张富峥博士曾担任ASONAM的工业界主席,IJCAI、WSDM、SIGIR等国际会议和TKDE、TOIS、TIST等国际期刊的评审委员。
王珺,博士,美团AI平台NLP中心产品和数据负责人。在此之前,王珺在阿里云负责智能顾问多产品线,推动建立了阿里云智能服务体系。
明洋,硕士,美团AI平台NLP中心知识图谱算法工程师。2016年毕业于清华大学计算机系知识工程实验室。
思睿,硕士,美团AI平台NLP中心知识图谱算法专家。此前在百度AIG知识图谱部负责知识图谱、NLP相关算法研究,参与了百度知识图谱整个构建及落地过程。
一飞,负责AI平台NLP中心知识图谱产品。目前主要负责美团大脑以及知识图谱落地项目。
梦迪,美团AI平台NLP中心知识图谱算法工程师,此前在金融科技公司文因互联任高级工程师及开放数据负责人,前清华大学知识工程实验室研究助理,中文开放知识图谱联盟OpenKG联合发起人。
招聘信息
美团点评 NLP 团队招聘各类算法人才,Base 北京上海均可。NLP 中心使命是打造世界一流的自然语言处理核心技术和服务能力,依托 NLP（自然语言处理）、Deep Learning（深度学习）、Knowledge Graph（知识图谱）等技术,处理美团点评海量文本数据,打通餐饮、旅行、休闲娱乐等各个场景数据,构建美团点评知识图谱,搭建通用 NLP Service,为美团点评各项业务提供智能的文本语义理解服务。我们的团队既注重AI技术的落地,也开展中长期的NLP及知识图谱基础研究。目前项目及业务包括美团点评知识图谱、智能客服、语音语义搜索、文章评论语义理解、美团点评智能助理等。真正助力于“帮大家吃得更好,生活更好”企业使命的实现,优化用户的生活体验,改善和提升消费者的生活品质。欢迎各位朋友推荐或自荐至 hr.ai@meituan.com。
算法岗 ： NLP算法工程师/专家/研究员 、 知识图谱算法工程师/专家/研究员
工程岗 ： C++/Java研发专家/工程师 、 AI平台研发工程师/专家
产品岗 ： AI产品经理/专家 （NLP、数据方向）
| 
.png)
大数据引擎.png)
大数据应用.png)
大数据底层技术.png)
ForeSpider软件
.png)
采集服务.png)
软件学习.png)
智能分析.png)
特征提取.png)
智能计算.png)
数据可视化.png)
数据分析应用.png)
系统集成服务.png)
代码工具.png)
金融方案.png)
制造业&物流.png)
企业数字化.png)
医疗方案.png)
政务方案.png)
实时监测.png)
智能分析.png)
数据智能挖掘.png)
全网自动采集.png)
场景智慧采集.png)
主题识别采集
022-2345 2937
185 2247 0110
business@forenose.com
022-2345 2937
185 2247 0110
business@forenose.com
前嗅大数据
津公网安备12010102001008号