概要
把常用的机器学习算法：\\(k\\)-近邻算法、朴素贝叶斯、逻辑回归、\\(K\\)-均值聚类其思想有及 python 代码实现总结一下。做到既要知其然又要知其所以然。参考《机器学习实战》。
\\(k\\)-近邻算法
基本原理
\\(k\\)-近邻算法是分类数据最简单有效的方法。简单地来说，它采用测量不同特征值之间的距离方法进行分类。提取样本集中特征最相邻数据的分类标签，一般来说，我们只选择样本数据集中前 \\(k\\) 个最相似的数据。
代码实现
代码的关键是计算数据集中每个点与点之间的距离并按递增排序。牢记 distances.argsort() 返回的是数组 distances 中数值从小到大排序之后的索引位置，不得不说， python 的封装功能很强大。
def classify0(inX, dataSet, labels, k):
\'\'\'
inX: 用于分类的输入向量
dataSet: 输入的训练样本集
labels: 标签向量，数目与 dataSet 行数相同
k: 用于选择最近邻居的数目
\'\'\'
dataSetSize = dataSet.shape[0] # 样本数
diffMat = tile(inX, (dataSetSize,1)) - dataSet #np.tile把数据inX扩展成第二个参数形状
sqDiffMat = diffMat**2 #平方求欧氏距离
sqDistances = sqDiffMat.sum(axis=1) # 列求和，返回数组
distances = sqDistances**0.5 # 得到欧式距离
sortedDistIndicies = distances.argsort() # 数值从小到大 的索引位置
classCount = # 创建空字典，字典是无顺序的
\'\'\'
得到字典的 key 值可以用 get() 方法，如果 key 不存在，可以返回 None，或者自己指定
的 value， 比如下边的如果 key 不存在就给 0 值
\'\'\'
for i in range(k): # 选择距离最小的 k 个点
voteIlabel = labels[sortedDistIndicies[i]]
classCount[voteIlabel] = classCount.get(voteIlabel,0)+1
\'\'\'
python字典的items方法作用：是可以将字典中的所有项，以列表方式返回，每项是元组。
因为字典是无序的，所以用items方法返回字典的所有项，也是没有顺序的。
eg:A = \'a\':1, \'b\':2, \'c\':3 A.items() 输出为：
[(\'a\', 1), (\'c\', 3), (\'b\', 2)]
python字典的iteritems方法作用：与items方法相比作用大致相同，
只是它的返回值不是列表，而是一个迭代器。
\'\'\'
# operator模块提供的itemgetter函数用于获取对象的哪些维的数据，
# 参数为一些序号（即需要获取的数据在对象中的序号），
#itemgetter函数获取的不是值，而是定义了一个函数，通过该函数作用到对象上才能获取值
sortedClassCount = sorted(classCount.iteritems(), #将字典变成迭代器(列表形式)
key=operator.itemgetter(1), reverse=True) # 排序为逆序，即从大到小
return sortedClassCount[0][0]
优缺点
优点：精度高、对异常值不敏感、无数据输入假定
缺点：计算复杂度高、空间复杂度高，无法给出任何数据的基础结构信息
朴素贝叶斯
基本原理
贝叶斯决策理论的核心思想：选择具有最高概率的决策。
核心是贝叶斯准则，它告诉我们如何交换条件概率中的条件与结果，即如果已知 \\(P(x|c)\\)，要求 \\(P(c|x)\\)，那么可以使用下面的计算方法：
\\beginalign
p(c|x) = \\fracp(x|c)p(c)p(x) \\notag
\\endalign
朴素贝叶斯假设特征之间相互独立，这个假设正是朴素贝叶斯中“朴素”一词的含义。朴素贝叶斯分类器中的另一个假设是每个特征同等重要。这两个假设虽然存在一些小瑕疵，但朴素贝叶斯的实际效果却很好。
使用条件概率来分类
贝叶斯决策理论要求计算两个概率 \\(p(c_1|x)\\) 与 \\(p(c_2|x)\\)（对于二分类）。具体意义是：给定某个由 \\(x\\) 表示的数据点，那么该数据点来自类别 \\(c_1\\) 的概率是多少？来自 \\(c_2\\) 的概率又是多少？注意这些概率和 \\(p(x|c_1)\\) 并不一样，可以使用贝叶斯准则交换概率中条件与结果。使用这些定义，可以定义贝叶斯分类准则：
- 如果 \\(p(c_1|x) > p(c_2|x)\\)，那么属于类别 \\(c_1\\).
- 如果 \\(p(c_1|x) < p(c_2|x)\\)，那么属于类别 \\(c_2\\).
对于一个实际的问题，我们需要做以下步骤：
- 统计计算 \\(p(c_i),\\quad i=1,2\\).
- 接下来计算 \\(p(x| c_i)\\)，这里要用到朴素贝叶斯假设，如果将 \\(x\\) 展开一个个独立特征，则 \\(p(x|c_i)=p(x_0,x_1,\\cdots,x_n | c_i)= p(x_0|c_i)p(x_1|c_i)\\cdots p(x_n|c_i)\\).（如果每个数字过小，可以用到取对数的技巧）
- 假如要分类的向量是 \\(w\\)， 计算 \\(p(w|c_i)p(c_i),\\quad i=1,2\\)，哪个值大归于哪个类。
优缺点
优点：在数据较少的情况下仍然有效，可以处理多类别问题
缺点：对于输入数据的准备方式较为敏感
逻辑回归
基本原理
逻辑回归的目标是寻找一个非线性函数 Sigmoid 的最佳拟合参数，求解过程由最优化算法来完成。最常用的就是梯度上升算法。逻辑回归其实包含非常多的内容，面试中经常会被问到的问题，请点击.
Sigmoid 函数具体的计算公式如下：
\\beginalign
\\sigma(z) = \\frac11+\\mathrme^-z \\notag
\\endalign
显然 \\(\\sigma(0) = 0.5\\). 为了实现 Logsitic 回归分类器，我们可以在每个特征上都乘以一个回归系数，然后把所有的结果值相加，将这个总和代入 Sigmoid 函数中，进而得到一个范围在 \\(0 \\sim 1\\) 之间的数值。任何大于 \\(0.5\\) 的数据被分入 \\(1\\) 类，小于 \\(0.5\\) 即被归入 \\(0\\) 类。所以 Logistic 回归也可以被看成是一种概率估计。现在主要的问题是 ：如何确定最佳回归系数？我们定义好代价函数之后，用梯度上升算法即可求解。
代码实现
该算法的主要部分就是梯度上升算法的编写，下面给出：
def gradAscent(dataMatIn, classLabels): # 梯度上升算法
m, n = np.shape(dataMatIn)
alpha = 0.001
maxCycles = 500
weights = np.ones(n) # 1*n 的数组
for k in range(maxCycles):
h = sigmoid(np.dot(dataMatIn, weights)) # 1*m 的数组，sigmoid 是 Sigmoid 函数，自己编写
error = classLabels - h
weights = weights+alpha*np.dot(error, dataMatIn) // 在这里是按差值方向调整，也可以求解出梯度
return weights
def stocGradAscent0(dataMatIn, classLabels, numIter=40): # 随机梯度上升算法
m, n = np.shape(dataMatIn)
#maxCycles = 500
weights = np.ones(n) # 初始化权重，1*n 的数组
for j in range(numIter):
dataIndex = range(m)
for i in range(m):
alpha = 4 / (1.+j+i)+0.01 # 迭代步长设定
randIndex = int(np.random.uniform(0, len(dataIndex))) # 与梯度上升唯一的区别：随机选取更新
h = sigmoid(np.sum(dataMatIn[randIndex]*weights)) # 一个数
error = classLabels[randIndex] - h # 一个向量
weights = weights+alpha*error*dataMatIn[randIndex]
del(dataIndex[randIndex])
return weights
优缺点
优点：计算代价不高，易于理解和实现
缺点：容易欠拟合，分类精度可能不高
\\(K\\) 均值聚类
基本原理
聚类是一种无监督的学习，它将相似的对象归到同一个簇中。\\(K\\) 均值聚类之所以称之为 \\(K\\) 均值是因为它可以发现 \\(k\\) 个不同的簇，且每个簇的中心采用簇中所含值的均值计算而成。
\\(K\\) 均值聚是发现给定数据集中 \\(k\\) 个簇的算法。簇个数 \\(k\\) 是用户给定的，每一个簇通过其质心，即簇中所有点的中心来描述。其算法流程：
创建 k 个点作为起始质心（经常随机选择）
当任意一个点的簇分配结果发生改变时（说明还没收敛）
对数据集中的每个数据点
对每个质心
计算质心与数据点之间的距离
数据点分配到距其最近的簇
对每一个簇，计算簇中所有点的均值并将均值作为质心
代码实现
假设我们对一堆数据点进行聚类操作，数据点来自机器学习实战。代码如下：
# coding:utf-8
import numpy as np
def loadDataSet(fileName): #general function to parse tab -delimited floats
dataMat = [] #assume last column is target value
fr = open(fileName)
for line in fr.readlines():
curLine = line.strip().split(\'\\t\')
fltLine = list(map(float,curLine)) #map all elements to float()
dataMat.append(fltLine) #一个列表包含很多列表
return np.array(dataMat)
def distEclud(vecA, vecB):
return np.sqrt(sum(np.power(vecA - vecB, 2))) #la.norm(vecA-vecB)
def randCent(dataSet, k): # 构建簇质心，矩阵dataSet 每行表示一个样本
n = np.shape(dataSet)[1]
centroids = np.zeros((k,n)) #create centroid mat
for j in range(n):
minJ = min(dataSet[:,j]) # 随机质心必须要在整个数据集的边界之内
rangeJ = float(max(dataSet[:,j]) - minJ)
centroids[:,j] = (minJ + rangeJ * np.random.rand(k,1)).flatten() #随机
return centroids
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
m = np.shape(dataSet)[0] # m 个样本
clusterAssment = np.zeros((m,2))#创建一个矩阵来存储每个点的分配结果
#两列：一列记录索引值，第二列存储误差
centroids = createCent(dataSet, k) # 创建 k 个质心
clusterChanged = True
while clusterChanged:
clusterChanged = False
for i in range(m): #将每个点分配到最近的质心
minDist = np.inf; minIndex = -1
for j in range(k): # 寻找最近的质心
distJI = distMeas(centroids[j,:],dataSet[i,:])
if distJI < minDist:
minDist = distJI; minIndex = j
if clusterAssment[i,0] != minIndex: # 直到数据点的簇分配结果不再改变
clusterChanged = True
clusterAssment[i,:] = minIndex,minDist**2
#print (centroids)
for cent in range(k): #重新计算质心，更新质心的位置
ptsInClust = dataSet[np.nonzero(clusterAssment[:,0] == cent)] # 通过数组过滤来获得给定簇的所有点
centroids[cent,:] = np.mean(ptsInClust, axis=0) #计算所有点的均值
return centroids, clusterAssment # 返回所有的类质心与点分配结果
import matplotlib.pyplot as plt
if __name__ == \'__main__\':
datMat = loadDataSet(\'testSet.txt\')
k = 4
centroids = randCent(datMat, k)
#print(centroids)
myCentroids, clustAssing = kMeans(datMat, 4)
fig = plt.figure()
ax = fig.add_subplot(1,1,1)
#ax.scatter(datMat[:,0], datMat[:,1]) # 必须是 array 类型
scatterMarkers = [\'s\', \'o\', \'^\', \'8\', \'p\', \'d\', \'v\', \'h\', \'>\', \'<\']
for i in range(k):
ptsIncurrCluster = datMat[np.nonzero(clustAssing[:,0] == i)]
ax.scatter(ptsIncurrCluster[:,0], ptsIncurrCluster[:,1], marker=scatterMarkers[i], s=90)
ax.scatter(myCentroids[:,0], myCentroids[:,1], marker=\'+\', s=300)
plt.show()
可视化如下图：
由于初始质心的随机选择，每次运行结果会稍微有所不同。
优缺点
- 优点：容易实现
- 缺点：可能收敛到局部最小值，在大规模数据集上收敛较慢
如何确定超参 \\(k\\)?
如果 \\(k\\) 选择的过于小，该算法收敛到了局部最小值，而非全局最小值。一种用于度量聚类效果的指标是 SSE（Sum of Squared Error，误差平方和），对应程度中 clusterAssment 矩阵的第一列之和。SSE 值越小表示数据点越接近于它们的质心，聚类效果也越好。一种肯定可以降低 SSE 值的方法是增加簇的个数，但这违背了聚类的目标。聚类的目标是在保持簇数目不变的情况下提高簇的质量。
那么如何提高呢？一种方法是将具有最大 SSE 值的簇划分成两个簇。具体实现时可以将最大簇包含的点过滤出来并在这些点上运行 \\(K\\) 均值算法，为了保持簇总数不变，可以将某两个簇进行合并，这两个簇的选择一般有两种可以量化的方法：合并最近的质心，或者合并两个使得 SSE 增幅最小的质心。
二分 \\(K\\) 均值算法
为克服 \\(K\\) 均值算法收敛于局部最小值的问题，有人提出了另一个称为二分 \\(K\\) 均值的算法。该算法首先将所有点作为一个簇，然后将该簇一分为二。之后选择一个簇继续进行划分，选择哪一个簇进行划分取决于对其划分是否可以最大程度降低 SSE 的值。上述基于 SSE 的划分过程为断重复，直到得到用户指定的簇数为止。另一种做法是选择 SSE 最大的簇进行划分，直到簇数目达到用户指定的数目为止。