5 q$ U- N4 T0 M: c A机器学习算法整理(内含代码)0 e/ k! M& m% V
: p) J k* M; s' b1 N
一般来说,机器学习有三种算法:# ^2 S" K5 o% L4 g
" ^3 E! P I$ @1 w; J9 z; e! `1.监督式学习4 w4 z+ J& R/ u' I. G( I1 I
$ Z6 Q4 |- k b( f# W
监督式学习算法包括一个目标变量(也就是因变量)和用来预测目标变量的预测变量(相当于自变量).通过这些变量,我们可以搭建一个模型,从而对于一个自变量,我们可以得到对应的因变量.重复训练这个模型,直到它能在训练数据集上达到理想的准确率4 N% S) u m) u! d
, L& `+ T& Z }8 E3 W属于监督式学习的算法有:回归模型,决策树,随机森林,K近邻算法,逻辑回归等算法 ) N+ V& v) N) k1 W; M( f @( G ) `7 e- H4 t( _2.无监督式算法 & X" p$ h6 p* H# T- x; t 3 U2 T5 x8 q; A5 ?! q8 P/ L5 l无监督式学习不同的是,无监督学习中我们没有需要预测或估计的因变量.无监督式学习是用来对总体对象进行分类的.它在根据某一指标将客户分类上有广泛作用.2 s6 ]- C n$ c/ h. i0 L$ M
( g2 s0 l- h; y1 x* m9 T10.Gradient Boost和Adaboost算法6 z# j' J) J3 G
一个一个来说:2 v" q6 [' ^6 t& z; T
1.线性回归 " e6 _) N c' O& B. X" H9 y) z4 K; R9 S! R( l$ j
线性回归是利用连续性变量来估计实际数值(比如房价等),我们通过线性回归算法找出自变量和因变量的最佳线性关系,图形上可以确定一条最佳的直线.这条最佳直线就是回归线.线性回归关系可以用Y=ax+b表示.1 [4 U& m7 W; r4 C; P* I
) s* h5 t! M/ b* K9 g7 K k
在这个Y=ax+b这个公式里: $ ~3 x! n( ^- l( b2 s( s! S6 h$ u$ F0 C6 _0 C
Y=因变量' r7 r- N8 u2 t0 `( \8 z
2 O8 s, H# D6 |5 I7 J, }8 @ a =斜率5 i9 f% P9 |$ j* ^9 @. ?8 T; q8 K2 \! L5 @/ I
2 j& @* M/ W+ Q9 N, a
x=自变量 ) |+ T" [ e) z! |) o( ]7 V) y( E& J# k
b=截距+ ~$ f5 h: u' r" y6 C
2 m0 k) p9 x$ l, A1 B l3 o7 { a和b可以通过最下化因变量误差的平方和得到(最小二乘法) # X/ g* o9 v6 o6 W* ~3 Y7 j# G6 _" h: A3 W. z0 |; }
我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。 8 H' h5 w5 y+ m0 i( E 8 O0 C$ x5 v) s7 Y% y# H! R/ d给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息. 6 _" |& P0 j! w$ ^# S" q5 t 3 g1 C0 @1 c) {. K1 T. k4 {5 i* `( V1 u4 l4 F! z8 R f
9 {9 m9 J" |7 o$ o
线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量.6 V2 J1 ?; d3 @3 q- P L0 j7 ^ U
# ^/ F6 Z1 n% G. C2 ]* g
拟合多元线性回归的时候,可以利用多项式回归或曲线回归 % v4 ^2 O' c: }" O0 |1 Z$ X 0 ?# c4 z6 k0 s: Q, ^( s$ r, R. CImport Library/ q [- ~$ `: Z
from sklearn import linear_model ) g( {6 j# Z, S# X$ x5 o/ q& X0 E2 D- j" b P
x_train=input_variables_values_training_datasets" i* H* L; F) g; `/ R, q
y_train=target_variables_values_training_datasets( a+ u6 Q X/ c0 z
x_test=input_variables_values_test_datasets 7 L: E: c7 m0 R# ? " b4 P& J# w! C/ n: T: q- p# Create linear regression object ! u5 k9 C7 M; a/ m6 F" hlinear = linear_model.LinearRegression()! W9 @6 B, J+ w* |
- R( S3 G5 D" I. N# Train the model using the training sets and check score 5 h0 V; \4 {1 Clinear.fit(x_train, y_train) % u) R+ Z* f3 w8 x* F+ ~8 z" Zlinear.score(x_train, y_train) r+ T. [6 F8 r# L6 q/ h4 K
$ R9 W. P$ E" Z#Equation coefficient and Intercept7 O3 c- U7 E6 ]0 L9 L
print('Coefficient: \n', linear.coef_) ; M' }: x7 v' K+ u6 ~) m O& {print('Intercept: \n', linear.intercept_)6 L# z- @3 X4 E8 ]8 t
/ L) F. B' f- }3 n3 |, } S f
#Predict Output( N1 d* T5 y9 z$ U, R1 `0 I3 ~6 h
predicted= linear.predict(x_test)5 f" \- ^$ T R0 o. S+ Z3 L' S' f
2.逻辑回归/ U& q E# p. I7 U% P6 c
逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归! 2 Z+ a) }1 U2 ?5 I& A8 X 4 ?' u5 y; @1 F1 M同样用例子来理解:% s; A# ^- u5 s6 m3 H
) K$ e2 i$ g& p. g, U/ o: |8 b2 [
假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。* q0 N7 d6 ?- X0 I# P1 M
: p* I+ Y9 g, V
数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧 [0 c7 G, e5 y( H, \! x z3 @ z6 Q M6 s O
最终事件的预测变量的线性组合就是: + A ?2 l5 {% B % ^/ l) y* N5 M0 H, N) r. C& f" s& |( _* Z6 h
odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence% D$ V2 A1 a& l u8 [2 w3 ~* b, c
8 z. s; V' j1 d! q6 `ln(odds) = ln(p/(1-p))& j, A$ O. |1 m9 E2 o" F% a& y
" \+ S$ Y$ k) _至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法. $ o. |5 B V! C( _( O, D! F1 k4 B& r9 D ^0 T( Y/ A
6 w+ R: s1 Q, L: A. p
9 V2 J- U- {1 m9 o; q
from sklearn.linear_model import LogisticRegression4 u6 J' M0 E5 h5 ` r
5 ~1 Q! Y: i: f$ f5 u2 L: n
model = LogisticRegression()6 m5 U' l+ L3 R6 a7 Y, j
% u* {* Z0 ^+ H% ~ # Train the model using the training sets and check score 0 n8 {) |. T; Z% n* ^- X model.fit(X, y) $ _( T8 ?! I1 {8 M( ^ model.score(X, y)1 G% v6 f; f0 ]8 P0 B
3 p8 X5 i4 U/ p. e
#Equation coefficient and Intercept$ K5 j2 T1 x5 L
print('Coefficient: \n', model.coef_)3 d" r" `0 q; c' \; }8 v' x7 @
print('Intercept: \n', model.intercept_) u/ Y3 }5 o, A9 J
X: x0 h7 E) m/ ? #Predict Output 0 y/ S2 u; |+ A/ ] predicted= model.predict(x_test) 0 _+ A, x5 K0 [逻辑回归的优化: 2 |/ n, Q; p* j, ~+ h加入交互项, E8 T3 m+ a6 X$ y. {' Q
) K' u* M: N6 n5 s- T: Q$ G0 x! z7 k 减少特征变量 $ ?8 V4 ` {& a4 x, y9 o 7 ~; m7 X. D1 U3 Q1 c 正则化 # }! H7 V7 T3 S* P: J0 \# _: H/ A8 B1 D; C |
使用非线性模型 , e0 O( y$ l# u3 h( Q* U- n! g* d4 F
3.决策树 " q8 F1 I+ M5 e) r这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。. f( S7 D( e! i
$ t2 ^: z7 @# o5 a4 m! G4 p
0 ~1 M( O) s9 R% T$ ^5 `3 W- e' i/ W3 D
( ^$ J" v. w2 _0 q, o
从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。2 ^" C: J) j7 f/ Y; R
4 f6 s' a' ?$ t : ]% N A/ }% ~/ ?1 e3 M0 `from sklearn import tree # _+ m% k6 ^9 ` [+ q, a$ N I% f7 L# s9 |- t
5 g/ l" y7 @- D6 [
# Create tree object 1 v9 Y# y' w9 zmodel = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini 8 w. A3 j& o! i0 A8 B7 d
( c: e! W1 k8 Q& A" d, b8 l- _
# model = tree.DecisionTreeRegressor() for regression 1 g5 s" }4 j) ]' r$ g, `3 y7 F# T- c1 i5 K' b+ h
# Train the model using the training sets and check score / e2 y( m2 C/ Z; }# J5 E S: J$ Wmodel.fit(X, y) 1 @: `. u. ]( ]0 ?model.score(X, y)6 v4 i& `% Y# |" K* h" Q4 _
9 W8 x( u, H3 k! X#Predict Output ! y8 |4 j) O ?8 T7 Q, Z9 X$ f+ dpredicted= model.predict(x_test) ' E H3 x( p6 @4 l" K$ u' e4. 支持向量机(SVM)+ L& {' v4 T' e1 O
这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。 : D( F. `% f8 Q, v' Y5 ?7 x 9 A( c$ ?9 x$ @/ I5 `7 u# T现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。 9 E1 b7 q. D, V! {/ }& P ) H7 U) T& R7 G! I " U6 p* H6 r; }9 T; B , }. [9 j: c4 I在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。6 K1 T4 h7 S8 m, M$ w9 ~( `9 \, n
' W! Q4 G( `' u9 X% Y4 z" j1 D0 W; m
#Import Library % r5 j5 V, `& m2 R, E; @from sklearn import svm 0 P6 y4 a; l; k/ F4 ^#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset / K! B' Z+ y9 U; L% G# Create SVM classification object 2 U; J8 _* K3 G2 S/ M" O
. }# x5 S8 ?8 H8 ~7 P& ]0 xmodel = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.* }3 t _- ~/ }4 b
+ }4 n( I; w G& @: _
# Train the model using the training sets and check score5 |* L( D% G) g' |: D6 z7 f! _% _
model.fit(X, y) _, v2 ?( x9 X) |model.score(X, y) 0 S( c, }0 l+ ?- S) Y- e/ x% K2 Y + j E! C& G) N- l ^4 w& X6 W#Predict Output ' H, z s) ?7 opredicted= model.predict(x_test) & e# d- ~% ~. g/ \% ^5. 朴素贝叶斯 1 Z/ W5 f5 f3 |) k5 T" h- T% ]这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。 $ l. o2 q/ v6 x. j( c7 H9 I4 X; Z& Z% c/ R5 _$ X
朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。 " V- h, z" I" p) n : `# I# Z2 P; g' t贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下: ( O3 u: j7 D. [! n/ b' B" I" y. ^ / e( }! S6 v5 P. p0 i; Z- J5 K, m7 k7 b5 D! n# z2 K( T
P(c|x)是已知特征x而分类为c的后验概率。 + W% n6 x! e& \4 e. n8 Z. c. D( C. ?) ~5 d7 z
P(c)是种类c的先验概率。3 d- t* Q" d0 K; D
" s4 k3 I' d& `" f4 R. a
P(x|c)是种类c具有特征x的可能性。! ~" \: A! \& U
7 \& }2 i4 g2 [/ n; ?& ^
P(x)是特征x的先验概率。! A. Z" ?, K! |5 z4 p5 n& {' {. k! C! O
6 m$ I; ]" b5 T: Z3 @* X! S- @
7 `1 I. l( y2 f& J. p2 J, l/ J6 [例子: 以下这组训练集包括了天气变量和目标变量“是否出去玩”。我们现在需要根据天气情况将人们分为两组:玩或不玩。整个过程按照如下步骤进行: ( e$ }. D ~2 f* m3 T, \2 J0 m, \6 f: ^2 ]5 _# h8 N1 ]9 v6 A
步骤1:根据已知数据做频率表 ! C, J* f6 {5 H+ X7 A. G/ ]& Z7 X! O3 t1 [/ `/ B, y7 o0 y
步骤2:计算各个情况的概率制作概率表。比如阴天(Overcast)的概率为0.29,此时玩的概率为0.64.$ Y1 t9 Z5 h: ~ l
+ Q& ]. u9 J/ X% T+ w4 t. e
' s6 |. j$ y* N. W! R) _
步骤3:用朴素贝叶斯计算每种天气情况下玩和不玩的后验概率。概率大的结果为预测值。, ^# U3 Y' r0 Q5 P! k2 n; A
提问: 天气晴朗的情况下(sunny),人们会玩。这句陈述是否正确? & y3 @8 I# o; a) H, P4 p9 c" t7 G2 c, v
我们可以用上述方法回答这个问题。P(Yes | Sunny)=P(Sunny | Yes) * P(Yes) / P(Sunny)。 7 [- W" Y# }5 Q' w$ _& ?9 ~6 H7 A$ m# \* a+ B0 G
这里,P(Sunny |Yes) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P(Yes)= 9/14 = 0.64。 ! {' w3 i% x; y1 S% q& r8 n4 i* m6 a7 k5 U5 ]7 b d" A
那么,P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60>0.5,说明这个概率值更大。/ o1 M% N' g( Z+ T" D6 Q. e
/ h* x9 H: A9 `0 W. N' D- f$ [当有多种类别和多种特征时,预测的方法相似。朴素贝叶斯通常用于文本分类和多类别分类问题。, [1 M7 h: h0 h+ R M
) B2 e/ F5 e+ q4 e& V- }2 }( X* e#Import Library " }- c1 e7 N1 @* I5 B. jfrom sklearn.naive_bayes import GaussianNB& ^/ n) `; }+ Z1 u2 W
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset ; C+ T# d" R+ i - M, ^- I* n8 [ a% A, ~4 a# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link2 l+ [' O% |+ t8 i1 \8 U
/ J# r) x% c; Y6 l# Train the model using the training sets and check score ! k" J: C' f' L' ?model.fit(X, y) 9 C- G, U1 s! q* O5 E" c4 a4 r* V5 _
#Predict Output : E$ E2 C6 D" K+ I% Gpredicted= model.predict(x_test) 8 P! W/ ?# C# u D& d6.KNN(K-邻近算法) " c1 T* D" _7 N; {2 |这个算法既可以解决分类问题,也可以用于回归问题,但工业上用于分类的情况更多。 KNN先记录所有已知数据,再利用一个距离函数,找出已知数据中距离未知事件最近的K组数据,最后按照这K组数据里最常见的类别预测该事件。 - A. J" l% H: X! W+ Q% a 0 G! F' R. L* H0 e0 z: d& I4 B距离函数可以是欧式距离,曼哈顿距离,闵氏距离 (Minkowski Distance), 和汉明距离(Hamming Distance)。前三种用于连续变量,汉明距离用于分类变量。如果K=1,那问题就简化为根据最近的数据分类。K值的选取时常是KNN建模里的关键。 2 q# p' `+ H b `/ O 9 h! O* S5 D* B6 m! `& \4 T4 i0 Y, S; ~
: t8 f3 j) B, n* I! I' q7 `) a; p5 R
KNN在生活中的运用很多。比如,如果你想了解一个不认识的人,你可能就会从这个人的好朋友和圈子中了解他的信息。 h4 Y0 l, }7 W: G% U* ]: r) e2 c( ?3 P/ @+ M; g) K
在用KNN前你需要考虑到:& }5 l7 Z! F, p7 ?
/ M3 ~: Y2 H$ T1 i7 {% Z
KNN的计算成本很高3 v4 ]/ ?# G/ h
, V/ g0 }( d' W4 y% ~" V. r
所有特征应该标准化数量级,否则数量级大的特征在计算距离上会有偏移。 0 M* H7 b4 N' r1 v% H 1 k, R; H6 ?" l% s" F在进行KNN前预处理数据,例如去除异常值,噪音等。 - g4 b( N8 s! z- M% P% r * ?* B/ T( j. } i#Import Library* `' e$ G F: f) [2 ~
from sklearn.neighbors import KNeighborsClassifier M. b# L2 f v. R" B & l0 b/ ~+ ?; i% H7 I#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset 8 U! ]; @- |5 f0 ^! @9 }/ \. z# Create KNeighbors classifier object model $ m/ ^/ w4 F: H/ F9 B* G1 J) u / _: f. k( F' V: `KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5 / [7 L6 \% a0 z7 r ; \6 _. a: o5 Y, M# Train the model using the training sets and check score 2 U" Y5 {3 t- a" b5 m$ A H: omodel.fit(X, y) % X2 R3 r: {% C. [. N! ~5 l* e1 a# `7 L: o
#Predict Output 7 N( {" q2 R- A3 d M! l! vpredicted= model.predict(x_test)7 Z$ S- [3 z. `
7. K均值算法(K-Means)$ |7 l9 @9 w/ X- d5 t3 h1 Z
这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。 $ W: ~& Q: W+ V* r- T K: I+ u* X. e5 X. a5 h6 F2 ?
还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量!2 i: v1 F, i2 v# X. U! A. ?# _
5 U, N- B& E% V' i3 B. o# P. f5 m; ~5 Q' q* K
K均值算法如何划分集群:# i9 _7 |" U* l/ \! S6 ^
* L g% X& W# p, ]
: m% ~4 l3 f& q
" h! B; _4 y4 X1 ~- W" O- ^从每个集群中选取K个数据点作为质心(centroids)。+ ?, C' N0 {$ J* M3 V
4 @' v" w$ n- E( m L$ m
将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。; O7 p8 N3 p, R1 `8 C
3 O1 Z$ n& v" r/ i8 a2 |
找出新集群的质心,这样就有了新的质心。* e1 Y# f* E& E1 i& Q3 r. P
. W! J P1 J1 V- ^6 A+ |' N
重复2和3,直到结果收敛,即不再有新的质心出现。 " J2 Q+ ?6 J) E% q) \/ o+ K; U4 L. }; t$ _( i. v
' L1 g5 j" A7 N `
怎样确定K的值: R; r' y* U$ U) W% _4 K
3 f1 c a* x5 z0 s$ c2 f2 U如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。9 \% j8 i' Q, Y
0 F2 [) b. ]: K7 V3 ?
我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。 # |6 \( Z$ I, A* B2 d `* O9 n$ P1 y6 ^" M6 T
0 i9 N$ W: z" w Q. u#Import Library * x2 y8 P; i7 X; u- nfrom sklearn.cluster import KMeans : c0 x1 B1 d7 g X' ?: U " f' R; H3 K- ~$ M2 n$ c4 K#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset, l. Y" j" D }6 v6 Z5 _$ N; ~
# Create KNeighbors classifier object model 2 D6 R+ Z. b M; p' w
k_means = KMeans(n_clusters=3, random_state=0) O" B8 \; f8 ^ `8 o" R
5 R8 a& ]% T* D" o- V
# Train the model using the training sets and check score/ h/ C5 Z# H" i3 S Q
model.fit(X)% G% Y% ^2 d" I: x3 I' c7 D
0 Y8 D3 W" D6 ^" L0 b7 L Q
#Predict Output0 f h) C5 e+ X' g0 Y( z$ ^
predicted= model.predict(x_test); [7 M; x* P* l3 c% c
8.随机森林# o& Q% n0 e+ X, D8 v ]5 v& Q2 Y4 w
随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。 : l1 { p0 ~# S, d: ?& O* P 3 t1 M3 O0 F8 {) U. F' f怎样生成决策树: * x1 u% ~4 Q1 T" D1 a" b+ x: U/ ^2 F- w/ c X" Z* [5 y
如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。 ) W0 n; v! K* x; P0 ]7 `' ]3 L+ Q' Q
如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。 ' q- { w8 L5 p9 p. s" W, |; Q + P* u$ z" t0 n! h- X. p L每个决策树都最大程度上进行分割,没有剪枝。 1 R# F' ^% f# | S * k: j: Z' H3 @! W, K#Import Library $ J% j* h8 @( C! xfrom sklearn.ensemble import RandomForestClassifier% a& S( x3 j2 d: V$ E
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset 7 P. o7 P0 S. a2 m+ A4 A2 r7 V0 P$ R/ e+ P( A4 w
# Create Random Forest object ; |- r1 ?( b/ p8 s/ imodel= RandomForestClassifier() - w# l0 q! T% L4 Y/ s 3 _5 a+ C: u1 T: y& G- X# Train the model using the training sets and check score 6 C! ]. J( V! j2 @! l& ]model.fit(X, y) % t+ x: U' L9 N r: t - W* y& h/ _% H- I# i2 N#Predict Output. k. I$ V; T; z7 E6 R
predicted= model.predict(x_test)1 |- i% I! H2 @7 f
9.降维算法(Dimensionality Reduction Algorithms)) h8 N5 |# w! H b! l& k
在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。. Q, P7 Q% a7 N/ h' P* w
" h9 V3 m# }' E5 V g作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。 # @, z/ }/ n4 @/ F# w : `2 e; i3 e' g! f/ N2 I/ }3 o8 L, L8 l. S% {9 e% u: ]
#Import Library + k% B& t4 L9 K" W3 C3 U& Ffrom sklearn import decomposition+ b. h# `: V; [' c# G3 k
#Assumed you have training and test data set as train and test' D$ E Y: ]9 f& I6 D! `
# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features) ) {) J+ S' L( U, r& l# For Factor analysis4 g6 j, @, M0 k% H( \, G$ U
#fa= decomposition.FactorAnalysis() ) e6 O1 K; f- i0 \, c# Reduced the dimension of training dataset using PCA! W- L. r) G6 x' q$ v9 x7 J
# O6 X7 p* x/ ]' ptrain_reduced = pca.fit_transform(train) % z* @, B5 {* @; {' i, g2 ~8 J+ o0 A9 Z6 O1 N2 L
#Reduced the dimension of test dataset + l' `+ V& C" Q; _; C$ etest_reduced = pca.transform(test)! u/ o: T+ p( N1 C/ j
10.Gradient Boosing 和 AdaBoost1 {6 X3 |1 `4 z+ h1 ^, ~7 e7 w9 J
GBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。 $ s# W+ A. h3 d1 f- K$ w; C8 i" t9 I7 d. j& O& K- L+ r& W6 I
#Import Library 1 u$ H- n1 Y: o% }from sklearn.ensemble import GradientBoostingClassifier ; C$ m8 f' c2 \9 e, D#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset: c$ |; |! N" k2 p
# Create Gradient Boosting Classifier object : k5 k2 ~8 f `( V& u; m/ H0 \' fmodel= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0) 8 `6 Y) V! S0 K+ E. U Q! j ' w0 K4 U h& d, Q% q" ~2 U) Y# Train the model using the training sets and check score ' a: L. T0 m3 \+ r" Hmodel.fit(X, y) $ d7 E) n2 j/ {" [#Predict Output % x0 v* j3 [" @6 A3 I9 d; Vpredicted= model.predict(x_test)' ^# F2 a+ J" x" ?0 F- I1 e
GradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。 2 P G q% L' u# D# `. N0 D) \- k/ ?
原文链接:http://blog.csdn.net/han_xiaoyang/article/details/51191386: ?9 X( _! J" L! m2 _; e, w
———————————————— 7 b$ ^9 A, N) E) O: R+ Q版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。2 R0 S7 N2 r; Z+ r0 x
原文链接:https://blog.csdn.net/qq_39303465/article/details/79176075! s; X0 _2 N- i2 k8 M8 ^
: F# s5 V; s* g6 `