基本机器学习算法思想以及编程实现

Posted 小鱼吻水

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了基本机器学习算法思想以及编程实现相关的知识,希望对你有一定的参考价值。

概要

把常用的机器学习算法:\\(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)\\),那么可以使用下面的计算方法:
\\begin{align}
p(c|x) = \\frac{p(x|c)p(c)}{p(x)} \\notag
\\end{align}

朴素贝叶斯假设特征之间相互独立,这个假设正是朴素贝叶斯中“朴素”一词的含义。朴素贝叶斯分类器中的另一个假设是每个特征同等重要。这两个假设虽然存在一些小瑕疵,但朴素贝叶斯的实际效果却很好。
 

使用条件概率来分类

 
贝叶斯决策理论要求计算两个概率 \\(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 函数具体的计算公式如下:
\\begin{align}
\\sigma(z) = \\frac{1}{1+\\mathrm{e}^{-z}} \\notag
\\end{align}
显然 \\(\\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 最大的簇进行划分,直到簇数目达到用户指定的数目为止。

以上是关于基本机器学习算法思想以及编程实现的主要内容,如果未能解决你的问题,请参考以下文章

SIGAI机器学习第二十五集 聚类算法2

机器学习-决策树

为啥要选择Python语言实现机器学习算法

第一章 为什么我们对机器学习感兴趣?

机器学习-决策树的基本思想

希尔排序的介绍和希尔排序基本思想以及代码实现