GBDT(MART) 迭代决策树入门教程 | 简介

2012年11月29日 19:12:19

在网上看到一篇对从代码层面理解gbdt比较好的文章,转载记录一下:

GBDT(Gradient Boosting Decision Tree) 又叫 MART(Multiple Additive Regression Tree),是一种迭代的决策树算法,该算法由多棵决策树组成,所有树的结论累加起来做最终答案。它在被提出之初就和SVM一起被认为是泛化能力(generalization)较强的算法。近些年更因为被用于搜索排序的机器学习模型而引起大家关注。

后记:发现GBDT除了我描述的残差版本外还有另一种GBDT描述,两者大概相同,但求解方法(Gradient应用)不同。其区别和另一版本的介绍链接见这里。由于另一版本介绍博客中亦有不少错误,建议大家还是先看本篇,再跳到另一版本描述,这个顺序当能两版本都看懂。

第1~4节:GBDT算法内部究竟是如何工作的?

第5节:它可以用于解决哪些问题?

第6节:它又是怎样应用于搜索排序的呢? 

在此先给出我比较推荐的两篇英文文献,喜欢英文原版的同学可直接阅读:

【1】Boosting Decision Tree入门教程 http://www.schonlau.net/publication/05stata_boosting.pdf

【2】LambdaMART用于搜索排序入门教程 http://research.microsoft.com/pubs/132652/MSR-TR-2010-82.pdf

GBDT主要由三个概念组成:Regression Decistion Tree(即DT),Gradient Boosting(即GB),Shrinkage (算法的一个重要演进分枝,目前大部分源码都按该版本实现)。搞定这三个概念后就能明白GBDT是如何工作的,要继续理解它如何用于搜索排序则需要额外理解RankNet概念,之后便功德圆满。下文将逐个碎片介绍,最终把整张图拼出来。

一、 DT:回归树 Regression Decision Tree

提起决策树(DT, Decision Tree) 绝大部分人首先想到的就是C4.5分类决策树。但如果一开始就把GBDT中的树想成分类树,那就是一条歪路走到黑,一路各种坑,最终摔得都要咯血了还是一头雾水说的就是LZ自己啊有木有。咳嗯,所以说千万不要以为GBDT是很多棵分类树。决策树分为两大类,回归树和分类树。前者用于预测实数值,如明天的温度、用户的年龄、网页的相关程度;后者用于分类标签值,如晴天/阴天/雾/雨、用户性别、网页是否是垃圾页面。这里要强调的是,前者的结果加减是有意义的,如10岁+5岁-3岁=12岁,后者则无意义,如男+男+女=到底是男是女? GBDT的核心在于累加所有树的结果作为最终结果,就像前面对年龄的累加(-3是加负3),而分类树的结果显然是没办法累加的,所以GBDT中的树都是回归树,不是分类树,这点对理解GBDT相当重要(尽管GBDT调整后也可用于分类但不代表GBDT的树是分类树)。那么回归树是如何工作的呢?

下面我们以对人的性别判别/年龄预测为例来说明,每个instance都是一个我们已知性别/年龄的人,而feature则包括这个人上网的时长、上网的时段、网购所花的金额等。

作为对比,先说分类树,我们知道C4.5分类树在每次分枝时,是穷举每一个feature的每一个阈值,找到使得按照feature<=阈值,和feature>阈值分成的两个分枝的熵最大的feature和阈值(熵最大的概念可理解成尽可能每个分枝的男女比例都远离1:1),按照该标准分枝得到两个新节点,用同样方法继续分枝直到所有人都被分入性别唯一的叶子节点,或达到预设的终止条件,若最终叶子节点中的性别不唯一,则以多数人的性别作为该叶子节点的性别。

回归树总体流程也是类似,不过在每个节点(不一定是叶子节点)都会得一个预测值,以年龄为例,该预测值等于属于这个节点的所有人年龄的平均值。分枝时穷举每一个feature的每个阈值找最好的分割点,但衡量最好的标准不再是最大熵,而是最小化均方差–即(每个人的年龄-预测年龄)^2 的总和 / N,或者说是每个人的预测误差平方和 除以 N。这很好理解,被预测出错的人数越多,错的越离谱,均方差就越大,通过最小化均方差能够找到最靠谱的分枝依据。分枝直到每个叶子节点上人的年龄都唯一(这太难了)或者达到预设的终止条件(如叶子个数上限),若最终叶子节点上人的年龄不唯一,则以该节点上所有人的平均年龄做为该叶子节点的预测年龄。若还不明白可以Google “Regression Tree”,或阅读本文的第一篇论文中Regression Tree部分。

二、 GB:梯度迭代 Gradient Boosting

好吧,我起了一个很大的标题,但事实上我并不想多讲Gradient Boosting的原理,因为不明白原理并无碍于理解GBDT中的Gradient Boosting。喜欢打破砂锅问到底的同学可以阅读这篇英文wikihttp://en.wikipedia.org/wiki/Gradient_boosted_trees#Gradient_tree_boosting

Boosting,迭代,即通过迭代多棵树来共同决策。这怎么实现呢?难道是每棵树独立训练一遍,比如A这个人,第一棵树认为是10岁,第二棵树认为是0岁,第三棵树认为是20岁,我们就取平均值10岁做最终结论?–当然不是!且不说这是投票方法并不是GBDT,只要训练集不变,独立训练三次的三棵树必定完全相同,这样做完全没有意义。之前说过,GBDT是把所有树的结论累加起来做最终结论的,所以可以想到每棵树的结论并不是年龄本身,而是年龄的一个累加量。GBDT的核心就在于,每一棵树学的是之前所有树结论和的残差,这个残差就是一个加预测值后能得真实值的累加量。比如A的真实年龄是18岁,但第一棵树的预测年龄是12岁,差了6岁,即残差为6岁。那么在第二棵树里我们把A的年龄设为6岁去学习,如果第二棵树真的能把A分到6岁的叶子节点,那累加两棵树的结论就是A的真实年龄;如果第二棵树的结论是5岁,则A仍然存在1岁的残差,第三棵树里A的年龄就变成1岁,继续学。这就是Gradient Boosting在GBDT中的意义,简单吧。

三、 GBDT工作过程实例。

还是年龄预测,简单起见训练集只有4个人,A,B,C,D,他们的年龄分别是14,16,24,26。其中A、B分别是高一和高三学生;C,D分别是应届毕业生和工作两年的员工。如果是用一棵传统的回归决策树来训练,会得到如下图1所示结果:

现在我们使用GBDT来做这件事,由于数据太少,我们限定叶子节点做多有两个,即每棵树都只有一个分枝,并且限定只学两棵树。我们会得到如下图2所示结果:

在第一棵树分枝和图1一样,由于A,B年龄较为相近,C,D年龄较为相近,他们被分为两拨,每拨用平均年龄作为预测值。此时计算残差(残差的意思就是: A的预测值 + A的残差 = A的实际值),所以A的残差就是16-15=1(注意,A的预测值是指前面所有树累加的和,这里前面只有一棵树所以直接是15,如果还有树则需要都累加起来作为A的预测值)。进而得到A,B,C,D的残差分别为-1,1,-1,1。然后我们拿残差替代A,B,C,D的原值,到第二棵树去学习,如果我们的预测值和它们的残差相等,则只需把第二棵树的结论累加到第一棵树上就能得到真实年龄了。这里的数据显然是我可以做的,第二棵树只有两个值1和-1,直接分成两个节点。此时所有人的残差都是0,即每个人都得到了真实的预测值。

换句话说,现在A,B,C,D的预测值都和真实年龄一致了。Perfect!:

A: 14岁高一学生,购物较少,经常问学长问题;预测年龄A = 15 – 1 = 14

B: 16岁高三学生;购物较少,经常被学弟问问题;预测年龄B = 15 + 1 = 16

C: 24岁应届毕业生;购物较多,经常问师兄问题;预测年龄C = 25 – 1 = 24

D: 26岁工作两年员工;购物较多,经常被师弟问问题;预测年龄D = 25 + 1 = 26

那么哪里体现了Gradient呢?其实回到第一棵树结束时想一想,无论此时的cost function是什么,是均方差还是均差,只要它以误差作为衡量标准,残差向量(-1, 1, -1, 1)都是它的全局最优方向,这就是Gradient。

讲到这里我们已经把GBDT最核心的概念、运算过程讲完了!没错就是这么简单。不过讲到这里很容易发现三个问题:

1)既然图1和图2 最终效果相同,为何还需要GBDT呢?

答案是过拟合。过拟合是指为了让训练集精度更高,学到了很多”仅在训练集上成立的规律“,导致换一个数据集当前规律就不适用了。其实只要允许一棵树的叶子节点足够多,训练集总是能训练到100%准确率的(大不了最后一个叶子上只有一个instance)。在训练精度和实际精度(或测试精度)之间,后者才是我们想要真正得到的。

我们发现图1为了达到100%精度使用了3个feature(上网时长、时段、网购金额),其中分枝“上网时长>1.1h” 很显然已经过拟合了,这个数据集上A,B也许恰好A每天上网1.09h, B上网1.05小时,但用上网时间是不是>1.1小时来判断所有人的年龄很显然是有悖常识的;

相对来说图2的boosting虽然用了两棵树 ,但其实只用了2个feature就搞定了,后一个feature是问答比例,显然图2的依据更靠谱。(当然,这里是LZ故意做的数据,所以才能靠谱得如此狗血。实际中靠谱不靠谱总是相对的) Boosting的最大好处在于,每一步的残差计算其实变相地增大了分错instance的权重,而已经分对的instance则都趋向于0。这样后面的树就能越来越专注那些前面被分错的instance。就像我们做互联网,总是先解决60%用户的需求凑合着,再解决35%用户的需求,最后才关注那5%人的需求,这样就能逐渐把产品做好,因为不同类型用户需求可能完全不同,需要分别独立分析。如果反过来做,或者刚上来就一定要做到尽善尽美,往往最终会竹篮打水一场空。

2)Gradient呢?不是“G”BDT么?

到目前为止,我们的确没有用到求导的Gradient。在当前版本GBDT描述中,的确没有用到Gradient,该版本用残差作为全局最优的绝对方向,并不需要Gradient求解.

3)这不是boosting吧?Adaboost可不是这么定义的。

这是boosting,但不是Adaboost。GBDT不是Adaboost Decistion Tree。就像提到决策树大家会想起C4.5,提到boost多数人也会想到Adaboost。Adaboost是另一种boost方法,它按分类对错,分配不同的weight,计算cost function时使用这些weight,从而让“错分的样本权重越来越大,使它们更被重视”。Bootstrap也有类似思想,它在每一步迭代时不改变模型本身,也不计算残差,而是从N个instance训练集中按一定概率重新抽取N个instance出来(单个instance可以被重复sample),对着这N个新的instance再训练一轮。由于数据集变了迭代模型训练结果也不一样,而一个instance被前面分错的越厉害,它的概率就被设的越高,这样就能同样达到逐步关注被分错的instance,逐步完善的效果。Adaboost的方法被实践证明是一种很好的防止过拟合的方法,但至于为什么则至今没从理论上被证明。GBDT也可以在使用残差的同时引入Bootstrap re-sampling,GBDT多数实现版本中也增加的这个选项,但是否一定使用则有不同看法。re-sampling一个缺点是它的随机性,即同样的数据集合训练两遍结果是不一样的,也就是模型不可稳定复现,这对评估是很大挑战,比如很难说一个模型变好是因为你选用了更好的feature,还是由于这次sample的随机因素。

四、Shrinkage 

Shrinkage(缩减)的思想认为,每次走一小步逐渐逼近结果的效果,要比每次迈一大步很快逼近结果的方式更容易避免过拟合。即它不完全信任每一个棵残差树,它认为每棵树只学到了真理的一小部分,累加的时候只累加一小部分,通过多学几棵树弥补不足。用方程来看更清晰,即

没用Shrinkage时:(yi表示第i棵树上y的预测值, y(1~i)表示前i棵树y的综合预测值)

y(i+1) = 残差(y1~yi), 其中: 残差(y1~yi) =  y真实值 – y(1 ~ i)

y(1 ~ i) = SUM(y1, …, yi)

Shrinkage不改变第一个方程,只把第二个方程改为:

y(1 ~ i) = y(1 ~ i-1) + step * yi

即Shrinkage仍然以残差作为学习目标,但对于残差学习出来的结果,只累加一小部分(step*残差)逐步逼近目标,step一般都比较小,如0.01~0.001(注意该step非gradient的step),导致各个树的残差是渐变的而不是陡变的。直觉上这也很好理解,不像直接用残差一步修复误差,而是只修复一点点,其实就是把大步切成了很多小步。本质上,Shrinkage为每棵树设置了一个weight,累加时要乘以这个weight,但和Gradient并没有关系。这个weight就是step。就像Adaboost一样,Shrinkage能减少过拟合发生也是经验证明的,目前还没有看到从理论的证明。

五、 GBDT的适用范围

该版本GBDT几乎可用于所有回归问题(线性/非线性),相对logistic regression仅能用于线性回归,GBDT的适用面非常广。亦可用于二分类问题(设定阈值,大于阈值为正例,反之为负例)。

六、 搜索引擎排序应用 RankNet

搜索排序关注各个doc的顺序而不是绝对值,所以需要一个新的cost function,而RankNet基本就是在定义这个cost function,它可以兼容不同的算法(GBDT、神经网络…)。

实际的搜索排序使用的是LambdaMART算法,必须指出的是由于这里要使用排序需要的cost function,LambdaMART迭代用的并不是残差。Lambda在这里充当替代残差的计算方法,它使用了一种类似Gradient*步长模拟残差的方法。这里的MART在求解方法上和之前说的残差略有不同,其区别描述见这里

就像所有的机器学习一样,搜索排序的学习也需要训练集,这里一般是用人工标注实现,即对每一个(query,doc) pair给定一个分值(如1,2,3,4),分值越高表示越相关,越应该排到前面。然而这些绝对的分值本身意义不大,例如你很难说1分和2分文档的相关程度差异是1分和3分文档差距的一半。相关度本身就是一个很主观的评判,标注人员无法做到这种定量标注,这种标准也无法制定。但标注人员很容易做到的是”AB都不错,但文档A比文档B更相关,所以A是4分,B是3分“。RankNet就是基于此制定了一个学习误差衡量方法,即cost function。具体而言,RankNet对任意两个文档A,B,通过它们的人工标注分差,用sigmoid函数估计两者顺序和逆序的概率P1。然后同理用机器学习到的分差计算概率P2(sigmoid的好处在于它允许机器学习得到的分值是任意实数值,只要它们的分差和标准分的分差一致,P2就趋近于P1)。这时利用P1和P2求的两者的交叉熵,该交叉熵就是cost function。它越低说明机器学得的当前排序越趋近于标注排序。为了体现NDCG的作用(NDCG是搜索排序业界最常用的评判标准),RankNet还在cost function中乘以了NDCG。

好,现在我们有了cost function,而且它是和各个文档的当前分值yi相关的,那么虽然我们不知道它的全局最优方向,但可以求导求Gradient,Gradient即每个文档得分的一个下降方向组成的N维向量,N为文档个数(应该说是query-doc pair个数)。这里仅仅是把”求残差“的逻辑替换为”求梯度“,可以这样想:梯度方向为每一步最优方向,累加的步数多了,总能走到局部最优点,若该点恰好为全局最优点,那和用残差的效果是一样的。这时套到之前讲的逻辑,GDBT就已经可以上了。那么最终排序怎么产生呢?很简单,每个样本通过Shrinkage累加都会得到一个最终得分,直接按分数从大到小排序就可以了(因为机器学习产生的是实数域的预测分,极少会出现在人工标注中常见的两文档分数相等的情况,几乎不同考虑同分文档的排序方式)

另外,如果feature个数太多,每一棵回归树都要耗费大量时间,这时每个分支时可以随机抽一部分feature来遍历求最优(ELF源码实现方式)。

xgboost: 速度快效果好的 boosting 模型

本文作者:何通,SupStat Inc(总部在纽约,中国分部为北京数博思达信息科技有限公司)数据科学家,加拿大 Simon Fraser University 计算机学院研究生,研究兴趣为数据挖掘和生物信息学。

主页:https://github.com/hetong007

引言

在数据分析的过程中,我们经常需要对数据建模并做预测。在众多的选择中,randomForestgbm 和 glmnet 是三个尤其流行的 R 包,它们在 Kaggle 的各大数据挖掘竞赛中的出现频率独占鳌头,被坊间人称为 R 数据挖掘包中的三驾马车。根据我的个人经验,gbm 包比同样是使用树模型的 randomForest 包占用的内存更少,同时训练速度较快,尤其受到大家的喜爱。在 python 的机器学习库 sklearn 里也有 GradientBoostingClassifier 的存在。

Boosting 分类器属于集成学习模型,它基本思想是把成百上千个分类准确率较低的树模型组合起来,成为一个准确率很高的模型。这个模型会不断地迭代,每次迭代就生成一颗新的树。对于如何在每一步生成合理的树,大家提出了很多的方法,我们这里简要介绍由 Friedman 提出的 Gradient Boosting Machine。它在生成每一棵树的时候采用梯度下降的思想,以之前生成的所有树为基础,向着最小化给定目标函数的方向多走一步。在合理的参数设置下,我们往往要生成一定数量的树才能达到令人满意的准确率。在数据集较大较复杂的时候,我们可能需要几千次迭代运算,如果生成一个树模型需要几秒钟,那么这么多迭代的运算耗时,应该能让你专心地想静静……

Rocket

现在,我们希望能通过 xgboost 工具更好地解决这个问题。xgboost 的全称是 eXtreme Gradient Boosting。正如其名,它是 Gradient Boosting Machine 的一个 c++ 实现,作者为正在华盛顿大学研究机器学习的大牛陈天奇。他在研究中深感自己受制于现有库的计算速度和精度,因此在一年前开始着手搭建 xgboost 项目,并在去年夏天逐渐成型。xgboost 最大的特点在于,它能够自动利用 CPU 的多线程进行并行,同时在算法上加以改进提高了精度。它的处女秀是 Kaggle 的希格斯子信号识别竞赛,因为出众的效率与较高的预测准确度在比赛论坛中引起了参赛选手的广泛关注,在 1700 多支队伍的激烈竞争中占有一席之地。随着它在 Kaggle 社区知名度的提高,最近也有队伍借助 xgboost 在比赛中夺得第一

为了方便大家使用,陈天奇将 xgboost 封装成了 python 库。我有幸和他合作,制作了 xgboost 工具的 R 语言接口,并将其提交到了 CRAN 上。也有用户将其封装成了 julia 库。python 和 R 接口的功能一直在不断更新,大家可以通过下文了解大致的功能,然后选择自己最熟悉的语言进行学习。

功能介绍

一、基础功能

首先,我们从 github 上安装这个包:

devtools::install_github('dmlc/xgboost',subdir='R-package')

动手时间到!第一步,运行下面的代码载入样例数据:

require(xgboost)
data(agaricus.train, package='xgboost')
data(agaricus.test, package='xgboost')
train <- agaricus.train
test <- agaricus.test

这份数据需要我们通过一些蘑菇的若干属性判断这个品种是否有毒。数据以 1 或 0 来标记某个属性存在与否,所以样例数据为稀疏矩阵类型:

class(train$data)
[1] "dgCMatrix"
attr(,"package")
[1] "Matrix"

不用担心,xgboost 支持稀疏矩阵作为输入。下面就是训练模型的命令

bst <- xgboost(data = train$data, label = train$label, max.depth = 2, eta = 1,nround = 2, objective = "binary:logistic")
[0] train-error:0.046522
[1] train-error:0.022263

我们迭代了两次,可以看到函数输出了每一次迭代模型的误差信息。这里的数据是稀疏矩阵,当然也支持普通的稠密矩阵。如果数据文件太大不希望读进 R 中,我们也可以通过设置参数data = 'path_to_file'使其直接从硬盘读取数据并分析。目前支持直接从硬盘读取 libsvm 格式的文件。

做预测只需要一句话:

pred <- predict(bst, test$data)

做交叉验证的函数参数与训练函数基本一致,只需要在原有参数的基础上设置nfold

cv.res <- xgb.cv(data = train$data, label = train$label, max.depth = 2, eta = 1, nround = 2, objective = "binary:logistic", 
nfold = 5)
[0] train-error:0.046522+0.001102   test-error:0.046523+0.004410
[1] train-error:0.022264+0.000864   test-error:0.022266+0.003450
cv.res
   train.error.mean train.error.std test.error.mean test.error.std
1:         0.046522        0.001102        0.046523       0.004410
2:         0.022264        0.000864        0.022266       0.003450

交叉验证的函数会返回一个 data.table 类型的结果,方便我们监控训练集和测试集上的表现,从而确定最优的迭代步数。

二、高速准确

上面的几行代码只是一个入门,使用的样例数据没法表现出 xgboost 高效准确的能力。xgboost 通过如下的优化使得效率大幅提高:

  1. xgboost 借助 OpenMP,能自动利用单机 CPU 的多核进行并行计算。需要注意的是,Mac 上的 Clang 对 OpenMP 的支持较差,所以默认情况下只能单核运行。
  2. xgboost 自定义了一个数据矩阵类 DMatrix,会在训练开始时进行一遍预处理,从而提高之后每次迭代的效率。

在尽量保证所有参数都一致的情况下,我们使用希格斯子竞赛的数据做了对照实验。

Model and Parameter gbm xgboost(1 thread) xgboost(2 threads) xgboost(4 threads) xgboost(8 threads)
Time (in secs) 761.48 450.22 102.41 44.18 34.04

以上实验使用的 CPU 是 i7-4700MQ。python 的 sklearn 速度与 gbm 相仿。如果想要自己对这个结果进行测试,可以在比赛的官方网站下载数据,并参考这份 demo 中的代码。

除了明显的速度提升外,xgboost 在比赛中的效果也非常好。在这个竞赛初期,大家惊讶地发现 R 和 python 中的 gbm 竟然难以突破组织者预设的 benchmark。而 xgboost 横空出世,用不到一分钟的训练时间便打入当时的 top 10,引起了大家的兴趣与关注。准确度提升的主要原因在于,xgboost 的模型和传统的 GBDT 相比加入了对于模型复杂度的控制以及后期的剪枝处理,使得学习出来的模型更加不容易过拟合。更多算法上的细节可以参考这份陈天奇给出的介绍性讲义

三、进阶特征

除了速度快精度高,xgboost 还有一些很有用的进阶特性。下面的 “demo” 链接对应着相应功能的简单样例代码。

  1. 只要能够求出目标函数的梯度和 Hessian 矩阵,用户就可以自定义训练模型时的目标函数。demo
  2. 允许用户在交叉验证时自定义误差衡量方法,例如回归中使用 RMSE 还是 RMSLE,分类中使用 AUC,分类错误率或是 F1-score。甚至是在希格斯子比赛中的 “奇葩” 衡量标准 AMSdemo
  3. 交叉验证时可以返回模型在每一折作为预测集时的预测结果,方便构建 ensemble 模型。demo
  4. 允许用户先迭代 1000 次,查看此时模型的预测效果,然后继续迭代 1000 次,最后模型等价于一次性迭代 2000 次。demo
  5. 可以知道每棵树将样本分类到哪片叶子上,facebook 介绍过如何利用这个信息提高模型的表现。demo
  6. 可以计算变量重要性并画出树状图。demo
  7. 可以选择使用线性模型替代树模型,从而得到带 L1+L2 惩罚的线性回归或者 logistic 回归。demo

这些丰富的功能来源于对日常使用场景的总结,数据挖掘比赛需求以及许多用户给出的精彩建议。

四、未来计划

现在,机器学习工具在实用中会不可避免地遇到 “单机性能不够” 的问题。目前,xgboost 的多机分布式版本正在开发当中。基础设施搭建完成之日,便是新一轮 R 包开始设计与升级之时。

结语

我为 xgboost 制作 R 接口的目的就是希望引进好的工具,让大家使用 R 的时候心情更愉悦。总结下来,xgboost 的特点有三个:速度快,效果好,功能多,希望它能受到大家的喜爱,成为一驾新的马车。

xgboost 功能较多,参数设置比较繁杂,希望在上手之后有更全面了解的读者可以参考项目 wiki。欢迎大家多多交流,在项目 issue 区提出疑问与建议。我们也邀请有兴趣的读者提交代码完善功能,让 xgboost 成为更好用的工具。

另外,在使用 github 开发的过程中,我深切地感受到了协作写代码带来的变化。一群人在一起的时候,可以写出更有效率的代码,在丰富的使用场景中发现新的需求,在极端情况发现隐藏很深的 bug,甚至在主代码手拖延症较为忙碌的时候有人挺身而出拿下一片 issue。这样的氛围,能让一个语言社区的交流丰富起来,从而充满生命力地活跃下去。

转:时间序列预测之–ARIMA模型

什么是 ARIMA模型

ARIMA模型的全称叫做自回归移动平均模型,全称是(ARIMA, Autoregressive Integrated Moving Average Model)。也记作ARIMA(p,d,q),是统计模型(statistic model)中最常见的一种用来进行时间序列 预测的模型。

1. ARIMA的优缺点

优点: 模型十分简单,只需要内生变量而不需要借助其他外生变量。

缺点:
1.要求时序数据是稳定的(stationary),或者是通过差分化(differencing)后是稳定的。
2.本质上只能捕捉线性关系,而不能捕捉非线性关系。
注意,采用ARIMA模型预测时序数据,必须是稳定的,如果不稳定的数据,是无法捕捉到规律的。比如股票数据用ARIMA无法预测的原因就是股票数据是非稳定的,常常受政策和新闻的影响而波动。

2. 判断是时序数据是稳定的方法。

严谨的定义: 一个时间序列的随机变量是稳定的,当且仅当它的所有统计特征都是独立于时间的(是关于时间的常量)。
判断的方法:

  1. 稳定的数据是没有趋势(trend),没有周期性(seasonality)的; 即它的均值,在时间轴上拥有常量的振幅,并且它的方差,在时间轴上是趋于同一个稳定的值的。
  2. 可以使用Dickey-Fuller Test进行假设检验。(另起文章介绍)

3. ARIMA的参数与数学形式

ARIMA模型有三个参数:p,d,q。

  • p–代表预测模型中采用的时序数据本身的滞后数(lags) ,也叫做AR/Auto-Regressive项
  • d–代表时序数据需要进行几阶差分化,才是稳定的,也叫Integrated项。
  • q–代表预测模型中采用的预测误差的滞后数(lags),也叫做MA/Moving Average项

先解释一下差分: 假设y表示t时刻的Y的差分。

if d=0, yt=Ytif d=1, yt=YtYt1if d=2, yt=(YtYt1)(Yt1Yt2)=Yt2Yt1+Yt2if d=0, yt=Ytif d=1, yt=Yt−Yt−1if d=2, yt=(Yt−Yt−1)−(Yt−1−Yt−2)=Yt−2Yt−1+Yt−2

ARIMA的预测模型可以表示为:

Y的预测值 = 常量c and/or 一个或多个最近时间的Y的加权和 and/or 一个或多个最近时间的预测误差。

假设p,q,d已知,
ARIMA用数学形式表示为:

ytˆ=μ+ϕ1yt1+...+ϕpytp+θ1et1+...+θqetqyt^=μ+ϕ1∗yt−1+…+ϕp∗yt−p+θ1∗et−1+…+θq∗et−q

 

,ϕARθMA其中,ϕ表示AR的系数,θ表示MA的系数

4.ARIMA模型的几个特例

1.ARIMA(0,1,0) = random walk:

当d=1,p和q为0时,叫做random walk,如图所示,每一个时刻的位置,只与上一时刻的位置有关。
file-list
预测公式如下:

Yˆt=μ+Yt1Y^t=μ+Yt−1

2. ARIMA(1,0,0) = first-order autoregressive model:

p=1, d=0,q=0。说明时序数据是稳定的和自相关的。一个时刻的Y值只与上一个时刻的Y值有关。

Yˆt=μ+ϕ1Yt1.where, ϕ[1,1],Y^t=μ+ϕ1∗Yt−1.where, ϕ∈[−1,1],是一个斜率系数

3. ARIMA(1,1,0) = differenced first-order autoregressive model:

p=1,d=1,q=0. 说明时序数据在一阶差分化之后是稳定的和自回归的。即一个时刻的差分(y)只与上一个时刻的差分有关。

yˆt=μ+ϕ1yt1YˆtYt1=μ+ϕ1(Yt1Yt2)Yˆt=μ+Yt1+ϕ1(Yt1Yt2)y^t=μ+ϕ1∗yt−1结合一阶差分的定义,也可以表示为:Y^t−Yt−1=μ+ϕ1∗(Yt−1−Yt−2)或者Y^t=μ+Yt−1+ϕ1∗(Yt−1−Yt−2)

4. ARIMA(0,1,1) = simple exponential smoothing with growth.

p=0, d=1 ,q=1.说明数据在一阶差分后市稳定的和移动平均的。即一个时刻的估计值的差分与上一个时刻的预测误差有关。

yˆt=μ+α1et1q=1ytp=1ytyˆt=YˆtYˆt1, et1=Yt1Yˆt1,θ1=1α1Yˆt=μ+Yˆt1+α1(Yt1Yˆt1)=μ+Yt1θ1et1y^t=μ+α1∗et−1注意q=1的差分yt与p=1的差分yt的是不一样的其中,y^t=Y^t−Y^t−1, et−1=Yt−1−Y^t−1,设θ1=1−α1则也可以写成:Y^t=μ+Y^t−1+α1(Yt−1−Y^t−1)=μ+Yt−1−θ1∗et−1

5. ARIMA(2,1,2)

在通过上面的例子,可以很轻松的写出它的预测模型:

yˆt=μ+ϕ1yt1+ϕ2yt2θ1et1θ2et2:Yˆt=μ+ϕ1(Yt1Yt2)+ϕ2(Yt2Yt3)θ1(Yt1Yˆt1)θ2(Yt2Yˆt2)y^t=μ+ϕ1∗yt−1+ϕ2∗yt−2−θ1∗et−1−θ2∗et−2也可以写成:Y^t=μ+ϕ1∗(Yt−1−Yt−2)+ϕ2∗(Yt−2−Yt−3)−θ1∗(Yt−1−Y^t−1)−θ2∗(Yt−2−Y^t−2)

6. ARIMA(2,2,2)

yˆt=μ+ϕ1yt1+ϕ2yt2θ1et1θ2et2Yˆt=μ+ϕ1(Yt12Yt2+Yt3)+ϕ2(Yt22Yt3+Yt4)θ1(Yt1Yˆt1)θ2(Yt2Yˆt2)y^t=μ+ϕ1∗yt−1+ϕ2∗yt−2−θ1∗et−1−θ2∗et−2Y^t=μ+ϕ1∗(Yt−1−2Yt−2+Yt−3)+ϕ2∗(Yt−2−2Yt−3+Yt−4)−θ1∗(Yt−1−Y^t−1)−θ2∗(Yt−2−Y^t−2)

7. ARIMA建模基本步骤

  1. 获取被观测系统时间序列数据;
  2. 对数据绘图,观测是否为平稳时间序列;对于非平稳时间序列要先进行d阶差分运算,化为平稳时间序列;
  3. 经过第二步处理,已经得到平稳时间序列。要对平稳时间序列分别求得其自相关系数ACF 和偏自相关系数PACF,通过对自相关图和偏自相关图的分析,得到最佳的阶层 p 和阶数 q
  4. 由以上得到的d、q、p,得到ARIMA模型。然后开始对得到的模型进行模型检验。
    具体例子会在另一篇文章中给出。

转自geek精神   https://www.cnblogs.com/bradleon/p/6827109.html

机器学习的六大条件

1. 你的问题能否被自动化
    问题复杂度高、问题的数量级比较大的问题,适合进行机器学习。
2. 问题是否被定义清楚
3. 是否能够获取数据
    一般来说,数据越多,结果越好。
4. 数据是否有显著的规律
    机器学习可以学习规律和固定的模式,但是对于无规律的数据是无法学习的。
5. 是否能够提炼出量化的特征
    机器只能识别量化的特征,所有的特征都要转化为量化的才能被计算机识别。
6. 能否评估模型的好坏
    模型的结果需要满足业务目标

Your First Machine Learning Project in Python Step-By-Step

你的第一个机器学习项目

Do you want to do machine learning using Python, but you’re having trouble getting started?

In this post, you will complete your first machine learning project using Python.

In this step-by-step tutorial you will:

  1. Download and install Python SciPy and get the most useful package for machine learning in Python.
  2. Load a dataset and understand it’s structure using statistical summaries and data visualization.
  3. Create 6 machine learning models, pick the best and build confidence that the accuracy is reliable.

If you are a machine learning beginner and looking to finally get started using Python, this tutorial was designed for you.

Let’s get started!

  • Update Jan/2017: Updated to reflect changes to the scikit-learn API in version 0.18.
  • Update Mar/2017: Added links to help setup your Python environment.
  • Update Apr/2018: Added some helpful links about randomness and making predictions.

Your First Machine Learning Project in Python Step-By-Step

How Do You Start Machine Learning in Python?

The best way to learn machine learning is by designing and completing small projects.

Python Can Be Intimidating When Getting Started

Python is a popular and powerful interpreted language. Unlike R, Python is a complete language and platform that you can use for both research and development and developing production systems.

There are also a lot of modules and libraries to choose from, providing multiple ways to do each task. It can feel overwhelming.

The best way to get started using Python for machine learning is to complete a project.

  • It will force you to install and start the Python interpreter (at the very least).
  • It will given you a bird’s eye view of how to step through a small project.
  • It will give you confidence, maybe to go on to your own small projects.

Beginners Need A Small End-to-End Project

Books and courses are frustrating. They give you lots of recipes and snippets, but you never get to see how they all fit together.

When you are applying machine learning to your own datasets, you are working on a project.

A machine learning project may not be linear, but it has a number of well known steps:

  1. Define Problem.
  2. Prepare Data.
  3. Evaluate Algorithms.
  4. Improve Results.
  5. Present Results.

The best way to really come to terms with a new platform or tool is to work through a machine learning project end-to-end and cover the key steps. Namely, from loading data, summarizing data, evaluating algorithms and making some predictions.

If you can do that, you have a template that you can use on dataset after dataset. You can fill in the gaps such as further data preparation and improving result tasks later, once you have more confidence.

Hello World of Machine Learning

The best small project to start with on a new tool is the classification of iris flowers (e.g. the iris dataset).

This is a good project because it is so well understood.

  • Attributes are numeric so you have to figure out how to load and handle data.
  • It is a classification problem, allowing you to practice with perhaps an easier type of supervised learning algorithm.
  • It is a multi-class classification problem (multi-nominal) that may require some specialized handling.
  • It only has 4 attributes and 150 rows, meaning it is small and easily fits into memory (and a screen or A4 page).
  • All of the numeric attributes are in the same units and the same scale, not requiring any special scaling or transforms to get started.

Let’s get started with your hello world machine learning project in Python.

Machine Learning in Python: Step-By-Step Tutorial
(start here)

In this section, we are going to work through a small machine learning project end-to-end.

Here is an overview of what we are going to cover:

  1. Installing the Python and SciPy platform.
  2. Loading the dataset.
  3. Summarizing the dataset.
  4. Visualizing the dataset.
  5. Evaluating some algorithms.
  6. Making some predictions.

Take your time. Work through each step.

Try to type in the commands yourself or copy-and-paste the commands to speed things up.

If you have any questions at all, please leave a comment at the bottom of the post.

Need help with Machine Learning in Python?

Take my free 2-week email course and discover data prep, algorithms and more (with code).

Click to sign-up now and also get a free PDF Ebook version of the course.

Start Your FREE Mini-Course Now!

1. Downloading, Installing and Starting Python SciPy

Get the Python and SciPy platform installed on your system if it is not already.

I do not want to cover this in great detail, because others already have. This is already pretty straightforward, especially if you are a developer. If you do need help, ask a question in the comments.

1.1 Install SciPy Libraries

This tutorial assumes Python version 2.7 or 3.5.

There are 5 key libraries that you will need to install. Below is a list of the Python SciPy libraries required for this tutorial:

  • scipy
  • numpy
  • matplotlib
  • pandas
  • sklearn

There are many ways to install these libraries. My best advice is to pick one method then be consistent in installing each library.

The scipy installation page provides excellent instructions for installing the above libraries on multiple different platforms, such as Linux, mac OS X and Windows. If you have any doubts or questions, refer to this guide, it has been followed by thousands of people.

  • On Mac OS X, you can use macports to install Python 2.7 and these libraries. For more information on macports, see the homepage.
  • On Linux you can use your package manager, such as yum on Fedora to install RPMs.

If you are on Windows or you are not confident, I would recommend installing the free version of Anaconda that includes everything you need.

Note: This tutorial assumes you have scikit-learn version 0.18 or higher installed.

Need more help? See one of these tutorials:

1.2 Start Python and Check Versions

It is a good idea to make sure your Python environment was installed successfully and is working as expected.

The script below will help you test out your environment. It imports each library required in this tutorial and prints the version.

Open a command line and start the python interpreter:

I recommend working directly in the interpreter or writing your scripts and running them on the command line rather than big editors and IDEs. Keep things simple and focus on the machine learning not the toolchain.

Type or copy and paste the following script:

Here is the output I get on my OS X workstation:

Compare the above output to your versions.

Ideally, your versions should match or be more recent. The APIs do not change quickly, so do not be too concerned if you are a few versions behind, Everything in this tutorial will very likely still work for you.

If you get an error, stop. Now is the time to fix it.

If you cannot run the above script cleanly you will not be able to complete this tutorial.

My best advice is to Google search for your error message or post a question on Stack Exchange.

2. Load The Data

We are going to use the iris flowers dataset. This dataset is famous because it is used as the “hello world” dataset in machine learning and statistics by pretty much everyone.

The dataset contains 150 observations of iris flowers. There are four columns of measurements of the flowers in centimeters. The fifth column is the species of the flower observed. All observed flowers belong to one of three species.

You can learn more about this dataset on Wikipedia.

In this step we are going to load the iris data from CSV file URL.

2.1 Import libraries

First, let’s import all of the modules, functions and objects we are going to use in this tutorial.

Everything should load without error. If you have an error, stop. You need a working SciPy environment before continuing. See the advice above about setting up your environment.

2.2 Load Dataset

We can load the data directly from the UCI Machine Learning repository.

We are using pandas to load the data. We will also use pandas next to explore the data both with descriptive statistics and data visualization.

Note that we are specifying the names of each column when loading the data. This will help later when we explore the data.

The dataset should load without incident.

If you do have network problems, you can download the iris.data file into your working directory and load it using the same method, changing URL to the local file name.

3. Summarize the Dataset

Now it is time to take a look at the data.

In this step we are going to take a look at the data a few different ways:

  1. Dimensions of the dataset.
  2. Peek at the data itself.
  3. Statistical summary of all attributes.
  4. Breakdown of the data by the class variable.

Don’t worry, each look at the data is one command. These are useful commands that you can use again and again on future projects.

3.1 Dimensions of Dataset

We can get a quick idea of how many instances (rows) and how many attributes (columns) the data contains with the shape property.

You should see 150 instances and 5 attributes:

3.2 Peek at the Data

It is also always a good idea to actually eyeball your data.

You should see the first 20 rows of the data:

3.3 Statistical Summary

Now we can take a look at a summary of each attribute.

This includes the count, mean, the min and max values as well as some percentiles.

We can see that all of the numerical values have the same scale (centimeters) and similar ranges between 0 and 8 centimeters.

3.4 Class Distribution

Let’s now take a look at the number of instances (rows) that belong to each class. We can view this as an absolute count.

We can see that each class has the same number of instances (50 or 33% of the dataset).

4. Data Visualization

We now have a basic idea about the data. We need to extend that with some visualizations.

We are going to look at two types of plots:

  1. Univariate plots to better understand each attribute.
  2. Multivariate plots to better understand the relationships between attributes.

4.1 Univariate Plots

We start with some univariate plots, that is, plots of each individual variable.

Given that the input variables are numeric, we can create box and whisker plots of each.

This gives us a much clearer idea of the distribution of the input attributes:

Box and Whisker Plots

We can also create a histogram of each input variable to get an idea of the distribution.

It looks like perhaps two of the input variables have a Gaussian distribution. This is useful to note as we can use algorithms that can exploit this assumption.

Histogram Plots

4.2 Multivariate Plots

Now we can look at the interactions between the variables.

First, let’s look at scatterplots of all pairs of attributes. This can be helpful to spot structured relationships between input variables.

Note the diagonal grouping of some pairs of attributes. This suggests a high correlation and a predictable relationship.

Scattplot Matrix

5. Evaluate Some Algorithms

Now it is time to create some models of the data and estimate their accuracy on unseen data.

Here is what we are going to cover in this step:

  1. Separate out a validation dataset.
  2. Set-up the test harness to use 10-fold cross validation.
  3. Build 5 different models to predict species from flower measurements
  4. Select the best model.

5.1 Create a Validation Dataset

We need to know that the model we created is any good.

Later, we will use statistical methods to estimate the accuracy of the models that we create on unseen data. We also want a more concrete estimate of the accuracy of the best model on unseen data by evaluating it on actual unseen data.

That is, we are going to hold back some data that the algorithms will not get to see and we will use this data to get a second and independent idea of how accurate the best model might actually be.

We will split the loaded dataset into two, 80% of which we will use to train our models and 20% that we will hold back as a validation dataset.

You now have training data in the X_train and Y_train for preparing models and a X_validation and Y_validation sets that we can use later.

5.2 Test Harness

We will use 10-fold cross validation to estimate accuracy.

This will split our dataset into 10 parts, train on 9 and test on 1 and repeat for all combinations of train-test splits.

The specific random seed does not matter, learn more about pseudorandom number generators here:

We are using the metric of ‘accuracy‘ to evaluate models. This is a ratio of the number of correctly predicted instances in divided by the total number of instances in the dataset multiplied by 100 to give a percentage (e.g. 95% accurate). We will be using the scoring variable when we run build and evaluate each model next.

5.3 Build Models

We don’t know which algorithms would be good on this problem or what configurations to use. We get an idea from the plots that some of the classes are partially linearly separable in some dimensions, so we are expecting generally good results.

Let’s evaluate 6 different algorithms:

  • Logistic Regression (LR)
  • Linear Discriminant Analysis (LDA)
  • K-Nearest Neighbors (KNN).
  • Classification and Regression Trees (CART).
  • Gaussian Naive Bayes (NB).
  • Support Vector Machines (SVM).

This is a good mixture of simple linear (LR and LDA), nonlinear (KNN, CART, NB and SVM) algorithms. We reset the random number seed before each run to ensure that the evaluation of each algorithm is performed using exactly the same data splits. It ensures the results are directly comparable.

Let’s build and evaluate our five models:

5.4 Select Best Model

We now have 6 models and accuracy estimations for each. We need to compare the models to each other and select the most accurate.

Running the example above, we get the following raw results:

Note, you’re results may differ. For more on this see the post:

We can see that it looks like KNN has the largest estimated accuracy score.

We can also create a plot of the model evaluation results and compare the spread and the mean accuracy of each model. There is a population of accuracy measures for each algorithm because each algorithm was evaluated 10 times (10 fold cross validation).

You can see that the box and whisker plots are squashed at the top of the range, with many samples achieving 100% accuracy.

Compare Algorithm Accuracy

6. Make Predictions

The KNN algorithm was the most accurate model that we tested. Now we want to get an idea of the accuracy of the model on our validation set.

This will give us an independent final check on the accuracy of the best model. It is valuable to keep a validation set just in case you made a slip during training, such as overfitting to the training set or a data leak. Both will result in an overly optimistic result.

We can run the KNN model directly on the validation set and summarize the results as a final accuracy score, a confusion matrix and a classification report.

We can see that the accuracy is 0.9 or 90%. The confusion matrix provides an indication of the three errors made. Finally, the classification report provides a breakdown of each class by precision, recall, f1-score and support showing excellent results (granted the validation dataset was small).

You can learn more about how to make predictions and predict probabilities here:

You Can Do Machine Learning in Python

Work through the tutorial above. It will take you 5-to-10 minutes, max!

You do not need to understand everything. (at least not right now) Your goal is to run through the tutorial end-to-end and get a result. You do not need to understand everything on the first pass. List down your questions as you go. Make heavy use of the help(“FunctionName”) help syntax in Python to learn about all of the functions that you’re using.

You do not need to know how the algorithms work. It is important to know about the limitations and how to configure machine learning algorithms. But learning about algorithms can come later. You need to build up this algorithm knowledge slowly over a long period of time. Today, start off by getting comfortable with the platform.

You do not need to be a Python programmer. The syntax of the Python language can be intuitive if you are new to it. Just like other languages, focus on function calls (e.g. function()) and assignments (e.g. a = “b”). This will get you most of the way. You are a developer, you know how to pick up the basics of a language real fast. Just get started and dive into the details later.

You do not need to be a machine learning expert. You can learn about the benefits and limitations of various algorithms later, and there are plenty of posts that you can read later to brush up on the steps of a machine learning project and the importance of evaluating accuracy using cross validation.

What about other steps in a machine learning project. We did not cover all of the steps in a machine learning project because this is your first project and we need to focus on the key steps. Namely, loading data, looking at the data, evaluating some algorithms and making some predictions. In later tutorials we can look at other data preparation and result improvement tasks.

Summary

In this post, you discovered step-by-step how to complete your first machine learning project in Python.

You discovered that completing a small end-to-end project from loading the data to making predictions is the best way to get familiar with a new platform.

Your Next Step

Do you work through the tutorial?

  1. Work through the above tutorial.
  2. List any questions you have.
  3. Search or research the answers.
  4. Remember, you can use the help(“FunctionName”) in Python to get help on any function.

Do you have a question?
Post it in the comments below.

如何使用Anaconda设置机器学习和深度学习的Python环境

有一些平台安装Python机器学习环境可能很麻烦。

首先你得安装Python,然后安装许多软件包这很容易把初学者搞懵。

在本教程中,你将学会如何用Anaconda设置Python机器学习开发环境。

完成本教程后,你将拥有一个Python工作环境,可以让你学习、练习和开发机器学习和深度学习软件。

本说明适用于Windows,Mac OS X和Linux平台。我将在OS X上演示它们,因此你可能会看到一些mac对话框和文件扩展名。

  • 更新 2017/03:注:你需要一个Theano或TensorFlow才能使用Kears进行深度学习。

教程概述

在本教程中,我们将介绍如下步骤:

  1. 下载Anaconda
  2. 安装Anaconda
  3. 启动和更新Anaconda
  4. 更新 scikit-learn库
  5. 安装深度学习库

下载蟒蛇

在此步骤中,我们将为您的平台下载Anaconda Python。

Anaconda是一个免费且易于操作的科学Python环境。

如何使用Anaconda设置机器学习和深度学习的Python环境

3.选择适合您平台的下载(Windows,OSX或Linux):

  • 选择Python 3.5
  • 选择图形安装程序(Graphical Installer)

如何使用Anaconda设置机器学习和深度学习的Python环境

将Anaconda Python包下载到您的工作站。

我在OS X上,所以我选择了OS X版本。文件约426 MB。

你应该下载到一个名称如下的文件:

Anaconda3-4.2.0-MacOSX-x86_64.pkg

2.安装蟒蛇

在此步骤中,我们将在您的系统上安装Anaconda Python软件。

此步骤假定你具有足够的管理权限来在系统上安装软件。

  • 1.双击下载的文件。
  • 2.按照安装向导。

如何使用Anaconda设置机器学习和深度学习的Python环境

安装很顺利应该不会遇到棘手的问题

如何使用Anaconda设置机器学习和深度学习的Python环境

安装需要不到10分钟,占用硬盘上1 GB的空间。

3.启动和更新蟒蛇

在此步骤中,我们将确认您的Anaconda Python环境是不是最新的。

Anaconda配有一套名为Anaconda Navigator的图形工具。您可以从应用程序启动器打开Anaconda Navigator。

您可以点击这里了解有关Anaconda Navigator的所有信息。

我们稍后使用Anaconda Navigator和图形开发环境; 现在,我建议从Anaconda命令行环境开始,它被称为conda

Conda快速,简单,不会遗漏错误信息,您可以快速确认您的环境已安装并正常工作。

  • 1.打开终端(命令行窗口)。
  • 2.通过键入以下内容,确认正确安装:
1 conda-V

你应该看到以下(或类似的东西):

1 conda4.2.9
  • 3.键入以下内容,确认Python已正确安装:
1 python-V

你应该看到以下(或类似的东西):

Python 3.5.2 :: Anaconda 4.2.0 (x86_64)

如何使用Anaconda设置机器学习和深度学习的Python环境

如果命令不起作用或报错,请查看平台的帮助文档。

也可以参阅“延伸阅读”部分的一些资料。

  • 4.为确认您的conda环境是最新的,请输入:
1 conda update conda
2 conda update anaconda

你可能需要给一些包安装更新。

  • 5.确认您的SciPy环境。

下面的脚本将打印您需要用于机器学习开发的关键SciPy库的版本号,如: SciPy、NumPy、Matplotlib、Pandas、Statsmodels和Scikit-learn。

您可以键入“python”然后直接键入命令。但我建议打开一个文本文档,并将脚本复制到文档中。

01 # scipy
02 import scipy
03 print('scipy: %s' % scipy.__version__)
04 # numpy
05 import numpy
06 print('numpy: %s' % numpy.__version__)
07 # matplotlib
08 import matplotlib
09 print('matplotlib: %s' % matplotlib.__version__)
10 # pandas
11 import pandas
12 print('pandas: %s' % pandas.__version__)
13 # statsmodels
14 import statsmodels
15 print('statsmodels: %s' % statsmodels.__version__)
16 # scikit-learn
17 import sklearn
18 print('sklearn: %s' % sklearn.__version__)

将脚本保存为名称为versions.py的文件。

在命令行中,将目录更改为保存脚本的位置然后键入:

1 python versions.py

您应该看到如下输出:

1 scipy:0.18.1
2 numpy:1.11.1
3 matplotlib:1.5.3
4 pandas:0.18.1
5 statsmodels:0.6.1
6 sklearn:0.17.1

如何使用Anaconda设置机器学习和深度学习的Python环境

4.更新scikit-learn库

在这一步中,我们将在Python中更新用于机器学习的库,名为scikit-learn。

  • 1.更新scikit-learn到最新版本。

在撰写本文时,Anaconda发行的scikit-learning版本已经过期(0.17.1,而不是0.18.1)。您可以使用conda命令更新特定的库; 以下是将scikit-learn更新到最新版本的示例。

输入:

1 conda update scikit-learn

如何使用Anaconda设置机器学习和深度学习的Python环境

你也可以键入如下内容把他升级到特定的版本:

1 conda install-c anaconda scikit-learn=0.18.1

为了确认是否安装成功,你可以键入以下内容重新运行version.py脚本:

你应该看到如下的输出:

1 scipy:0.18.1
2 numpy:1.11.3
3 matplotlib:1.5.3
4 pandas:0.18.1
5 statsmodels:0.6.1
6 sklearn:0.18.1

你可以根据需要使用这些命令更新机器学习和SciPy库。

点击下方链接阅读scikit-learn教程:

5.安装深度学习库

在这一步中,我们将安装用于深度学习的Python库,主要是:Theano,TensorFlow和Keras。

注意:我建议使用Keras进行深度学习,而Keras只需要安装Tnano或TensorFlow中的一个。在某些Windows系统上安装TensorFlow可能会出现问题。

  • 1.通过键入以下内容安装Theano深度学习库:
1 conda install theano
  • 2.安装TensorFlow深度学习库(Windows除外),键入以下内容:
1 conda install-c conda-forge tensorflow

或者,您可以选择使用pip和特定版本的tensorflow为您的平台进行安装。

详情请参阅tensorflow的安装说明

  • 3.通过键入以下内容安装Keras:
1 pip install keras
  • 4.确认您的深入学习环境已安装并正常工作。

创建一个脚本,该脚本打印每个库的版本号,就像我们上面为安装SciPy环境所做的那样。

1 # theano
2 import theano
3 print('theano: %s' % theano.__version__)
4 # tensorflow
5 import tensorflow
6 print('tensorflow: %s' % tensorflow.__version__)
7 # keras
8 import keras
9 print('keras: %s' % keras.__version__)

将脚本保存成文件deep_versions.py。输入以下命令来运行脚本:

1 python deep_versions.py

你应该看到如下输出:

1 theano:0.8.2.dev-901275534cbfe3fbbe290ce85d1abf8bb9a5b203
2 tensorflow:0.12.1
3 Using TensorFlow backend.
4 keras:1.2.1

如何使用Anaconda设置机器学习和深度学习的Python环境

尝试一下Keras深度学习教程,如:Anaconda

进一步阅读

本节提供一些进一步阅读的链接。

总结

恭喜你现在拥有一个用于机器学习和深入学习的工作Python开发环境。

你现在可以在工作站上学习和练习机器学习和深度学习。

阿里云漏洞修复RHSA-2018:0169: kernel security and bug fix update

基本信息

CVE-2017-11176 严重

标题: Linux kernel ‘mq_notify’内存错误引用漏洞

披露时间: 2017-07-11 00:00:00

CVEID: CVE-2017-11176

简介:
Linux kernel是美国Linux基金会发布的操作系统Linux所使用的内核。

Linux kernel 4.11.9及之前的版本中的’mq_notify’函数存在安全漏洞。攻击者可利用该漏洞造成拒绝服务。

解决方案:
请直接在漏洞处理页面,选择对应服务器和漏洞,生成修复命令后,登录到服务器上运行即可。


解决步骤

  1. 升级内核版本
    [root@CYBSERVER_HK ~]# uname -r
    2.6.32-696.16.1.el6.x86_64
    [root@CYBSERVER_HK ~]#rpm --import https://www.elrepo.org/RPM-GPG-KEY-elrepo.org
    [root@CYBSERVER_HK ~]#rpm -Uvh http://www.elrepo.org/elrepo-release-6-8.el6.elrepo.noarch.rpm #安装yum源
    ...
    Installed:
      kernel-lt.x86_64 0:4.4.101-1.el6.elrepo
    
    Complete!
    
  2. 修改GRUB启动顺序

    [root@CYBSERVER_HK ~]#vim /etc/grub.conf #将默认启动顺序default修改为0 ,default=0

        # grub.conf generated by anaconda
        #
        # Note that you do not have to rerun grub after making changes to this file
        # NOTICE:  You do not have a /boot partition.  This means that
        #  all kernel and initrd paths are relative to /, eg.
        #  root (hd0,0)
        #  kernel /boot/vmlinuz-version ro root=/dev/xvda1
        #  initrd /boot/initrd-[generic-]version.img
        #boot=/dev/xvda
        default=0
        title CentOS (4.4.135-1.el6.elrepo.i686)
            root (hd0,0)
            kernel /boot/vmlinuz-4.4.135-1.el6.elrepo.i686 ro root=UUID=e76a7b8d-20c2-4f94-bdd1-f4054a34c206 rd_NO_LUKS rd_NO_LVM LANG=en_US.UTF-8 rd_NO_MD SYSFONT=latarcyrheb-sun16 crashkernel=auto  KEYBOARDTYPE=pc KEYTABLE=us rd_NO_DM rhgb quiet
    
  3. 重启并查看内核版本
    [root@CYBSERVER_HK ~]# reboot
    [root@CYBSERVER_HK ~]# uname -r
    4.4.135-1.el6.elrepo.i686
    
  4. 升级kernel-devel version,kernel-headers version,kernel-doc version
    [root@CYBSERVER_HK ~]# yum check-update
    [root@CYBSERVER_HK ~]# yum update
    [root@CYBSERVER_HK ~]# yum --enablerepo=elrepo-kernel install kernel-lt-headers -y
    [root@CYBSERVER_HK ~]# yum --enablerepo=elrepo-kernel install kernel-lt-devel -y
    [root@CYBSERVER_HK ~]# yum --enablerepo=elrepo-kernel install kernel-lt-doc -y
    

rpm命令参考

rpm命令是RPM软件包的管理工具。rpm原本是Red Hat Linux发行版专门用来管理Linux各项套件的程序,由于它遵循GPL规则且功能强大方便,因而广受欢迎。逐渐受到其他发行版的采用。RPM套件管理方式的出现,让Linux易于安装,升级,间接提升了Linux的适用度。

语法

rpm(选项)(参数)

选项

-a:查询所有套件;
-b<完成阶段><套件档>+或-t <完成阶段><套件档>+:设置包装套件的完成阶段,并指定套件档的文件名称;
-c:只列出组态配置文件,本参数需配合"-l"参数使用;
-d:只列出文本文件,本参数需配合"-l"参数使用;
-e<套件档>或--erase<套件档>:删除指定的套件;
-f<文件>+:查询拥有指定文件的套件;
-h或--hash:套件安装时列出标记;
-i:显示套件的相关信息;
-i<套件档>或--install<套件档>:安装指定的套件档;
-l:显示套件的文件列表;
-p<套件档>+:查询指定的RPM套件档;
-q:使用询问模式,当遇到任何问题时,rpm指令会先询问用户;
-R:显示套件的关联性信息;
-s:显示文件状态,本参数需配合"-l"参数使用;
-U<套件档>或--upgrade<套件档>:升级指定的套件档;
-v:显示指令执行过程;
-vv:详细显示指令执行过程,便于排错。

参数

软件包:指定要操纵的rpm软件包。

实例

如何安装rpm软件包

rpm软件包的安装可以使用程序rpm来完成。执行下面的命令:

rpm -ivh your-package.rpm

其中your-package.rpm是你要安装的rpm包的文件名,一般置于当前目录下。

安装过程中可能出现下面的警告或者提示:

... conflict with ...

可能是要安装的包里有一些文件可能会覆盖现有的文件,缺省时这样的情况下是无法正确安装的可以用rpm –force -i强制安装即可

... is needed by ...
... is not installed ...

此包需要的一些软件你没有安装可以用rpm –nodeps -i来忽略此信息,也就是说rpm -i –force –nodeps可以忽略所有依赖关系和文件问题,什么包都能安装上,但这种强制安装的软件包不能保证完全发挥功能。

如何安装.src.rpm软件包

有些软件包是以.src.rpm结尾的,这类软件包是包含了源代码的rpm包,在安装时需要进行编译。这类软件包有两种安装方法:

方法一:
rpm -i your-package.src.rpm
cd /usr/src/redhat/SPECS
rpmbuild -bp your-package.specs             #一个和你的软件包同名的specs文件
cd /usr/src/redhat/BUILD/your-package/      #一个和你的软件包同名的目录
./configure                                 #这一步和编译普通的源码软件一样,可以加上参数
make
make install
方法二:
rpm -i you-package.src.rpm
cd /usr/src/redhat/SPECS

前两步和方法一相同

rpmbuild -bb your-package.specs       #一个和你的软件包同名的specs文件

这时在/usr/src/redhat/RPM/i386/(根据具体包的不同,也可能是i686,noarch等等)在这个目录下,有一个新的rpm包,这个是编译好的二进制文件。

执行rpm -i new-package.rpm即可安装完成。

如何卸载rpm软件包

使用命令rpm -e包名,包名可以包含版本号等信息,但是不可以有后缀.rpm,比如卸载软件包proftpd-1.2.8-1,可以使用下列格式:

rpm -e proftpd-1.2.8-1
rpm -e proftpd-1.2.8
rpm -e proftpd-
rpm -e proftpd

不可以是下列格式:

rpm -e proftpd-1.2.8-1.i386.rpm
rpm -e proftpd-1.2.8-1.i386
rpm -e proftpd-1.2
rpm -e proftpd-1

有时会出现一些错误或者警告:

... is needed by ...

这说明这个软件被其他软件需要,不能随便卸载,可以用rpm -e –nodeps强制卸载

如何不安装但是获取rpm包中的文件

使用工具rpm2cpio和cpio

rpm2cpio xxx.rpm | cpio -vi
rpm2cpio xxx.rpm | cpio -idmv
rpm2cpio xxx.rpm | cpio --extract --make-directories

参数i和extract相同,表示提取文件。v表示指示执行进程,d和make-directory相同,表示根据包中文件原来的路径建立目录,m表示保持文件的更新时间。

如何查看与rpm包相关的文件和其他信息

下面所有的例子都假设使用软件包mysql-3.23.54a-11

  1. 我的系统中安装了那些rpm软件包。

    rpm -qa 讲列出所有安装过的包
    如果要查找所有安装过的包含某个字符串sql的软件包

    rpm -qa | grep sql

  2. 如何获得某个软件包的文件全名。

    rpm -q mysql

    可以获得系统中安装的mysql软件包全名,从中可以获得当前软件包的版本等信息。这个例子中可以得到信息mysql-3.23.54a-11

  3. 一个rpm包中的文件安装到那里去了?

    rpm -ql 包名

    注意这里的是不包括.rpm后缀的软件包的名称,也就是说只能用mysql或者mysql-3.23.54a-11而不是mysql-3.23.54a-11.rpm。如果只是想知道可执行程序放到那里去了,也可以用which,比如:
    which mysql

  4. 一个rpm包中包含那些文件。

    一个没有安装过的软件包,使用rpm -qlp ****.rpm

    一个已经安装过的软件包,还可以使用rpm -ql ****.rpm

  5. 如何获取关于一个软件包的版本,用途等相关信息?

    一个没有安装过的软件包,使用rpm -qip ****.rpm
    一个已经安装过的软件包,还可以使用rpm -qi ****.rpm

  6. 某个程序是哪个软件包安装的,或者哪个软件包包含这个程序。
    rpm -qf `which 程序名`    #返回软件包的全名
    rpm -qif `which 程序名`   #返回软件包的有关信息
    rpm -qlf `which 程序名`   #返回软件包的文件列表
    

    注意,这里不是引号,而是`,就是键盘左上角的那个键。也可以使用rpm -qilf,同时输出软件包信息和文件列表。

  7. 某个文件是哪个软件包安装的,或者哪个软件包包含这个文件。

    注意,前一个问题中的方法,只适用与可执行的程序,而下面的方法,不仅可以用于可执行程序,也可以用于普通的任何文件。前提是知道这个文件名。首先获得这个程序的完整路径,可以用whereis或者which,然后使用rpm -qf例如:

    whereis ftptop
    ftptop: /usr/bin/ftptop /usr/share/man/man1/ftptop.1.gz
    
    rpm -qf /usr/bin/ftptop
    proftpd-1.2.8-1
    
    rpm -qf /usr/share/doc/proftpd-1.2.8/rfc/rfc0959.txt
    proftpd-1.2.8-1