4 x( F4 G5 y) d" k8 V* G' L Y=因变量5 P: w, t+ P0 f) u, B
Y& j- B8 c2 }( [; _
a =斜率 ( a, T+ Z( _) E$ s5 |" ]% A4 c, h) M5 l
x=自变量0 w" R; m$ o& k2 g4 F
5 a! m, ]! J1 J% Z: v6 d
b=截距 9 ~$ C5 \! d' }. a& a1 x% O1 N & A* U9 \' r9 ~+ v. P+ G a和b可以通过最下化因变量误差的平方和得到(最小二乘法)& r5 {' R( R& x( e+ F; O
6 \3 O2 `( u) K+ z4 B
我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。* n. Y* s5 U" j# B5 [- N3 k1 M
, l; V2 q" \6 Y# B; s. t给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息.+ h. m$ K1 T; B7 I7 \$ s6 O
' K4 [+ Z0 U8 u, @4 x* b
8 O; r- T+ N. Z; k& k7 ~0 `2 \! \- M! g7 {" Y" y
线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量. 5 v$ N! J. {# }; M2 L# f3 F. h3 F, c7 f: n) P: P+ a' N: K
拟合多元线性回归的时候,可以利用多项式回归或曲线回归2 b" Q2 `5 t. _6 r
7 ^5 D8 V* o; m; Y' t1 u
Import Library; y+ d) _! u+ t
from sklearn import linear_model: m. o6 ?+ C0 y; k. T8 i0 v' R% C
1 H+ ?6 W3 d. p
x_train=input_variables_values_training_datasets- _# G. b" u& H* o1 E. D% B& T# G
y_train=target_variables_values_training_datasets9 d% [& f5 {: J: G) K" S- B: N
x_test=input_variables_values_test_datasets ' r/ x6 \, Y6 `$ y! K, ~/ o2 G1 t( ~/ _* `
# Create linear regression object 9 b6 u h1 V( i- c4 Slinear = linear_model.LinearRegression() ) C3 b- R0 k. `# Y6 a6 s& q4 A# S4 V
# Train the model using the training sets and check score8 t S. o* G" T1 x
linear.fit(x_train, y_train)& f9 [! `& ~$ |; C
linear.score(x_train, y_train) 9 y# w7 A% h( t8 l1 ~* c5 e7 V7 ~) G# U* c6 r
#Equation coefficient and Intercept% S' M6 G& U9 q3 l1 O; r
print('Coefficient: \n', linear.coef_)1 T! p4 g" j2 a% C! C1 t
print('Intercept: \n', linear.intercept_)( W+ G, [& m# v" w/ N
$ g. _' @8 X! Z#Predict Output. F( A/ E6 K3 v& {
predicted= linear.predict(x_test)% ]# |" V) s h" k
2.逻辑回归: S5 K7 J4 O6 e
逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归! : ^. e' Y1 W0 h" i1 R9 n) ^8 y( L1 M- t$ C! F* N
同样用例子来理解: $ t- }7 q; k% s( v9 r. I9 M# ]4 _# m3 |9 q( v
假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。 0 [6 h6 e( D: p2 q) b* S" Z( \ 0 G9 d( s# b* t# P. j8 Y: p# U数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧% p3 v1 J9 E( v
0 f3 J8 G& ], ]( C8 c6 h7 s$ g$ A9 Z最终事件的预测变量的线性组合就是:1 E i% w/ @* V m) f. l
. _" F# |1 ^9 C( A* s 8 h6 b5 C# c! ?. F# i xodds= p/ (1-p) = probability of event occurrence / probability of not event occurrence* r. ^+ _9 w/ m. H+ p# {( g
' }# V" m; S: L9 [3 i
ln(odds) = ln(p/(1-p))7 E0 M V* O1 p3 b' C4 Q; |
, |3 O; O4 v( n9 r9 X6 Z2 D
logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk" X* V! \! K) ]9 H
在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和.3 ]! g; X- z# \( X5 H
$ @$ R* ^3 Y7 W8 X7 I
至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法.8 w( T" H4 e. h. v
# ^' u' U: [, Z% ]5 q
- Q2 A3 b: I5 e, ^2 d- K
' T0 A- _7 Q3 F$ A4 _ from sklearn.linear_model import LogisticRegression " t" [* B% |+ B/ |& H& K( z" P# l 0 X/ ^* y8 \6 y2 o/ @6 \7 j model = LogisticRegression() 4 `9 Z$ A# ?* [ z . i" z$ k: t6 c8 u! I # Train the model using the training sets and check score% N8 j1 e, q+ T, Q
model.fit(X, y)+ W. ^: L( H. h, ^- y
model.score(X, y) ) E% T# \# E- S* g $ K P3 J- l) U" m8 M #Equation coefficient and Intercept1 x# C. w0 U- _2 p
print('Coefficient: \n', model.coef_) + N; r3 F" Y! z6 x. H print('Intercept: \n', model.intercept_) $ B- v% E$ |+ P( l4 K* h , R" j( h6 G( l6 n& l- H8 g, d9 Z- g #Predict Output 0 r# p% g! F7 D2 S# y, | predicted= model.predict(x_test)- F) ]3 w7 @) Y- J# @( c6 \' `
逻辑回归的优化: , f1 L I+ I' ?3 h& j9 l5 x* }加入交互项 2 U: o0 V+ T' P" H/ z0 o5 [$ p+ `5 T( j6 N* Q. g) J
减少特征变量 2 D8 N/ }6 t3 S7 ?! | * P( K8 U" t8 D4 n6 {0 w0 x" r 正则化 & N9 {8 H' ]7 c4 o5 W$ C+ ?* B+ l2 b' p7 u* ~6 H
使用非线性模型 4 Z: T' E n& M' S* w # W2 n9 m: m$ V& n& w2 {, E3.决策树 I2 y% a7 b2 Z$ q8 G
这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。 ! Y; u1 d b) W1 Y% y: r# X. N$ l" y
- p8 A( h5 t4 u7 D/ u' B4 X / _! `1 j6 r. A3 k3 }6 [/ a' _ [从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。4 Z' Y9 v- J; y3 @, }3 [2 ^
[/ {2 s3 \/ c " Y" G" R4 z; nfrom sklearn import tree : l2 S& o( |5 L, l) z$ | 8 b5 f; M" E0 n3 Y( D9 y( C3 p. \1 Q& o4 v+ w9 B9 B i7 l
# Create tree object : r( J0 _# O# \6 G8 H# N0 L1 R" }( _
model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini : M) X3 i% N( s* s; R
9 x/ @# Y! D: |. b1 E- c* E
# model = tree.DecisionTreeRegressor() for regression% e1 \3 Q; J4 B
8 b( t3 K. H$ t6 {* V" J- B9 ]# Train the model using the training sets and check score 0 u( N) W: R# |5 L( W9 ?9 m1 U; Hmodel.fit(X, y)2 z0 ^- U1 l3 d" |
model.score(X, y) $ W4 X0 s; u; i3 r# n% l3 T6 H# e" }% @! Q; l
#Predict Output ) N9 a) C% X* O9 [7 k/ s7 S6 A' Vpredicted= model.predict(x_test) ^' H7 h, g! V( G% K6 A2 v
4. 支持向量机(SVM) 9 @* S q7 t0 p1 E7 H5 z这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。 J2 r+ ]6 L9 J" ^: L- y6 T( u: e4 T" m b6 O" f4 N0 X: b2 w
现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。 ! O, G: u" W0 C' ?- A/ i7 |) j' q* H: o' o% [
$ e; R3 r. n0 I! I; x7 b" C- K4 @
2 G( _) W- P- o$ f# S; K在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。+ {! P3 c4 T) U& p5 Z2 L
: T) \3 s' h+ s* A Y
#Import Library7 ?$ U# B1 \& C+ t% X
from sklearn import svm $ X- M4 N& z/ i0 r#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset s- t* z7 p3 f. N& h: _, _8 ~# Create SVM classification object + V% @' |) `5 ^* ]/ e " b% u9 a) O' C3 b7 [5 D; hmodel = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail.6 j" E; D4 m( O* p6 [; d
8 v% G8 @$ o) F# _# Train the model using the training sets and check score* e# D" K4 a8 Z9 Z+ }: R0 G
model.fit(X, y)" h4 t" ~$ O `1 L
model.score(X, y) 4 \+ o8 o7 y' l* x3 C& z" I2 }. ^7 U9 r/ J# n: I
#Predict Output# }& k q+ Q! j, n; j7 y
predicted= model.predict(x_test)8 S Q6 f" a! p* q! J8 Z
5. 朴素贝叶斯* m9 u4 H D! V! I* I/ r& ^) m0 _
这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。7 |$ [: Z: j0 t+ A1 u! U# P
7 {" Y5 ]$ X+ e
朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。 5 R8 ? M f2 g- [6 G$ ` % y, R' P5 W/ q0 z贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下:' t% L/ k* u) j3 U h5 G
' l! v9 J' r. P( Q) v- {& P& P
' t$ x. a3 z/ e' O% r( V
P(c|x)是已知特征x而分类为c的后验概率。 . q3 L/ W6 ~7 A/ T+ D# X' s! e7 O: ]9 F
P(c)是种类c的先验概率。; d! F- s2 r; z: V0 u
/ W1 q$ A w( _0 ]6 U& v. {4 @) M那么,P (Yes | Sunny) = 0.33 * 0.64 / 0.36 = 0.60>0.5,说明这个概率值更大。7 O+ b2 h- w( q7 J$ j
, r4 `9 k3 M# y, {9 M: Z8 t
当有多种类别和多种特征时,预测的方法相似。朴素贝叶斯通常用于文本分类和多类别分类问题。 $ N% P& ^6 |4 D6 `8 |1 z ( A. e# i2 a- N+ }) J8 A#Import Library3 F4 z8 F# X. N- E
from sklearn.naive_bayes import GaussianNB % S2 D( F# t+ \& @! F, _) ], L#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset% s- A/ P3 @- k( `
# K! E! D0 d7 ^% v
# Create SVM classification object model = GaussianNB() # there is other distribution for multinomial classes like Bernoulli Naive Bayes, Refer link ! E' Y1 n0 ?/ Z" Y% Y6 z" _# |2 c' {9 ^
# Train the model using the training sets and check score , Q7 B" S& g$ l$ jmodel.fit(X, y) L6 f, l) P2 m6 b2 u8 o4 @8 j; H3 V# M0 F! j
#Predict Output 8 m! S* k& H/ w6 ]- hpredicted= model.predict(x_test) ' X& W& R# E" D; |% l5 D3 G6.KNN(K-邻近算法)5 B) K0 L' F8 _: L3 X6 \
这个算法既可以解决分类问题,也可以用于回归问题,但工业上用于分类的情况更多。 KNN先记录所有已知数据,再利用一个距离函数,找出已知数据中距离未知事件最近的K组数据,最后按照这K组数据里最常见的类别预测该事件。 " U' J, }: u+ K% [* | # u8 t0 f; M* n8 p6 |* d距离函数可以是欧式距离,曼哈顿距离,闵氏距离 (Minkowski Distance), 和汉明距离(Hamming Distance)。前三种用于连续变量,汉明距离用于分类变量。如果K=1,那问题就简化为根据最近的数据分类。K值的选取时常是KNN建模里的关键。 , A0 ^9 W% I1 w) P1 n5 O* T# h1 N4 i* P1 r* Q8 }2 c
7 z) d8 A7 M6 M$ t1 f - k U, M7 M- D4 a: j ~6 rKNN在生活中的运用很多。比如,如果你想了解一个不认识的人,你可能就会从这个人的好朋友和圈子中了解他的信息。 6 `8 k) h# R( S' D 0 k- A$ W0 M4 K! ~在用KNN前你需要考虑到:- i" j: z& Y2 M
/ A( x) J+ Y9 h% G3 V- y, [' ^
KNN的计算成本很高2 Z+ f# y; F4 r( |! c
" \; [$ [- I8 _& t3 V4 c
所有特征应该标准化数量级,否则数量级大的特征在计算距离上会有偏移。2 d8 K, D/ a. ?$ m2 I6 `
) k# v- ]+ e! l" H5 S5 [" {& I S: X
在进行KNN前预处理数据,例如去除异常值,噪音等。 2 H+ D8 T6 U3 t, v1 t ( l- B8 V2 [& l; q! C# H i/ c#Import Library# N, ?6 e5 h* l$ P0 v, R$ E: M
from sklearn.neighbors import KNeighborsClassifier7 e( ^9 u- G) y2 Q( U5 \* \
- ~' y: ?0 i3 r2 s
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset9 N" l% J% _# S2 S
# Create KNeighbors classifier object model . c- A$ {: m, l6 g6 y& I% A* ~ z
! p" [5 x! Z$ n* y& P
KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5 , _# Z1 I0 w( L2 w% ~ 5 W* d c! v8 i8 ^* X2 c6 x# Train the model using the training sets and check score. d! b' ^* {" C
model.fit(X, y) 4 g6 ?! x4 D; Y" \, p! X F) ^ $ A. y" D- P# x4 C#Predict Output. J+ Z3 h" z: r; U
predicted= model.predict(x_test) % I4 W! {# P( p' ~, `1 G b7. K均值算法(K-Means) 1 S' b) p- V2 ~& c' w. L这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。 ; c) b* ?7 x J4 j, S2 x6 j7 B# ]5 E) C& d: ~
还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量! X& @$ a# _; g% }3 |8 \9 v7 w$ ^7 W# }0 ~. w1 M
5 X1 N. `7 L, w+ Q
K均值算法如何划分集群:% S- I( U' ]' X6 ~% T- i; y S# f
7 u; t* l5 C; ]3 x( d
; r1 N2 f6 O% w+ w; E # ?* k* R% z# N. y! K3 w从每个集群中选取K个数据点作为质心(centroids)。1 @9 }* p. c/ t9 K2 I9 T
9 |7 B& T# ~% B, y) }$ w
将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。 # }3 l* R3 o% ~& q( ?4 C, u. N1 K- D8 l% Z5 k. _
找出新集群的质心,这样就有了新的质心。7 J& \* a+ }9 e
2 z2 ^7 ^0 y2 |* J3 m
重复2和3,直到结果收敛,即不再有新的质心出现。) B2 V$ O' B# k' t. h, u
; M/ @- }, x; p2 Z+ Q( \5 U- o) ^! v2 b- H2 v
怎样确定K的值:. m6 N; ~$ {- t
# A( b' ^! v" Z- z
如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。0 K% j/ w. o5 o# Z+ q
. U" }1 Z4 k, T# n' S0 F我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。, \% ~+ n+ C- e+ F, u8 {3 b7 H5 c
- e+ u& G" I5 s4 P v) h/ E! X9 M9 e3 `/ b1 U/ \% a
#Import Library: D5 q( s! z U) Q4 L9 q1 l, P
from sklearn.cluster import KMeans j3 p1 B4 d( T6 H f
+ v$ q0 n9 E9 @6 l) a#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset # k; `6 O4 ^) R! W* L8 q2 }# Create KNeighbors classifier object model 4 Y: }- f9 X4 J1 W4 `( }k_means = KMeans(n_clusters=3, random_state=0)9 F( ~/ u5 y, B; a, c* R
^- v4 @$ ^" o: `7 e# Train the model using the training sets and check score 2 T" m% n- C. Kmodel.fit(X) {1 T) V% z/ d* K* ~* g! h% Z% z