0 \! `0 _# r# \/ ?1 b! }; Y Y=因变量 # ]* Y/ b( d2 l4 }& c$ @4 {( T5 X/ L3 M( O
a =斜率 , u( {1 t: L$ U9 V+ v) T; C9 E. U. j& L
x=自变量3 a0 u6 f, O5 ^
& }; Q' h& F, V8 S3 V
b=截距 % a# ^" L, h3 C0 y! I$ K. ]& @) w9 R# e: s( V% |- ~
a和b可以通过最下化因变量误差的平方和得到(最小二乘法) m! ]1 M+ z; j4 V* N, s # g3 U( ^( r# x \7 T我们可以假想一个场景来理解线性回归.比如你让一个五年级的孩子在不问同学具体体重多少的情况下,把班上的同学按照体重从轻到重排队。这个孩子会怎么做呢?他有可能会通过观察大家的身高和体格来排队。这就是线性回归!这个孩子其实是认为身高和体格与人的体重有某种相关。而这个关系就像是前一段的Y和X的关系。2 ]" G" N( J. X4 Q7 Q
3 I6 c( j7 v: b% c/ i2 c
给大家画一个图,方便理解,下图用的线性回归方程是Y=0.28x+13.9.通过这个方程,就可以根据一个人的身高预测他的体重信息. 8 d! y! C- H: P# R0 g; ]6 {# t . p6 u1 ]" g& X( P) w0 _5 v# R$ A z1 q
2 C2 ]& p, z6 d# ?, y
线性回归还分为:一元线性回归和多元线性回归.很明显一元只有一个自变量,多元有多个自变量.6 i. y+ H% v/ H' \1 c# M3 e
7 S( {' w4 L. g. h拟合多元线性回归的时候,可以利用多项式回归或曲线回归 $ s" K* z9 M3 Q 8 O* J# ?) E4 n1 [9 J; j- IImport Library6 S X; K: {0 r) V* I- G) E
from sklearn import linear_model4 P9 V5 m9 i9 }; Y, y0 P
% q8 E+ [7 B, U: d! M5 j
x_train=input_variables_values_training_datasets% N7 }! {0 L ^8 R
y_train=target_variables_values_training_datasets . g, S5 h$ b( ex_test=input_variables_values_test_datasets - C% b. i. P( M7 ~' i- Z8 y; o' k% K3 Z) i! {: X! n$ o
# Create linear regression object - q# ?6 P x) Zlinear = linear_model.LinearRegression()7 s# v# D) P3 R
\5 d N8 f- m" a y; J# Train the model using the training sets and check score $ j: E; l1 E( x$ h. nlinear.fit(x_train, y_train) ^+ H, K" d. k. D3 k
linear.score(x_train, y_train) ! k/ f3 ]# {6 ^5 V( n$ C! h6 _6 i* j9 b1 y: k6 H
#Equation coefficient and Intercept 4 D' a! t2 G0 x# B( `print('Coefficient: \n', linear.coef_)/ O8 ~/ t/ Z9 p/ u% D1 @% o1 l
print('Intercept: \n', linear.intercept_)! S2 y+ @7 Q- u# P& y% }
6 ^2 w- n. r9 W$ Q. p
#Predict Output/ J7 V. x8 F6 x4 Y
predicted= linear.predict(x_test) / N; [; o) o% U$ E& _$ o2.逻辑回归* o0 A* i5 g( N
逻辑回归最早听说的时候以为是回归算法,其实是一个分类算法,不要让他的名字迷惑了.通常利用已知的自变量来预测一个离散型因变量的值(通常是二分类的值).简单来讲,他就是通过拟合一个Lg来预测一个时间发生的概率,所以他预测的是一个概率值,并且这个值是在0-1之间的,不可能出这个范围,除非你遇到了一个假的逻辑回归! # ~6 M7 [0 a$ e. U% w6 P 3 b( a- x, E4 i/ E! a9 I) J n同样用例子来理解: % g9 A& I; ^/ p, `* E0 |6 g/ J k& l
假设你的一个朋友让你回答一道题。可能的结果只有两种:你答对了或没有答对。为了研究你最擅长的题目领域,你做了各种领域的题目。那么这个研究的结果可能是这样的:如果是一道十年级的三角函数题,你有70%的可能性能解出它。但如果是一道五年级的历史题,你会的概率可能只有30%。逻辑回归就是给你这样的概率结果。: R4 e# C/ ]( o+ k% _
2 P: i+ y8 H. U( E1 }
数学又来了,做算法这行业是离不开数学的,还是好好学学数学吧 - @* B: c7 B& |( ]: K9 i j6 {) `, n
最终事件的预测变量的线性组合就是: . W1 V5 R; A8 p/ C* E* W% U+ s & S7 [* {! ^2 F b; b, b: P% w8 y. y( [
odds= p/ (1-p) = probability of event occurrence / probability of not event occurrence1 F' l$ B( T7 p4 C/ d" K. ]
# I0 ` T9 U- `2 x/ L3 Y; o
ln(odds) = ln(p/(1-p)) * j# |1 ]( M( ? . x8 t) z$ n7 Q2 I; Y- f: ~! clogit(p) = ln(p/(1-p)) = b0+b1X1+b2X2+b3X3....+bkXk" M7 |. B& K# n
在这里,p是我们感兴趣的事件出现的概率.他通过筛选出特定参数值使得观察到的样本值出现的概率最大化,来估计参数,而不是像普通回归那样最小化误差的平方和. ( a1 k( o% c; a/ t0 ? d; ] @0 `7 R1 {* }3 `
至于有的人会问,为什么需要做对数呢?简单来说这是重复阶梯函数的最佳方法. 1 q- h) i$ x; ?! k0 S( e- i ) \1 T1 B* I% x2 v( l4 z- k0 ?5 U. i/ u. [3 P
$ U7 ]" x" ]. {$ V+ h: t2 `* E
from sklearn.linear_model import LogisticRegression 6 ?9 C" x+ y; g6 w1 D: E) g: B( H7 P) j' y/ K, N! T5 F
model = LogisticRegression()9 a- r2 E4 n' `/ l
' f& U/ b% R) {6 L% u+ @. g
# Train the model using the training sets and check score; ?; ?0 I8 S' d* b" x& C5 W
model.fit(X, y)+ ~# ^# I. V* A' f
model.score(X, y) 1 [+ B6 q- {2 _- B9 \7 Q ( Y# {+ w( R3 s; C #Equation coefficient and Intercept & B3 _+ v" `5 }9 t! t/ @1 ^" w print('Coefficient: \n', model.coef_) 8 \+ d# A' v/ a( d- ?5 y/ X print('Intercept: \n', model.intercept_) ' c$ K4 g) N+ S! i. c: n- b+ m7 I9 C% F$ [
#Predict Output8 G# U' F& ^& S/ D. j
predicted= model.predict(x_test) + v0 s" X% S& o( M N- m8 k逻辑回归的优化: & n. y0 b0 g) X加入交互项6 n& l, s$ U$ Z
: `, i0 ^; {& |; Q3 r7 t
减少特征变量- c& l* E- c& Y. T' ^
9 p3 K: |- x! i0 ?# u9 v! l
正则化 ! T5 Y" G% x6 O* Q' ]# L9 \ ' k; s) c/ e# S; V, | 使用非线性模型 ) s1 m+ @4 H. e# [ {( I ' q: d& M1 V' [9 a: s" v+ K8 n% U3.决策树 ; Y4 [) t: H2 T+ Q$ R; M. x( I这是我最喜欢也是能经常使用到的算法。它属于监督式学习,常用来解决分类问题。令人惊讶的是,它既可以运用于类别变量(categorical variables)也可以作用于连续变量。这个算法可以让我们把一个总体分为两个或多个群组。分组根据能够区分总体的最重要的特征变量/自变量进行。4 [+ e2 d# c( {0 R* N
/ u: q, y3 _8 F 8 i/ @0 [' B0 B2 m7 ~7 W$ P) `9 \+ Z: U3 u/ Z. g8 r6 n
从上图中我们可以看出,总体人群最终在玩与否的事件上被分成了四个群组。而分组是依据一些特征变量实现的。用来分组的具体指标有很多,比如Gini,information Gain, Chi-square,entropy。6 }& u5 {9 {0 o3 @# h
5 M( `% g6 K. }0 Z r+ E2 o/ T- b" G5 X7 B9 R
from sklearn import tree! U& X. x" i) q$ T9 b, I5 [
/ j+ H# X! ^) k0 { + ^8 T. L7 K' C( Y# Create tree object % X( Q$ S i& y# g: r% p( @
model = tree.DecisionTreeClassifier(criterion='gini') # for classification, here you can change the algorithm as gini or entropy (information gain) by default it is gini ; f( C2 g: J1 w8 V* t5 P
0 a' {1 i# j" L, t3 U ?+ h
# model = tree.DecisionTreeRegressor() for regression . R* s; f' n( i( A : V% y. _6 W: B: S. n7 ^# Train the model using the training sets and check score 4 N% J* H4 s# f* V t6 pmodel.fit(X, y) # s/ S) | ~' s$ b( Pmodel.score(X, y) ! e9 V: V- Q ^% A8 _5 ]7 D- E" ^8 D
#Predict Output & h# B+ Q5 N- q3 L& J5 {& H2 Tpredicted= model.predict(x_test)' x0 L# Y4 C( x# b0 D1 `; d* g. v
4. 支持向量机(SVM); Y% T7 Q; f/ @% i
这是一个分类算法。在这个算法中我们将每一个数据作为一个点在一个n维空间上作图(n是特征数),每一个特征值就代表对应坐标值的大小。比如说我们有两个特征:一个人的身高和发长。我们可以将这两个变量在一个二维空间上作图,图上的每个点都有两个坐标值(这些坐标轴也叫做支持向量)。 - u5 ?3 U c* ~! E: u7 T3 p# Y# m a( U( I i) S' z/ {
现在我们要在图中找到一条直线能最大程度将不同组的点分开。两组数据中距离这条线最近的点到这条线的距离都应该是最远的。1 D" R% L. J! ~, i
$ R$ ?- x$ g5 L
5 u+ D, }5 k0 [% e& O4 Y ) |. f: i. F; z: L7 \5 w) Z Y) f) _在上图中,黑色的线就是最佳分割线。因为这条线到两组中距它最近的点,点A和B的距离都是最远的。任何其他线必然会使得到其中一个点的距离比这个距离近。这样根据数据点分布在这条线的哪一边,我们就可以将数据归类。 ! Q3 t6 O' | ~, {! s; ?" U: W' Q) J; o* R 3 g E9 M( r/ i1 s# ]6 e9 i' i#Import Library+ G+ M5 d7 l0 y0 P7 n6 H0 [* r
from sklearn import svm 7 T) M" F* l! d6 r- m#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset" B% I+ }$ X8 y: o0 ^
# Create SVM classification object ! b3 i- L: ^+ h0 n4 @: l! G$ S9 m; Q# Z
model = svm.svc() # there is various option associated with it, this is simple for classification. You can refer link, for mo# re detail. F5 y" m c% E# U. D
* z9 Y8 ~1 ?/ W, x; Q& Q/ B# Train the model using the training sets and check score 9 O' S. j4 {* l, @! J8 umodel.fit(X, y) ) Y7 J% h% }# I' Nmodel.score(X, y) % _; x1 w* G2 D, o' M4 R: X4 n, h2 d2 R/ f1 r l6 `. I$ l1 s2 e7 ^
#Predict Output3 }) V# N2 L, S9 X2 t1 Z
predicted= model.predict(x_test), v ~4 \, R/ M! [ e0 `8 }
5. 朴素贝叶斯) z/ z' c& K4 ^; B
这个算法是建立在贝叶斯理论上的分类方法。它的假设条件是自变量之间相互独立。简言之,朴素贝叶斯假定某一特征的出现与其它特征无关。比如说,如果一个水果它是红色的,圆状的,直径大概7cm左右,我们可能猜测它为苹果。即使这些特征之间存在一定关系,在朴素贝叶斯算法中我们都认为红色,圆状和直径在判断一个水果是苹果的可能性上是相互独立的。 / p# ~+ }& K; V* Q. g7 I! z0 M4 p: {' F- h. z6 q
朴素贝叶斯的模型易于建造,并且在分析大量数据问题时效率很高。虽然模型简单,但很多情况下工作得比非常复杂的分类方法还要好。 % p* r" J- M' ~/ v 5 n5 J# q; S2 G贝叶斯理论告诉我们如何从先验概率P(c),P(x)和条件概率P(x|c)中计算后验概率P(c|x)。算法如下:1 \2 n) s+ P8 ^& K7 {* b
/ k* n' K. s0 f, s) Z " f# T- D4 l p! O% j- |8 r$ MP(c|x)是已知特征x而分类为c的后验概率。 + U+ g3 [4 B$ e) @ 2 t" Q% d/ @" O wP(c)是种类c的先验概率。 E3 d6 }: i( z( p 3 R# H- \# i* OP(x|c)是种类c具有特征x的可能性。 - X$ o. y) A' |4 Z+ L; { ) i0 T( @* h) m" EP(x)是特征x的先验概率。/ H. G; r1 n* j
8 I4 H5 [4 t# A5 M
5 z$ D# V# u& |0 @3 z#Import Library 0 n% t) ]4 H5 Afrom sklearn.neighbors import KNeighborsClassifier 9 @7 f& s% x" W2 k: q9 e- N! `- e; M" O7 i
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset 2 R) f# h# j2 I# Create KNeighbors classifier object model & N$ d' D2 r' O/ P& o( M 7 L" d: D# e" V2 ?0 r( iKNeighborsClassifier(n_neighbors=6) # default value for n_neighbors is 53 [8 P* c; u2 G3 P9 v2 T( W
5 F. Z4 K. w" _# Train the model using the training sets and check score6 H; e% t& [; g/ z2 H, o% |
model.fit(X, y)) ]1 X. d3 O) e
; r! S$ |8 [9 h0 @5 y5 w
#Predict Output) ]5 D) R+ v9 {6 G
predicted= model.predict(x_test)4 ] v4 B5 `0 L# K* K
7. K均值算法(K-Means): D* I. s: B8 S! I5 s
这是一种解决聚类问题的非监督式学习算法。这个方法简单地利用了一定数量的集群(假设K个集群)对给定数据进行分类。同一集群内的数据点是同类的,不同集群的数据点不同类。4 f$ q( ]( p1 X6 m. H9 ~& \
# G: k7 w- m0 r: g* B* i9 \/ k还记得你是怎样从墨水渍中辨认形状的么?K均值算法的过程类似,你也要通过观察集群形状和分布来判断集群数量!9 ]+ i4 i" j+ D. D* K
8 V! c' v! m! D8 Y- B9 O* G( \: c# D3 ?. B v+ F4 _$ ]
K均值算法如何划分集群:8 ^* @9 p' t; m! r
7 \' c* p" j) y" d
$ D: Y; H# a& M( |8 n
- d7 C/ J7 ~2 @) \1 W$ v
从每个集群中选取K个数据点作为质心(centroids)。0 q6 D- l" x+ Z$ _) @
% i5 A* @. B, @5 E. B8 Q; P( k! S% d将每一个数据点与距离自己最近的质心划分在同一集群,即生成K个新集群。1 u. E5 \; `! S2 _1 E5 L! B
$ @: H* q/ W1 P! i5 \& i
找出新集群的质心,这样就有了新的质心。' @# Z3 O$ N# C0 o1 g; p* k
8 h- r6 Q$ {) [ X- }* G0 G1 {, n
重复2和3,直到结果收敛,即不再有新的质心出现。 0 W" \, l! P o; v( t 6 n& p7 Y6 x, l& K0 }7 [ V ; K/ b3 J' |: G* l/ @. E) }怎样确定K的值: + s: m2 E' L* d8 s/ H6 E% a; ^* b5 g" D; G/ f% V- S
如果我们在每个集群中计算集群中所有点到质心的距离平方和,再将不同集群的距离平方和相加,我们就得到了这个集群方案的总平方和。9 \" i! U/ H3 S6 m3 I6 I* D: x
# r* H! @+ [" _5 X+ b5 @) v `
我们知道,随着集群数量的增加,总平方和会减少。但是如果用总平方和对K作图,你会发现在某个K值之前总平方和急速减少,但在这个K值之后减少的幅度大大降低,这个值就是最佳的集群数。 * G* [, A* J) y6 E. V" j3 Q) m2 r4 k% ?; R) `
2 T t" n, B/ p4 q4 b4 D#Import Library- c {3 D7 e' O* d4 o9 I
from sklearn.cluster import KMeans b$ W& @. G, j" c" K: P
5 `& D7 h$ f H2 v, Y; g8 a#Assumed you have, X (attributes) for training data set and x_test(attributes) of test_dataset, Z1 _1 V$ t* G% d. M1 g2 O2 l
# Create KNeighbors classifier object model " U7 _% d( b: }" [" {' b* Y5 P
k_means = KMeans(n_clusters=3, random_state=0) 7 C; H% p4 }1 C9 e e1 A0 L8 [+ {; g, V' r
# Train the model using the training sets and check score ; [: q8 n4 N+ [ c* o; o2 ?+ P0 j; f Bmodel.fit(X); A5 z0 F/ [6 R2 C e1 A' w
9 g' O4 ^6 K* p7 t8 [- ~# S9 @7 R: o
#Predict Output 5 s0 d* h- M/ C. ^" Wpredicted= model.predict(x_test): x% [% V% `, a) d; f- V/ H u
8.随机森林( s$ l" j6 t" E- X8 L0 t6 C
随机森林是对决策树集合的特有名称。随机森林里我们有多个决策树(所以叫“森林”)。为了给一个新的观察值分类,根据它的特征,每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。& Z6 w1 E8 v+ E: ~
: |: U- a8 @4 ?6 O8 M j# G7 K怎样生成决策树: ) ^6 A7 z9 V; [" [3 v 0 N0 c& g5 a' ?1 R5 r如果训练集中有N种类别,则有重复地随机选取N个样本。这些样本将组成培养决策树的训练集。 ( y! g% f% U( b/ h : H0 E) j8 ~0 @( g如果有M个特征变量,那么选取数m << M,从而在每个节点上随机选取m个特征变量来分割该节点。m在整个森林养成中保持不变。 ; P3 P" N7 t5 S3 I0 P# }1 v% u2 o) x \( {8 R
每个决策树都最大程度上进行分割,没有剪枝。 ! ]$ d# R' b! A) o2 [ 8 I0 h, e' r$ k Y0 G3 [#Import Library1 I" a4 {1 t- y- p+ X) J6 E1 C, |
from sklearn.ensemble import RandomForestClassifier 4 G3 j7 l( ^( l+ x2 ~#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset' z; p" ^; y3 D5 u
; Y1 L' k; p/ W- N- U
# Create Random Forest object6 V3 e, R" Y4 l
model= RandomForestClassifier()& @) o& c0 K" t' B; e: b6 i$ A
% L" j* b; N4 G5 r" ?& R3 o
# Train the model using the training sets and check score0 e: \7 r- A1 H# T0 m( |) l
model.fit(X, y)9 m L* C" A" @) V" C. g' j
7 U7 m( m, a, ^5 ?# m6 f1 C
#Predict Output ( i: l0 Y I V) Tpredicted= model.predict(x_test) A9 `9 {- o% N4 |( Q7 n/ ^
9.降维算法(Dimensionality Reduction Algorithms)3 Q: [8 z1 z& z( @* I
在过去的4-5年里,可获取的数据几乎以指数形式增长。公司/政府机构/研究组织不仅有了更多的数据来源,也获得了更多维度的数据信息。 }1 \: ]% t& D: @" n, P8 B+ ~/ d . r) d2 a$ F, ~: M6 x例如:电子商务公司有了顾客更多的细节信息,像个人信息,网络浏览历史,个人喜恶,购买记录,反馈信息等,他们关注你的私人特征,比你天天去的超市里的店员更了解你。 4 ~- t9 a" F+ C' y7 |4 ]3 i, _ o5 f1 b
作为一名数据科学家,我们手上的数据有非常多的特征。虽然这听起来有利于建立更强大精准的模型,但它们有时候反倒也是建模中的一大难题。怎样才能从1000或2000个变量里找到最重要的变量呢?这种情况下降维算法及其他算法,如决策树,随机森林,PCA,因子分析,相关矩阵,和缺省值比例等,就能帮我们解决难题。/ I$ V) P: U4 A7 [
& _. G( P: T7 H. r# N9 n: q# k
+ {2 @1 \5 K+ I+ {8 _
#Import Library1 R3 A/ f1 {: p- E$ K
from sklearn import decomposition ( n* B7 C% a4 [+ Y#Assumed you have training and test data set as train and test |5 v" v. v* ~- j: G# Create PCA obeject pca= decomposition.PCA(n_components=k) #default value of k =min(n_sample, n_features) - ~: {% _$ w1 Y$ t0 j2 J% [4 `# For Factor analysis6 B( N! _+ M9 H1 o1 G! v
#fa= decomposition.FactorAnalysis()9 Q) S/ F$ U0 m1 c; {
# Reduced the dimension of training dataset using PCA 4 d% ?6 v t. s0 ]. `$ G# f7 s2 _3 j) z6 l& H5 N& A
train_reduced = pca.fit_transform(train)3 c9 t5 p% N( A1 u; [0 A' u
% ]9 Q' h' N1 E$ w w
#Reduced the dimension of test dataset 7 }* D9 y2 e5 l% htest_reduced = pca.transform(test)7 J4 _4 j) R: E( }. L3 M0 r
10.Gradient Boosing 和 AdaBoost5 s; c+ I" f& m& Q/ }4 r
GBM和AdaBoost都是在有大量数据时提高预测准确度的boosting算法。Boosting是一种集成学习方法。它通过有序结合多个较弱的分类器/估测器的估计结果来提高预测准确度。这些boosting算法在Kaggle,AV Hackthon, CrowdAnalytix等数据科学竞赛中有出色发挥。) F" I% v# t4 g, H$ L6 F( h
! v" v7 d# ]" c1 a
#Import Library % n0 H9 w/ p9 ]3 O' [9 }from sklearn.ensemble import GradientBoostingClassifier) T5 p. r4 }2 s: J" c
#Assumed you have, X (predictor) and Y (target) for training data set and x_test(predictor) of test_dataset. N4 H+ z6 ?1 x7 \% a' d" a9 S
# Create Gradient Boosting Classifier object - U4 m6 O' m5 _' Bmodel= GradientBoostingClassifier(n_estimators=100, learning_rate=1.0, max_depth=1, random_state=0)* o1 L8 C) s. s* T5 m5 C4 {7 m
% }+ K" L' h0 O, y2 ~/ A3 u! K3 p
# Train the model using the training sets and check score( J" x# A1 V5 `" ~$ J
model.fit(X, y)+ b5 O% i9 j4 |) Q+ d: E
#Predict Output2 l" t) r0 P! T' A0 E1 g" g
predicted= model.predict(x_test) 5 I# k0 X9 t/ ~1 rGradientBoostingClassifier 和随机森林是两种不同的boosting分类树。人们经常提问 这两个算法有什么不同。 ' O2 n/ A' E1 m- N/ ] / \& D6 w4 r3 C- K9 P( }原文链接:http://blog.csdn.net/han_xiaoyang/article/details/51191386 4 P" J- @' s# B9 B4 {————————————————* p$ A, I0 y% @: I! G* @4 z/ Q" i
版权声明:本文为CSDN博主「_小羊」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。 . m) H8 o, K% H) u! P% r3 w原文链接:https://blog.csdn.net/qq_39303465/article/details/79176075$ i4 H# P' z. X/ t
' I( w9 F4 J" e& A! Y/ z. I& J . \3 `1 Z- n% q5 W% L