) l( c3 p/ T) t4 P% B: L属于强化学习的算法有:马尔可夫决策过程 8 o0 r2 O/ `4 q r9 B5 u. K; @! n# n3 _- L3 A+ U2 y4 ?( s1 t6 N
常见的机器学习算法有:* U3 W2 D, h) T1 w
/ ^2 ]! I2 u, V: F9 Z + q. c: t: L1 f1 P+ B' R0 N- v! R1.线性回归 (Linear Regression) ! x% M- p/ H( I$ p, M" W ) g! {0 H8 W, K l, p/ w2.逻辑回归 (Logistic Regression)* j' H+ V* z' b
, u N: m' w0 R" Q" K5 P1 W
3.决策树 (Decision Tree) 0 `# J5 c5 o3 P2 t& d# t * l$ A0 F8 W1 m# K/ }9 M8 k4.支持向量机(SVM) $ L% q( g$ B' Q% {5 D' ]- n7 H ' |4 }6 a9 n# C; |2 G7 F; O$ X, ?5.朴素贝叶斯 (Naive Bayes)# U3 C+ q$ N. \! o4 \
! ~/ l( k' @# E# ]4 Y9 l
6.K邻近算法(KNN)& o/ E1 ]: a. G( C
0 F+ v( W5 o. e; Y6 L* ?2 [
7.K-均值算法(K-means)+ k+ {+ u6 e0 W0 s7 U
$ f2 X' s$ J" P2 I! _% G* ]/ O
8.随机森林 (Random Forest)6 }, ~1 V u7 b
" X, V! V+ {1 Y7 S3 x, w9 c9.降低维度算法(Dimensionality Reduction Algorithms) ) c7 Y$ V; y( V6 K5 i W. s8 A) {. ^! M* p8 I, I
10.Gradient Boost和Adaboost算法% ~/ E" i' B' o# p( O
一个一个来说: 1 x5 d% I# Z B1.线性回归 ! }. L) K( P! k. Q5 F% P H% z: l5 d% L7 g/ b1 k& O线性回归是利用连续性变量来估计实际数值(比如房价等),我们通过线性回归算法找出自变量和因变量的最佳线性关系,图形上可以确定一条最佳的直线.这条最佳直线就是回归线.线性回归关系可以用Y=ax+b表示.% ^3 y5 h S4 u% Z
( M# w. m+ r5 q: d5 t7 t7 W9 V$ k$ a在这个Y=ax+b这个公式里: " O& L8 \3 d, x4 {- F4 N* K0 v4 F q 0 x- V! ^ N- m7 T7 f Y=因变量+ A" F1 d# L# W
/ b" J: D H) d3 X a =斜率9 N# |: T d2 Q3 \' e5 ]% j
0 s) X1 ]8 V C- `" V& m( P; V }( v
x=自变量, q* d4 Q2 n2 o2 y
! `$ z" O- a" ]- {1 j; m b=截距 3 v5 Z: `' u( z. H # a& t9 u1 i1 r! w, s a和b可以通过最下化因变量误差的平方和得到(最小二乘法) 6 c5 d; i) u: S# b/ o' _" S! C+ a* e( X) w
我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。3 i5 h& x& J/ k$ i
2 y/ b" t, u$ P* S给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息.' c1 `) v. e' F* X5 C
0 {- o) a& p5 a2 s/ i% N
, L' m: n. l( M+ }" i9 I
5 w. s2 `& |: _; P- Q# e) j# Create linear regression object1 E. l8 w( y# Y7 Q* U
linear = linear_model.LinearRegression() , Z5 T2 x1 P6 B) G& @6 Y% D ]1 ~, W& R) q
# Train the model using the training sets and check score . h5 G8 N: Q; u# }7 x+ i& c# _0 Clinear.fit(x_train, y_train)0 {. b/ U1 u) z9 T$ z# u5 A
linear.score(x_train, y_train) & L' N- g' B- n* N: g1 W " m9 F4 ?! j1 H ~2 e8 [#Equation coefficient and Intercept: H% L5 N7 a: [0 [. i. k: M* v
print('Coefficient: \n', linear.coef_) 7 E. p U4 a$ N) \7 _print('Intercept: \n', linear.intercept_) 2 e. I9 \ K1 A# U9 T h' [+ d o; ~* R5 p; [
#Predict Output ) |6 y) \0 k( F. S- L8 V$ H- }% `( Bpredicted= linear.predict(x_test) : d& _3 N. H: X; y2 E+ b6 s2.逻辑回归) R$ n: t+ a9 C3 @0 k2 F
逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归!6 q9 I$ H4 f% k! F% c4 D
/ g7 Z. R+ E8 {% k
同样用例子来理解: % o! L* A5 ]4 y& j& o) w- X" k! U5 u0 J Y) P) q1 K; u8 E% y
假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。 . J, M5 S4 p& |: Y) B+ k$ L 6 U0 R9 n8 h" q# U数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧 $ u3 ?! u% @8 V* W% q/ _) d/ b: C, p$ T" [2 a. d* c8 q
最终事件的预测变量的线性组合就是: . r8 x" ^, ?9 @0 V 2 K0 }, o* `' B6 b; M L . m) Z: D: ?6 S# qodds= p/ (1-p) = probability of event occurrence / probability of not event occurrence : p$ x. n. _: e- g 2 R% Y( Y% ~6 s2 w( w. aln(odds) = ln(p/(1-p)) : _" j" F& D+ E6 X# D# ? T / F, E, o9 a( Q! ?" b9 ~logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk - M. ?3 W0 N# Y- w6 q在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和. # M' k# ^* r! E* Q . [! P6 ?- ~3 O* b至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法.2 B K% k$ I9 V$ e5 o& W
5 l: y4 f( t# r# Y2 v$ J6 b: N3 H - F3 m F" g( w+ _* b0 i2 }& Y & K, i& {! s1 O% f# q! J% s from sklearn.linear_model import LogisticRegression ( }0 R0 _6 X6 N. d( W; _$ \1 x+ N% f. @" ?: e
model = LogisticRegression()$ k* c, n( I5 Y- {$ q
- [6 m+ r3 _# }+ S8 ]. n # Train the model using the training sets and check score 1 @ P4 D& K- U* Y, _ model.fit(X, y)3 n& s5 }: s: }+ ]2 {1 ]
model.score(X, y)2 X7 e9 \% [: d6 m
, h! ?! U- r1 F5 P8 X. s #Equation coefficient and Intercept ; {' |' e* k6 C: p3 C print('Coefficient: \n', model.coef_) ) ~0 Q2 n7 E/ ]) q8 ] print('Intercept: \n', model.intercept_); `2 V0 A3 h* z; [4 Q
" ?; a/ O+ \& L- i$ B9 J/ \7 F8 A
#Predict Output6 }1 |" o( k# k! `5 ?$ Q+ y! A
predicted= model.predict(x_test) 5 p3 _# C! J; i7 a, c+ p逻辑回归的优化:# y- i9 C: l% j
加入交互项 & v' X; v) {, Q+ C6 d6 U, e: S0 X, M$ j) `9 k
减少特征变量% A' p& b' u- ]0 |3 T( z
% q/ m: L; r( f
正则化 9 L& V8 P6 K) ^5 |6 e/ G' q 1 |; B# W& M1 X3 V1 M0 ~6 [ 使用非线性模型& l9 ?+ Q# ]* e3 o1 B9 ~4 M: G
- w2 H6 S' [0 y) q: M
3.决策树 9 R9 o, q5 N/ t3 w! `: @5 m这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。( w$ j+ I, N# o" }/ j: n: u
! g) X6 p* \5 C: L) g3 E
! R+ D2 ]4 r% h' \: H- E
7 {" O+ m0 E& F/ C- k$ l4 P
从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。 ) N" x+ a' J8 F) R6 v, d ' U( K9 a' i- u: Q0 C: _4 m3 K7 J9 K & Z# Q# r4 ?, m' @) [4 o; ` a$ Wfrom sklearn import tree6 i& H( ^/ D2 e2 `8 U/ O) o0 K0 @
4 R$ U- q1 L4 ]) |! t+ l* j 1 R$ X: F% d" A# Create tree object $ z& o7 P8 h/ Y* b- |
model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini # [3 o! R) s: k- c- P
% x5 {) V# d d" M6 M
# model = tree.DecisionTreeRegressor() for regression % @ Q, j* A$ K" g$ d- X4 A& p( q; n- _9 e( h
# Train the model using the training sets and check score1 `& Q9 W0 _' a3 d( A7 v
model.fit(X, y) 3 `) h; n; i" J5 }( Q/ C/ U/ Xmodel.score(X, y) - E2 s: X, Y; i $ s$ A5 l3 X; H0 K#Predict Output 0 ?( c0 Y. O9 ?" N: | ypredicted= model.predict(x_test)6 j/ } l6 o: Q
4. 支持向量机(SVM), i$ n3 J0 K6 g% p5 d
这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。 Q: c8 S& g0 h6 F $ W$ O9 |, c8 L9 K' h4 P1 Q# V现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。7 v* X2 A* R% u) d
# ?: a! V( h O# ?
5 Q9 d9 q3 \) T1 G P6 y$ v9 V, X( ?7 W0 R在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。 7 ?& {) a2 l: h( ?8 l) l5 [ k h! A
#Import Library ~* Y) W- i0 ]- vfrom sklearn import svm 6 _# M3 p: k4 V5 j8 _# G6 e#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset % z S8 H2 Z+ f. v p: d# Create SVM classification object & s% ]3 h3 X) t+ I0 ]- d: s1 P& s* _4 ?# F ]: U! _
model = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail. , a* f$ g$ x2 s + r8 w1 r6 o( F1 m# Train the model using the training sets and check score7 u- F' Z: d {& ?8 E% j) i* P" ~
model.fit(X, y)% U9 o/ j4 k" U4 p K3 }
model.score(X, y) & z4 D+ f$ G0 r3 O1 t " ~0 {" g- W0 R3 U# l/ s#Predict Output" D0 F+ F5 w2 U) S# W
predicted= model.predict(x_test). ^9 v! b6 P9 [3 ]8 H" ]
5. 朴素贝叶斯6 F! `8 A4 Y% P) Q, \" X
这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。1 Z) a/ J" \% n+ O) q2 S* j
1 |; B& i- ?/ d8 f0 w8 D1 N在进行KNN前预处理数据,例如去除异常值,噪音等。7 f" s( o6 h d' s, e
& H$ |1 w7 [2 k* e#Import Library. ^6 v1 N9 i* q
from sklearn.neighbors import KNeighborsClassifier; g% D' ?3 j1 R: M* i$ ?" ]7 t
, K9 B) {% L1 J& q# [( O5 B, w* D#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset / a9 G; v: R( ~$ k/ M# Create KNeighbors classifier object model 4 \: G* x- R% [& \ / N- e l4 W3 G F( f# t* HKNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 50 b6 O7 C( `$ A* Q& y3 ?
% ^# V" w9 V: ^' B
# Train the model using the training sets and check score5 N( m* e$ k% L3 A/ ~: X _9 v
model.fit(X, y)5 `; `7 H4 p& J" e
. S/ w* t7 n3 k% r
#Predict Output" g" f' H3 ?+ J0 P4 q
predicted= model.predict(x_test)& u9 U1 \5 _' Z1 |/ ?
7. K均值算法(K-Means)0 m* L5 I7 b7 x/ ^4 l' X
这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。 & r4 a) N* _7 [, `( l% Q! m6 z8 H n$ p0 ]; V* _. C) l8 e
还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量!9 J& U7 A. {9 X4 o v8 `# o7 f
- c0 ~$ J. P1 A, G3 i- A# r( d
) F, v u0 h/ @: K
K均值算法如何划分集群: , ?0 y" l8 x n. L $ c( F3 G* P+ Y6 L `) l c # d: E2 y; _3 w/ X1 V* Q 7 `( T8 U1 ?) j! |: h从每个集群中选取K个数据点作为质心(centroids)。5 G$ j9 T/ n2 W: n
/ {3 m' @9 G* m H) F9 B* {
将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。 K; g! l' e5 R3 U2 L 5 N' a: k$ v7 D% W6 w% H- [# I J8 n. q找出新集群的质心,这样就有了新的质心。4 L+ r; X' q8 Z% g* `
8 p& ^3 r1 t- y% g6 ^3 G' P# Z0 u重复2和3,直到结果收敛,即不再有新的质心出现。4 z, G1 s" h6 S4 n- n: `' A
& N T' y9 g9 ~# ?" O
+ z# L% _6 m( D9 I$ p% E( H, }+ m& e* w
怎样确定K的值: + E" n% b! B9 Z* P. A& S" c) f5 R8 p9 E5 p$ W9 y) \
如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。 : ^) g m6 k2 @& x; n! o' l, o7 M; n) I# `) S A1 E( E' X0 T
我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。5 U$ m; s# F5 c' O/ X$ `
0 n+ P. d. i3 F" m7 r
$ I$ D$ w O5 x' J$ ?% j#Import Library8 p8 A! g6 S; D Y5 j
from sklearn.cluster import KMeans 6 _$ t9 z/ a: x" i. U d; ]9 r 5 [$ r E; m+ `8 a, d#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset' j' r# A5 f* H( o$ B% y
# Create KNeighbors classifier object model # H6 r2 e0 ^+ m# Wk_means = KMeans(n_clusters=3, random_state=0) 9 w3 v3 X( Z: | U T 7 y* E0 @9 W7 ?( j- N% ~# Train the model using the training sets and check score2 a# ]4 d& o) b/ t" l& _
model.fit(X) # l( x) n; t/ O# z. R; H4 Y' A% V8 _+ |9 Z( X
#Predict Output% U* ]9 ^3 w( n
predicted= model.predict(x_test)! o' b+ O2 o. O3 h! [- x1 m
8.随机森林 ! E Q# g6 R# `随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。 8 `) p9 p. k$ ?& p' X$ q7 o( ^& v3 g
怎样生成决策树: 3 Q6 G: d+ i; X+ L7 W' U8 T! o" L/ [" K% w% V' L% Y
如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。 . d; |8 @0 i" `) ~' M: ~6 a 0 q2 V3 i x+ T# F- o/ Y如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。3 a3 _7 i; L; F$ c! ~
+ t4 J, S3 @% |每个决策树都最大程度上进行分割,没有剪枝。 3 L) ?; K& G4 Z% H2 a1 Z ( ]/ b3 E" ~8 J2 I4 x0 p8 ?#Import Library * p9 P5 f) ?# P- Y( t. l7 efrom sklearn.ensemble import RandomForestClassifier ) ?2 P. a* W8 }: e: _0 s/ V#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset % ~7 Q% a* ]/ q$ H- _( o) H9 N/ x; t x
# Create Random Forest object5 V2 J- D, [- t7 q7 c
model= RandomForestClassifier()! e+ U, [& r' N/ I0 I
+ _$ i3 ~2 u: C" L' x8 ^6 G8 f
# Train the model using the training sets and check score 9 l7 u1 ]5 \! V; g( O; H2 R) Jmodel.fit(X, y)$ F% @3 G4 u" D3 A8 C' w4 f
* A1 U5 C5 n l% Y& o
#Predict Output1 M0 R- U* ?" p% F2 ^
predicted= model.predict(x_test) ; B& f2 ]! f+ @$ F9.降维算法(Dimensionality Reduction Algorithms) % V! ]" R( O" f5 e+ p在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。 9 w0 O! d; X8 p. k1 i4 i; H# J0 ^6 q6 k6 G
例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。 8 n1 H9 s3 q7 t( B( g: M: n0 \8 e$ \+ c/ Q i
作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。 ; T- K1 \2 Z, S1 Q' U2 u1 e% J. W
, g8 }) K: t/ F0 ~3 B#Import Library - }, `) k3 }+ p# |) Mfrom sklearn import decomposition 6 ]1 O+ v/ [1 ]+ V" G" l j#Assumed you have training and test data set as train and test; W6 \8 v% u- q. U' _& Y0 M
# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features) 2 d# O) a9 Y+ B ]& f# For Factor analysis2 w+ x" k& D) Q, }, O$ a) }! z
#fa= decomposition.FactorAnalysis() / y0 { r$ N* H# Reduced the dimension of training dataset using PCA8 H! U. K" }) Y' l2 F" ?
6 z' D. r( o- O% Y7 p/ ttrain_reduced = pca.fit_transform(train) $ V0 X" d. O, s2 ^3 n4 r% K% K8 K* f2 |% c" L1 f
#Reduced the dimension of test dataset# o7 H; t4 p, i8 R# x5 u
test_reduced = pca.transform(test) 8 o$ [) m, q. e; B10.Gradient Boosing 和 AdaBoost . N7 X, n9 D, E' y. EGBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。0 K$ Q' d5 j- u9 b: N
$ x6 X" A7 |0 R5 X#Import Library' \8 ]* \* R" p$ T# _$ Q
from sklearn.ensemble import GradientBoostingClassifier 9 F- u# j$ R) f4 C#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset0 j; f5 X' j+ q8 T+ U$ T
# Create Gradient Boosting Classifier object . t1 v0 }8 M" I8 h u$ G7 bmodel= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)5 T( D4 T% |+ k* w# j$ K; z6 @
+ E. q+ A5 q* {% ?$ T5 ^
# Train the model using the training sets and check score: S9 h- W" H% Y" C
model.fit(X, y), Z# M1 B) U' g( @5 `
#Predict Output8 H$ _8 I5 O0 M' T% {- A
predicted= model.predict(x_test) 8 G$ z% c+ p' ?% N% [8 h& ?% X6 RGradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。& x* T* Z$ N$ @7 k) E- H
I6 |7 F' [: d, n原文链接:http://blog.csdn.net/han_xiaoyang/article/details/511913860 L0 x# ]* R7 P( N$ c
———————————————— + j/ {* v4 ^( l0 H* Y! a" J$ c* Y7 M' f5 t版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。% w/ i5 B# J# _1 Q6 ]' c& l
原文链接:https://blog.csdn.net/qq_39303465/article/details/79176075 2 S1 [* x. o$ g1 f( ~ % K/ d: j0 x8 e5 o' f' O# G ) H: C# M0 s4 e& p1 M9 r