郑捷《机器学习算法原理与编程实践》学习笔记（第一章机器学习基础）

时间 2019-11-20

标签机器学习算法原理与编程实践学习笔记第一章机器基础繁體版

原文原文链接

第一章机器学习的基础python

1.1编程语言与开发环境算法

1.1.1 Python 安装（略）编程

1.2.2 Python安装包的安装：能够选选择安装集成包anaconda（略）dom

1.1.3 IDE配置及安装测试机器学习

　　IDE选择UltraEdit高级文本编辑器，配置步骤以下：编程语言

　　（1）选择“高级”-->“用户工具”命令，如图1.4所示。编辑器

　　图1.5 配置UltraEdit步骤1ide

　　（2）在如图1.5所示输入各项参数，而后单击“应用按钮”函数

　　　图1.5 配置UltraEdit步骤2工具

　　（3）按照如图1.6所示进行设置，而后单击“肯定”按钮

　　图1.6 配置UltraEdit步骤3

　　经过测试代码，检验安装效果：

#coding:utf-8
#Filename:mytest1.py

import numpy as np      #导入NumPy库
from numpy import *  #导入NumPy库
import matplotlib.pyplot as plt

#测试数据集————二维list
dataSet = [[1,2],[3,4],[5,6],[7,8],[9,10]]

dataMat = mat(dataSet).T    #将数据集转换为NumPy矩阵，并转秩
plt.scatter(dataMat[0],dataMat[1],c = 'red',marker = 'o') #绘制数据散点图

#绘制直线图形
X = np.linspace(-2,2,100)      #产生直线数据
#创建线性方程
Y = 2.8*X+9

plt.plot(X,Y)                   #绘制直线图
plt.show()                      #显示绘制效果

　　图1.7 显示执行效果

1.2 对象、矩阵与矢量化编程

1.2.1对象与维度（略）

1.2.2初识矩阵（略）

1.2.3矢量化编程与GPU运算（略）

1.2.4理解数学公式与NumPy矩阵运算

1.矩阵的初始化

#coding:utf-8 import numpy as np #导入NumPy包 #建立3*5的全0矩阵和全1的矩阵 myZero = np.zeros([3,5])#3*5的全0矩阵 print myZero myZero = np.ones([3,5])##3*5的全1矩阵 print myZero

输出结果：

Connected to pydev debugger (build 141.1580)
[[ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.]]
[[ 1.  1.  1.  1.  1.] [ 1. 1. 1. 1. 1.] [ 1. 1. 1. 1. 1.]]

#生成随机矩阵 myRand = np.random.rand(3,4)#3行4列的0~1之间的随机数矩阵 print myRand 输出结果以下： [[ 0.14689327 0.15077077 0.88018968 0.75112348] [ 0.30944489 0.77563281 0.82905038 0.25430367] [ 0.53958541 0.89695376 0.90681161 0.25453046]]

#单位阵 myEye = np.eye(3)#3*3的矩阵 print myEye 输出结果以下： [[ 1. 0. 0.] [ 0. 1. 0.] [ 0. 0. 1.]]

2.矩阵的元素运算

矩阵的元素运算是指矩阵在元素级别的加减乘除运算。

#元素的加和减：条件是矩阵的行数和列数必须相同 from numpy import *#导入NumPy包 myOnes = ones([3,3])#3*3的全1矩阵 myEye = eye（3） print myOnes+myEye print myOnes-myEye 输出结果以下： [[ 2. 1. 1.] [ 1. 2. 1.] [ 1. 1. 2.]] [[ 0. 1. 1.] [ 1. 0. 1.] [ 1. 1. 0.]]

#矩阵乘法 mymatrix = mat([[1,2,3],[4,5,6],[7,8,9]]) a = 10 print a*mymatrix 输出结果： [[10 20 30] [40 50 60] [70 80 90]]

#矩阵全部元素求和 mymatrix = mat([[1,2,3],[4,5,6],[7,8,9]]) print mymatrix.sum() 输出结果： 45

''' 矩阵各元素的积：矩阵的点乘同维对应元素的相乘。 当矩阵的维度不一样时，会根据必定的广播将维数扩 充到一致的形式 ''' mymatrix1 = mat([[1,2,3],[4,5,6],[7,8,9]]) mymatrix2 = 1.5*ones([3,3]) print multiply(mymatrix1,mymatrix2) 输出结果： [[ 1.5 3. 4.5] [ 6. 7.5 9. ] [ 10.5 12. 13.5]]

#矩阵各元素的n次幂:n=2 mymatrix1 = mat([[1,2,3],[4,5,6],[7,8,9]]) print power(mymatrix1,2) 输出结果： [[ 1 4 9] [16 25 36] [49 64 81]]

#矩阵乘以矩阵 mymatrix1 = mat([[1,2,3],[4,5,6],[7,8,9]]) mymatrix2 = mat([[1],[2],[3]]) print mymatrix1*mymatrix2 输出结果： [[14] [32] [50]]

#矩阵的转置 mymatrix1 = mat([[1,2,3],[4,5,6],[7,8,9]]) print mymatrix1.T #矩阵的转置 mymatrix1.transpose() #矩阵的转置 print mymatrix1 输出结果以下： [[1 4 7] [2 5 8] [3 6 9]] [[1 2 3] [4 5 6] [7 8 9]]

mymatrix = mymatrix1[0]#按行切片 print u"按行切片：",mymatrix mymatrix = mymatrix1.T[0]#按列切片 print u"按列切片：",mymatrix mymatrix = mymatrix1.copy()#矩阵的复制 print u"复制矩阵：",mymatrix #比较 print u"矩阵元素的比较:\n",mymatrix<mymatrix1.T 输出结果： 矩阵的行数和列数： 3 3 按行切片： [[1 2 3]] 按列切片： [[1 4 7]] 复制矩阵： [[1 2 3] [4 5 6] [7 8 9]] 矩阵元素的比较: [[False True True] [False False True] [False False False]]

1.2.5 Linalg线性代数库

　　在矩阵的基本运算基础之上，NumPy的Linalg库能够知足大多数的线性代数运算。

　　.矩阵的行列式

　　.矩阵的逆

　　.矩阵的对称

　　.矩阵的秩

　　.可逆矩阵求解线性方程

1.矩阵的行列式

In [4]: from numpy import * In [5]: #n阶矩阵的行列式运算  In [6]: A = mat([[1,2,3],[4,5,6],[7,8,9]]) In [7]: print "det(A):",linalg.det(A) det(A): 6.66133814775e-16

2.矩阵的逆

In [8]: from numpy import * In [9]: A = mat([[1,2,3],[4,5,6],[7,8,9]]) In [10]: invA = linalg.inv(A)#矩阵的逆  In [11]: print "inv(A):",invA inv(A): [[ -4.50359963e+15 9.00719925e+15 -4.50359963e+15] [ 9.00719925e+15 -1.80143985e+16 9.00719925e+15] [ -4.50359963e+15 9.00719925e+15 -4.50359963e+15]]

3.矩阵的对称

In [12]: from numpy import * In [13]: A = mat([[1,2,3],[4,5,6],[7,8,9]]) In [14]: AT= A.T In [15]: print A*AT [[ 14 32 50] [ 32 77 122] [ 50 122 194]]

4.矩阵的秩

In [16]: from numpy import * In [17]: A = mat([[1,2,3],[4,5,6],[7,8,9]]) In [18]: print linalg.matrix_rank(A)#矩阵的秩 2

5.可逆矩阵求解

1.3 机器学习的数学基础

1.3.1 类似度的度量

　　范数（来自百度百科）：向量的范数能够简单、形象的理解为长度，或者向量到坐标系原点的距离，或者相应空间内两点之间的距离。

　　向量的范数定义：向量的范数是一个函数||x||,知足非负性||x||≥0，齐次性||cx|| = |c| ||x||,三角不等式||x+y||≤||x||+||y||。

　　L1范数:||x||为x向量各个元素绝对值之和

　　L2范数：||x||为x向量各个元素的平方和的开方。L2范数又称Euclidean范数或者Frobenius范数

　　Lp范数：||x||为x向量各个元素绝对值p次方和的1/p次方。

　　L∞范数：||x||为x向量各个元素绝对值最大的元素，以下：

　　向量范数的运算以下：

In [27]: A = [8,1,6]

In [28]: #手工计算  In [29]: modA = sqrt(sum(power(A,2))) In [30]: #库函数  In [31]: normA = linalg.norm(A) In [32]: print "modA:",modA,"norm(A):",normA modA: 10.0498756211 norm(A): 10.0498756211

1.3.2 各种距离的意义与Python代码的实现　　本小节所列的距离公式列表和代码以下：

　　•闵可夫斯基距离（Minkowski Distance）

　　•欧式距离(Euclidean Distance)

　　•曼哈顿距离(Manhattan Distance)

　　•切比雪夫距离(Chebyshev Distance)

　　•夹角余弦(Cosine)

　　•汉明距离(Hamming Distance)

　　•杰卡德类似系数(Jaccard Similiarity Coeffcient)

　　1. 闵可夫斯基距离（Minkowski Distance）

　　严格意义上讲，闵可夫斯基距离不是一种距离，而是一组距离的定义。

　　两个n维变量A（x₁₁，x₁₂,...,x_1n）与B（x₂₁，x₂₂,...,x_2n）间的闵可夫斯基距离定义为：

　　其中p是一个变参数

　　•当p=1时，就是曼哈顿距离

　　•当p=2时，就是欧式距离

　　•当p=∞时，就是切比雪夫距离

　　根据变参数的不一样，闵可供夫斯基能够表示一类的距离

　　2.欧式距离（Euclidean Distance）

　　欧氏距离（L2范数）是最易于理解的一种距离计算方法，源自欧式空间中两点间的距离公式，如图所示

　　（1）二维平面上两点a(x₁,y₁)与b（x₂,y₂）间的欧式距离

　　　　　（2）三维空间两点A（x₁,y₁,z₁）与B（x₂,y₂,z₂）

　　（3）　两个n维向量A(x₁₁,x₁₂,...,x_1n)与B(x₂₁,x₂₂,...,x_2n)间的欧氏距离：

　　（4）Python实现欧式距离

In [33]: from numpy import * In [34]: vector1 = mat([1,2,3]) In [35]: vector2 = mat([4,5,6]) In [36]: print sqrt((vector1-vector2)*((vector1-vector2).T)) [[ 5.19615242]]

　　3.曼哈顿距离（Manhattan Distance）　　

　　（1）二维平面两点A(x₁,y₁)与B(x_2,y₂)间的曼哈顿距离：

　（2）两个n维向量A(x₁₁,x₁₂,...,x_1n)与B（x₂₁,x₂₂,...,x_2n）间的曼哈顿距离

　　（3）Python实现曼哈顿

In [1]: from numpy import * In [2]: vector1 = mat([1,2,3]) In [3]: vector2 = mat([4,5,6]) In [4]: print sum(abs(vector1-vector2)) 9

　　四、切比雪夫距离（Chebyshev Distance）

　　（1）二维平面两点A(x₁,y₁)与B（x₂,y₂）间的切比雪夫距离：

　　（2）两个n维平面两点A(x₁₁,y_12，..,x_1n)与B（x₂₁,y_22，..,x_2n）间的切比雪夫距离：　　　　

　　这个公式的另一种等价形式是：

　　（3）Python实现切比雪夫距离。

In [1]: from numpy import * In [2]: vector1 = mat([1,2,3]) In [3]: vector2 = mat([4,7,5]) In [4]: print abs(vector1-vector2).max() 5

　　5.夹角余弦（Consine）

　　几何中的夹角余弦可用来衡量两个向量方向的差别

　　（1）二维平面两点A(x₁,y₁)与B（x₂,y₂）间的夹角余弦公式：

　　(2)两个n维样本点A（x₁₁,x₁₂,x₁₃,...,x_1n）与B（x₂₁,x₂₂,...,x_2n）的夹角余弦：

　　即：

　　夹角余弦取值范围为[-1,1]。夹角余弦越大，表示向量的夹角越小；夹角余弦越小，表示两个向量的夹角越大。当两个向量的方向重合时，夹角余弦取最大值1；当两个向量的方向彻底相反时，夹角余弦取值最小值-1.

　　（3）Python实现夹角余弦

In [7]: from numpy import * In [8]: vector1 = mat([1,2,3]) In [9]: vector2 = mat([4,7,5]) In [10]: cosV12 = dot(vector1,vector2.T)/(linalg.norm(vector1)*linalg.norm(vector2)) In [11]: print cosV12 [[ 0.92966968]]

　　6.汉明距离（Hamming Distance）

　　（1）汉明距离的定义：两个等长的字符串s1和s2之间的汉明距离定义为将其中一个变为另一个所须要的最小替换次数。例如字符串“111“与“1001”之间的汉明距离为2.

　　应用：信息编码（为了加强容错性，应使编码间的最小汉明距离尽量大）。

　　（2）使用Python实现汉明距离。

In [20]: from numpy import * In [21]: matV = mat([[1,1,0,1,0,1,0,0,1],[0,1,1,0,0,0,1,1,1]]) In [22]: smstr = nonzero(matV[0]-matV[1]) In [23]: smstr Out[23]: (array([0, 0, 0, 0, 0, 0], dtype=int64), array([0, 2, 3, 5, 6, 7], dtype=int64)) In [24]: print shape(smstr[0]) (6L,)

　　7.杰卡德类似系数（Jaccard Similarity Coefficient）

　　（1）杰卡德类似系数：两个集合A和B的交集元素在A、B的并集中所占的比例，成为两个集合的杰卡德类似系数，用符号J(A,B)表示。

　　杰卡德类似系数是衡量两个集合的类似度的一种指标。

　　（2）杰卡德距离：与杰卡德类似系数相反的概念是杰卡德距离（Jaccard Distance），杰卡德距离可用以下的公式表示：

　　杰卡德距离用两个集合中不一样元素占全部元素的比例来衡量两个集合的区分度

　　（3）杰卡德类似系数与杰卡德距离的应用。

　　可将杰卡德类似系数用在衡量样本的类似度上。

　　样本A与样本B是两个n维向量，并且全部维度上的取值都是0或者1.例如，A（0111）和B（1011）。咱们将样本当作一个集合，1表示该集合包含该元素，0表示集合不包含该元素。

　　P：样本A与B都是1的维度的个数

　　q：样本A是一、样本B是0的维度的个数

　　r: 样本A是0、样本B是1的维度的个数

　　s：样本A与B都是0的维度的个数

　　那么样本A与B的杰卡德类似系数能够表示为：

　　这里p+q+r能够理解为A与B的并集的元素个数，而p是A与B的交集的元素个数。

　　（4）Python实现杰卡德距离。

In [25]: from numpy import * In [26]: import scipy.spatial.distance as dist #导入Scipy距离公式  In [27]: matV = mat([[1,1,0,1,0,1,0,0,1],[0,1,1,0,0,0,1,1,1]]) In [28]: print "dist.jaccard:",dist.pdist(matV,'jaccard') dist.jaccard: [ 0.75]

　 1.3.3理解随机性（略）

　 1.3.4回顾几率论（略）

　　1.3.5多元统计基础（略）

　　1.3.6特征相关性

　　1.相关系数

　　（1）相关系数定义：

　　（2）相关距离定义：

　　（3）Python实现相关系数

In [13]: from numpy import *

In [14]: matV = mat([[1,1,0,1,0,1,0,0,1],[0,1,1,0,0,0,1,1,1]])
    ...:

In [15]: mv1 = mean(matV[0])#第一列的均值

In [16]: mv2 = mean(matV[1])#第二列的均值

In [17]: #计算两列的标准差

In [18]: dv1 = std(matV[0])

In [19]: dv2 = std(matV[1])

In [20]: corref = mean(multiply(matV[0]-mv1,matV[1]-mv2))/(dv1*dv2)

In [21]: print corref

2马氏距离

　　（1）马氏距离的定义：有M个样本向量X1~Xm，协方差矩阵记为S，均值记为向量μ，则其中样本向量X到μ的距离为：

　　而其中xi与Xj之间的马氏距离为：

　　若协方差矩阵是单位矩阵（各个样本向量之间独立同分布），则公式变成欧式距离公式：

　　若协方差是对角矩阵，则公式变成可标准化的欧式距离公式

　　（2）马氏距离的优势：量纲无关，排除变量之间的相关性的干扰。

　　（3）马氏距离的Python计算：

In [49]: from numpy import *

In [50]: matV = mat([[1,1,0,1,0,1,0,0,1],[0,1,1,0,0,0,1,1,1]])

In [51]: covinv = linalg.inv(cov(matV))

In [52]: tp =matV.T[0]-matV.T[1]

In [53]: distma = sqrt(dot(dot(tp,coninv),tp.T))

In [54]: distma = sqrt(dot(dot(tp,covinv),tp.T))

In [55]: distma
Out[55]: matrix([[ 2.02547873]])

　　1.3.7 再谈矩阵-空间的变换（略）

　　5.特征值和特征向量

　　python求取矩阵的特征值和特征向量。

In [56]: A = [[8,1,6],[3,5,7],[4,9,2]]

In [57]: evals,evecs = linalg.eig(A)

In [58]: print '特征值:',evals,'\n特征向量:',evecs
特征值: [ 15.           4.89897949  -4.89897949]
特征向量: [[-0.57735027 -0.81305253 -0.34164801]
 [-0.57735027  0.47140452 -0.47140452]
 [-0.57735027  0.34164801  0.81305253]]

　　1.3.8 数据的归一化

　　2.欧式距离标准化：

　　X* = （X-M）/S

　　标准化的后的值 = （标准化前的值-份量的均值）/份量的标准差

　　两个n维向量的之间的标准化的欧式距离公式：

　　标准化欧式距离Python的实现

In [2]: from numpy import *

In [3]: vectormat = mat([[1,2,3],[4,5,6]])

In [4]: v12 = vectormat[0]-vectormat[1]

In [5]: print sqrt(v12*v12.T)
[[ 5.19615242]]

In [6]: #norm

In [7]: varmat = std(vectormat.T,axis=0)

In [16]: normvmat =(vectormat-mean(vectormat))/varmat.T

In [17]: normv12 =normvmat[0]-normvmat[1]

In [18]: sqrt( normv12* normv12.T)
Out[18]: matrix([[ 8.5732141]])

　　1.4 数据处理和可视化

　　1.4.1 数据的导入和内存管理

　　1.数据表文件的读取

　　Python读取数据表例程：

#coding:utf-8
import sys
import os
from numpy import *

#配置UTF-8的输出环境
reload(sys)
sys.setdefaultencoding('utf-8')

#数据文件转矩阵
#path：数据文件路径
#delimiter：行内字段分隔符
def file2matrix(path,delimiter):
    recordlist = []
    fp         = open(path,"rb")#读取文件内容
    content    = fp.read()
    fp.close()
    rowlist    = content.splitlines()#按行转化为一维表
    #逐行遍历，结果按分割符分割为行向量
    recordlist = [map(eval,row.split(delimiter)) for row in rowlist if row.strip()]
    return  mat(recordlist)#返回转换后的矩阵形式
root = "testdata"         #数据文件所在路径
pathlist = os.listdir(root)
for path in pathlist:
    recordmat = file2matrix(root + "/"+path," ")#文件到矩阵的转换
    print shape(recordmat)

　　2.对象的持久化

　　有时候，咱们但愿数据以对象的方式保存。Pytho提供了cPickle模块支持对象的读写

#继续上面的代码
import cPickle as pickle #导入序列化库

file_obj = open(root +"/recordmat.dat","wb")
pickle.dump(recordmat[0],file_obj)#强生成的矩阵对象保存到指定的位置
file_obj.close()
#c此段代码可将刚才转换为矩阵的数据持久化为对象的文件
#读取序列化后的文件
read_obj = open(root+"/recordmat.dat","rb")
readmat = pickle.load(read_obj) #从指定的位置读取对象
print shape(readmat)

　　3.高效的读取大文本的文件

#按行读取文件，读取指定的行数：nmax = 0 按行读取所有
def readfilelines(path,nmax = 0):
    fp = open(path,"rb")
    ncount = 0 #读取行
    while True:
        content = fp.readline()
        if content == "" or (ncount>=nmax and nmax !=0):#判断文件尾或读完指定行数
            break
        yield content#返回读取的行
        if nmax != 0:
            ncount += 1
        fp.close()
root = "testdata/01.txt"         #数据文件所在路径
for line in readfilelines(path,nmax=10):#读取10行
    print  line.strip()

　　1.4.2 表与线性结构的可视化

　　示例代码：

In [1]: import numpy as np

In [2]: import matplotlib.pyplot as plt

In [3]: #曲线数据加入噪声

In [4]: x = np.linspace(-5,5,200)

In [5]: y = np.sin(x)  #给出y与x的基本关系

In [6]: yn = y+np.random.rand(1,len(y))*1.5#加入噪声的点集

In [7]: #绘图

In [8]: fig = plt.figure()

In [9]: ax = fig.add_subplot(1,1,1)

In [10]: ax.scatter(x,yn,c='blue',marker='o')
Out[10]: <matplotlib.collections.PathCollection at 0x6b7f780>

In [11]: ax.plot(x,y+0.75,'r')
Out[11]: [<matplotlib.lines.Line2D at 0x6d510f0>]

In [12]: plt.show()

　　1.4.3 树与分类结构的可视化（略）

　　1.4.4 图与网格结构的可视化（略）

资料来源及版权全部：《机器学习算法原理与编程实践》郑捷

郑捷《机器学习算法原理与编程实践》学习笔记（第一章 机器学习基础）

郑捷《机器学习算法原理与编程实践》学习笔记（第一章机器学习基础）