《Python机器学习》笔记---第三章：使用scikit-learn实现机器学习分类算法

知识点1：sklearn.model_selection.train_test_split（）随机划分训练集和测试集

原文demo：

from sklearn.cross_validation import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3,random_state=0)

一般形式：
train_test_split是交叉验证中常用的函数，功能是从样本中随机的按比例选取train data和testdata，形式为：

X_train,X_test, y_train, y_test =
cross_validation.train_test_split(train_data,train_target,test_size=0.4, random_state=0)

参数解释：
train_data：所要划分的样本特征集
train_target：所要划分的样本结果
test_size：样本占比，如果是整数的话就是样本的数量
random_state：是随机数的种子。
随机数种子：其实就是该组随机数的编号，在需要重复试验的时候，保证得到一组一样的随机数。比如你每次都填1，其他参数一样的情况下你得到的随机数组是一样的。但填0或不填，每次都会不一样。
随机数的产生取决于种子，随机数和种子之间的关系遵从以下两个规则：

种子不同，产生不同的随机数；种子相同，即使实例不同也产生相同的随机数。

知识点3：使用sklearn.preprocessing.StandardScaler类，对特征进行标准化处理

原文代码：

from sklearn.preprocessing import StandardScaler
sc = StandardScaler()
sc.fit(X_train)
X_train_std = sc.transform(X_train)
X_test_std = sc.transform(X_test)

使用该类的好处在于可以保存训练集中的参数（均值、方差）直接使用其对象转换测试集数据。

使用StandardScaler中的fit方法，计算训练数据中每个特征的均值和标准差，

通过调用transform方法，可以使用计算得到的均值和方差来对训练数据做标准化处理。

知识点4：使用Perceptron类进行感知机模型进行训练

原文代码：

from sklearn.linear_model import Perceptron
ppn = Perceptron(max_iter =40,eta0=0.1,random_state=0)
ppn.fit(X_train_std,y_train)

max_iter :迭代次数
eta0:学习速率

random_state:在每次迭代后初始化重排训练数据集

知识点5：sklearn predict(X)：预测方法，将返回预测值y_pred

知识点6： sklearn ︱分类效果评估,准确率 accuracy_score

原文代码：

from sklearn.metrics import accuracy_score
print('Accuracy:%.2f'% accuracy_score(y_test,y_pred))

eg:

# 准确率
import numpy as np
from sklearn.metrics import accuracy_score
y_pred = [0, 2, 1, 3,9,9,8,5,8]
y_true = [0, 1, 2, 3,2,6,3,5,9]

accuracy_score(y_true, y_pred)
Out[127]: 0.33333333333333331

accuracy_score(y_true, y_pred, normalize=False)  # 类似海明距离，每个类别求准确后，再求微平均
Out[128]: 3

知识点7：Numpy中stack()，hstack()，vstack()函数详解

1. stack()函数 

函数原型为：stack(arrays, axis=0)，arrays可以传数组和列表。axis的含义我下面会讲解，我们先来看个例子，然后我会分析输出结果。

import numpy as np
a=[[1,2,3],
   [4,5,6]]
print("列表a如下：")
print(a)

print("增加一维，新维度的下标为0")
c=np.stack(a,axis=0)
print(c)

print("增加一维，新维度的下标为1")
c=np.stack(a,axis=1)
print(c)

输出：
列表a如下：
[[1, 2, 3], [4, 5, 6]]
增加一维，新维度下标为0
[[1 2 3]
 [4 5 6]]
增加一维，新维度下标为1
[[1 4]
 [2 5]
 [3 6]]

首先这里arrays我传的是一个列表，现在我开始讲解这个stack()函数的意思，它就是对arrays里面的每个元素(可能是个列表，元组，或者是个numpy的数组)变成numpy的数组后，再对每个元素增加一维(至于维度加在哪里，是靠axis控制的)，然后再把这些元素串起来(至于怎么串，我下面会说)。

arrays里面的每个元素必须形状是一样的，例如本例中列表a中的两个元素[1,2,3]和[4,5,6]的形状是一样的，如果把[4,5,6]换成[4,5] ，那么程序会报错！而axis代表的是在哪个维度上加一维，例如axis=0(它是默认的)代表的就是增加的这一维的下标为0，axis等于多少不是随便乱写的，如果参数arrays里面的每个元素是个1维的，那么调用stack()函数增加一维后会变成2维的，所以axis只能等于0和1（维度的下标是从0开始的），而参数axis=0和axis=1得到的结果是不一样的。

例如上面的代码中a列表中的第一个元素为[1,2,3]，那么当axis=0的时候，就是在它的中括号外面再加一个中括号，变成[ [1,2,3] ]（其实1，2，3之间是没有逗号的，因为stack()函数会先把参数arrays中的每个元素变成numpy的数组，数组之间是没有逗号的，看看上面的代码输出就知道了，这里大家明白就行，我为了方便讲解，下面还会加上逗号），这样最外面那层中括号才代表维度下标为0的那维；当axis=1的时候，就是在里面加个中括号，变成了[ [1]，[2]，[3] ],这样里面加的那层中括号才代表维度下标为1的那维。同理当axis=0的时候[4,5,6]变成[ [ 4，5，6] ]，当axis=1的时候，变成[ [4]，[5]，[6] ]。下面我们讲如何把增加一维度后的每个元素串起来。

怎么把上面那两个元素增加维度后的结果串起来呢，其实很简单。现在我们已经知道了增加维度无非是增加中括号的意思，至于在哪里加中括号，取决于axis等于几。我们把增加的中括号想像成一个个的箱子。还拿上面的代码来说，当axis=0的时候，我们把套在[1,2,3]外面的中括号(就是[ [1,2,3] ]最外层的那个中括号)看做是箱子A，这个箱子A也会套在[4,5,6]的外面，所以我们就先把[1,2,3]和[4,5,6]放在一起，变成[1,2,3],[4,5,6]，然后再一起套上箱子A，变成[ [1,2,3],[4,5,6] ]这就是当axis=0的时候程序的输出结果。

现在再来看当axis=1的时候，对于[1，2，3]，我们把套在1外面的箱子(就是上面讲的[ [1]，[2]，[3] ]中1外面的那层中括号)看做A，套在2外面的看做B，套在3外面的看做C，同理，箱子A也会套在4的外面，箱子B也会套在5的外面，箱子C也会套在6的外面。那么我们就把1和4放一起，2和5放一起，3和6放一起，变成[ 1,4 ，2,5 ，3,6 ]然后把箱子A,B,C分别套在1,4 ， 2,5 ， 3,6的外面，变成[ [1,4] , [2,5] , [3,6] ]这就是程序中axis=1的时候程序的输出结果。
 

大家发现了没有，串起来的时候其实就是把arrays中每个元素在相同的位置套箱子的一些小块(这里叫小块这个名词可能不洽当，但是大家明白就行)放在一起后，再套箱子，就是外面套个中括号，这就是堆叠。

再看下面的代码的输出，测试下你理解的没有。

import numpy as np
a=[[1,2,3,4],
   [5,6,7,8],
   [9,10,11,12]]
print("列表a如下：")
print(a)

print("增加一维，新维度的下标为0")
c=np.stack(a,axis=0)
print(c)

print("增加一维，新维度的下标为1")
c=np.stack(a,axis=1)
print(c)

输出：
列表a如下：
[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]
增加一维，新维度的下标为0
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
增加一维，新维度的下标为1
[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]

不知道和你想象的输出一样不一样，还有另一种情况，先看下面的代码。

import numpy as np
a=[1,2,3,4]
b=[5,6,7,8]
c=[9,10,11,12]
print("a=",a)
print("b=",b)
print("c=",c)

print("增加一维，新维度的下标为0")
d=np.stack((a,b,c),axis=0)
print(d)

print("增加一维，新维度的下标为1")
d=np.stack((a,b,c),axis=1)
print(d)

输出：
('a=', [1, 2, 3, 4])
('b=', [5, 6, 7, 8])
('c=', [9, 10, 11, 12])
增加一维，新维度的下标为0
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
增加一维，新维度的下标为1
[[ 1  5  9]
 [ 2  6 10]
 [ 3  7 11]
 [ 4  8 12]]

你会发现输出结果和上面的代码一样，其实它俩就是一样的。只不过当你对arrays传参的时候，如果你传的参数是类似于(a,b,c)这种，它会把(a,b,c)当做一个元组来看，a,b,c都是元组的每个元素。然后分别对每个元素处理，上面我已经说了，arrays传的参数可以是列表，元组，或者numpy数组。所以传(a,b,c)和传[a,b,c]或者当x=[a,b,c]的时候传x，效果都是一样的。
 

上面的代码处理的arrays元素都是一维变二维的情况，下面我们看看二维变三维是什么样的。

import numpy as np
a=[[1,2,3],
   [4,5,6]]
b=[[1,2,3],
   [4,5,6]]
c=[[1,2,3],
   [4,5,6]]
print("a=",a)
print("b=",b)
print("c=",c)

print("增加一维，新维度的下标为0")
d=np.stack((a,b,c),axis=0)
print(d)

print("增加一维，新维度的下标为1")
d=np.stack((a,b,c),axis=1)
print(d)
print("增加一维，新维度的下标为2")
d=np.stack((a,b,c),axis=2)
print(d)

输出：
('a=', [[1, 2, 3], [4, 5, 6]])
('b=', [[1, 2, 3], [4, 5, 6]])
('c=', [[1, 2, 3], [4, 5, 6]])
增加一维，新维度的下标为0
[[[1 2 3]
  [4 5 6]]

 [[1 2 3]
  [4 5 6]]

 [[1 2 3]
  [4 5 6]]]
增加一维，新维度的下标为1
[[[1 2 3]
  [1 2 3]
  [1 2 3]]

 [[4 5 6]
  [4 5 6]
  [4 5 6]]]
增加一维，新维度的下标为2
[[[1 1 1]
  [2 2 2]
  [3 3 3]]

 [[4 4 4]
  [5 5 5]
  [6 6 6]]]

当axis=0的时候，列表a，b，c最外面都需要套箱子(就是加中括号)，那么我把你们先放一起，变成下面这样

[[1,2,3],[4,5,6]],
[[1,2,3],[4,5,6]],
[[1,2,3],[4,5,6]]

然后在最外面套箱子，变成

[
[[1,2,3],[4,5,6]],
[[1,2,3],[4,5,6]],
[[1,2,3],[4,5,6]]
]

当axis=1的时候，列表a，b，c中的[1,2,3]需要套同样的箱子，列表a，b，c中的[4,5,6]需要套同样的箱子，好，我先把你们放一块变成下面这样

[
    [1,2,3],[1,2,3],[1,2,3]
    ,
    [4,5,6],[4,5,6],[4,5,6]

]

然后开始分别在 [1,2,3],[1,2,3],[1,2,3]的外面和[4,5,6],[4,5,6],[4,5,6]的外面套箱子，变成下面这样

[
    [[1,2,3],[1,2,3],[1,2,3]]
    ,
    [[4,5,6],[4,5,6],[4,5,6]]

]

当axis=2的时候，列表a，b，c中的1，2，3，4，5，6都需要套箱子，我把你们先放一起变成：

[
    [1,1,1  ,  2,2,2  , 3,3,3],
    [4,4,4  ,  5,5,5  , 6,6,6]
]

然后在1,1,1 ………6,6,6的外面分别套箱子变成：

[
    [[1,1,1]  ,  [2,2,2]  , [3,3,3]],
    [[4,4,4]  ,  [5,5,5]  , [6,6,6]]
]

2. hstack()函数 

 

函数原型：hstack(tup) ，参数tup可以是元组，列表，或者numpy数组，返回结果为numpy的数组。看下面的代码体会它的含义

 

import numpy as np
a=[1,2,3]
b=[4,5,6]
print(np.hstack((a,b)))

输出：[1 2 3 4 5 6 ]

import numpy as np
a=[[1],[2],[3]]
b=[[1],[2],[3]]
c=[[1],[2],[3]]
d=[[1],[2],[3]]
print(np.hstack((a,b,c,d)))

输出：
[[1 1 1 1]
 [2 2 2 2]
 [3 3 3 3]]

它其实就是水平(按列顺序)把数组给堆叠起来，vstack()函数正好和它相反。


3. vstack()函数 

函数原型：vstack(tup) ，参数tup可以是元组，列表，或者numpy数组，返回结果为numpy的数组。看下面的代码体会它的含义

import numpy as np
a=[1,2,3]
b=[4,5,6]
print(np.vstack((a,b)))

输出：
[[1 2 3]
 [4 5 6]]

import numpy as np
a=[[1],[2],[3]]
b=[[1],[2],[3]]
c=[[1],[2],[3]]
d=[[1],[2],[3]]
print(np.vstack((a,b,c,d)))

输出：
[[1]
 [2]
 [3]
 [1]
 [2]
 [3]
 [1]
 [2]
 [3]
 [1]
 [2]
 [3]]

它是垂直（按照行顺序）的把数组给堆叠起来。

知识点8：plt.axhline()、plt.axvline()

 

原文代码：

plt.axvline(0.0, color='k') # 在坐标轴上加一条竖直的线，0.0为竖直线在坐标轴上的位置

axhline()表示绘制了一条y=0的水平线

axvline()表示绘制了一条x=0的垂直线

axhline(4)表示绘制了一条y=4的水平线

l=[-1, 1, -10, 10]
plt.axis(l)
plt.axhline()
plt.axvline()
plt.axhline(4)

知识点9：plt.axhspan(ymin,ymax,xmin,xmax) —— 添加一个穿越axis的水平矩形（span）

原文代码：

plt.axhspan(0.0,1.0,facecokor='1.0',alpha=1.0,ls='dotted')

eg：

import matplotlib.pyplot as plt
plt.plot([1,3,4,8])
plt.axhspan(1,2,0.5,1)
plt.show()

知识点10：sklearn逻辑回归LR

原文代码：

from sklearn.linear_model import LogisticRegression
lr = LogisticRegression(C=1000.0,random_state=0)

eg：

from sklearn.linear_model import LogisticRegression
# 定义逻辑回归模型
model = LogisticRegression(penalty=’l2’, dual=False, tol=0.0001, C=1.0, 
    fit_intercept=True, intercept_scaling=1, class_weight=None, 
    random_state=None, solver=’liblinear’, max_iter=100, multi_class=’ovr’, 
    verbose=0, warm_start=False, n_jobs=1)

"""参数
---
    penalty：使用指定正则化项（默认：l2）
    dual: n_samples > n_features取False（默认）
    C：正则化lambda的倒数，值越小正则化强度越大
    n_jobs: 指定线程数
    random_state：随机数生成器
    fit_intercept: 是否需要常量
"""

知识点11：plt.ylim(0,20) # 设置y轴刻度的范围,从0~20

知识点12：二叉决策树中常用的三个不纯度衡量标准：基尼系数（Gini index）、熵（entropy），误分类率（classification error）

知识点13：Python sklearn库中决策树tree.DecisionTreeClassifier()函数参数介绍

 使用sklearn中自带的决策树方法简单代码 如下：

from sklearn import tree
 
mode = tree.DecisionTreeClassifier(criterion='gini')
 
mode.fit(X,Y)
y_test = mode.predict(x_test)

 其中对于函数 tree.DecisionTreeClassifier()中的具体参数，在sklearn的官网中有给出，如下：

class sklearn.tree.DecisionTreeClassifier(criterion='gini', splitter='best',max_depth=None, min_samples_split=2,min_samples_leaf =1, min_weight_fraction_leaf=0.0, max_features=None, random_state=None, max_leaf_nodes=None,class_weight=None, presort=False)

 

根据官网提供的信息，这里进行了简单的翻译（自己理解的也不够透彻，仅供简单参考）：

criterion:string类型，可选（默认为"gini"）
    衡量分类的质量。支持的标准有"gini"代表的是Gini impurity(不纯度)与"entropy"代表的是information gain（信息增益）。

splitter:string类型，可选（默认为"best"）
    一种用来在节点中选择分类的策略。支持的策略有"best"，选择最好的分类，"random"选择最好的随机分类。

max_features:int,float,string or None 可选（默认为None）
    在进行分类时需要考虑的特征数。
    1.如果是int，在每次分类是都要考虑max_features个特征。
    2.如果是float,那么max_features是一个百分率并且分类时需要考虑的特征数是int(max_features*n_features,其中n_features是训练完成时发特征数)。
    3.如果是auto,max_features=sqrt(n_features)
    4.如果是sqrt,max_features=sqrt(n_features)
    5.如果是log2,max_features=log2(n_features)
    6.如果是None，max_features=n_features
    注意：至少找到一个样本点有效的被分类时，搜索分类才会停止。

max_depth:int or None,可选（默认为"None"）
    表示树的最大深度。如果是"None",则节点会一直扩展直到所有的叶子都是纯的或者所有的叶子节点都包含少于min_samples_split个样本点。忽视max_leaf_nodes是不是为None。

 

min_samples_split:int,float,可选（默认为2）
    区分一个内部节点需要的最少的样本数。    
    1.如果是int，将其最为最小的样本数。
    2.如果是float，min_samples_split是一个百分率并且ceil(min_samples_split*n_samples)是每个分类需要的样本数。ceil是取大于或等于指定表达式的最小整数。

min_samples_leaf:int,float,可选（默认为1）
    一个叶节点所需要的最小样本数：
    1.如果是int，则其为最小样本数
    2.如果是float，则它是一个百分率并且ceil(min_samples_leaf*n_samples)是每个节点所需的样本数。

min_weight_fraction_leaf:float,可选（默认为0）
    一个叶节点的输入样本所需要的最小的加权分数。

max_leaf_nodes:int,None 可选（默认为None）
    在最优方法中使用max_leaf_nodes构建一个树。最好的节点是在杂质相对减少。如果是None则对叶节点的数目没有限制。如果不是None则不考虑max_depth.


class_weight:dict,list of dicts,"Banlanced" or None,可选（默认为None）
    表示在表{class_label:weight}中的类的关联权值。如果没有指定，所有类的权值都为1。对于多输出问题，一列字典的顺序可以与一列y的次序相同。
    "balanced"模型使用y的值去自动适应权值，并且是以输入数据中类的频率的反比例。如：n_samples/(n_classes*np.bincount(y))。
    对于多输出，每列y的权值都会想乘。
    如果sample_weight已经指定了，这些权值将于samples以合适的方法相乘。


random_state:int,RandomState instance or None
    如果是int,random_state 是随机数字发生器的种子；如果是RandomState，random_state是随机数字发生器，如果是None，随机数字发生器是np.random使用的RandomState instance.


persort:bool,可选（默认为False）
    是否预分类数据以加速训练时最好分类的查找。在有大数据集的决策树中，如果设为true可能会减慢训练的过程。当使用一个小数据集或者一个深度受限的决策树中，可以减速训练的过程。

原文代码：

from sklearn.tree import DecisionTreeClassifier
tree = DecisionTreeClassifier(criterion='entropy',max_depth=3,random_state=0)

调整图像边缘及图像间的空白间隔

图像外部边缘的调整可以使用plt.tight_layout()进行自动控制，此方法不能够很好的控制图像间的间隔。

如果想同时控制图像外侧边缘以及图像间的空白区域，使用命令：

plt.subplots_adjust(left=0.2, bottom=0.2, right=0.8, top=0.8，hspace=0.2, wspace=0.3)

 知识点11：参数化模型和非参数化模型

 

  知识点12：KNN算法

 步骤：

1）选择近邻的数量k和距离度量方法。

2）找到待3分类样本的k个最近邻居。

3）根据最近的类标邻居进行多少投票。

     基于选定距离度量标准，KNN算法从训练集数据中找到与待预测目标点的k个距离最近的样本。目标点的类标基于这k个最近的邻居的类标使用多数投票确定。

from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=5,p=2,metric='minkowski')

n_neighbors=5           

int 型参数    knn算法中指定以最近的几个最近邻样本具有投票权，默认参数为5

　　weights='uniform'       

str参数        即每个拥有投票权的样本是按什么比重投票，'uniform'表示等比重投票，'distance'表示按距离反比投票，[callable]表示自己定义的一个函数，这个函数接收一个

距离数组，返回一个权值数组。默认参数为‘uniform’

　　algrithm='auto'           

str参数       即内部采用什么算法实现。有以下几种选择参数：'ball_tree':球树、'kd_tree':kd树、'brute':暴力搜索、'auto':自动根据数据的类型和结构选择合适的算法。默认情况下是‘auto’。暴力搜索就不用说了大家都知道。具体前两种树型数据结构哪种好视情况而定。KD树是对依次对K维坐标轴，以中值切分构造的树,每一个节点是一个超矩形，在维数小于20时效率最高--可以参看《统计学习方法》第二章。ball tree 是为了克服KD树高维失效而发明的，其构造过程是以质心C和半径r分割样本空间，每一个节点是一个超球体。一般低维数据用kd_tree速度快，用ball_tree相对较慢。超过20维之后的高维数据用kd_tree效果反而不佳，而ball_tree效果要好，具体构造过程及优劣势的理论大家有兴趣可以去具体学习。

　　leaf_size=30               

int参数      基于以上介绍的算法，此参数给出了kd_tree或者ball_tree叶节点规模，叶节点的不同规模会影响数的构造和搜索速度，同样会影响储树的内存的大小。具体最优规模是多少视情况而定。

　　matric='minkowski'     

str或者距离度量对象   即怎样度量距离。默认是闵氏距离，闵氏距离不是一种具体的距离度量方法，它可以说包括了其他距离度量方式，是其他距离度量的推广，具体各种距离度量只是参数p的取值不同或者是否去极限的不同情况，具体大家可以参考这里，讲的非常详细    　　　　　　　　　　　　　　　　　　　　　　　　　　　　

   

　　p=2                         

int参数       就是以上闵氏距离各种不同的距离参数，默认为2，即欧氏距离。p=1代表曼哈顿距离等等

　　metric_params=None                

距离度量函数的额外关键字参数，一般不用管，默认为None

　　n_jobs=1                

int参数       指并行计算的线程数量，默认为1表示一个线程，为-1的话表示为CPU的内核数，也可以指定为其他数量的线程，这里不是很追求速度的话不用管，需要用到的话去看看多线程。