QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 2193|回复: 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

    * V+ ^( _0 @4 a机器学习算法整理(内含代码)0 h  ?" R$ n. {# X" d

    7 J' |9 q  X8 \* {- K/ q: ~一般来说,机器学习有三种算法:
    ! m3 ~  F) i7 ~& i& _: S. r4 p+ G5 s! ~
    6 @# J' k: \5 G) U1.监督式学习
    3 Y2 v$ m( t( A" D
    : \" t% p0 G: }8 d+ n+ o) J 监督式学习算法包括一个目标变量(也就是因变量)和用来预测目标变量的预测变量(相当于自变量).通过这些变量,我们可以搭建一个模型,从而对于一个自变量,我们可以得到对应的因变量.重复训练这个模型,直到它能在训练数据集上达到理想的准确率# y* N3 W$ h4 |

    " N& g7 |4 ~( D) G5 w属于监督式学习的算法有:回归模型,决策树,随机森林,K近邻算法,逻辑回归等算法
    ; Y$ O8 K* r( M6 E6 D  G- J8 [) J; }! G: O% @; s
    2.无监督式算法
    : j& K1 `8 T4 S$ p8 Y1 f$ }! x% j' b2 Z  M
    无监督式学习不同的是,无监督学习中我们没有需要预测或估计的因变量.无监督式学习是用来对总体对象进行分类的.它在根据某一指标将客户分类上有广泛作用.$ T8 [- ]( c: _0 V0 B
    4 M: h! X( e# V1 P# j
    属于无监督式学习的算法有:关联规则,K-means聚类算法等# v& P- s5 n9 g
    - w! T3 o8 S, ?0 V# I6 j2 r
    3.强化学习; A- F5 _8 R2 {2 M* x' L

    & b' ]+ i( u& @  |- a这个算法可以训练程序作出某一决定,程序在某一情况下尝试所有的可能行为,记录不同行动的结果并试着找出最好的一次尝试来做决定- e& ?, n8 M) ^# L; P% T3 Z. Y
    6 J# {9 a7 X4 u" [
    属于强化学习的算法有:马尔可夫决策过程& T( f! ^3 c0 z( _" w

    1 S4 r3 @% D& `! {常见的机器学习算法有:
    8 q6 w: [+ x$ A- W5 W! z7 j7 ~5 R1 i2 V9 \6 ?

    0 Y- ~) e" H) c2 q1.线性回归 (Linear Regression)' E: `" X& K# O& V5 M' `
    ! A3 }  B* @6 Z6 Q( y
    2.逻辑回归 (Logistic Regression)8 V  K( c" T0 D% T; w4 ?, b* F7 G

    ' @3 B6 t0 T- o9 G( H( S5 j3.决策树 (Decision Tree)+ y4 N- a4 M$ L4 X* J( q

    " Q# B, q: c5 |3 n+ c+ r* I4.支持向量机(SVM)0 c; w8 S/ C# m: a

    # l1 u7 o$ W' P# i5.朴素贝叶斯 (Naive Bayes)
    6 n0 O& l0 U* m) j: J
    , r! w* O# J0 Q& \; F+ i$ f6.K邻近算法(KNN)0 I, |7 O# g) }' z( T. q* ]' @

    . Z" V/ t3 H' p" c; W/ f) x7.K-均值算法(K-means)
    ; b7 l* K2 q7 R7 l/ e. n% [# }6 X7 f$ H) y3 u
    8.随机森林 (Random Forest)2 l6 C4 }9 R7 d3 U0 V0 m& g; j! C
    - C) n% [, F- B. i6 i$ s: h: _
    9.降低维度算法(Dimensionality Reduction Algorithms)
    7 R2 D2 U3 F9 f. g' \- V( c- [
    + F* M* T. G* @" l10.Gradient Boost和Adaboost算法3 l( i# t4 ^' O+ Z
    一个一个来说:
    ( k7 v& r. N7 ^& ^9 G- z; g, |! A1.线性回归
    2 W: g6 `. D5 u# s1 r3 O: f! R) _# M" Y# S
    线性回归是利用连续性变量来估计实际数值(比如房价等),我们通过线性回归算法找出自变量和因变量的最佳线性关系,图形上可以确定一条最佳的直线.这条最佳直线就是回归线.线性回归关系可以用Y=ax+b表示.
    % G2 g) C3 M4 `3 L! V, r' |. p4 A, E+ o% S0 E7 H6 u
    在这个Y=ax+b这个公式里:& @, B* E0 C0 j6 B) s8 ~; ]) r: A$ C
    # n# {( t. j( x9 L. x, ^; O2 D
    Y=因变量
    / U- a9 s! z7 G, l% f8 g0 K8 {2 P( i$ j1 }! R, x+ W9 M# h0 S
    a =斜率8 V% _' F- n0 z

    " |; g4 |& w* l5 ]" o7 }3 D: E x=自变量
    * k/ E7 g' j0 h5 ]: R: n/ P
    / H* M% |& o: N% w$ a' { b=截距
    4 r7 C9 t( d) {* n, K4 p0 c& r" ^# h- ?, z$ @  M; g8 w
    a和b可以通过最下化因变量误差的平方和得到(最小二乘法); T0 ^" d: M$ u) i
    $ F, c' h& o8 V
    我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。
    . c" g  c. ?- V6 p- {1 d6 R3 \8 n% ]. K: `* ?/ ]
    给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息.
    ' R; q1 U* K! i$ Q: z/ v+ N% ]* a! S
    7 s" d6 H2 x6 Q! l$ j4 }) M% j9 Y
    0 A/ h2 S2 }' a% r7 [$ S: m4 q5 L. T% s; L# m
    线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量.
    6 F5 X- Y1 @0 {7 {, |8 _
    8 m( R3 ^, p' p+ ~5 k6 x拟合多元线性回归的时候,可以利用多项式回归或曲线回归/ r# O1 Q0 U: x7 Q& {) u2 S1 E+ D; _

    2 c( d  X  Z. yImport Library
    . H& W! F, i( S' X+ W0 ?from sklearn import linear_model
    % e: D! z4 X+ Q; v$ f5 v# u& x, d6 K  f3 x3 `
    x_train=input_variables_values_training_datasets; [3 U2 d# M. [& {9 S6 E
    y_train=target_variables_values_training_datasets1 S8 e2 I+ Z# Y  ?
    x_test=input_variables_values_test_datasets
    9 c2 m$ K! T  X& x( Y
    2 A- l5 M  ?. W# Create linear regression object$ K3 g1 A1 N6 C- x0 z
    linear = linear_model.LinearRegression()
    0 J/ K. _2 h0 \( A. t* X6 y9 T# I8 {4 o6 V( o4 z
    # Train the model using the training sets and check score
    / H4 n  y) N! H6 l2 ~1 F& ^6 @& \" g' ?linear.fit(x_train, y_train), Q0 }) \( G6 @! t6 F& S# g  c
    linear.score(x_train, y_train)
    $ A+ c0 P4 z! ^* F9 @
    7 {! W  d0 z- P, h5 E8 W* L#Equation coefficient and Intercept/ Q9 Z1 `$ C( O' ]3 N% y
    print('Coefficient: \n', linear.coef_)
    9 c/ `2 S0 B' N+ l5 iprint('Intercept: \n', linear.intercept_)
    7 |8 Y/ O3 X4 t/ A8 ~
    - t% r% F! o( Z5 H3 x#Predict Output
    4 d8 W1 E, I2 h. O& P# jpredicted= linear.predict(x_test)7 L3 |' P5 @4 G7 w  T+ H
    2.逻辑回归
    9 s8 u( k, `+ d3 X6 B+ n) `; f逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归!
    3 ?1 X# U1 v6 _* f, h) y& \" q2 C9 S6 ]( _/ a' K6 j4 M; P" h) D" y& f
    同样用例子来理解:+ F4 o  O' P$ ]% _8 V: T) O

    & R! n4 Y1 O4 A: e  d假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。
    ! Y, W; T" Q* i
    % j' U' M3 Z0 W数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧
    % J/ |* p+ H: l
    0 A/ I* z% t* v$ C最终事件的预测变量的线性组合就是:
    1 [! B# F5 L! {: i2 m, r( Y& z) m% I" A: `8 }3 ~
    9 j/ z: l2 T) [9 H$ Y) q
    odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence- [& j& ~7 Z% p$ I9 V: J

    $ ?% D/ ~' I7 e/ U3 ]+ Lln(odds) = ln(p/(1-p))' K; Z# @1 C9 T- K- {3 ]  Z# V* C

    ; l* @+ C! I2 L: a  Llogit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk
    " y+ a- G. B. V) |' [5 b在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和.
    9 [( A3 H( }1 P9 m1 e: u# |2 K" g, R; d3 k
    至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法.
    2 N' _0 e. E( H% q
    9 p/ |2 C" K# q; r) u# t# U  H% p
    0 K+ O4 Z. E" H  u9 {+ X' N0 K; X- l$ r, P
    from sklearn.linear_model import LogisticRegression8 E! b1 a0 y  A! P2 X+ |( y

    - x1 ]- Q( p6 i  a3 G model = LogisticRegression()
    4 S* r. B( `$ I+ M5 `* ^
    # L" a& w3 |( I& p/ t* l # Train the model using the training sets and check score; Y; x/ q; F: n
    model.fit(X, y)9 C7 ]2 t+ X6 I9 U$ \/ o" }
    model.score(X, y)+ b1 U# L9 h- _: ]
    - I. ]. g/ o- e( G+ b4 x
    #Equation coefficient and Intercept
    6 S8 o7 R) w8 p4 y8 K print('Coefficient: \n', model.coef_)
    % q0 d! Y. V4 @( W- P print('Intercept: \n', model.intercept_)
    4 A! I0 j7 f- x) `% ]) F
    ) T0 G6 P3 [5 s# M: i #Predict Output: O: l+ x1 V; J
    predicted= model.predict(x_test); g5 F. i; l) T7 k) Q) i
    逻辑回归的优化:
    * Z  ^9 R; s( ^( r6 g5 ?$ ?加入交互项
    9 a- m* i: R# |+ W. m+ q* t8 R; V1 Z! V
      减少特征变量% E9 N7 x: A6 C5 K/ X6 o7 f3 }

    * ]2 w! ^. p- G; c" p  正则化
    6 N  S9 w+ Z% K7 m4 K4 z4 e3 v6 d
      使用非线性模型3 Z' {% z! L9 e' V8 r
    ; |8 j: r. ]4 l% L- X6 r
    3.决策树
    % v6 I( g6 n5 j7 J1 K7 W这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。' |1 D4 C! k' ?1 D

    ( ]  F8 C( ?) f& U1 D' t# Q0 O/ K9 m5 A' o' v

    4 q, y# ^# z& ^& ?1 h! l6 N从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。
    # V3 w/ G8 V$ y/ c! ]
    ; P" f) l. x9 Z- j6 F( z6 F
    5 F. S* |/ T" o; P2 M) ]from sklearn import tree
    ' b$ }0 _$ [% _0 N6 |5 l+ w! M- b8 J; n
    ; Q& d; J2 G4 B9 [4 A5 {  B4 O
    # Create tree object
    ! W8 F/ e0 ~! X6 h0 S* K! `model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini  & `( l$ |: Z4 P1 F0 F0 t6 l
    ' u% y8 P7 c+ ]) @/ V0 A; e  i( g
    # model = tree.DecisionTreeRegressor() for regression. n4 z  ?$ R* J9 W! x7 J' v& m$ }  D7 w

    0 ]* g9 I. q1 I0 r# Train the model using the training sets and check score
    . ]+ L7 }: Q/ I' j$ H  }: u/ bmodel.fit(X, y)
    $ ]) v; g( T, B( jmodel.score(X, y)
    8 Y5 P9 y2 P. w) ?; g9 j* D& k8 r3 V' m
    #Predict Output
    ' f  t4 n6 ?* Y2 {/ D8 c# |predicted= model.predict(x_test). t8 j6 K8 D/ X7 c9 R0 F
    4. 支持向量机(SVM)
    0 h8 f7 r) \$ W) M. {0 m0 Q) e这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。9 [3 ^4 ]" T( @( K, |$ J. X! _( z
    * Y2 s3 t6 W; X% C2 X
    现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。
    2 g, L! J- ~& t9 Z( S  H" ]/ @
    ( x4 [+ x$ Z- G- C1 {7 k3 [6 @) {
    6 N; ^" ?+ d* [' g6 }
    9 d& W6 A+ H9 \在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。
    % L# ?! j1 }3 `) H1 o  e( M
    1 Z5 Y8 j' t3 y9 S: E#Import Library
    ' u" ~9 a, ]: yfrom sklearn import svm% X+ g2 C7 ~6 R" @
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    . y' i+ C& s- \$ n" a# Create SVM classification object
    6 C0 d8 @1 e. j* S8 ^& o0 f
    0 C( l: h* K( o) S4 P+ Gmodel = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.
    8 m4 d3 f/ e1 S& {! d' ]1 Z
    0 }) y/ Y- D. a% O9 U" ]6 v1 x# Train the model using the training sets and check score4 l7 B" ^& P! W$ V
    model.fit(X, y)
    5 [6 q6 S5 o. q1 [# T8 |model.score(X, y)' ?+ b) C0 K3 ?( o( i: x
    : [( s( X/ C9 U: m; h$ G/ S
    #Predict Output: [, @1 C8 E4 p$ A+ e* o) ^
    predicted= model.predict(x_test)
    ( Z; R( u" m& a* j5. 朴素贝叶斯* ^  b! V$ R) X0 o
    这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。
    & q! {# O3 F' ^" e3 A  t! K' X: E. H& N3 F/ ~8 v' H9 I
    朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。
    + K' T* v7 Q& L5 f/ B
      X! b7 h6 _5 j0 k  U贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下:
    / L( G) o7 K8 d- p$ }0 N& d* u8 J! s: N" R

    , Z1 ^% ~8 H3 K! o: F( u! \0 pP(c|x)是已知特征x而分类为c的后验概率。
    ! t7 e- t/ F( v* \; V! j$ }
    $ z( \5 @# y) d4 m, k4 I# lP(c)是种类c的先验概率。" o: \& a2 `+ ?
    5 ^8 h2 j2 A( I" u2 Z! O
    P(x|c)是种类c具有特征x的可能性。
    * n' M% {* }# ~. j! Q. _
    2 Y( e; p) G4 E. [7 d! IP(x)是特征x的先验概率。
      E# w; v# Q, c' u, W. o1 u; u
    3 r! D- {: C& B, }5 z  N# e# q; f# c$ i& l
    例子: 以下这组训练集包括了天气变量和目标变量“是否出去玩”。我们现在需要根据天气情况将人们分为两组:玩或不玩。整个过程按照如下步骤进行:
    9 W# q2 H& |2 o) W+ J2 d5 j/ R5 F( Q9 q0 I4 j1 P  j
    步骤1:根据已知数据做频率表
    $ j) h. K% h! n# C8 |- L8 t2 }- Z& @3 b4 x$ T" j
    步骤2:计算各个情况的概率制作概率表。比如阴天(Overcast)的概率为0.29,此时玩的概率为0.64.
    5 ~+ Q$ Z9 A, p( L+ B5 J- w+ v: e5 g% Z1 K- p5 \9 U- y1 T4 t% e/ Z
    ) _+ Z3 `3 k8 U2 \
    步骤3:用朴素贝叶斯计算每种天气情况下玩和不玩的后验概率。概率大的结果为预测值。
    ) {6 }* K( X6 g" |提问: 天气晴朗的情况下(sunny),人们会玩。这句陈述是否正确?
    6 y7 j8 M$ }3 U, D- n# U
    0 {1 M, P5 {2 D0 }( V. n4 K我们可以用上述方法回答这个问题。P(Yes | Sunny)=P(Sunny | Yes) * P(Yes) / P(Sunny)。" W( y6 ~2 s! A8 w  Y

    ( S% e4 }. U$ b: R; ]6 R0 {这里,P(Sunny |Yes) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P(Yes)= 9/14 = 0.64。# ^" I5 u; M2 q, ^

    / Y. L  s, s) e" A3 D2 }( I那么,P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60>0.5,说明这个概率值更大。
    6 K* s/ K4 s% K
    ' N/ N" r5 e4 b$ v& h* Q; h当有多种类别和多种特征时,预测的方法相似。朴素贝叶斯通常用于文本分类和多类别分类问题。
    ; W4 c3 n% M- B4 T( u9 ?2 ?
    5 c+ u( p2 t2 o1 I% w7 d0 `7 {#Import Library! O/ Z: \% X) ?! q* j: w
    from sklearn.naive_bayes import GaussianNB* Y- \* N1 B0 r; D9 }6 b6 C, N
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    - s) q+ k; b, p5 a; g
    / M" k* ]) }& L# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link
    2 \+ N5 E8 D: g" F6 f1 Y. M
    ; J% j' T, C  b7 \# Train the model using the training sets and check score
    ! v+ _% M8 `4 a/ L" ^- g" i- Amodel.fit(X, y)6 B' f. R  @" b$ j

    4 V. W9 C, S# U2 @$ [# _: y& B#Predict Output
    9 B* v+ I6 M2 y8 H$ Epredicted= model.predict(x_test)
    4 }, g$ b6 x" G) u. c6.KNN(K-邻近算法)
    * T; c/ C2 p% l5 H这个算法既可以解决分类问题,也可以用于回归问题,但工业上用于分类的情况更多。 KNN先记录所有已知数据,再利用一个距离函数,找出已知数据中距离未知事件最近的K组数据,最后按照这K组数据里最常见的类别预测该事件。
    1 O" c( ], A" J7 \0 c, g% p6 B: ?1 r/ Y& F
    距离函数可以是欧式距离,曼哈顿距离,闵氏距离 (Minkowski Distance), 和汉明距离(Hamming Distance)。前三种用于连续变量,汉明距离用于分类变量。如果K=1,那问题就简化为根据最近的数据分类。K值的选取时常是KNN建模里的关键。/ \; \0 T+ n' f/ h( p8 C! @1 W

    ! j  A2 A: A% S' l: z+ t+ _
    / Z" L" b1 H& Y2 \& P7 ]
    2 s! H7 |! D1 B; M& m4 J0 O! ^3 M  l8 qKNN在生活中的运用很多。比如,如果你想了解一个不认识的人,你可能就会从这个人的好朋友和圈子中了解他的信息。+ J" Q; {. E7 F- a/ a, f

    " x' `# [% z4 G$ c+ P5 X, J6 |& o在用KNN前你需要考虑到:
    . `0 B- j: ]9 J: N1 Y7 i% U4 [! [: j; q; ~" u: H
    KNN的计算成本很高. ~: V5 L/ v9 p$ \6 b8 I% y' c
    - u2 t0 X/ n4 \& g
    所有特征应该标准化数量级,否则数量级大的特征在计算距离上会有偏移。5 f% y7 [$ \0 }5 p
    ; w6 G3 f" A, d2 Q
    在进行KNN前预处理数据,例如去除异常值,噪音等。
    2 w7 p" c$ Y( N% P# t( V, P) |2 X  A  m0 r2 t3 ?" u
    #Import Library$ U1 B$ b! T6 q0 @  x5 @
    from sklearn.neighbors import KNeighborsClassifier
    ! e% m, T3 v& |" ~" N
    ! v" S* V1 H6 [& Q#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset2 ~$ X& {2 T2 G+ Y1 O
    # Create KNeighbors classifier object model
    * [) E. J9 W7 S' T$ s
    - o# a8 J8 N0 O$ NKNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5
    1 v0 w, ]  B! L" U0 Q( c) b1 r, m, w+ ?
    # Train the model using the training sets and check score& A! r, t( {: L6 P- F
    model.fit(X, y)
    . @3 @8 u/ n/ ?  Z2 m
    ' T. w. `3 V& P#Predict Output" o, U4 \  E& k! s0 m. n
    predicted= model.predict(x_test)1 s$ F7 p2 R  U; ]
    7. K均值算法(K-Means)7 V! N1 B, M# }1 x
    这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。9 k8 @5 ~# k9 h! ]9 C' ]% g/ n

    7 M/ C5 d; n+ q" u1 y; x还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量!- v8 ?( ?  t9 ~

    " A; b. p8 V: k- u
      s7 ^" R$ k* _- S8 Y* VK均值算法如何划分集群:
    * r' E: {/ F% C/ d! U9 x. l
    : X5 l4 `/ h! P- N1 i( o( E- y5 p& p
    2 ?5 s  y% t$ u! l  W
    从每个集群中选取K个数据点作为质心(centroids)。
    * c% L& H7 T+ ?; @  w& V3 H4 j& G" R: G$ T' I/ Q' H, b
    将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。
    4 m9 V: e- p' W
    . p" ~  d' ^9 r5 q4 ~找出新集群的质心,这样就有了新的质心。( h# l' h& O1 ?/ {3 k  J3 c$ J

    - C3 ^( Q+ Y1 ^! D9 t重复2和3,直到结果收敛,即不再有新的质心出现。7 @' b. J/ S8 d5 r7 P' }

    5 E; a. {- |& T+ ^( m8 [
    2 C! c- _+ S1 @0 ?) u+ T$ Y- T怎样确定K的值:. D6 V$ v0 `& @5 w0 n( H+ `
    % q# Q6 H* c9 [  a' Q
    如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。
    ( }  p' s5 \8 n  g9 f" a9 |+ D( p! }$ R0 e1 }
    我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。- i) d+ g8 C2 Q* q
    ( x% ]; J) i! s+ X/ i8 s2 J

      W+ {4 R  \  R1 ~5 g* d$ I#Import Library
    3 y: J8 y0 f: U  Ufrom sklearn.cluster import KMeans$ v& m/ X- }- k5 D
    0 p3 A% |( ^" ?
    #Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset
      Z7 m2 p5 ^) S* A, z6 S  H" E! E# Create KNeighbors classifier object model
    ) r" ^/ Z' c/ Ck_means = KMeans(n_clusters=3, random_state=0)
    0 [1 n4 b- r: f) f0 s* J( M* e7 g
    # Train the model using the training sets and check score+ \' U2 t5 j0 W' l! R, `( `
    model.fit(X)
    " J% d  ]- \7 }0 I  n" x% B5 h" X1 o4 v% K. S" m* F, s2 j
    #Predict Output
    - `; Q6 T6 E' g. t+ C$ W3 _predicted= model.predict(x_test)  p  w( B# t7 t! \# d" J3 b
    8.随机森林* J: R! _6 p1 F3 u5 O, g" m  v: e
    随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。
    9 p' W' T: m- j& Z, g- {5 E; d2 D  _& v# I+ U5 j
    怎样生成决策树:
    ( U) ^  X% T' M# @! V6 W' S5 H3 b
    如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。
    * S7 n8 v0 w" y
    " J, P0 I/ t* t4 t0 ]如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。5 a  z/ [7 L. Y, u

    ( z7 L' ^) S0 m: ~# \每个决策树都最大程度上进行分割,没有剪枝。* ^* ^1 B- D) i( ^; P, f
    9 N0 m0 _5 U- d  }6 z8 Z! s
    #Import Library/ G; _. ^+ K' ~
    from sklearn.ensemble import RandomForestClassifier; m5 o7 O. D+ g8 I' w6 Z8 {
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset1 N( l/ q8 V) p2 A8 h0 O3 D8 G
    6 V) M/ N4 T  t
    # Create Random Forest object
    ( a" _4 K4 d: P1 Y$ Fmodel= RandomForestClassifier()$ ]5 Z  L. g9 S$ t4 g; l8 d
    . M/ o3 }9 w4 B
    # Train the model using the training sets and check score
    0 T) ]( v! ?3 K6 {+ Pmodel.fit(X, y)
    & K% R$ \# s# N8 D: J9 J& x$ f
    5 ~9 z! O: ?9 ^3 u#Predict Output: N& D$ N0 J7 E3 c
    predicted= model.predict(x_test)- [9 G( S" v$ R9 k9 m6 X
    9.降维算法(Dimensionality Reduction Algorithms)
    5 p% j$ A2 G7 O, I- r1 q4 {( T在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。
    * ]& ~/ ?2 e2 a- F+ A4 j' S) f. {$ C. G* }8 S" K1 p9 p- h% r
    例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。
    6 @+ M9 z% x6 {: ~! V+ v4 _; A- @! Y& v: ?8 t0 I
    作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。; ]5 I4 c# ?6 s5 U3 S- z, Z

    ) V8 K# B! J# |8 s6 l( q
    5 j: q& i" `, a0 f  \#Import Library' W/ ?- F- O* T6 @1 Q" h
    from sklearn import decomposition' j7 y, Z' j1 H. U: A$ V! F/ J* {
    #Assumed you have training and test data set as train and test
    + V7 s$ {  x2 U  q% S) N# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)6 v. C; a( s* ?- y6 L
    # For Factor analysis
    ) t9 S( U" N8 C& i#fa= decomposition.FactorAnalysis()6 K/ {, `& r# q
    # Reduced the dimension of training dataset using PCA
    ' p# ~9 N4 [5 L) }5 t) B3 r* m3 T( S
    ! x- h) c' a; {- ^: [5 O; b$ ytrain_reduced = pca.fit_transform(train)/ }% A# Z) |3 E. x9 x
    + J. ^! y9 U' d" ~* \* A
    #Reduced the dimension of test dataset5 t# i, T! z& i7 x
    test_reduced = pca.transform(test)
    . J9 V& Q, F9 C2 x( w) g. x" ]10.Gradient Boosing 和 AdaBoost& v2 u1 _/ a9 D6 m4 I9 M( l! t# V0 d
    GBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。" C5 e, b5 S$ y7 P, H8 J# S! e

    ; K3 _4 w; L0 W#Import Library( o" d: o4 j+ j3 m6 n) D
    from sklearn.ensemble import GradientBoostingClassifier+ ~2 ]* {2 j$ A- S! i
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    # d. U  U5 C5 [7 L6 D# Create Gradient Boosting Classifier object$ e& c0 [' x, T) b1 j6 G
    model= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)3 A) E- H! H* F; p
    & P$ C3 h+ m# s) \
    # Train the model using the training sets and check score; @' Q. S3 H: q; P' u2 H
    model.fit(X, y)* c( Q" l1 d4 g8 C" u# [
    #Predict Output
    3 f: {. }, A5 i/ ^4 s& m4 }predicted= model.predict(x_test)) }' e: O& w4 C% h
    GradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。
    ! a; Y; h9 n) {0 M- x# K2 l  B$ R
    原文链接:http://blog.csdn.net/han_xiaoyang/article/details/51191386! w8 \0 R6 U$ A: {6 Q
    ————————————————
    3 a* C% U! R4 x& t版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    0 l$ W2 V) M8 u) \' h2 s+ i原文链接:https://blog.csdn.net/qq_39303465/article/details/79176075
    / [# L7 o9 k, l' H/ I7 b
    9 U# M" K0 h9 E% q6 Q0 O
    0 {$ _# |3 v/ K% P* T
    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-22 04:58 , Processed in 0.623369 second(s), 51 queries .

    回顶部