, I m. J6 J# C0 `: o# Train the model using the training sets and check score ; }) C. B- J% m: R/ F R: Y1 Qlinear.fit(x_train, y_train)" f& p& e/ b* G2 N9 \$ t5 F9 F
linear.score(x_train, y_train) r& {/ x3 Y! G; E8 O9 }
2 |% _( n& q) |& g- n#Equation coefficient and Intercept% o! h9 F A- |% |
print('Coefficient: \n', linear.coef_): k% K( [5 L# k1 e% h( V
print('Intercept: \n', linear.intercept_) 5 Q8 B5 Z) R. s- n ' O7 _4 v a, r% f#Predict Output& y$ f/ n9 V& j( b) A% r$ {
predicted= linear.predict(x_test)+ b0 b% }. `( d2 [! a& w' a; N
2.逻辑回归 ( w4 T$ D0 a; v A/ E# B( Z5 j J逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归! 9 K' s) }3 O D: g! i1 c( V- ]) |. P4 X - A' |+ N e' h* Q+ I% w4 n同样用例子来理解:+ ~- Q' g, x$ u2 u9 l7 A
/ j, J- [8 U2 Z$ T5 J7 Z假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。 ! v1 r% W' z* L$ t2 ^6 G& U1 r. n+ F7 q# T# t2 w
数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧+ l( L) ^8 v7 ]& ~0 r. [
8 ^, k( v6 ^7 _! E8 f0 s k! u最终事件的预测变量的线性组合就是: " d# o. K/ y' y8 F2 s) w+ u) l/ ?
& w: I6 e: R7 Q8 y3 k7 T
odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence ; Z" ~8 ]0 K; _) Q! b/ R. j: T : C& l7 q2 G( p- Oln(odds) = ln(p/(1-p)), {4 G1 E( @& h1 O% f9 R
# ^/ B8 h, |' a9 t+ \7 w
logit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk4 _1 @! o& J; o
在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和.8 H; D! {6 Z0 M( U* |- ~
7 K( Z! T5 m* i* q' \9 ]. v& ~
至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法. ' ~. m* V2 T0 r/ x* f! S( F& ~5 G : t* R) U5 H. f* o5 q ) ]7 Q: t+ k5 p# W3 R3 | H0 N/ @2 V3 N" D
from sklearn.linear_model import LogisticRegression ! g5 H' J% _" d% F: U7 ? 0 I3 l( v7 V$ }3 Z% R0 X model = LogisticRegression() : g$ P1 e8 Z$ V# K3 [ + _7 @, x/ L, O* O3 T # Train the model using the training sets and check score" A8 M2 p/ L* q! C" i( M
model.fit(X, y)8 D8 {$ O/ G$ e, [; L
model.score(X, y) ; [- F; U a. {9 b* c0 A( J& y 0 c& ?3 V- o: A$ Q #Equation coefficient and Intercept7 k$ U1 e2 l1 Z6 s: z& t3 f' K( w
print('Coefficient: \n', model.coef_)+ i7 o! p6 b8 J% l
print('Intercept: \n', model.intercept_); i, ^1 y5 j+ l7 p7 v2 A
1 d( _9 e! ^/ s% c0 U' U #Predict Output 8 [4 |% v1 E4 B5 S7 h+ w. N predicted= model.predict(x_test) 0 a' l9 Z% t) u' S: Q+ a逻辑回归的优化: ; j5 |/ {, U0 R, D2 r加入交互项1 `9 {: ^6 T/ E8 z/ a Z! Z* r1 V( w
" w7 I( C0 l8 }# d# j; \ l2 d4 @% y) L
从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。" i9 H1 S% s* k+ Y" ?8 ]
p9 X/ r1 b5 ^* c& K
+ X# Y& z# d9 C, t8 R4 j; V3 q$ m% u
from sklearn import tree 3 B3 s( u, u: ]* f- K2 f+ E' x 5 Q# v& v2 W3 R0 V2 W . X k1 I" y9 K4 ~9 w3 i# Create tree object $ m% R2 Y M: Q; k+ F
model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini 8 [3 h6 W g, l$ ]- v! c& e. m
* f* g! F) ?6 r$ u) {! B
# model = tree.DecisionTreeRegressor() for regression6 i; P( V$ N/ Y; _0 z& \
) g' N0 Z: R) A: F: E# Train the model using the training sets and check score: ^, G+ E& o9 m3 L
model.fit(X, y)1 `; i# B% [$ @% h, C
model.score(X, y) K8 Y$ D" D9 Q4 {" t$ e 7 ~: k6 d+ b$ H4 h- e& }) h#Predict Output! U2 G4 K' W4 f4 ~. D, _
predicted= model.predict(x_test)$ L5 H6 A# |8 ^& Y" Q( \3 q
4. 支持向量机(SVM)% D S* J2 N2 b9 o4 n7 W! y# R5 P
这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。- r' v& P! ^$ ?) t+ a
- g% I1 p* Q4 S( \
现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。 / W2 b( e. i5 N$ m, g% Z9 r [1 V7 f, R& C+ s$ f }, h: E6 P( C
6 f7 Z3 z; N: E2 m8 ~
3 h! e' }+ `* N/ n在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。 $ p! T/ A' g2 H% X6 e + E9 }1 B0 {( G7 Q, u9 [# {#Import Library : o/ b: p* x; ^! g. {: M" _from sklearn import svm! u5 U" _3 K( P. C2 }
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset, F. k, Q0 ~1 _2 v/ D \6 U
# Create SVM classification object : R, e* @2 S/ M3 l
6 S" e# | Z; L
model = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail., E s# z* W* p) b8 U
+ V" |! _4 F0 ]
# Train the model using the training sets and check score2 H8 y1 j7 z, b/ i9 ^2 _
model.fit(X, y)% G$ P7 N9 |# O7 y8 {
model.score(X, y) 1 P4 v. x) e+ O( @, y 1 Y9 Y& o2 i# ^1 L6 i3 J7 ?; ~#Predict Output * z. A! G$ z; g5 L! C5 i2 Wpredicted= model.predict(x_test)4 a# M" a* q! p7 f
5. 朴素贝叶斯 , j* L; R1 G% _ ], a这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。 / k) \2 W6 {7 e: j% I, ^5 h# Q) p+ Z$ R. y7 ~/ K
朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。 * U/ d4 R' ?8 \. F# ?# ]7 g0 B9 {9 m/ M+ m1 _7 y: U7 G; ^
贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下: * v/ L# @! X9 r6 n- b( Z ; P% l( U2 O3 m; P$ ]0 N" H+ S; _ 5 ]' V2 m% m' M, @0 V) o; ~8 G& zP(c|x)是已知特征x而分类为c的后验概率。 , _; m3 _& K) F p8 F; v 2 W# J, m) z3 y _ m" s+ nP(c)是种类c的先验概率。' @6 r; W4 ~/ [; k* B; g, I
6 `$ k1 V! z' g3 {& q2 @P(x|c)是种类c具有特征x的可能性。+ T6 U% c6 E+ z. n( |# K
J9 z, j5 q) o4 H! D
P(x)是特征x的先验概率。* _: p( z( B( W& i" N9 n
8 {1 }% A: E0 T3 Y- P$ ~. K
) h4 L% w3 R8 M& N0 z
例子: 以下这组训练集包括了天气变量和目标变量“是否出去玩”。我们现在需要根据天气情况将人们分为两组:玩或不玩。整个过程按照如下步骤进行:6 f, F. M& a5 s; G$ m5 k. f* U' X
' K4 A- U0 A3 n8 E% m/ n$ ~0 h/ f
步骤1:根据已知数据做频率表/ j' O7 T, A0 r2 w9 k
8 u3 f$ E$ k- Q* E#Import Library3 t1 A5 L9 w$ F1 h) z4 W
from sklearn.neighbors import KNeighborsClassifier" j9 X' T$ J9 i: z
2 U: o, f) u* {' T8 ^) o3 Z2 n n
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset3 v. r) n9 D, |! C1 @4 w& l
# Create KNeighbors classifier object model # N& ~- ^5 _6 F7 s
' L/ p& J, x$ p: G: g2 ?KNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 5$ o" Y6 Z7 ]8 |2 _
: P2 T5 B5 H4 I C. P8 g/ p( ^
# Train the model using the training sets and check score( q# ~; B# P: I, y2 V0 j+ T6 v0 [9 b
model.fit(X, y)/ s( S" Q8 D/ A" h' p
' p) \0 N' `) R3 o, K#Predict Output1 B2 b. t/ ^+ {3 C4 u/ H
predicted= model.predict(x_test)) b0 e2 I c' ?/ y; B
7. K均值算法(K-Means) " w& G5 {* W0 _9 F/ d, w这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。2 e' I* B5 n1 S7 ?& g
1 x g2 D8 n+ ]3 z9 c/ r! W" C
还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量! 2 l/ k% r; H- m M" U! T) A8 f6 k4 o 3 ?4 O4 Q) ~$ D! X- T/ b& Z4 V# x; S7 V) c1 F% F
K均值算法如何划分集群:' @& P: f7 i7 V5 D
+ Q4 Q! a8 c2 X" ^ + l) U& \' k6 K4 T% @0 a, H* L3 \6 J0 }/ w
从每个集群中选取K个数据点作为质心(centroids)。 * v- M: V5 T7 P. B+ z3 s F, w8 G# y$ L ]将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。 + S9 }1 M; N' ]4 p7 T @0 _ 8 r% `( y- a8 k找出新集群的质心,这样就有了新的质心。 ! J! @& q2 V' f7 s4 S 5 g- g5 |: W- z9 M重复2和3,直到结果收敛,即不再有新的质心出现。5 E/ x& o1 X! s
) y$ e y1 f; j! S' c |5 Z # w, h" P" q' z9 e9 e4 c4 S0 M6 ~怎样确定K的值:5 z b( z& _4 \; m! a) [
% g2 \; H, u0 |如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。 # Q% a- o5 x ~' }' y) q, c3 B \" `8 k9 i+ n& t" {5 a* b
我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。 $ e) C9 v& Y. P* C: k, Z- H 5 R6 {8 `3 R2 \ k1 E: M" T 2 a' V3 i( G1 S( }, O1 R#Import Library ! S% @ w$ x7 A! d. L2 Ffrom sklearn.cluster import KMeans & o( l$ Q0 M7 d C+ p9 ^ , c* r/ \1 D* g: ]$ r#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset ( t O. M" V( P2 y8 v+ {# Create KNeighbors classifier object model + [- e( @% j1 p8 `) z, C# s. l) jk_means = KMeans(n_clusters=3, random_state=0) $ ~6 }' X, r& m% N1 q% G9 }& k- k" I7 ?2 Q; S0 f2 t: J8 [
# Train the model using the training sets and check score 7 O( \& a+ m, y& Xmodel.fit(X)% Z1 S" X; y: F- C5 ?- `0 W
5 Y& ^' q2 X \+ q#Predict Output3 p2 @. l. _3 H4 ]
predicted= model.predict(x_test) ' S. V9 d3 l6 @: T$ p6 G8.随机森林 5 L' d8 i2 X: K# ?; R随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。8 ]! w5 X! I& ? f: N3 _
, r) J5 B y# H0 t
怎样生成决策树: ) ?1 I4 o } _7 E E% U$ [ , X( K8 c6 K& ]如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。4 }3 q- n$ t$ t
7 L: ]# w% w H' ?# S5 B如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。7 \1 v2 c1 V7 `' k/ j( S8 x
. {6 f- i0 K7 D @每个决策树都最大程度上进行分割,没有剪枝。: N4 \6 l2 Q* E! ^& C% ?& d& V
" j! T6 L. q/ z1 e
#Import Library / u! T' x/ Z/ |, _from sklearn.ensemble import RandomForestClassifier " q- ]# O) B h9 E7 v7 J#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset# y! ~$ f5 e; P) l' s) ], {
& |" Q9 t$ T+ c! D; H
# Create Random Forest object1 T4 z a6 `: R, U
model= RandomForestClassifier() + \( r9 {: c; G5 \$ u( Z ; P6 I- y! P2 C0 a Q" ~# Train the model using the training sets and check score! u, V# |/ F! R" ]6 l7 w
model.fit(X, y)2 ^- z- L2 s, u" @) T. {
0 a+ w+ t' S+ Q, ]% A
#Predict Output( f5 }" }: `; y4 _1 w# a; |
predicted= model.predict(x_test) " @ X3 D, E- [2 i9.降维算法(Dimensionality Reduction Algorithms)8 F* M, ~$ F k
在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。( H5 k! R) X; Y3 }0 ^
7 n: s1 N* h: W U' O
例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。 ( t0 ?' @" H5 k5 Y5 I0 d9 r" ^1 [) I" k6 F7 z3 |6 s$ A% M1 z1 H
作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。 2 m1 R( _7 @( `6 i" k5 }# Z. f3 T9 S1 D7 U+ }$ F5 `1 }9 h
5 f( a' o6 S9 s2 Y7 P' `' m
#Import Library+ @) @# |# e& z
from sklearn import decomposition + o2 o+ X* L9 x: i% z% @/ I8 b0 a#Assumed you have training and test data set as train and test 1 }& @: T. s6 |# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features)+ c8 V* h' S; p9 K0 [- W
# For Factor analysis $ j1 Z) X' y1 t2 L7 {0 T7 w#fa= decomposition.FactorAnalysis()! v- U6 h" `( Y7 \
# Reduced the dimension of training dataset using PCA3 N- `2 E5 f1 q8 \. @$ o1 J
- \, ~& v2 i; B' o/ d: m
train_reduced = pca.fit_transform(train)+ j% ~7 }% Y$ u# }' }