数学建模社区-数学中国

标题: 机器学习算法整理(内含代码) [打印本页]

作者: 杨利霞    时间: 2021-4-9 16:23
标题: 机器学习算法整理(内含代码)

2 G7 Y% b* O/ e! I8 a# t机器学习算法整理(内含代码), Q/ [4 r  m% G- O" }, m* l

* t5 i3 }( ]1 G: S+ Q, t6 s1 f一般来说,机器学习有三种算法:
- Y0 m6 M3 [8 u; B8 L9 U+ ], ?0 j: \& A8 e% O7 \# `! S1 R) h
1.监督式学习
- u1 E3 Z' F- a. w
4 f% A/ q% H6 z# K* ^' w% F) t 监督式学习算法包括一个目标变量(也就是因变量)和用来预测目标变量的预测变量(相当于自变量).通过这些变量,我们可以搭建一个模型,从而对于一个自变量,我们可以得到对应的因变量.重复训练这个模型,直到它能在训练数据集上达到理想的准确率
: H4 M0 p6 V' E# b" K* ~; S6 U6 l3 b
属于监督式学习的算法有:回归模型,决策树,随机森林,K近邻算法,逻辑回归等算法  U4 o) v( j0 A& L( o1 F: I  h2 T

0 f$ p  E9 R& i# Z4 ]2.无监督式算法
3 b; `( Z( H+ D) s  l
0 A9 g, f  C$ a- s! J4 r无监督式学习不同的是,无监督学习中我们没有需要预测或估计的因变量.无监督式学习是用来对总体对象进行分类的.它在根据某一指标将客户分类上有广泛作用.
! h+ ~) A0 n2 b0 m+ B3 x0 {) H/ J$ M  ~% n+ K
属于无监督式学习的算法有:关联规则,K-means聚类算法等
/ {6 T3 ^( ~9 Y, H9 F0 c; t; W  M
( R) K2 g/ C  U3.强化学习
% V* q+ g' O8 \! a2 E
( _- q$ Z1 t0 A5 ?% d) @$ @这个算法可以训练程序作出某一决定,程序在某一情况下尝试所有的可能行为,记录不同行动的结果并试着找出最好的一次尝试来做决定4 z- k8 F9 l3 f/ G7 i$ D. |  @
2 T- ?2 o4 o! R# z6 F9 d% w
属于强化学习的算法有:马尔可夫决策过程) i/ o& |: k" f8 I9 g% O% ]7 p

; w* w+ D4 C! k, j; q常见的机器学习算法有:
# B! u! Y0 A" @* n6 S- H, T0 v4 }. P, g  w' P
$ `" @. p- g- m& m
1.线性回归 (Linear Regression)
: H3 x9 a6 R. c7 h8 F7 S1 V( Z
& j* O+ P* |' {: d2.逻辑回归 (Logistic Regression)
; ?  k3 \! h! T" r: K0 Q& K+ ?, B
% a/ [+ w7 o1 j0 z- H3.决策树 (Decision Tree)
  G) E0 x4 C- H% V6 T9 ]$ G5 K# r# q3 x8 n
4.支持向量机(SVM)
# w3 K) K4 I+ ?. c& m) U9 M. s7 [0 B: c( ~# Q* o
5.朴素贝叶斯 (Naive Bayes)
/ I  c5 z" ^8 J$ N' x
- W5 y9 i' n  q  @2 o  ?6.K邻近算法(KNN)
, v0 V8 n* Y6 c/ J
" z2 d, g+ F$ k; J7.K-均值算法(K-means)
1 u% w. y. o$ M9 g: v. u' p* [( p( j3 M4 f; l! F
8.随机森林 (Random Forest)+ _9 K9 ~' R' z. v) G

) m: C) \/ A$ X' {) A9.降低维度算法(Dimensionality Reduction Algorithms)/ }# e( U! q5 F$ h+ k- `: k

9 @# c% X7 a2 Z5 c* g1 l10.Gradient Boost和Adaboost算法- y5 J  @- r' |5 U+ w
一个一个来说:
! @, U+ r9 H! C% ?1.线性回归
9 u& E# G6 r+ U# m0 ?% h
' y$ r# C3 Q5 I. o& f$ R6 ]线性回归是利用连续性变量来估计实际数值(比如房价等),我们通过线性回归算法找出自变量和因变量的最佳线性关系,图形上可以确定一条最佳的直线.这条最佳直线就是回归线.线性回归关系可以用Y=ax+b表示.
8 `; I# d$ \' \/ a$ {% u' h# b2 _+ g2 Q! L$ ]3 ^
在这个Y=ax+b这个公式里:& Z& _8 w& G" F, d9 X$ ]0 _

/ w2 b( Q: T# J1 H, q& e2 X' _ Y=因变量
. i8 i9 P  l6 h) m1 u2 _" k7 g& m) S& K& r9 A  t$ W+ O
a =斜率: i; M# w9 n% o  }) r

! i! S: F8 E0 a; ]( B9 ]' {$ U x=自变量
- o6 w& @. m, b" L1 K, @9 s" m0 t3 X* ]/ D# u. A$ u
b=截距
5 G5 m+ P5 a8 {# ?: W5 I
: K$ G' I0 s% {- q# R a和b可以通过最下化因变量误差的平方和得到(最小二乘法)
. G; S: N5 p: a# L) d) ~5 {' }$ w% R' D$ l: i2 z$ c: a
我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。
. C4 }* d- k- V% W6 m1 s
1 M  Q5 |! {, M给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息.
# ~0 t) U# }3 b/ C- s% I& _7 e& q+ k6 c
. B- O0 C* p4 F  L/ a
( j0 \9 ~2 n8 @- e. ^
) O1 K* F) I% |! Q% n# P7 V! N线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量.
& A" m4 G' l: C2 A, p  N& g
9 d, I! t! L% i8 K拟合多元线性回归的时候,可以利用多项式回归或曲线回归
2 k. G/ R* E( ^' p; o$ H( z: V4 f5 l  w
Import Library1 r! C2 a8 j  i/ H; y& Y
from sklearn import linear_model
' `) I, `2 i- b5 l; a8 D  C/ D0 R: @, f0 F% c/ M
x_train=input_variables_values_training_datasets
7 v" ]2 G& a( r1 Q; S( Cy_train=target_variables_values_training_datasets3 }" T0 z7 N. w+ B# A1 |
x_test=input_variables_values_test_datasets
3 R- O1 W0 F2 d: `8 E+ h, z5 u; Q- r  D, o1 t
# Create linear regression object
' V& O( T# u# `$ ]0 {) Plinear = linear_model.LinearRegression()  c, `" X8 x! d1 w- B, }
4 f: v4 s" e! V0 ]/ C/ H# n! n, \. o
# Train the model using the training sets and check score
: ]* O/ k- s; r, I( p4 H2 Glinear.fit(x_train, y_train)
( {8 @  ?' L9 c7 y6 Hlinear.score(x_train, y_train)
7 [( M. W0 c: L
8 X9 O* c3 `6 a! }#Equation coefficient and Intercept2 f1 Z2 z( q- X0 W6 F
print('Coefficient: \n', linear.coef_)2 I6 @, Q. ~4 Z+ Z
print('Intercept: \n', linear.intercept_)$ K2 q. a" q7 E( j/ N( v" L

# n8 q! C7 y7 t/ C5 _0 u#Predict Output% l0 v9 P' C3 v+ m7 t1 Q/ F4 I
predicted= linear.predict(x_test)
( m- I% o7 r( E4 W7 h9 l. I2.逻辑回归
& K, ~. M: M; x1 o2 A* k逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归!
) U. j' K8 k* x) s5 h$ g. L: W4 Q3 {! k, F# T9 }
同样用例子来理解:
7 Q) J7 ]8 i1 ?: k8 ]1 v# c" o. o6 b; u5 r
假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。
; ~4 T! _+ X: q9 x! d# B+ N/ g
: x" a: }% [, n6 t  R. |( k数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧* G: }" O) I  m6 K$ ~
+ R, X8 X. j) o$ v7 n3 z" Y
最终事件的预测变量的线性组合就是:! \( x: M# e7 @; g

) F4 U2 k" t7 |+ F" a4 O! S; I1 E4 M# m1 G5 X
odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence
& `7 `* w) Y/ X1 E& F
! y9 W- {8 K, I& y" D" _ln(odds) = ln(p/(1-p)). ]; a% C  s  |& L4 ]: _$ O
( ^3 x7 l" V" f8 ^# N
logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk
3 F3 K1 i( P3 d; N+ N) I在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和.1 a; Q" X2 |, p9 e; q5 O1 T7 i
: P& A5 S6 O! l! U+ f! [
至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法.4 D6 S/ u" |: P  U% Q) y% t

, q2 r3 {- r8 f; R4 _# N
+ B2 C. T7 `* O! M8 U. o8 R1 {/ ]- \7 f- ]4 J# K. E6 F7 |& t
from sklearn.linear_model import LogisticRegression8 |/ S+ m  M- j2 P9 N9 x; v$ q

9 z3 `: b5 ?, w3 Z( J. \ model = LogisticRegression()
# s5 A9 k  O; Y# u; X! ], t% I* G* d8 J2 ^( R# I. b2 @
# Train the model using the training sets and check score
8 H2 {- Y/ U! z1 R. ~9 H1 |2 g model.fit(X, y)0 E: W/ N  E9 R5 z- x, n
model.score(X, y)
! q9 `" _5 U/ h8 i% x0 q
, k* \1 e+ K/ k8 [; P #Equation coefficient and Intercept8 t" ~5 b2 s) s8 N# t
print('Coefficient: \n', model.coef_). A. ?1 r' U( C( \; ~
print('Intercept: \n', model.intercept_)6 n# i) [5 s* B3 ]
. |/ K9 q" b4 d  B9 t+ u9 |3 F
#Predict Output
+ J1 D& Y1 n% V* q- C+ {3 j1 ` predicted= model.predict(x_test): B0 u. y9 _1 _. W' ]+ M: v
逻辑回归的优化:
1 D) q7 n- a& W2 z! d$ y加入交互项) j$ S2 ^( G& C2 x' k: Z+ x
# F# U" D- r( [5 u
  减少特征变量+ g$ p. I& }2 S  v8 U  V3 E9 V8 o  x1 u

8 A0 G( r- n8 m! x" p) o# V1 g3 Z1 S  正则化
; D! _4 A( h; t  o8 k9 V$ v" p  F' d
  使用非线性模型
( i1 Q5 d  Z" a% \. l6 W! ^0 \: U% b2 q. e6 }4 b+ Q+ w' E
3.决策树& H8 N8 r+ r1 ^" W, m
这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。# E8 a% e  }; v

3 I6 `- @+ d3 R3 k' e0 g4 Z
$ Y1 H/ W+ Y) a( {1 }: s, J3 j
# ]# |- @2 Q) Q6 C/ N4 X从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。  Q7 w# b- Y" P+ J0 k0 N) I+ c

3 V! s: i1 M; y/ Y6 W
5 u6 S2 k6 K" z0 k7 o3 pfrom sklearn import tree
5 J7 ?/ s% W: _7 ]' E5 }, H: {/ e% }2 O

1 l$ m) t( ?: C3 M# Create tree object
3 a/ Z: |/ i0 v5 U7 N! Bmodel = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini  
! j8 u( \  e8 q% a/ O; V! T3 @" e( V! C" R! ]: Q# `
# model = tree.DecisionTreeRegressor() for regression) H. ]* T) y/ s$ L: L1 B
7 n# W" e# A' K( H1 E% s+ ~
# Train the model using the training sets and check score1 F2 i) S/ G+ ]! ~7 L) t9 I
model.fit(X, y)
. s) z  m7 J& Gmodel.score(X, y)* k& |6 E. g8 K. H
# d* A0 D: m, |  N0 v2 j. t0 O5 P
#Predict Output- |7 ]  L% ~8 X. V% i9 E
predicted= model.predict(x_test)
% y6 U6 A% B) P5 z: S  C% S4. 支持向量机(SVM)& w& N4 f2 j( H  a- p* _1 d
这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。
2 S+ `- ^) k! \" L+ Z5 B( ?4 u. x7 M
( ?7 Z! C: ~' a5 I% }0 A3 i现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。
  I0 J2 ?7 h, N6 ^) f1 i; t: {6 ^' {  q
6 M6 M, C+ f5 f
; l+ ~! K5 j+ l
在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。
# |2 ^. \, d6 x/ v( A; o: P$ U* C4 ]
#Import Library" u3 J, f: a4 @* _9 e7 h
from sklearn import svm; K! s- a( P) o% ~# ?
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset) t5 U+ B3 E8 s+ ]9 D
# Create SVM classification object
6 Q; f: I) p: r5 j2 ~* g  |7 w* u! A
( i4 j' r+ Y- G3 s2 ]( z) Mmodel = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.# \6 {0 C; V) ^' g0 y$ q0 o! p; Q

1 q/ r9 i8 _# e' {7 W# [) p# Train the model using the training sets and check score, \+ i/ K# g8 T3 H
model.fit(X, y)/ a. E* L/ l/ m) ^' {- O) ]
model.score(X, y)
1 g8 O/ }* P1 `$ Y# B; N
9 H5 m2 I# f2 G5 D! Q$ x9 @#Predict Output
. H7 k% e6 \2 y! P. l- H: ]1 T4 spredicted= model.predict(x_test)
# |$ U% ?: q7 H' B5. 朴素贝叶斯
; g$ [3 G4 }1 C: v6 b这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。% o7 ^9 Y4 _  [( y: i
) w% M$ }, g4 x4 ~
朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。
: D" v* n0 ~; j7 z
( v( Y9 B: G# E! y贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下:( j+ V% ]8 q  o4 F
) L/ q$ l7 X0 O# w+ u2 Y1 t
, [5 O/ {. x$ x- _
P(c|x)是已知特征x而分类为c的后验概率。
: W7 Q! U! R. h5 g2 ~) G
. W8 i4 c& J" V9 _) z/ tP(c)是种类c的先验概率。
  H' @$ }! P, ?* ^% j% t  d  f2 H2 t5 T+ G( B, L
P(x|c)是种类c具有特征x的可能性。/ i+ A/ [6 f! q$ J

, Y0 j0 e! M" y! uP(x)是特征x的先验概率。
9 j) L8 c: Q$ S( T* `- D. ^) s
. a4 U& M1 L! ]$ h$ ^3 o/ X" G& Y. B1 }' P# q, h, l2 Y
例子: 以下这组训练集包括了天气变量和目标变量“是否出去玩”。我们现在需要根据天气情况将人们分为两组:玩或不玩。整个过程按照如下步骤进行:' G/ X- z5 C+ ^# R9 Z
8 j, x# }3 U& d3 B
步骤1:根据已知数据做频率表0 ^: v) P0 o& D$ n+ K9 U. L2 l

% C3 m2 Q( q( S: l7 P: j步骤2:计算各个情况的概率制作概率表。比如阴天(Overcast)的概率为0.29,此时玩的概率为0.64.* D2 G$ f8 x3 ^% N: Y1 o; K

: I" Q) Z; b) j6 {/ X! v1 n
6 T; U1 o- R) a' I8 _步骤3:用朴素贝叶斯计算每种天气情况下玩和不玩的后验概率。概率大的结果为预测值。4 `. V. w2 ~4 B! W- O1 f- ~# l
提问: 天气晴朗的情况下(sunny),人们会玩。这句陈述是否正确?$ T0 \$ g& ]3 q3 y/ V  e

/ Z, Z: \! Y) e" [我们可以用上述方法回答这个问题。P(Yes | Sunny)=P(Sunny | Yes) * P(Yes) / P(Sunny)。# ?# C, O6 S* u7 I/ V2 F. N
$ U, f) `, x0 ]/ @0 ~) E
这里,P(Sunny |Yes) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P(Yes)= 9/14 = 0.64。
7 y. D! t9 |" R& g* n! ~3 D6 Q+ B
0 F( ^4 j% G( q2 c那么,P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60>0.5,说明这个概率值更大。, c9 U* x0 m9 V: b9 S4 _

+ M2 x7 Z' n6 s, i当有多种类别和多种特征时,预测的方法相似。朴素贝叶斯通常用于文本分类和多类别分类问题。/ o6 y. S0 n2 E& N" x- C

0 x9 Y- Q$ c; }. S; ^#Import Library. L5 s+ ]! D0 u: [" p
from sklearn.naive_bayes import GaussianNB
; a1 [9 N( j% _, _" F+ U#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset0 r. f# q7 h' p' W

( s: J% O# b+ D$ [) g5 G" n# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link
$ K4 c( f8 C' K
# `' e0 j' {( E7 e, S# Train the model using the training sets and check score. ^6 U% J) Z# G) [
model.fit(X, y)
2 e" K0 j& m8 z* H2 e/ T6 Z/ U9 {- D7 {* o1 X  V2 ?
#Predict Output" |; J8 _9 j+ K& F) R, F5 \
predicted= model.predict(x_test)0 }- Z: D) R- k$ o: w5 T) t( r. d5 h
6.KNN(K-邻近算法)% g) Z, Y1 U9 e* A. j. X
这个算法既可以解决分类问题,也可以用于回归问题,但工业上用于分类的情况更多。 KNN先记录所有已知数据,再利用一个距离函数,找出已知数据中距离未知事件最近的K组数据,最后按照这K组数据里最常见的类别预测该事件。
- y( ~) f, N+ U: K* T0 f/ N
  Q0 i( O, H! v8 ?距离函数可以是欧式距离,曼哈顿距离,闵氏距离 (Minkowski Distance), 和汉明距离(Hamming Distance)。前三种用于连续变量,汉明距离用于分类变量。如果K=1,那问题就简化为根据最近的数据分类。K值的选取时常是KNN建模里的关键。  f/ j' f5 {0 L; p" S

# N$ b5 j) O8 e+ N: ]
% @' b* G" n& N1 ]0 J+ Y3 _
# \/ F4 w2 R; Z) O9 L- S1 P3 hKNN在生活中的运用很多。比如,如果你想了解一个不认识的人,你可能就会从这个人的好朋友和圈子中了解他的信息。
' K) \8 {. E; Z4 G) s0 |' k' }9 S% a0 [2 F1 t$ s* R# s2 @3 x& z9 @
在用KNN前你需要考虑到:
; p) W8 I2 y2 K' d$ ]% N4 Z
( R# H  |; @9 d4 VKNN的计算成本很高
3 F) l8 S0 @5 y$ c0 Z
' b+ V5 a* \0 d  W: D* J9 t所有特征应该标准化数量级,否则数量级大的特征在计算距离上会有偏移。" u8 \9 i4 W2 W3 p
2 H" I8 E8 R% Y
在进行KNN前预处理数据,例如去除异常值,噪音等。, u4 {6 p5 J% _& f( V
' [- E: H. ]; R
#Import Library
5 J$ Z+ X% q3 W3 z# g% T2 Xfrom sklearn.neighbors import KNeighborsClassifier4 Y- o) [$ P! S- D- Q

5 l% o+ x5 i9 l" V9 e( w: u#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset; \; h& i7 ~5 I- A" Y# p- k
# Create KNeighbors classifier object model : [- _4 g6 {0 E6 w; \/ [

/ G) u- ~* I& b/ C4 n+ j- x1 LKNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5
( f. Y8 G8 Q; M0 ]! Z
& `5 z4 E4 C* a$ o3 h# Train the model using the training sets and check score) W0 i1 e+ t) t) G) Q
model.fit(X, y)
- p2 Q5 P! u9 z; q# [% c
) f/ N% q4 d2 F/ k7 C#Predict Output
& l# w$ u& Z! epredicted= model.predict(x_test)
+ |" ~5 N5 \- ?$ n; a+ |7. K均值算法(K-Means)
6 j$ U$ r7 J; W4 b* I% i这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。$ E' [" {/ ]1 G* ]' T5 N- l* f
' n( D* j! w( H0 h7 k( v
还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量!! R4 j2 y2 n, y7 ~, W( h' C. M+ V$ V
: v8 I" `. ^! C! D3 |0 f
& W0 E, i- M3 Z$ \+ h; c
K均值算法如何划分集群:3 {: w; `1 |* z3 k$ C1 \" _( ^
4 C) Y( B. |( H0 H6 S9 p

" E2 r6 W2 ^, p/ d# f& k! q. U) }* D4 M) o$ p8 c/ k6 r+ ]9 R
从每个集群中选取K个数据点作为质心(centroids)。
( R' N3 q" G* `0 }
& P3 M0 J; {7 G' X! O. `/ y将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。
) S5 g; J1 s1 y
2 P/ S5 ^) p4 {% R, q% v: Q找出新集群的质心,这样就有了新的质心。
* q2 W2 Z8 f" B( g( b% `( A  C1 x
4 t* {# n' H* p" j8 W: m重复2和3,直到结果收敛,即不再有新的质心出现。2 N$ h$ ^( A& _  ^8 Q
1 u3 |' L: Z, z9 ?' R, `4 p- o' ^

7 q6 f* I) ]; Y0 C! @, F怎样确定K的值:& a) A1 J+ F( i  m/ ~* r( R# S
1 \$ J' A. m0 w" D
如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。0 [6 ]; _0 C6 C( d

) y7 i3 ?0 Q9 l. P! j% r* w我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。
8 C, R8 u2 s# ~% A. @: O+ Y; P% b  T" W3 w& t- @0 L" h, t

' i$ F4 e- l& @7 o#Import Library& @  n# x& V5 {+ v0 X
from sklearn.cluster import KMeans
3 \+ q. y/ z* b9 ?  K/ ~
3 N% W; E8 G2 A7 Q8 {#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset
8 ?' S3 f# V# l, r# Create KNeighbors classifier object model
; o2 B  S4 I) y$ c8 U& mk_means = KMeans(n_clusters=3, random_state=0)
7 o9 \; G& }: r9 S: ]+ |- E: w* k! a
# Train the model using the training sets and check score
) B' a: y9 C* R% ^' Hmodel.fit(X)
2 S' D* J0 q3 _9 L
" U- U8 z5 T9 \: f1 L#Predict Output: q% \& u* [$ j4 f
predicted= model.predict(x_test)
  X9 _7 g0 h5 {2 S8.随机森林
- P# ^! ?" m+ X3 G' v随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。! l# V: H& u! G7 U+ I

5 f3 T! ]) ^; i8 Q& t怎样生成决策树:# v0 k5 L1 y. n6 D6 b. m

; @" [- f' K6 G3 v6 D9 H9 u如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。% B- m% D' d, A! P9 G; n

7 Z4 n, A/ Z- C3 ]" u如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。
$ _5 }1 a8 V8 \: C
0 ?9 ~: l0 _! h1 \" [每个决策树都最大程度上进行分割,没有剪枝。
& \4 t- b& d' \5 Y6 G) k' M% s4 S- y- ]2 O( G" L/ B
#Import Library
, t7 e$ @# ?6 p2 T+ x" f2 R" ?; efrom sklearn.ensemble import RandomForestClassifier2 ~7 ]  ^5 C  R
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
1 U) q+ v! N' u! w' S9 I& O4 S2 J0 b$ r8 F# H) Z
# Create Random Forest object
& s1 r" l9 S* }# X  Q7 C" kmodel= RandomForestClassifier()
5 U; n+ H3 ?# \% ]4 D& Q% y& R; K2 A9 w, N
# Train the model using the training sets and check score$ l3 n5 _+ f1 `
model.fit(X, y): h$ k: F. _8 ~1 f" U
4 _$ `' e& Z3 q: i- B+ H" j
#Predict Output9 G2 `$ v5 @8 e# q/ m& k
predicted= model.predict(x_test)
2 r3 ?3 u4 W$ u7 n9.降维算法(Dimensionality Reduction Algorithms)$ ]7 u/ H6 m0 g: U, k$ I
在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。
2 R; C5 ]6 H* s9 m; }! U' u% m
& R7 c) i8 O7 @& |4 J  a例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。
5 }( `' Q  o1 }0 F; P% Q5 U
  `; g2 G6 Z& i: W9 d  [' `  w) \$ @" K作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。/ a& i: I, Y! n7 P+ _7 ?% D6 \0 s3 j

  D1 g; k6 P% e) v9 A  n; M% e- h7 ?7 A' f! r
#Import Library( D  a- O- ^6 p3 |7 ?
from sklearn import decomposition
$ J4 u4 g- S. I, P5 F. E% T7 d#Assumed you have training and test data set as train and test
  D- P' s: @- _' H# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)
: I; l( l& P! F( N: Q; `, p( j# For Factor analysis5 e8 _  N& [6 j& n: T; T
#fa= decomposition.FactorAnalysis()
) c- \+ k: d/ @# Reduced the dimension of training dataset using PCA3 P7 }* D* ]7 o! F" w
8 @4 N1 F, d- E
train_reduced = pca.fit_transform(train)
6 v  h9 Z2 `5 m* e* _  P/ g& V. S% @/ k0 k- R# y* I5 U" \
#Reduced the dimension of test dataset
- ~) s) m9 t7 W, P( c) `( [: Utest_reduced = pca.transform(test)
$ Y9 {3 ~2 T4 c10.Gradient Boosing 和 AdaBoost
& Q! p1 N8 u1 l" _; JGBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。) H0 M9 G- G& A3 Y5 K
6 E( S: T( q+ e' ]0 Z- ^+ `
#Import Library
# i# \+ l3 }% V% x3 b4 p  w6 N) wfrom sklearn.ensemble import GradientBoostingClassifier6 b1 m# F0 n4 |. p
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
7 p- d) j# E3 Q- o" @" l# Create Gradient Boosting Classifier object
* a3 t; r0 K! I+ Z/ O$ E# Wmodel= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)
( K+ V! e. U8 n' S. u
2 L5 j4 z: T. ?/ ^- W) C/ ?1 Q# Train the model using the training sets and check score
+ o- ^% A  [! \2 ?model.fit(X, y)
: ~; M3 F+ C( U+ e! w) f#Predict Output
: G6 y9 |1 o/ }: v* @- ~predicted= model.predict(x_test)
& m+ O2 y9 w8 f) v$ r% t. mGradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。- u3 O# V, G; x8 v+ @
7 t/ P! d4 S% C& B/ J3 U$ t
原文链接:http://blog.csdn.net/han_xiaoyang/article/details/51191386% P" I( D5 a0 i7 i
————————————————; Q! }8 y2 O  ]) m! z- f9 \$ z9 J! b
版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
  b0 F8 v% [# i1 F" I原文链接:https://blog.csdn.net/qq_39303465/article/details/791760751 _$ f7 k# a- {  {8 g, e- V, L

4 `$ y: e' c) h" y* J0 M  s8 y7 C, o, D# H+ v8 S: j





欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5