QQ登录

只需要一步,快速开始

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

    ! N) y  Q5 T/ Z/ v+ u机器学习算法整理(内含代码)  F0 F# q: l  O
    # H+ `/ F+ g2 G3 x5 i$ D
    一般来说,机器学习有三种算法:
    ) W) j$ q1 v4 v5 `& u6 E
    - C" l4 J* \+ z, P9 R9 q2 @1.监督式学习5 P0 B( J- q3 }7 [  `8 U& c2 S# r6 D( A% l
    & U% J2 _2 u9 ]+ T* M: J) y3 {
    监督式学习算法包括一个目标变量(也就是因变量)和用来预测目标变量的预测变量(相当于自变量).通过这些变量,我们可以搭建一个模型,从而对于一个自变量,我们可以得到对应的因变量.重复训练这个模型,直到它能在训练数据集上达到理想的准确率
    3 v5 S& K2 l  f2 K) p9 O
    0 c, E, @2 I$ I属于监督式学习的算法有:回归模型,决策树,随机森林,K近邻算法,逻辑回归等算法
    . `; }5 o; z% S
    , \# s  `$ }% ?$ W0 G' S2.无监督式算法, b1 m2 R4 Z: e$ r; C
    # g' u" H# B: q9 z: p  ]
    无监督式学习不同的是,无监督学习中我们没有需要预测或估计的因变量.无监督式学习是用来对总体对象进行分类的.它在根据某一指标将客户分类上有广泛作用.: I8 V  Q3 t8 u( p

      _, Y$ T, w0 Y' ^# S8 j( @1 E属于无监督式学习的算法有:关联规则,K-means聚类算法等) @5 N, o+ I8 u+ s! S

    " `6 v+ f7 K" }$ ~9 u, ?3.强化学习
    ( j2 ^) e) u' h$ K, n
    - F4 Q7 w) Z1 f. Q" p' f; x这个算法可以训练程序作出某一决定,程序在某一情况下尝试所有的可能行为,记录不同行动的结果并试着找出最好的一次尝试来做决定9 a1 I' G' c" o: m; A

    1 u% _7 r$ s& d+ H4 R9 X属于强化学习的算法有:马尔可夫决策过程
    1 T% \  U* \# Z
    7 ?- K) r0 }; B常见的机器学习算法有:
    ) b) f& g3 y4 V) _
    & e* y7 v1 h% I2 f: Q( [  v, b( r. \% W. J
    1.线性回归 (Linear Regression)
    ; @& c+ R+ L3 b4 B+ J, Y
    ; g6 r6 t0 G) e' I4 {5 ?5 x8 c* g2.逻辑回归 (Logistic Regression), P! c+ A" g/ g# z* D- D

    0 J) z  D  b- o2 F& }3.决策树 (Decision Tree)9 ?! ?, y" \2 B! o3 O9 y4 G2 q8 d

    + x5 T, H( u6 W4.支持向量机(SVM)
    + s( G. C7 q0 j% V- k5 z4 P
    8 `+ ]! i1 A# C' |4 `# X9 d& w6 F. g5.朴素贝叶斯 (Naive Bayes)
    6 y, x3 m- P1 w. N+ c% ~) {& z2 u% F+ ?4 S% c) g; @5 O6 c
    6.K邻近算法(KNN)
    1 L% S1 \3 \- a( k( k; k" p% Y
    , ]7 D* S# r/ F' F+ E( f) m8 t7.K-均值算法(K-means)
      |: S, E1 w  y/ s9 x, F6 S# v
    . ~. @/ R1 E- `) D8.随机森林 (Random Forest)
    * u' K  y3 |/ R: L9 v! V* H
    2 l! r8 W% ^! }* V8 Z3 b5 D8 v9.降低维度算法(Dimensionality Reduction Algorithms)$ s# }+ s4 W, m3 w8 U+ M' ?

    ! I/ d- v  E* u5 S4 t10.Gradient Boost和Adaboost算法
    # V$ S8 @, i; ]9 S0 S( w6 d' f一个一个来说:
    / R5 x1 t0 E( d( S& ~9 w1.线性回归
    2 N7 d* T& z1 k- K  _( M# e. v7 N; w8 `( G. ^8 V
    线性回归是利用连续性变量来估计实际数值(比如房价等),我们通过线性回归算法找出自变量和因变量的最佳线性关系,图形上可以确定一条最佳的直线.这条最佳直线就是回归线.线性回归关系可以用Y=ax+b表示.
    . K, A" T4 t; t2 N2 B# t/ [7 q; e: ^9 }) U
    在这个Y=ax+b这个公式里:: o# O2 i/ g! p) l$ i  c

    $ j' y: D' \. @& q1 m& g; d& u Y=因变量" t  N4 H* d7 o' }6 \# U/ Y

    2 x$ G" h- w$ v a =斜率
    ' \4 w, c! \4 Z. |1 }  v8 n5 R: K/ H) n/ }+ S( M
    x=自变量+ G# S8 P/ m3 a  w

    " k+ B  O! p! N: U, l+ ?  ] b=截距
    2 C0 M9 c# u. w! H
    , P3 T3 @, W4 y6 z, `* z a和b可以通过最下化因变量误差的平方和得到(最小二乘法)* ]. P' D8 {/ E) c; h: D9 P( h

    + c  e( K/ M7 ^  F我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。
    1 h  Q! {9 D* _6 `' s+ _
    6 Q0 n* f: r+ D# v6 ~' Q给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息.
    7 U: d4 _# k8 y9 y% O0 m7 n2 D7 U' ?1 ]$ o% n

    , A1 H3 Z2 A" s/ `- z# A3 Y! C8 V% D4 G8 {
    线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量.1 n5 ~; h1 U& B9 y3 b
    ( h, p5 B9 n4 i
    拟合多元线性回归的时候,可以利用多项式回归或曲线回归5 D1 d+ v  H7 B  ~( ~) d2 R
    : i4 R6 _& g; u. T" X
    Import Library
    5 g. R: C1 i( l4 I. m) jfrom sklearn import linear_model- `1 x; {) A# ^
    1 U9 T: f$ j! o0 X  H( E: c! K
    x_train=input_variables_values_training_datasets7 l' ^+ G& ^& ~" @; V$ w" D8 |$ X# L( }
    y_train=target_variables_values_training_datasets
    * `( P+ m% S9 t' g7 z8 ]x_test=input_variables_values_test_datasets& U& w5 E& q5 ~  w+ o+ _

    * A2 [7 q1 q- V1 I$ g5 M# Create linear regression object
    3 O- Q, i3 c0 z  e; ]2 Dlinear = linear_model.LinearRegression()+ _* l' f) z# f2 s. J
    8 ]$ I! K: O" u4 \' X8 `& z0 g# F
    # Train the model using the training sets and check score
    3 E7 J7 R' y6 ~9 I0 ilinear.fit(x_train, y_train)  n  A" x0 T7 F- ?7 Z
    linear.score(x_train, y_train)
    & O: x( n: i" D4 I4 z/ _( a" l2 V' o$ C
    #Equation coefficient and Intercept5 D+ R) C( I5 q! O
    print('Coefficient: \n', linear.coef_)# X  D) p+ a' E5 H
    print('Intercept: \n', linear.intercept_)+ O. C' ^9 n* V) a

    : h# V( z9 F- j, F2 U#Predict Output& O' q" X0 m% d* q$ U8 O
    predicted= linear.predict(x_test)5 q: l" [, W) k7 C' Y6 u
    2.逻辑回归! m4 u: s1 q! V+ ?5 t
    逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归!
    + T5 y0 N4 t0 s6 {; G
    , A! o9 E9 q! ?5 L9 K8 f7 ^同样用例子来理解:# T/ S, M( C5 t+ ?6 r$ L# ?: v7 }
    7 ?! A( a$ u/ v, P
    假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。, Y) t+ _% L& `5 b( F* \

    - T+ @" M2 R" \$ m! v数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧3 t1 z1 I) q# z  H1 ?
    0 M1 V7 a* l& h0 E/ Y
    最终事件的预测变量的线性组合就是:
    & j+ O( q; s6 x1 ~$ X1 H
    * u+ O# _9 v: k% `* F
    4 S* `- X$ m; a, sodds= p/ (1-p) = probability of event occurrence / probability of not event occurrence7 }2 e- Y/ z; {3 F& k
    9 q$ Y4 n. A/ B
    ln(odds) = ln(p/(1-p))
    + f8 f& f: ?& O( L/ f2 p# B/ o( @1 o
    logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk
    6 L% v! b1 q/ d! }在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和.8 k7 o3 k" U' s( q- c7 y$ s8 F

    & s/ J8 [+ @* R, E至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法.  {, k7 L" G2 ]( @  i' C: m

    " F- V$ d1 C  L8 l2 Z+ x: A* H8 |" m5 w; W( A  I% h

    % Q; k$ c- s  U, o- e! f7 ~ from sklearn.linear_model import LogisticRegression
    : {& n9 H% T" N" |  ^4 A: p: `$ e: G' S, w* P
    model = LogisticRegression()
    " ]2 d4 f2 F" l
    / C7 ~2 v9 F. K# { # Train the model using the training sets and check score
    $ z$ r* X) y+ t8 {* | model.fit(X, y)
    % c9 r/ h* q! j: b' i, ~ model.score(X, y)
    0 h: y8 u! X  q- t' W/ K" C, z# ]& G) k9 m/ Y6 q/ K4 z6 m
    #Equation coefficient and Intercept
    $ i  t- O* U& }6 u# | print('Coefficient: \n', model.coef_)
    + p8 b& e% _. m; m0 E4 s+ B print('Intercept: \n', model.intercept_)
    1 t/ ?! R& f+ y9 h8 b+ g/ ?" ]5 c7 P/ H$ C- o* v
    #Predict Output- W/ [' q, m6 Q% y
    predicted= model.predict(x_test)
    8 z; n( T3 g5 g+ S5 |( F* z逻辑回归的优化:( ~# c3 M5 ?' {1 h$ N! o% ~* x
    加入交互项& f$ ^( X& R* E8 Z8 c, J. B

    ' I' r& W$ G, G+ a/ U* s  减少特征变量$ e# g$ }" [8 |' k
    ( @# R! q; y) n) Y' [0 ?) a, G% K: U9 r
      正则化
    - l& h7 R) X1 G8 p7 W; U- J$ u) P  j' Q& ~5 K% T/ l% T
      使用非线性模型% P) X6 k  B2 P3 m

    7 b( t5 B4 o" B; o  h* l2 j3.决策树6 o7 R, b" }6 O" ^/ r
    这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。
    - n$ @5 }3 Y, g) d$ t4 G
    9 U$ X9 ?5 q4 ]5 ]& ^) z. {% A
    4 c9 U+ g# i, ?4 A3 S
    % U7 P1 ~. a2 O, l从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。# \+ c! U& @2 Y% Y1 s

    + C& O- l6 f/ I+ S" L* \5 ~0 d. |8 q6 a3 w2 ]; |& l. Z  ^
    from sklearn import tree
    3 _- D4 Y0 e+ J2 T, ~
    , O9 j) c# t" `
    ( w3 a+ k$ u* J# t+ E) e# Create tree object
    " o$ c8 M* J0 `/ Y1 Imodel = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini  . t8 m' T' J9 a6 s; ~1 e

    0 O6 Z! p. R6 B1 U# H# model = tree.DecisionTreeRegressor() for regression
    ; v, |0 _: f* K9 \. l6 o
    8 L2 F) @8 @& E2 H/ L, `* y) v# Train the model using the training sets and check score
    9 F) ?+ F  G# y' {. ?$ umodel.fit(X, y)
    $ z  t+ j" |2 s  k8 N' E" Rmodel.score(X, y): t! o2 p/ l0 g" R# \1 d. n+ p

    $ w% x4 ~; A- b& W& g#Predict Output
    , U* S! @8 S9 a; O- k: {/ Jpredicted= model.predict(x_test)
      v4 B. h, d- I- k9 H: i4. 支持向量机(SVM)
    ( k; `0 v7 T% ]4 j- I$ \这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。3 D/ e, {. n8 j1 u

    ) \1 t0 {/ k* `7 m4 I' n: B. O# ~现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。4 L( J' Y% X( x9 m& r

    ) @9 l) z8 _; U0 X7 m) z
    6 ^& @& j2 S& i* N: F' W, O) ~" {* u9 H8 q* ?7 @3 c% b) U' ?
    在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。
    2 J0 D1 W+ t  c3 {
    , I/ w; a' s' A- a  ?#Import Library
    8 `  L8 O* B7 d3 Q% t3 l) Tfrom sklearn import svm
    , b$ Y! Q) U' J6 r5 J#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset0 ^5 d' U2 j9 J. ^- {
    # Create SVM classification object ' g! F, H3 _$ f, {0 b

    0 C9 r% E, S* y( O- ^8 n" ?, F3 B5 dmodel = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.
    . j# R& w/ j/ U- L, `" ~1 |# _" S2 P
    # Train the model using the training sets and check score' r- V- B* ]6 e! H
    model.fit(X, y)
    + Y1 t/ U( x7 _! F+ umodel.score(X, y)
    7 R" U3 {. e+ ^6 k% u2 |( |# B! n# Q3 f2 S+ c7 l4 L
    #Predict Output# P& h1 L. I. [1 [' P7 Q" U" F
    predicted= model.predict(x_test)
    5 h, a# A8 S& r* O/ X, Y2 k2 S5. 朴素贝叶斯
    7 M8 A; I5 G' V- v; Y这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。
    8 _7 ^: S& f' v
    9 y# V, a6 ~# d朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。- |' n! J4 W2 W$ r1 U

    * m( v+ h0 J' s. b# W, e5 z贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下:
    # r/ q- z/ X) `- _0 V3 t, w" Y( T& u8 u' k
    & `: M8 Y4 g0 k- n
    P(c|x)是已知特征x而分类为c的后验概率。
    1 R8 b* \( S2 r# n2 z6 |
    & s4 b! k0 |: mP(c)是种类c的先验概率。
    # g. H$ S3 C% F, C/ r$ i9 r/ {& b( V
    P(x|c)是种类c具有特征x的可能性。
    7 K) ~, t, S( L% i, M
    $ J9 E3 D% I4 Y- a( N7 @P(x)是特征x的先验概率。' G7 J" C  B. N  K2 J) I

    + x7 Z  W  Y% {$ |, Y" S$ s" K$ R4 B& i- F& v$ I2 O' f
    例子: 以下这组训练集包括了天气变量和目标变量“是否出去玩”。我们现在需要根据天气情况将人们分为两组:玩或不玩。整个过程按照如下步骤进行:& J$ W% l. F; y: u6 U& t

    4 P" [# Z1 N$ q) G' ^1 S. e步骤1:根据已知数据做频率表
    - z, `  B3 A- }0 Q3 o* C3 g* }% r+ N. |/ Z& w+ }; @, g% }
    步骤2:计算各个情况的概率制作概率表。比如阴天(Overcast)的概率为0.29,此时玩的概率为0.64.
    $ u1 T4 [: M3 k' R" p2 y9 U! U% ^9 G' D/ Y; z8 i

    & }2 m' }! b* m* T7 p7 d步骤3:用朴素贝叶斯计算每种天气情况下玩和不玩的后验概率。概率大的结果为预测值。
    ' d# `! n. ^6 a9 _提问: 天气晴朗的情况下(sunny),人们会玩。这句陈述是否正确?# }! R" r- S6 S; v5 s
    4 M4 S! m4 ]; u' n/ E" c8 M! S
    我们可以用上述方法回答这个问题。P(Yes | Sunny)=P(Sunny | Yes) * P(Yes) / P(Sunny)。$ }; P: M; k( F9 V" \/ {6 X
    2 }$ G* {2 T0 _# r  j( \! ^, {2 c$ O0 N
    这里,P(Sunny |Yes) = 3/9 = 0.33, P(Sunny) = 5/14 = 0.36, P(Yes)= 9/14 = 0.64。
    $ J& z) q4 B7 f) n& E; ]
    . O+ ?- E. ?  d2 z, t' O那么,P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60>0.5,说明这个概率值更大。: U' Z3 a! ^! s0 x  R

    7 }. l" U4 g& B* N! P当有多种类别和多种特征时,预测的方法相似。朴素贝叶斯通常用于文本分类和多类别分类问题。) i# y/ C: g. |2 ~5 {: |
    5 A- W+ g$ v2 {* K0 ?
    #Import Library9 C  |7 t( r; ]0 ~/ ~
    from sklearn.naive_bayes import GaussianNB/ A7 w9 A9 b  e8 M# v2 U$ z7 l
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset8 n% Z* o3 }7 b: r# t% a! [$ t3 d

    7 S4 H1 P3 ~& J# \) L0 d5 s3 v/ q& q- d/ l8 l# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link
    9 G7 J: B2 z. Y6 j5 i- G- v/ d7 ?2 k/ |/ i$ h
    # Train the model using the training sets and check score
    0 C: p  [+ v8 V, g: Z; hmodel.fit(X, y)
    - N. x: E; G+ C' G( m5 y) q# Z8 x) i' q* r. n3 k
    #Predict Output  {& u  \$ P% v% i
    predicted= model.predict(x_test)( {# r( y* R2 q: e% G
    6.KNN(K-邻近算法)
    $ I* R9 {) Y: B: C, N6 o6 E; Q) ?这个算法既可以解决分类问题,也可以用于回归问题,但工业上用于分类的情况更多。 KNN先记录所有已知数据,再利用一个距离函数,找出已知数据中距离未知事件最近的K组数据,最后按照这K组数据里最常见的类别预测该事件。
    1 j8 s# W8 |; H  b6 G0 E' f2 N9 _/ A0 L" O
    距离函数可以是欧式距离,曼哈顿距离,闵氏距离 (Minkowski Distance), 和汉明距离(Hamming Distance)。前三种用于连续变量,汉明距离用于分类变量。如果K=1,那问题就简化为根据最近的数据分类。K值的选取时常是KNN建模里的关键。) e- H( U/ E$ Z& f
    ( D- h9 K7 u8 A& Z* \" j+ ^8 |% U8 U

    1 n' D2 i% o0 y: h2 M5 f3 E5 M
    9 z& s0 |4 x/ HKNN在生活中的运用很多。比如,如果你想了解一个不认识的人,你可能就会从这个人的好朋友和圈子中了解他的信息。
    * x7 j/ M2 T' l- S
    ; M3 _+ d  B: o7 ]$ M* W: z2 N在用KNN前你需要考虑到:: z$ P  P2 d% q( V, D  ^

    4 ^; q: m6 d3 H* E/ u  ?KNN的计算成本很高
    9 @3 a: E4 x9 G! W! v1 \; _+ K( C/ b, `1 ^/ t1 v
    所有特征应该标准化数量级,否则数量级大的特征在计算距离上会有偏移。& `/ Q% \/ m. s  }

    4 P+ I! H. l( k" Y, w% q. M( S7 R) j在进行KNN前预处理数据,例如去除异常值,噪音等。
    ( t% N2 i& N$ N8 W% k% r  a2 U6 V+ [) Z5 d  R
    #Import Library
    2 R0 n! d* |% Q; S% |: sfrom sklearn.neighbors import KNeighborsClassifier
    1 ~: \& O: H/ i7 X9 A
    8 p, [! K8 r. G! O#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset9 u. k' x. W0 L
    # Create KNeighbors classifier object model
    7 U$ T2 ~; ?) n& r+ K- n4 O/ j2 Z: ~2 U2 s2 V
    KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5
    & c4 s; O$ j8 c+ m% K6 L; n0 J  D- V2 v5 B
    # Train the model using the training sets and check score7 L6 U3 D/ y- o. G6 W7 D
    model.fit(X, y)
    ( |% W! l4 |$ }  w  V2 N1 S* w* D' Z
    #Predict Output9 O3 {: v1 H" r
    predicted= model.predict(x_test)" g# \5 n, i5 W. j
    7. K均值算法(K-Means)2 f! b4 E3 M9 _
    这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。
    4 {7 L5 l% U9 ~* [' _, U. P
    , f( H0 B' E) _- m7 {还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量!5 F5 l9 k& i5 k( d  U

    " {9 _! e) D$ Z4 j% n8 Y, h  N+ o& N) e: L' E  U
    K均值算法如何划分集群:  ?4 h& S4 Y, r7 w1 [

      l; ]8 W3 C% W9 c9 B8 R3 @' S- w, V2 m

    * t% Q2 O3 _; l% n% B% ]/ m5 b从每个集群中选取K个数据点作为质心(centroids)。
    : E, ~6 T. \2 w3 y- ^
    - o3 R7 H8 }. K' e0 v# f* K将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。
    ) S  Y8 n0 S# c) o( x
    & y! H; @, m+ u找出新集群的质心,这样就有了新的质心。8 r  X9 n" U7 L. S5 |  b

    / c$ s6 H3 U. z; N8 r; m/ F" o重复2和3,直到结果收敛,即不再有新的质心出现。7 b7 ?. H" Z% `- X9 C$ T

    & I; Q: L$ X) j+ ]# h( \7 O( M" j9 n5 O5 h6 b
    怎样确定K的值:
    0 s$ b) x. p1 \6 _6 h0 w9 h; A4 Q0 l& T3 Q2 F1 _( f
    如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。
    3 y6 y& T7 N; K9 \; k/ b9 x
    , m6 L4 O4 N3 l! Y1 ~' E我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。9 Z+ P8 ]* T  g1 _6 l' k

      J, j8 T6 z8 R) {/ y! H2 y: n
    ' F+ {5 I7 C2 i" W, N#Import Library
    - W& s4 \3 N! @from sklearn.cluster import KMeans. h  A( z0 P( R, M4 T0 `
    " A& h# Y& Y1 ^  A5 K6 L
    #Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset
    6 b; j9 B* l% F6 A; s' z/ |2 [4 X# Create KNeighbors classifier object model
    * W) C/ [  M4 ~- Rk_means = KMeans(n_clusters=3, random_state=0)
    , B  q2 H) Y/ y2 C2 U3 j* D+ g
    9 T, w7 Z. {: S& g) g# Train the model using the training sets and check score
    6 S* O3 P# J& c) f* A  e# `* ~* `& gmodel.fit(X)
    ) |* z6 u+ l) D7 ?1 l
    $ l, l# o$ k7 c" n8 }9 u: A. L#Predict Output
    8 e1 X, ~3 r9 b# Ipredicted= model.predict(x_test)4 t0 _1 Z3 b9 f$ A
    8.随机森林: |% \& W- r. V
    随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。+ T) x5 S9 i: S6 o2 E
    6 y0 ~9 J0 q7 e( A& d$ g
    怎样生成决策树:3 v0 r2 E5 A% P& L# v) R

    2 V. l$ z9 V, D( G+ a如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。" o! F8 E% I; Y2 i4 D5 f

    % q3 e# T1 B1 M* I0 ?7 n# P3 _8 _. w如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。& c. V# K  _/ x1 f. R5 m  J; y7 E: i

    ! t! f) K9 {3 {* M7 y; k每个决策树都最大程度上进行分割,没有剪枝。
    4 ]- z: x. w7 T7 \' U) w4 U' Z3 p& d
    #Import Library$ _& d4 e* J7 e3 ?4 j1 F
    from sklearn.ensemble import RandomForestClassifier/ p! S) ]- X+ X+ {1 D7 Q  i
    #Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    7 ?/ v0 d% N2 K- Q) g: X) \' ~7 ^( i4 X1 b  ~  p
    # Create Random Forest object9 p  G. Q9 p# u
    model= RandomForestClassifier()0 {: y6 e3 G8 B4 J: n* ~

    , f  ~7 b, c: W# S  s$ F8 ]# Train the model using the training sets and check score
    4 }/ r: T/ v, u4 w& mmodel.fit(X, y)8 o" ^" w/ x0 P7 k1 }6 c

    & t7 s% v0 \) A4 l# h; F1 c9 H#Predict Output
    ' Z& @" z. W1 v, ?% \6 \8 I+ `predicted= model.predict(x_test)1 \# H! F1 H- o% j9 `" ]
    9.降维算法(Dimensionality Reduction Algorithms)" q# Y& ^- J' v6 I8 |" o
    在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。
    0 ?; @* y+ _" i( `
    % t/ _. S1 j9 J例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。  g' n9 X9 R5 _% q' |0 s

    1 @9 q8 g7 V* c+ U+ M作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。
    . s: H* @/ j, {( P  T& J7 O, Z
    & e1 P  ~* Z. z$ ]- l1 y! H* H; u1 A
    #Import Library1 S8 @# j2 n% w/ x2 C( q7 y
    from sklearn import decomposition6 m4 Z+ b% U* u+ K: V
    #Assumed you have training and test data set as train and test+ e7 N/ o3 {% C- J5 `) \2 L
    # Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)2 m0 X: p% O# V8 p* Z$ _5 q, f
    # For Factor analysis
    1 x2 R9 [3 T2 r& B* G#fa= decomposition.FactorAnalysis()5 k) L# q2 ~9 `( Y2 K  @
    # Reduced the dimension of training dataset using PCA
    ' f, B+ O  Z# D. m# u- s6 N1 ]" H* k7 b( J+ m
    train_reduced = pca.fit_transform(train)
    ; Y3 B: P% B' `) x' C6 ]" E/ a7 s9 a: a
    #Reduced the dimension of test dataset$ K+ D2 E8 W+ n: M
    test_reduced = pca.transform(test)
    ( ^' P$ T, g5 ~/ J: C10.Gradient Boosing 和 AdaBoost
    7 w) u# n3 i" h  w/ g! lGBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。5 {6 s1 ?% M& e- K; G
    0 ~% S: f; L/ _/ V$ v% o) e+ e
    #Import Library) K7 s+ h& U* g5 J
    from sklearn.ensemble import GradientBoostingClassifier
    / |% C  e+ z. h' u6 z#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset
    8 P  P( c& Q% }& o6 e# Create Gradient Boosting Classifier object
    . h+ H: J4 k: A0 v) U6 F$ omodel= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)
    / G: r8 X: a/ w6 m) z. b( i- w0 A0 V7 q1 N" \
    # Train the model using the training sets and check score. a$ ]& d; B/ N+ H( C7 z
    model.fit(X, y)+ J5 Q7 v$ K3 s/ x
    #Predict Output
    + f7 X( F( H: @( Rpredicted= model.predict(x_test)  s5 b- B! e  e8 Q
    GradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。
    - l; D( c& J' U/ K( t' \: [; r
    5 h/ I8 j' Y1 y9 `原文链接:http://blog.csdn.net/han_xiaoyang/article/details/51191386
    3 u( B8 e6 @, {9 o/ e+ h" N————————————————
    1 i7 X+ W& D' q1 m; k* m版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。! r' N! j  p# b) U$ C$ m! E
    原文链接:https://blog.csdn.net/qq_39303465/article/details/79176075
    , ~, S% K4 p/ d) q( R
    6 M" W& l- x+ J. B1 l# Y% A1 i
    # |' T2 h7 d6 ^* Q" o! W
    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-6-10 02:26 , Processed in 0.395432 second(s), 51 queries .

    回顶部