QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 2188|回复: 0
打印 上一主题 下一主题

机器学习算法整理(内含代码)

[复制链接]
字体大小: 正常 放大
杨利霞        

5273

主题

82

听众

17万

积分

  • TA的每日心情
    开心
    2021-8-11 17:59
  • 签到天数: 17 天

    [LV.4]偶尔看看III

    网络挑战赛参赛者

    网络挑战赛参赛者

    自我介绍
    本人女,毕业于内蒙古科技大学,担任文职专业,毕业专业英语。

    群组2018美赛大象算法课程

    群组2018美赛护航培训课程

    群组2019年 数学中国站长建

    群组2019年数据分析师课程

    群组2018年大象老师国赛优

    跳转到指定楼层
    1#
    发表于 2021-4-9 16:23 |只看该作者 |倒序浏览
    |招呼Ta 关注Ta
    5 a6 w; h  g+ ]3 y3 @& l" \
    机器学习算法整理(内含代码)8 L0 I, P; i+ J# h

    . b5 I1 e$ k, V. L0 b- y7 S- T一般来说,机器学习有三种算法:
    5 X, I* [+ R7 h" ^5 ~1 ~1 D# j# ?9 l# o- F
    1.监督式学习
      r5 W. M( i' i; |2 _8 H
    ) S. N! C; p$ Q+ i5 y% y7 E% @" t 监督式学习算法包括一个目标变量(也就是因变量)和用来预测目标变量的预测变量(相当于自变量).通过这些变量,我们可以搭建一个模型,从而对于一个自变量,我们可以得到对应的因变量.重复训练这个模型,直到它能在训练数据集上达到理想的准确率9 r: i9 B. T7 T. B- P

    2 f4 ?. L8 L/ W+ h属于监督式学习的算法有:回归模型,决策树,随机森林,K近邻算法,逻辑回归等算法4 I, i4 [# M( r# `7 C) c
    ' Q8 e$ D# e/ N# ^+ t9 H/ j
    2.无监督式算法( K8 G* e, E, w* E0 q3 H
    0 }$ ~( m" H2 M' y1 v* a( K3 J
    无监督式学习不同的是,无监督学习中我们没有需要预测或估计的因变量.无监督式学习是用来对总体对象进行分类的.它在根据某一指标将客户分类上有广泛作用.
    * Q/ m7 _7 q* H2 }, ^1 Z. P
    0 V9 M9 B. H' a( u, l/ i" l9 z属于无监督式学习的算法有:关联规则,K-means聚类算法等7 M% l6 ]1 A. E0 ]: J2 L2 A
    ' [" W7 N( y, {3 p3 c( \- r% o
    3.强化学习
    6 C' X  y8 a" w2 A( O* ^0 F9 A/ j
    这个算法可以训练程序作出某一决定,程序在某一情况下尝试所有的可能行为,记录不同行动的结果并试着找出最好的一次尝试来做决定
    " E+ g8 z0 u' ]& N( e
      `( P/ D) f& b, x4 {: g* u属于强化学习的算法有:马尔可夫决策过程
    6 U: u. x$ J; d. p, l; k( _
    & F8 ~" {) N8 u8 @常见的机器学习算法有:# J8 f4 {7 l, A' ^0 _: k( c

    0 T8 X5 E+ i: `
    8 t( C1 ~8 c% }% x2 n1.线性回归 (Linear Regression)
    # }4 q/ t3 S! M9 m; j, d6 i, y- b( \: b3 c  `0 \0 t
    2.逻辑回归 (Logistic Regression)
    3 P1 G. w8 `8 V* c7 E1 D! P$ P+ N9 L  X5 L4 e
    3.决策树 (Decision Tree)
    5 X9 d& m9 ]9 [- y7 ]( U
    0 I+ \' t" P' ]& E4.支持向量机(SVM)
    & i& }# h' \1 V. Y! L: F& H4 z  \7 Q/ Y
    5.朴素贝叶斯 (Naive Bayes)4 _$ ^1 V" m2 ~( ]+ ]5 }
    , [, n8 ^# i8 z9 K% E% s' i7 k, z
    6.K邻近算法(KNN)4 _4 R% H$ s$ E; B3 l2 d5 l  f# D

    - U, K& ~2 e. k, Z7.K-均值算法(K-means)
    " ^0 ]* F$ c1 y/ v# v: G
    , d; q) ?: H6 R; F1 y$ N- @5 N8.随机森林 (Random Forest)
    9 t5 f% F+ Y/ y3 j. y
    ! \7 S, F& u  M6 w7 ^9.降低维度算法(Dimensionality Reduction Algorithms)9 o8 z' ~2 w* G8 g8 H

    3 o! f7 j; a6 @1 i) J10.Gradient Boost和Adaboost算法
    4 S$ b" b9 i: m, N& {一个一个来说:. y2 @- v" A" s; i
    1.线性回归" n3 m* |8 a* D* ^% g
    - Q+ F; o7 y2 l" t( o
    线性回归是利用连续性变量来估计实际数值(比如房价等),我们通过线性回归算法找出自变量和因变量的最佳线性关系,图形上可以确定一条最佳的直线.这条最佳直线就是回归线.线性回归关系可以用Y=ax+b表示.0 T. k6 L- ~* V/ ^

    ; @6 i" J+ y# Q- i* b; U+ h7 E* T在这个Y=ax+b这个公式里:
    * f' i/ T; r  ]& W4 h
    4 Z/ j/ L5 Q) t; ?* |# q/ ^# a Y=因变量
      @: i! i0 q! l/ L7 H) f( }4 u$ }) k9 y3 R9 [; W  B, J
    a =斜率3 L9 I! Q2 W4 g

    & Z2 t! L$ ]: t6 M3 A x=自变量. B7 g, @- ?% [4 ~( L& w3 g% Q

    1 e0 G# w4 t7 i; k' z b=截距. Q/ I( t# c. G6 Q- m6 T

    - Q; K  h7 `! d# V8 ^$ a a和b可以通过最下化因变量误差的平方和得到(最小二乘法)0 }- |7 s/ m& n% G( N: h- f8 X8 ~

    " h6 W( g; u/ _* L. |' n+ }* [我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。
    2 U% N( v& R" a' `8 Q& k4 O2 a7 ]' F  f5 k- s' \
    给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息.
    2 f" a4 Q# z! O5 l4 {% R3 P) i' m! J2 S1 e) J: b0 d0 M

    ! {; I0 X) {* ]
    8 K# B+ l( ^  n线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量.
    2 i, {/ L( K; G1 ?# g" O# f$ X6 [0 h# q! \. W6 e8 x
    拟合多元线性回归的时候,可以利用多项式回归或曲线回归- Z3 s3 {9 @/ ^. T
    3 z* {: R" ]7 \/ U  k( B
    Import Library
    1 D9 u( {' h9 G7 u) dfrom sklearn import linear_model
    0 a3 c0 e, v3 U% I
    ' [# }9 B8 p  B0 W8 h7 Ex_train=input_variables_values_training_datasets6 E4 e9 t  A2 F- R4 H4 Z3 P1 r
    y_train=target_variables_values_training_datasets) Q# D' Y5 _# \- C
    x_test=input_variables_values_test_datasets( l/ l0 q' G- ~4 C+ c  x4 z
    - v6 f+ p. }# x" [' E: ^. W
    # Create linear regression object5 A% o  x! g+ }" B
    linear = linear_model.LinearRegression()
    ) R) J) F5 [$ e* m3 u9 |2 z7 P. ?4 u. J1 l
    # Train the model using the training sets and check score% p. E1 B0 N/ i3 h8 \# F
    linear.fit(x_train, y_train)
    9 A) A  S4 ?, Q7 T8 c+ h! H: \9 vlinear.score(x_train, y_train)7 s3 [) N, T& K7 d. E" @

    0 ?$ x) {" R- B) F% f#Equation coefficient and Intercept3 ~3 E1 t5 q1 f; E! L# _
    print('Coefficient: \n', linear.coef_)
    " b% w4 x6 u1 G* ^- |2 K; \print('Intercept: \n', linear.intercept_)8 R  Y1 g6 j4 C" R2 H6 s; Y
    . F  Y4 F' |  j# |, F
    #Predict Output/ H7 V/ G% A' `. i9 }- r8 x# Y
    predicted= linear.predict(x_test)
    ( l& U6 ?8 P" Q5 c0 R8 @2.逻辑回归
    3 A, f3 N* h" j0 P! L. `6 v# ~" s逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归!
    . v( u. a% z; l9 @9 m8 i* h% G8 |! M9 ~
    同样用例子来理解:
    8 |# g3 ^1 v# b: S" _0 e7 @9 f0 n) x( a
    假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。
    0 n: B( g$ x2 ?6 q  ]  ~& ^: E" o7 G2 V
    数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧. H- b) D: K1 J9 r/ P
    + L* A% S! C. V; ]! s4 D& D: K9 G
    最终事件的预测变量的线性组合就是:: A) r9 B1 {. j( g; f" F: z

    ! R! `( _# D1 ?- q- W4 }( Y, u+ T2 x7 y5 R- s+ i; i
    odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence( Y- R% z( T3 `& d! k
    ' a8 ?' P6 G2 C( c& p
    ln(odds) = ln(p/(1-p))
    3 P+ H! ?1 e5 j9 }0 J7 Q: o% v- o( O# |$ i! F. q
    logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk" h. S# q) r$ p- A( e% i
    在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和.. {% Y9 W' x7 w* u9 t) d  k

    & A% f) H! s4 N" Z/ X5 x( ^5 R至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法.. t7 Y4 ]% V1 J  W7 A

    8 s; \" z, o( m' O0 }( T0 n# U$ @! U* K  F: H! F' I' u3 p* [

    & h) d  e: ^' a3 f, F% _8 } from sklearn.linear_model import LogisticRegression7 e# q. \+ ^) L$ @7 b
    1 Z! ?0 b& ~+ g+ e2 z
    model = LogisticRegression()
    ; q# s! o2 }- R+ I" h: o7 a" Z0 {5 a4 a! M' H
    # Train the model using the training sets and check score% F: s; s+ j! h7 ]
    model.fit(X, y)7 A4 T2 L# O8 u; }
    model.score(X, y)
    8 c% m' A1 g# G' N1 R% W' }' v! m* p# |% a. q+ i2 _: R
    #Equation coefficient and Intercept
    0 l; f# {' m: E! I1 m1 a9 _ print('Coefficient: \n', model.coef_)
    " w6 \( _$ E1 Q1 x$ G' o& y print('Intercept: \n', model.intercept_)/ n) Y6 K8 ]$ N6 w
    5 q; e) z4 D2 s6 Y0 |$ K& A, }# i
    #Predict Output
      X( Y8 |. O1 x# i" Y predicted= model.predict(x_test)7 m# b) h, E7 M, f
    逻辑回归的优化:. e% V; ^5 O  _. n) F* q3 K; f8 ?
    加入交互项$ f& p5 Q# `: T' w4 B8 n0 M

    9 Q( d% s* b+ L0 }' B8 d  减少特征变量
    ) c' Y  k5 o! N; R% }, n/ `# z; t# x% Z; J. g- K' }. C1 L( t
      正则化
    , N' ^7 L" `2 X3 N" Y5 o
    , I# F8 G' a7 h5 G  |  使用非线性模型4 t* Z, u8 y( O/ M! y
    : Z/ S# f2 v# _- B0 c+ U
    3.决策树
    + J2 g; E2 i* F8 F; k5 J这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。
    # U! p, Q: h& [/ R8 X5 d& W5 M( z2 N3 x! s3 c  ?

    $ ?$ `0 m9 G) T; r8 x. o6 z3 [
    6 W, G, u1 G0 `% J* k从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。
    ! R/ G& i$ V1 V: a0 V4 b9 G* }2 z; m& k2 H7 @- \- n

    % i2 ^2 K( |! {; R0 v% `8 M' x7 ufrom sklearn import tree7 S4 z3 @1 A6 U1 `# K

    . n3 ?# M0 @% @* Z; D$ i2 p! J
      A8 \- t' i7 s' k/ k( D# Create tree object
    , n7 B( e9 U) J/ v- t/ Dmodel = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini  6 I7 u" R2 U. @! V8 C

    # a; E7 S0 t' J5 ~' b# model = tree.DecisionTreeRegressor() for regression
    * G4 ~& K, M. {' \0 J
    ; C8 m" E7 k# h# m5 J& C( A# Train the model using the training sets and check score5 u' O7 u+ {0 `
    model.fit(X, y); P0 B$ O6 ]3 |
    model.score(X, y)
    / c* w3 d& }2 D5 n6 o
    $ o; H# S0 R; i' m9 F0 `8 e$ J#Predict Output
    ! d/ W: j. U) K  T" [, ~8 O3 Bpredicted= model.predict(x_test)2 |/ ~. c; j5 V7 S- R& X+ }  r& T  k
    4. 支持向量机(SVM)7 \' V5 `/ i& h3 r. k) ^9 K! F
    这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。
    " X$ }8 h5 Q. p4 O9 j' b4 r* S1 f  S, }4 |' z& {
    现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。
    , a% o2 S1 n) H, Z- [  G. c4 c. P6 U5 K: v

    - U6 l% O+ w6 D. ~0 c4 \; j' t- t3 \
    在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。1 o/ U% `8 ]% t, Y/ y
    " d4 l5 E5 q5 Y
    #Import Library8 M$ z% T9 O( R; w( x
    from sklearn import svm
    ( j, d: }1 X( F/ q#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset9 U% }3 P- G5 o, |
    # Create SVM classification object 6 ]5 F6 K2 I% x: F% j

    % u, X9 c: i4 ]# o, H' g; Qmodel = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.& [; S+ |  E+ O  `. E
    % \' {. {4 M' h+ R+ S
    # Train the model using the training sets and check score
    + P! g+ ]# e3 _8 Q7 Zmodel.fit(X, y)& G7 T. a0 Y+ d& ^7 A& _3 \6 R
    model.score(X, y), Q) M. W8 u" @! y, E) F. G, V/ Z
    - E3 b" r5 |7 V5 V
    #Predict Output
    ; u% b8 Z' Y& Y4 Ypredicted= model.predict(x_test)
      S; {7 M+ k0 S# _3 t/ S5. 朴素贝叶斯
    ' [2 v" c0 b) M! O! J7 \. {这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。, S8 o* S1 h0 E, F2 N2 N0 A

    7 S, {* ^$ ]# a9 q朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。- K9 p6 C2 e& p; ~0 H

    9 w- [7 L! a$ r1 R0 F2 l贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下:
    $ g. _, u# G" J
    ) Y8 m5 T6 U& V5 J  d) v
    , v9 b2 F0 {, \6 `& C% EP(c|x)是已知特征x而分类为c的后验概率。' Y, F4 ?8 k- o9 }& D2 m& }3 h

    % Q% t4 R$ g4 T3 SP(c)是种类c的先验概率。/ U, ]2 h3 G& g$ @4 J' E

    2 F& _/ C, M! N% gP(x|c)是种类c具有特征x的可能性。
    : L1 O6 m: q: w/ q7 S  z# x! G! ]5 A  F6 |
    P(x)是特征x的先验概率。+ a/ M3 }) p9 M5 z6 g- L
    8 j* j  B4 K  F) G8 A/ [" R9 T  E; ]
    : c' p/ C" W1 V
    例子: 以下这组训练集包括了天气变量和目标变量“是否出去玩”。我们现在需要根据天气情况将人们分为两组:玩或不玩。整个过程按照如下步骤进行:
    $ P& n* `( N; h* V
    2 H8 K" d+ f4 T% P步骤1:根据已知数据做频率表
    ! N5 }4 a8 h$ [: q" s5 U! D# J) H& N
    步骤2:计算各个情况的概率制作概率表。比如阴天(Overcast)的概率为0.29,此时玩的概率为0.64.- D5 l( E5 O) t  e
    - Z9 _( F+ H% [5 [6 S  H6 c( Y
    , ~- Q. m( g& R# S1 E
    步骤3:用朴素贝叶斯计算每种天气情况下玩和不玩的后验概率。概率大的结果为预测值。
      K' w  L* u% J8 D提问: 天气晴朗的情况下(sunny),人们会玩。这句陈述是否正确?# v+ g: z0 k/ w( V+ p6 s
    + I% T! R" a* ~/ l
    我们可以用上述方法回答这个问题。P(Yes | Sunny)=P(Sunny | Yes) * P(Yes) / P(Sunny)。
    ; z7 G1 h" Q- t+ ?% l" y% Y, G9 {# T/ o1 X8 Y7 D$ e( \
    这里,P(Sunny |Yes) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P(Yes)= 9/14 = 0.64。( T3 o" r" o0 u% o( v
    ; |% F! c8 E9 J% }6 _# h
    那么,P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60>0.5,说明这个概率值更大。8 M( h; I4 z! }! l: h

      n  }, R, p9 R5 u  r- _6 B当有多种类别和多种特征时,预测的方法相似。朴素贝叶斯通常用于文本分类和多类别分类问题。
    - I7 ?. O! M4 }* u: D, x. C
    7 Y) }( R: D  f* e4 C( S#Import Library
    - i! R7 h' F. a# p3 E* u4 mfrom sklearn.naive_bayes import GaussianNB
    0 T) S% X/ i- }# G& T2 W7 w#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    5 W0 n, M/ D! w5 @, f( [
    ( U5 i& Q8 ~2 K0 A% h# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link) n: A) ^! I/ }% ]2 A
    * z$ v: [1 Q$ e4 g! U& w' }
    # Train the model using the training sets and check score+ a1 |; j7 I  P. V' k- [$ j
    model.fit(X, y)
    / t( j9 U% Z: L) V
    " H) m1 F4 b) F! A#Predict Output
    " @. I7 N' L3 j$ U/ {2 O& Ipredicted= model.predict(x_test); w  I4 P% \- A6 u1 r
    6.KNN(K-邻近算法): s0 ^% q" k; B2 `# s, Q
    这个算法既可以解决分类问题,也可以用于回归问题,但工业上用于分类的情况更多。 KNN先记录所有已知数据,再利用一个距离函数,找出已知数据中距离未知事件最近的K组数据,最后按照这K组数据里最常见的类别预测该事件。! f, ?' o% S! F3 k& M* L) u) n

    3 v4 X6 W6 m" H距离函数可以是欧式距离,曼哈顿距离,闵氏距离 (Minkowski Distance), 和汉明距离(Hamming Distance)。前三种用于连续变量,汉明距离用于分类变量。如果K=1,那问题就简化为根据最近的数据分类。K值的选取时常是KNN建模里的关键。
    " Q: E) L3 p( C# V
    , C8 O0 f, S* V$ n2 c
    . H; K: z) ]$ c$ e% O
    + j" C6 A4 L8 b) |KNN在生活中的运用很多。比如,如果你想了解一个不认识的人,你可能就会从这个人的好朋友和圈子中了解他的信息。
    / e1 k$ X) K% X) q5 g: |: y' x1 M& R! p$ k6 k, Z) V
    在用KNN前你需要考虑到:2 ?' p) ~+ c1 F! d0 i) ]* \* U9 N
    4 E, h, r) i5 f% C# J9 I* J
    KNN的计算成本很高
    / Z/ a, x( K3 Q1 G# \4 g2 J
    5 ?$ b: g/ _6 k, ?) E: F所有特征应该标准化数量级,否则数量级大的特征在计算距离上会有偏移。3 J1 q" R7 }6 z1 j, z8 s9 L

    " n5 U" y% Q8 ^) L在进行KNN前预处理数据,例如去除异常值,噪音等。1 }) a6 \" s% |2 q
    $ I# `8 w# B: N4 K- Q
    #Import Library
    1 @* s0 |  W0 jfrom sklearn.neighbors import KNeighborsClassifier5 j4 b+ t# H+ F8 Y7 z
    ( z1 D0 H/ F4 W0 B* h
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    & O. e2 w1 d! n$ V% c' f% p# Create KNeighbors classifier object model
    ' E1 `7 p' V8 B0 g8 ^' X6 e4 U3 c$ ~6 a0 _& d4 c8 z1 J, y$ W: y
    KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5
    $ X2 l7 r) l/ E) d, b) b" X( Q& X; e; v: O) Z; f$ ~9 W+ |
    # Train the model using the training sets and check score2 l' U& r4 `+ P+ I
    model.fit(X, y)
    2 l) D- S! Z3 U1 C) m* |1 m# |1 [5 Z+ s% v5 J, l+ b9 P* V
    #Predict Output, V* A; P' H8 z: P9 @2 A
    predicted= model.predict(x_test)! O4 Y' |4 P. l7 \
    7. K均值算法(K-Means)
    2 U  [% Y1 E9 J* {这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。# X2 @9 J9 x! ~$ C& ^/ a( I: P: I
    $ R' u2 O# f- [* _" i
    还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量!
    : f* f# Y: L" M" S6 h* R! o
    # c' o  Z( B( s) L
    # l* C* H% s' }K均值算法如何划分集群:
    , ?4 j* F  }: \" E5 P8 r( F3 q& g& V+ N2 t) g$ x* y
    ! H8 ~" f  @6 t
      C8 {" ?' s- |. s
    从每个集群中选取K个数据点作为质心(centroids)。
    ) V  n2 v: b3 T6 V
    8 K5 d0 P" @- b& n将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。1 @* H9 B+ F: K0 p

    - m1 P1 D. |7 B6 z4 \8 ?. N找出新集群的质心,这样就有了新的质心。0 K; x5 A  M  _6 @% n

    + d0 h8 P/ K2 G3 n# D0 \重复2和3,直到结果收敛,即不再有新的质心出现。% q# T, v& v" S/ X% _, H* Y

    : `9 g! y2 Z* z4 K$ j
    0 o. A: G2 e4 t5 A怎样确定K的值:5 r4 w7 q9 O" ?) N0 a# f! X! r
    / N( |* c% e/ U
    如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。% D3 ]6 J+ v0 _  }$ p; h
    . ~- b! |+ k6 z9 Y% P7 M
    我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。
    & _: K9 H9 y* I3 A
    9 U, ^$ g% `0 L; I$ u% z* d8 f" N. _9 n, R' B9 p. J6 y
    #Import Library
    & D" K0 [, `% Q- J, Sfrom sklearn.cluster import KMeans4 N- w$ s: f7 i& D. t. p! R

      h1 x+ p9 i; y, \& H) Z#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset9 t; L2 r0 D% I; j8 [/ R( k
    # Create KNeighbors classifier object model * ]6 j, J5 D+ l5 D( Q, ^1 \
    k_means = KMeans(n_clusters=3, random_state=0)- @5 o% G" @+ ]" K

    ( D) j2 X% d* P9 T# Train the model using the training sets and check score+ Z. a( Y# [, E4 z
    model.fit(X)
    2 P* c& y, I/ V, ^
    8 v5 x' o1 V, ?: o#Predict Output
    7 ?' {0 x- L$ O' C. w) }6 Y5 q  mpredicted= model.predict(x_test)5 Z, H! _4 b! Y1 l- m/ y8 |
    8.随机森林# V; ^& f  H* C
    随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。+ \2 D, _* P2 B; I0 z7 w

    2 n1 H+ ^/ W2 N& M7 T4 v' r怎样生成决策树:) I8 H  P$ y# j7 _/ k, D

    9 y* f7 X; v7 H/ N8 D如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。
    ' L$ q+ P6 U# c. {! @+ w
    9 C( Z! O. p1 Q& H3 v' r/ e6 ^如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。: \' a6 M- e* A4 T# D: A# t% I& Q; j8 [

    2 D) u& f& R; C每个决策树都最大程度上进行分割,没有剪枝。3 e' J4 u- r" \; ^; [- p8 @
    4 t7 }8 l0 \$ P  C* L# [7 ^
    #Import Library7 [3 D, W" V4 o) m/ ?% L
    from sklearn.ensemble import RandomForestClassifier' T" p5 o" ]- t% t0 C
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    % o0 x: I. ^- D, h: d% U% Y9 {8 I% d- Q- [$ J& \6 u. Y
    # Create Random Forest object6 ^- V% [" k& x0 G# j9 H1 N
    model= RandomForestClassifier()8 _, h- g/ D  N2 @9 ?- C

    - t! I7 c+ d7 {2 a8 o# o+ ]# Train the model using the training sets and check score
    8 N; t5 J2 _! a/ qmodel.fit(X, y)
    " c4 f( D  f8 u4 z% E; x3 j8 o+ ^( z
    #Predict Output
    & l' L9 j0 _8 V2 lpredicted= model.predict(x_test)
    % I3 ~: ]  Y" Z5 x8 p) p6 f5 V9.降维算法(Dimensionality Reduction Algorithms)2 I. ]# P* H% ]4 b4 y, O
    在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。9 j7 n2 q  C: g& p8 J( P  c

    & h6 w" P  ~$ G- S3 O' X$ K" G例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。
    - s; W4 U% x/ t) R  {
    3 l. k7 t1 R6 t4 A( x7 y% W) J作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。/ q. O1 U1 r0 l  j& A8 _

    + Q0 L5 V/ F: Z, x5 |  W" d$ x" ~% [" ?% e* q, P; ~% ~' f
    #Import Library
    , [0 P/ ~( {2 `- C5 dfrom sklearn import decomposition, {3 s- ^9 w" n/ b( v! P% H
    #Assumed you have training and test data set as train and test9 e4 d6 T0 w5 n* `/ g; X
    # Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)4 V1 k8 r% `+ m) g
    # For Factor analysis
    & ]9 I9 V9 R" q5 Y#fa= decomposition.FactorAnalysis()
    4 k( ~, C* o/ X1 J- c' K* O& K# Reduced the dimension of training dataset using PCA( J9 z% L" u3 r5 a% q! s
    8 N2 d" b/ Y" G
    train_reduced = pca.fit_transform(train)
    - V! ~. T0 S2 U- z9 ]  }: o. M: D; ~9 r0 {# M( C
    #Reduced the dimension of test dataset& U9 Z$ m0 C, Q1 n
    test_reduced = pca.transform(test)
    , k: q6 W$ L" S# i% I( \10.Gradient Boosing 和 AdaBoost& f. y; a2 `% {
    GBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。4 y% f0 |/ N2 X) I4 m8 x3 Q
    $ [% k% x* }/ M2 D/ [0 w
    #Import Library3 }! `) o  c$ C. l( n1 V8 J3 @
    from sklearn.ensemble import GradientBoostingClassifier
    5 `# M, n4 U9 M) X: @) X5 _9 q#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    0 d- k6 p- C7 S; I# Create Gradient Boosting Classifier object0 L4 I. g$ E& _
    model= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)2 F- m  p" e5 F- B' {9 t/ ]! e

    4 W- _& U/ ^# C# Train the model using the training sets and check score6 Y/ A$ L  H( |4 X( |, E7 R( K
    model.fit(X, y)
    / `$ N, y0 `: h+ y( I; ^  Y+ c#Predict Output
    * Q4 h# ^! C) u- \) spredicted= model.predict(x_test)
    * U9 _6 ~+ B+ Z/ ^GradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。
    ' m, v  Y4 N6 g/ [1 C# ~. i( h8 `% ]" ?; b8 F! ^/ T( c
    原文链接:http://blog.csdn.net/han_xiaoyang/article/details/511913864 f2 f5 V4 R. _7 e" l
    ————————————————7 K( h0 ~* ~8 y
    版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。- ^' o& X4 Z& j
    原文链接:https://blog.csdn.net/qq_39303465/article/details/79176075* c4 O' R5 K" V; a; v5 I

    7 y9 R- J) V+ R. Q/ ?
    0 g% j/ y5 l: d+ t5 n+ d  V9 j
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对2 微信微信
    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩
    • 电话咨询

    • 04714969085
    fastpost

    关于我们| 联系我们| 诚征英才| 对外合作| 产品服务| QQ

    手机版|Archiver| |繁體中文 手机客户端  

    蒙公网安备 15010502000194号

    Powered by Discuz! X2.5   © 2001-2013 数学建模网-数学中国 ( 蒙ICP备14002410号-3 蒙BBS备-0002号 )     论坛法律顾问:王兆丰

    GMT+8, 2026-4-20 12:32 , Processed in 0.429148 second(s), 51 queries .

    回顶部