标题: 机器学习算法整理(内含代码) [打印本页] 作者: 杨利霞 时间: 2021-4-9 16:23 标题: 机器学习算法整理(内含代码) 2 o9 J4 U7 `# `' e. s7 j$ I 机器学习算法整理(内含代码) - S! z! \4 i1 W! F7 u, @! K4 _+ I7 [4 e, o# l
一般来说,机器学习有三种算法:: d3 |" r2 o! G9 d7 M& T; B' w
& Z$ l( J: S4 \5 A
1.监督式学习3 g6 o7 w: D$ f
9 G5 d) D- i: b" T Z1 H. @ 监督式学习算法包括一个目标变量(也就是因变量)和用来预测目标变量的预测变量(相当于自变量).通过这些变量,我们可以搭建一个模型,从而对于一个自变量,我们可以得到对应的因变量.重复训练这个模型,直到它能在训练数据集上达到理想的准确率 # f. m7 L. ]* {& C5 s 6 u' M2 {8 w3 p4 Z X) K属于监督式学习的算法有:回归模型,决策树,随机森林,K近邻算法,逻辑回归等算法 % b4 Z/ Z5 l# B# [8 v5 m5 Q/ J* Z. ~- p% P. z' g# k+ i
2.无监督式算法 - M' A) p+ }% j" }$ }' h1 Y0 ~5 f/ K; q, n
无监督式学习不同的是,无监督学习中我们没有需要预测或估计的因变量.无监督式学习是用来对总体对象进行分类的.它在根据某一指标将客户分类上有广泛作用. 1 b! I) S1 H! w( [ , \) V5 {4 H. M' M' }属于无监督式学习的算法有:关联规则,K-means聚类算法等* a6 e% `5 {5 o8 \: D3 H& K
0 s% k5 ?: `0 t x
3.强化学习" }6 v* i \% j& C% k, a: P2 N3 b
: w- ]& o6 W. R! u- I: j {" C \
这个算法可以训练程序作出某一决定,程序在某一情况下尝试所有的可能行为,记录不同行动的结果并试着找出最好的一次尝试来做决定! i8 M2 @/ z* v* S
- e7 _/ ~- E; z3 y: U2 t' Q8 u属于强化学习的算法有:马尔可夫决策过程% Z3 Z E! X! U! U
# K" o9 `% c7 S9 ^! x: ~
常见的机器学习算法有: : k, d) o; x5 `" c# ? E' i( f, b U% k1 b6 c8 T) c8 } B
0 T4 E* Y+ f. \- R/ |* S* M
1.线性回归 (Linear Regression) ' l1 [9 c0 }+ M3 J: U+ Z0 H: w, ]' P ; c0 x9 D: C5 u0 Q, C6 r6 E6 m2.逻辑回归 (Logistic Regression) 6 x7 ^: X0 E6 z' K* h4 x5 }' B" z; v o4 Z
3.决策树 (Decision Tree) 2 @6 H, P: R! r# G* l: c2 m7 X+ {) W 3 y1 q) k. _! |' p4.支持向量机(SVM)0 e% g0 H4 ]8 P, e
7 D7 v# y5 X ]8 M+ v5.朴素贝叶斯 (Naive Bayes) 5 @; T. b) g5 _- z" m6 y5 L/ J 8 l) ~+ V( A. M4 C8 k1 h& d, `6.K邻近算法(KNN) " p/ m+ d" F0 x# Z y4 \4 g. X6 e3 k7.K-均值算法(K-means)6 ~4 X$ g6 B+ {0 V1 S& c
# f! T/ c2 C, E8.随机森林 (Random Forest)1 Y' s7 v% U- f& y' ^! F
* T9 z( r/ ?9 z, L, O, o2 v9 f
9.降低维度算法(Dimensionality Reduction Algorithms) 6 U' i) r& A4 N8 K% H- o" B& f$ W( [: C1 l) N
10.Gradient Boost和Adaboost算法 # A8 @# A' G8 r s* j一个一个来说: r% U7 z# I8 U* k$ P y
1.线性回归 4 C& m; ^, H# M) F( _7 F" X- k8 T( K
线性回归是利用连续性变量来估计实际数值(比如房价等),我们通过线性回归算法找出自变量和因变量的最佳线性关系,图形上可以确定一条最佳的直线.这条最佳直线就是回归线.线性回归关系可以用Y=ax+b表示. : {$ n/ r2 F8 x* x6 ], h' e 0 p& M/ N5 a3 K$ p1 k2 @在这个Y=ax+b这个公式里:. ^" z9 O4 {+ U% a5 Y! a+ |& q
; G5 S' l ~6 X! I% h Y=因变量& }' V- x8 k' t
& z5 ?# p: S Y
a =斜率8 G% \" u2 b/ C# I' ]! i
2 }* `: r5 B, o! }4 A+ o
x=自变量3 [8 M, _# w9 r2 v# v7 l
' Y: @. z! z; I5 G! ?& e
b=截距 - L+ c7 r! \" S7 ]! I4 @ , o4 V% o. r& g U6 g a和b可以通过最下化因变量误差的平方和得到(最小二乘法) * i) \- C, R$ K& G4 N' ^) O( s8 @; F7 H
我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。 ) |) u; B7 Q' w: n ' j+ z1 G9 O* J& m; g C给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息. - a* f0 e }' X . {5 B$ M) ^& w7 o) U 6 @' ?% P8 _3 ~% X7 v8 \7 Z2 H: N% x; [5 H' N
线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量. Q! W/ X2 Z4 t* T* L+ @
7 g7 c% L! h- {% G
拟合多元线性回归的时候,可以利用多项式回归或曲线回归" Z) s/ Q3 l* L3 J
~( v) J; [4 o8 C" R# W- ~
Import Library ' J( R1 l' a4 |+ ^2 V! ]$ bfrom sklearn import linear_model; @1 X% B9 Q5 L
% {1 ]& g& T- fx_train=input_variables_values_training_datasets4 h" V/ ]% }1 h9 G7 k& K. Q
y_train=target_variables_values_training_datasets. ?# [, [9 r7 z z5 X! [2 v: V* }
x_test=input_variables_values_test_datasets 7 q3 ^6 G& `9 ]" ?8 W }5 d3 z8 M7 s" z9 u# Create linear regression object 1 ^. d) C: M& m7 {# N, {linear = linear_model.LinearRegression()) j/ x2 u, P$ b) l2 k
- [' B+ O* v( Z) V; M( o4 a/ B
# Train the model using the training sets and check score % ?& A4 F2 j6 m% J8 alinear.fit(x_train, y_train) 9 A3 X% ?3 {1 P3 H# d4 d9 {; Clinear.score(x_train, y_train)+ {6 S6 f; E; n0 i7 f; j
1 |- g j! w% w1 C! i- r" r
#Equation coefficient and Intercept: l9 o9 ?1 k, ]* y6 E6 c* s. u
print('Coefficient: \n', linear.coef_) ) j6 f' _1 k4 \+ N6 a. s9 \print('Intercept: \n', linear.intercept_) / {% n) e O% E* X. _2 }9 N. A ; X* L& p" U: L# F0 T#Predict Output - ?1 k/ U3 u" R$ y6 n N7 L y% d0 M& ppredicted= linear.predict(x_test) - Y. }! V' }0 _4 T4 V2.逻辑回归4 f* ]0 N# K H! u3 r
逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归! * X, t. P# {9 e9 k4 Z4 g* y% i! m& g! F* R
同样用例子来理解:3 v- e6 n- h# R, a. ]+ T
# v7 A9 t+ V% [2 h
假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。 8 `: w. T1 E! `; g 5 K$ O0 P3 o) O9 B% U: ?数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧 P l! x% a; i1 e6 y( l( X' F1 Z4 w9 M! v4 v& o1 \- H
最终事件的预测变量的线性组合就是:4 M/ k& x6 g- F& L" K
+ `8 Q( U+ O2 A8 n8 g& D5 q8 W" j, v, J- D: @% f0 m1 v
odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence 6 \" e7 {& O7 k) Z' i' z) ^9 v" A5 a9 `0 k+ [
ln(odds) = ln(p/(1-p))) l' \% j/ r1 s4 i! v
* o0 q Z, U. Z) Q8 Z( I0 P- x& hlogit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk & U9 P+ ^5 m9 E, C6 F: ?在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和. " i( ]9 d' S) n0 }* t4 ?0 j2 i1 |" m5 p% f. l& W1 K
至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法.9 X, A) t1 y& C5 g* M" u' D
" I7 Y/ `( A i8 O4 ^' A8 _
1 d. ?- l- o7 _- t7 y" k, r, {8 Q: a
from sklearn.linear_model import LogisticRegression 3 X$ C/ [$ e1 q3 k2 Q # T1 W) g M8 ~. q& S model = LogisticRegression() ( g) @, \8 C$ Y b1 g9 \ 6 X& Y; M* y9 _ # Train the model using the training sets and check score6 W( p0 X+ `1 z
model.fit(X, y)4 G* v* n g+ G
model.score(X, y) - c8 \9 Q1 t* {) Q3 S7 W( |; i3 y; y6 S3 y$ F7 E3 {$ Y1 s
#Equation coefficient and Intercept 8 P0 {5 Z# v& X: f: q; H print('Coefficient: \n', model.coef_)4 A% C, n$ z7 p. j7 B" ~
print('Intercept: \n', model.intercept_)0 g6 X" ^* f. w- w$ z
# A% ` a4 g0 \2 e
#Predict Output : { |/ y' {9 s predicted= model.predict(x_test)/ |! Z' w- I; |
逻辑回归的优化:9 a' i2 U3 ?8 F5 c3 ?
加入交互项" U0 h a* h) X; |) r7 l
4 l" p* H8 ^ |. N% v6 R2 m" @ 减少特征变量; v) B& s4 G- V+ U" _3 ]" s
/ ~8 G# A/ }7 p
正则化 2 j; w9 w* n6 }' p2 L% C; M' M; A9 T0 n A) }
使用非线性模型1 ]0 B7 t Z' q
4 V3 [ O# u+ o, \5 f8 N7 D3 _2 @3.决策树+ b" R! A3 ^( T3 |
这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。 ( _: K( Q& S4 D& N8 z9 C' }) R" M6 q% ~* d( _$ D
6 m ]* ^ h; \, m+ Q' ^1 m, a2 Q& M/ _7 P6 G& S
从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。9 s* s! M' T( \! K$ n
: g7 J3 H0 X. @5 L
; s2 b/ r4 P8 _
from sklearn import tree ' b3 {2 H( N' g* y3 J7 u$ @; ]& K3 n- v+ F9 o5 E* b% P
* D; v: Q5 g4 H, E# O/ L" Y
# Create tree object 2 F' \, @, k$ q
model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini 6 @" G6 Q% w) L( ~# Z
' i- v `+ P, @* U0 \ j, [+ ?" \% N# model = tree.DecisionTreeRegressor() for regression # y+ N* q6 ^, P% G( S+ O % v) z" D3 B7 } E3 V' m: _: p& a# Train the model using the training sets and check score' y @$ I# @ e2 Z% ?7 I, n
model.fit(X, y) + u* y3 g. @$ g& z8 W4 R8 ?model.score(X, y) R" v/ D5 F( Q/ c1 h/ l2 }1 K. Y: J
#Predict Output; b& |& p4 K# E: U, {/ C" _% p
predicted= model.predict(x_test)0 N' j+ B/ c: n0 B1 c( _. q9 A
4. 支持向量机(SVM) 5 }! ~$ ]9 A# h" D; k这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。 8 @) z& V8 n2 d; d- Z6 } / o: |4 G$ d5 L n6 i. s# ?# A9 V现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。 5 Q' C* \; y4 X: ]) |6 q $ j1 J/ D1 j- W3 b1 ? 4 U: J D# F1 }6 p8 y ) s6 X: ?3 W# @8 o+ ]在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。 ! |# f( l% A \! M2 B8 R& c, E - T. _- E, Q2 ^7 [3 A6 M" J4 F! ~( o#Import Library $ u( u0 J! g9 C, ]4 z' ffrom sklearn import svm 9 p$ O0 q# b; D7 w4 A* R) d#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset 3 o2 e" r) ^8 H0 K4 B' ~7 W# Create SVM classification object 5 S$ S$ W. ^! Y) G
5 y! d/ P! s) A" ], H! z
model = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail./ E6 P3 T$ R% E' M9 w
! T* o2 g$ H5 {: q; b3 o# Train the model using the training sets and check score 9 U. k' ^5 D8 j+ v+ C5 q2 [model.fit(X, y) & @5 V# q. y2 _$ i# vmodel.score(X, y)* e% _/ _, r8 s: S
$ t8 @/ n$ z7 y
#Predict Output2 E* H$ u& a, i+ u, o) m9 |
predicted= model.predict(x_test), a/ K6 \7 u1 a/ F( e8 s& |
5. 朴素贝叶斯& M$ r" j1 q' X
这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。 - L# {* U) u2 E % H8 m% G& u9 M$ m p朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。2 _! T/ ?* D7 I) y7 `
) j* B' _0 e2 a3 C#Import Library* G Y3 X/ a- }% \" u
from sklearn.cluster import KMeans 5 I7 n* _# l. o h& Z, o- S5 V! a: p- ]4 s
#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset % R! h7 S" R" W8 l: v* b( v3 D: g# Create KNeighbors classifier object model 6 f: H9 \3 B9 H7 @# ?
k_means = KMeans(n_clusters=3, random_state=0) ' K: g d. {4 K8 c% v( T) p- F1 r( Y! n5 |
# Train the model using the training sets and check score) a6 D F3 g0 ] S- y
model.fit(X)+ s' l5 T! w6 R2 b3 {
$ m+ V2 d3 s7 k' C* S#Predict Output + n# c. \$ ]1 |% e1 e8 epredicted= model.predict(x_test) : c! l" d8 Y+ e5 Y8.随机森林1 Z/ j) P; |" t; }9 B8 N8 n
随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。 * E, M) W& d4 \/ \& K) f* s, y) T1 U$ u7 x: P" o/ N, ~( Y' ^
怎样生成决策树:2 o- j& ?1 `+ T) @% ~6 B& b
4 L" A' T E# \" `+ {0 d- n' _如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。; J% o6 f$ n% p( f
: y3 v9 p; W% c* @6 S4 G. m
如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。 % y' _& m5 y* N' i. l) b. b; p3 J & E+ t+ w- k7 F4 q; H: Q每个决策树都最大程度上进行分割,没有剪枝。 ^8 j: v f: O$ B( M$ s/ S4 u- ^* c) b* u
#Import Library : N( d" e ]$ Ofrom sklearn.ensemble import RandomForestClassifier " q( } _7 Q# x: }; E; l#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset ! h b' f! A9 J1 S i, } * g. A& ]; |& i% r2 U+ m# Create Random Forest object% o! ]% `3 N0 L9 F9 L! Q# `
model= RandomForestClassifier() - x5 g0 A% B8 v8 w& u) D' c, j: N+ p) P7 b
# Train the model using the training sets and check score , z. i( _2 ]- H# vmodel.fit(X, y) : ^6 j7 j! r6 l" |: K1 ?. L1 J" } " a9 e/ p7 E% }" Z; i$ x( G#Predict Output - W. m& W" \9 B) y) Opredicted= model.predict(x_test)' c- w0 z% f; ?9 o4 H
9.降维算法(Dimensionality Reduction Algorithms) 3 | T0 h+ ]; H ?在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。 3 B0 N* y% i& Z9 f $ n" Y. z3 N( z+ ?* x" T例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。( X$ M5 o4 f1 V$ O
& q; {( t; h; e) V s
作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。 ! S1 R2 I+ N4 C4 A& K . u* `: C" |4 v; W% X* [) @ ]" n- |& f/ Y) d& g
#Import Library) |/ K* l; {- U' s+ L
from sklearn import decomposition+ @, C! |$ x* M9 W" w( h ]
#Assumed you have training and test data set as train and test& M6 s" V, q9 B+ ~6 f* n* M
# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features) - x2 H% C2 N- X' w4 ^5 i# For Factor analysis: g3 r& I1 s7 H" x
#fa= decomposition.FactorAnalysis() ' b: j3 ?9 ?! o" S/ d; B# Reduced the dimension of training dataset using PCA! [# L$ w% b% }) x& z$ d6 d; q" U9 i
7 |/ g2 X- b! d2 R# ]' B3 Z( Z
train_reduced = pca.fit_transform(train) ) v" ^9 L, E& J# V. B: ~, s" u, N, `. D+ ?: ^! ^9 j8 |
#Reduced the dimension of test dataset$ Q* X' p9 z5 ]$ x" v9 C5 [
test_reduced = pca.transform(test) " t) [0 A: F) u* ?- d E4 D+ z5 M) d10.Gradient Boosing 和 AdaBoost* i$ {; S6 [' t. E8 d1 ?; b
GBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。 % o* n4 E. W0 g2 F& @: ^( i1 O' W6 K" l& K' U- W
#Import Library7 @7 U3 |6 M2 }" {2 F: \6 W* w
from sklearn.ensemble import GradientBoostingClassifier3 v; |5 g2 s. W/ I6 Q
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset1 a4 s) O1 ~- W" I2 n) g: o
# Create Gradient Boosting Classifier object: F* X9 N; o5 z { Q% V
model= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)* M4 L. p9 i& K8 f5 {+ @* R6 A
" |$ Q2 ^! ^0 a/ ]% Y7 D) p2 c5 _
# Train the model using the training sets and check score - ]& z9 r- B& D3 I }model.fit(X, y)* R# E+ \4 m/ ]7 Z2 D( Y
#Predict Output# g2 o8 h$ e: L% d0 W
predicted= model.predict(x_test)" j7 A. E7 y8 ]0 K, e3 G
GradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。 # n% I- U% r' }: a3 u. E) O% M$ l" n* c4 {, G" U
原文链接:http://blog.csdn.net/han_xiaoyang/article/details/511913864 X5 S. C7 O% a0 i& _; k
———————————————— - ]- H Z) M' q版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。6 v7 A) ]' U6 [) ^
原文链接:https://blog.csdn.net/qq_39303465/article/details/79176075 * _: b' P$ J0 w, N ' N1 x, z: Q, ^# B5 a1 N N) B+ G7 A/ w* C9 w1 L% Q