2019-07-24 22:01:42 fbher 阅读数 26
  • 机器学习入门30天实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 系列课程包含Python机器学习库,机器学习经典算法原理推导,基于真实数据集案例实战3大模块。从入门开始进行机器学习原理推导,以通俗易懂为基础形象解读晦涩难懂的机器学习算法工作原理,案例实战中使用Python工具库从数据预处理开始一步步完成整个建模工作!具体内容涉及Python必备机器学习库、线性回归算法原理推导、Python实现逻辑回归与梯度下降、案例实战,信用卡欺诈检测、决策树与集成算法、支持向量机原理推导、SVM实例与贝叶斯算法、机器学习常规套路与Xgboost算法、神经网络。

    7608 人正在学习 去看看 唐宇迪

1.概念:

       什么是K临近算法,其实可以根据字面上了解,若我现在有一堆点,根据它们的特征我把它们分成若干类,现在再加入一个点,求出这个点是属于哪一个类,我们可以取K个点,然后我们再计算所有点到这个点的欧式距离或者某一种距离,然后选出离它最近的K个点,看这K个点中那种点比较多,然后就把这个点归为哪一类。

      什么是分类,分类是离散的,我们上面说的点的归类也是一种分类。

      什么是回归,回归是连续的,例如在二维坐标系中我们给出若干个点,求一条直线,这就是回归。

 

2.KNN实现分类

         1.我们用sklearn先生成一堆点,然后再用matplotlib将图像显示出来

           

            

2.再把它放进我们生成的KNN分类器中,图像就是我们的分类结果,不同颜色就是不同的类别,y2放的才是这个点正确的分类

 

3.答案

3.KNN实现回归 

生成点

 

2019-04-20 12:11:53 zz133110 阅读数 31
  • 机器学习入门30天实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 系列课程包含Python机器学习库,机器学习经典算法原理推导,基于真实数据集案例实战3大模块。从入门开始进行机器学习原理推导,以通俗易懂为基础形象解读晦涩难懂的机器学习算法工作原理,案例实战中使用Python工具库从数据预处理开始一步步完成整个建模工作!具体内容涉及Python必备机器学习库、线性回归算法原理推导、Python实现逻辑回归与梯度下降、案例实战,信用卡欺诈检测、决策树与集成算法、支持向量机原理推导、SVM实例与贝叶斯算法、机器学习常规套路与Xgboost算法、神经网络。

    7608 人正在学习 去看看 唐宇迪

K-临近算法

从今天开始,开始挖个坑。学习《机器学习实战》这本书,然后将学习的笔记记录下来。相关代码请参考:

https://github.com/pbharrin/machinelearninginaction
里面有数据集和源码。但是这是基于python2编写的代码。我的学习笔记都是基于python3 的。会有一些函数的不同。但是思路是一样的。

k近邻属于最简单的机器学习方法了,属于一种分类的方法,监督学习。原理就是计算待分类的点和训练集的距离。然后得出结果。其实准确的说训练集不妥当,因为该算法没有训练的过程,所以属于懒惰学习。

优点:精度高,对异常值不敏感,无数据输入假定

缺点:计算复杂度和空间复杂度高

简单实例

通过简单的一个例子。首先构造一个数据集如下:(记得安装numpy包)

from numpy import *
import operator 
def createDataSet():
    group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])
    labels = ['A','A','B','B']
    return group, labels
group,labels = createDataSet()

在(0,0)和(1,1)坐标附近分别有两个点AA和BB。然后给一个点(0,0),问这个点是属于A还是B。

解决思路如下,就是让(0,0)点分别和剩下的四个点算距离,然后取距离最近的k个值。

tile函数是干嘛的可以参考这篇文章,非常形象,两秒看懂:https://www.jianshu.com/p/9519f1984c70

dataSet = group
k=3
inX = [0,0]
# 计算距离
dataSetSize = dataSet.shape[0]
diffMat = tile(inX,(dataSetSize,1)) - dataSet
sqDiffMat = diffMat ** 2
sqDistances = sqDiffMat.sum(axis=1)
distances = sqDistances**0.5
sortedDistIndicies = distances.argsort()
classCount = {}
#选择距离最小的k个点
for i in range(k):
    voteIlable = labels[sortedDistIndicies[i]]
    classCount[voteIlable]=classCount.get(voteIlable,0)+1
#排序
sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)

print(sortedClassCount[0][0])
B

约会数据应用

然后就是通过约会数据做一个分类。如下有一种数据集,(可从这里下载:https://github.com/pbharrin/machinelearninginaction/blob/master/Ch02/datingTestSet.txt):

40920	8.326976	0.953952	largeDoses
14488	7.153469	1.673904	smallDoses
26052	1.441871	0.805124	didntLike
...

4列分别表示的意思是,每年获得的飞行常客里程数、玩游戏所消耗的时间百分比、每周消耗冰激凌的公升数、喜爱程度。

这是训练集,测试内容就是提供里程数、游戏时间和冰激凌量,让你分析一下是女性对该人喜爱程度。

需要先下载一下sklearn库。这里的作用就是将喜爱程度largeDosessmallDosesdidntLike转化为1,2,3。

下面的代码就是读取数据,然后把文本的数据分为训练集returnMat 和标签classLabelVector

from numpy import *
from sklearn.preprocessing import LabelEncoder,MinMaxScaler
from sklearn import preprocessing
import operator 
def file2matrix(filename):
    fr = open(filename, encoding='UTF-8-sig')
    arrayOlines = fr.readlines()
    numberOfLines = len(arrayOlines)
    returnMat=zeros((numberOfLines,3))
    classLabelVector=[]
    index=0
    #解析文件数据到列
    for line in arrayOlines:
        line = line.strip()
        listFromLine = line.split('\t')
        returnMat[index,:]=listFromLine[0:3]
        classLabelVector.append(listFromLine[-1]) 
        index +=1
    le = preprocessing.LabelEncoder()
    classLabelVector =le.fit_transform(classLabelVector)+1
    return returnMat,classLabelVector
 

运行瞅一下结果,注意地址别照抄。

file2matrix('data/datingTestSet.txt')

(array([[4.0920000e+04, 8.3269760e+00, 9.5395200e-01],
        [1.4488000e+04, 7.1534690e+00, 1.6739040e+00],
        [2.6052000e+04, 1.4418710e+00, 8.0512400e-01],
        ...,
        [2.6575000e+04, 1.0650102e+01, 8.6662700e-01],
        [4.8111000e+04, 9.1345280e+00, 7.2804500e-01],
        [4.3757000e+04, 7.8826010e+00, 1.3324460e+00]]),
 array([2, 3, 1, 1, 1, 1, 2, 2, 1, 2, 1, 1, 3, 1, 1, 1, 1, 1, 3, 2, 3, 1,
        ...
        2, 3, 3, 3, 3, 3, 1, 2, 2, 2], dtype=int64))

这一步就是把数据显示一下,数据可视化。下载matplotlib。运行结果的图就是游戏和冰激凌之间对于喜爱程度的一个可视化。
这一步就是把数据显示一下,数据可视化。下载matplotlib。运行结果的图就是游戏和冰激凌之间对于喜爱程度的一个可视化。

import matplotlib
import matplotlib.pyplot as plt
datingData,datingLable=file2matrix('data/datingTestSet.txt')
fig =plt.figure()
ax = fig.add_subplot(111)#画子图用的。就是画布fig里面可以有好多子图
ax.scatter(datingData[:,1],datingData[:,2],8*array(datingLable),array(datingLable))
#scatter(x,y,size,color) 前两个表示坐标轴,第三表示点的大小。第四个是颜色

在这里插入图片描述
航空里程和冰激凌量的对于喜爱程度的可视化。

ax.scatter(datingData[:,0],datingData[:,2],8*array(datingLable),array(datingLable))
plt.show()

在这里插入图片描述

航空里程和游戏时间的对于喜爱程度的可视化。

plt.scatter(datingData[:,0],datingData[:,1],8*array(datingLable),array(datingLable))
plt.show()

在这里插入图片描述(题外话:这些数据细思极恐,哈哈哈哈哈哈哈哈哈哈)

归一化数值

先说什么是归一化,就是把上面列举的那些参数都处理在0到1之间,或者-1到1。

= 归一化结果= \frac{当前数值-最小值}{最大值-最小值}

为什么要归一化,因为飞行距离的数据数量级大概是千和万左右的数量级。而其他两者则是十位或者个位数。这就导致算距离的结果严重受飞行距离的影响。也就是该参数占得权重太大了。因而为了让三者参数平衡,所以进行归一化。下面的程序和结果可以看到,归一化之后的数据样式。

def autoNorm(dataset):
    minVals=dataset.min(0)
    maxVals=dataset.max(0)
    ranges=maxVals-minVals
    normDataSet=zeros(shape(dataset))
    m=dataset.shape[0]
    normDataSet = dataset-tile(minVals,(m,1)) 
    normDataSet = normDataSet/tile(ranges,(m,1))
    return normDataSet,ranges,minVals
print(autoNorm(datingData))
(array([[0.44832535, 0.39805139, 0.56233353],
       [0.15873259, 0.34195467, 0.98724416],
       [0.28542943, 0.06892523, 0.47449629],
       ...,
       [0.29115949, 0.50910294, 0.51079493],
       [0.52711097, 0.43665451, 0.4290048 ],
       [0.47940793, 0.3768091 , 0.78571804]]), array([9.1273000e+04, 2.0919349e+01, 1.6943610e+00]), array([0.      , 0.      , 0.001156]))

数据集设置好之后,就开始分类了。classify0这个函数就是一开始简单例子中的代码。

def classify0(inX, dataSet, labels, k):
    dataSetSize = dataSet.shape[0]
    diffMat = tile(inX, (dataSetSize,1)) - dataSet
    sqDiffMat = diffMat**2
    sqDistances = sqDiffMat.sum(axis=1)
    distances = sqDistances**0.5
    sortedDistIndicies = distances.argsort()     
    classCount={}          
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    sortedClassCount = sorted(classCount.items(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]



hoRatio=0.1
datingData,datingLable=file2matrix('data/datingTestSet.txt')
normMat,ranges,minVals=autoNorm(datingData)
m=normMat.shape[0]
numTestVecs = int(m*hoRatio) 
errorCount=0.0
for i in range(numTestVecs): 
    classifierResult = classify0(normMat[i,:],normMat[numTestVecs-1:m,:],datingLable[numTestVecs-1:m],3)
    print ("the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLable[i]))
    if (classifierResult != datingLable[i]): errorCount += 1.0
print( "the total error rate is: %f" % (errorCount/float(numTestVecs))) 
    
the classifier came back with: 2, the real answer is: 2
the classifier came back with: 3, the real answer is: 3
...
the classifier came back with: 3, the real answer is: 3
the classifier came back with: 1, the real answer is: 1
the classifier came back with: 1, the real answer is: 1
the total error rate is: 0.040000

手写数字识别

在这里插入图片描述
数据是这样的,数据下载:https://github.com/pbharrin/machinelearninginaction/blob/master/Ch02/digits.zip

如果把1代表是黑色,0是白色,一个数据是一个像素点。这样就可以形成手写内容。k近邻的分类可以想象成把训练集的数据0-9的模样和测试数据求距离。这个距离其实可以代表图片的重合度。距离短重合度高,这样来识别。

首先先读取将这些数据读取为向量。

def img2vector(filename):
    returnVect = zeros((1,1024))
    fr=open(filename)
    for i in range(32):
        lineStr = fr.readline()
        for j in range(32):
            returnVect[0,32*i+j]=int(lineStr[j])
    return returnVect
testVector= img2vector('data/testDigits/0_13.txt')
testVector[0,32:63]
array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1.,
       1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

之后进行分类。每个文件就是一个数字,分为训练和测试集,其文件名都是采用数字和编号进行编码。也就是说上图编码为0_1.txt。按照这样的方式编码,所以我们取出“_”前面的数字作为标签。

from os import listdir
def handwritingClassTest():
    hwLabels=[]
    trainingFileList = listdir('data/trainingDigits')
    m = len(trainingFileList)#文件数
    trainingMat = zeros((m,1024))
    for i in range(m):
        fileNameStr = trainingFileList[i]
        fileStr = fileNameStr.split('.')[0] #取文件名  去掉后缀
        classNumStr = int (fileStr.split('_')[0]) #取出标记值
        hwLabels.append(classNumStr)
        trainingMat[i,:]=img2vector('data/trainingDigits/%s' % fileNameStr)
    testFileList =  listdir('data/testDigits')
    errorCount = 0.0
    mTest = len(testFileList)
    for i in range(mTest):
        fileNameStr = testFileList[i]
        fileStr = fileNameStr.split('.')[0] #取文件名  去掉后缀
        classNumStr = int (fileStr.split('_')[0]) #取出标记值
        vectorUnderTest = img2vector('data/testDigits/%s' % fileNameStr)
        classifierResult = classify0(vectorUnderTest,trainingMat,hwLabels,3)
        print ("the classifier came back with: %d, the real answer is: %d" % (classifierResult, classNumStr))
        if (classifierResult != classNumStr): errorCount += 1.0
    print ("\nthe total number of errors is: %d" % errorCount)
    print ("\nthe total error rate is: %f" % (errorCount/float(mTest)))
    
handwritingClassTest()
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
the classifier came back with: 0, the real answer is: 0
...
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9
the classifier came back with: 9, the real answer is: 9

the total number of errors is: 10

the total error rate is: 0.010571
2015-08-06 17:13:42 xcc_xing99 阅读数 654
  • 机器学习入门30天实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 系列课程包含Python机器学习库,机器学习经典算法原理推导,基于真实数据集案例实战3大模块。从入门开始进行机器学习原理推导,以通俗易懂为基础形象解读晦涩难懂的机器学习算法工作原理,案例实战中使用Python工具库从数据预处理开始一步步完成整个建模工作!具体内容涉及Python必备机器学习库、线性回归算法原理推导、Python实现逻辑回归与梯度下降、案例实战,信用卡欺诈检测、决策树与集成算法、支持向量机原理推导、SVM实例与贝叶斯算法、机器学习常规套路与Xgboost算法、神经网络。

    7608 人正在学习 去看看 唐宇迪

官方用书:机器学习实战(Machine Learning in Action)


好了,下面继续。

第2章主要讲述了k临近(k-NearestNeighbor算法,所以关于算法本身的思想就不在赘述,不了解的同学请参考下面的百度百科链接:http://baike.baidu.com/link?url=k1Md78fE3ETrLyDYwL8-3 度娘的解释已经很全面了,本编重点在书中例题的实现,和解释。

2.1.1 准备:使用Python导入数据

首先创建一个名为knn.py的文件,可以存放在电脑的任意位置,接下来打开knn.py 编写我们的代码。

from numpy import*
import operator

def createDataSet():
	group=array([[1.0,1.0],[1.0,1.1],[0,0],[0,0.1]])
	label=['A','A','B','B']
	return group,label

如果有同学不了解numpy或者operator模块的话,建议先百度一下,后面会有用(本博有关于operator的官方教程翻译)。


接下来我们测试一下这个代码:

打开终端,进入knn.py的文件目录 再进入python


如果可以和图片中的一样顺利运行的话,恭喜,knn.py已经完成。

2.1.2 实施knn算法

接下来我们在knn.py里继续编写 ,我们要写的是最主要的算法:knn算法

def classify0(inX,dataSet,labels,k):
	dataSetsize=dataSet.shape[0]
	diffMat=tile(inX,(dataSetsize,1))-dataSet
	sqDiffMat=diffMat**2
	sqDistance=sqDiffMat.sum(axis=1)
	distance=sqDistance**0.5
	sortedDistanceIndicies=distance.argsort()
	classCount={}
	for i in range(k):
		voteIlabel=labels[sortedDistanceIndicies[i]]
		classCount[voteIlabel]=classCount.get(voteIlabel,0)+1
	sortedClassCount=sorted(classCount.iteritems(),key=operator.itemgetter(1),reverse=True)
	return sortedClassCount[0][0]
这里就用到了operator 和 numpy 库里的函数了,不了解的赶快去补补。

接下来我们测试一下:

from knn import*

group,label=createDataSet()
print classify0([0.5,0.5],group,label,3)
运行下来的结果应该是B吧,如果是B,那么恭喜你,完成编写!


通过上面,我们就实现了一个最简单,最基础的knn算法。

2.2.1 准备数据:从文件中解析数据

在knn.py中添加下面的代码,使其可以从文件中读入数据:

def filematrix(filename):
	fin=open(filename)
	arryofLines=fin.readlines()
	numberofLines=len(arryofLines)
	returnMat=zeros((numberofLines,3))
	classLabelvector=[]
	index=0
	for line in arryofLines:
		line=line.strip()
		listFromLine=line.split('\t')
		returnMat[index,:]=listFromLine[0:3]
		classLabelvector.append(int(listFromLine[-1]))
		index+=1
	return returnMat.classLabelvector
可见使用python进行文件操作还是很方便的。







2017-05-10 09:04:28 wyisfish 阅读数 1667
  • 机器学习入门30天实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 系列课程包含Python机器学习库,机器学习经典算法原理推导,基于真实数据集案例实战3大模块。从入门开始进行机器学习原理推导,以通俗易懂为基础形象解读晦涩难懂的机器学习算法工作原理,案例实战中使用Python工具库从数据预处理开始一步步完成整个建模工作!具体内容涉及Python必备机器学习库、线性回归算法原理推导、Python实现逻辑回归与梯度下降、案例实战,信用卡欺诈检测、决策树与集成算法、支持向量机原理推导、SVM实例与贝叶斯算法、机器学习常规套路与Xgboost算法、神经网络。

    7608 人正在学习 去看看 唐宇迪

机器学习与python实践(一)k临近(knn)

knn算法分析
k最邻近分类算法是最简单的机器学习算法,它采用测量不同特征值之间的距离进行分类,想法很简单:如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本的大多数属于某个类,则这个样本也属于这个类。
knn算法中所选择的邻近都是已经分好类的对象,该方法在定类决策上只依赖最邻近的一个或几个样本的类别来决定待分类样本的类别,不是靠判别类域的方法来确定,对于类域交叉重合较多的分类样本集这个方法更为合适。
不足之处:样本不平衡时,一个类样本容量很大,其他样本容量很小,导致输入新样本时,该样本邻近中大样本占多数,因此可以采取权值的方法(和样本距离小的邻近权值大)来改进。计算量大时另一个问题,对每个待分类的文本都要计算他到全体样本的距离,才能得出k个最邻近点。解决方法是事先对以知样本剪辑,去掉对分类作用不大的样本,适用于容量大的样本。
总的来说,我们已经存在一个带有标签的数据库,然后输入没有标签的新数据,将新数据每个特征与样本集中数据对应的特征比较,提取样本集中特征最相似的分类标签,一般只选择样本数据库中前k个最相似的数据,最后选择k个最相似数据中出现次数最多的分类。描述如下:
1)计算已知类别数据集中的点与当前点之间的距离;
2)按照距离递增次序排序;
3)选取与当前距离最小的k个点;
4)确定k个点所在类别的出现概率;
5)返回前k个点出现频率最高的类别最为当前点的预测分类。

如何选择合适的算法
考虑两个问题:一目的是什么,需要完成何种任务,是预测概率还是对对象分组;二需要分析或搜集的数据是什么。
目的:如果是预测目标变量的值,选择监督学习算法,否则选择非监督。确定选择监督算法后,如果是离散目标变量,选择分类器算法;如果是连续型数值,选择回归算法。
如果不是预测值。选择无监督。进一步分析是否需要将数据划分为离散的组,是则使用聚类算法;如还需要估计数据与每个分组的相似度,则需要使用密度估计算法。
我们需要充分了解数据,对实际数据了解的越充分,越容易创建符合实际需求的程序。主要了解数据:离散还是连续,特征值是否存在缺失,是什么原因造成缺失,是否存在异常值,某个特征发生的频率如何等等。
在选择算法需要尝试不同算法的执行结果,反复试错迭代。机器学习开发过程:
1、搜集数据2、准备输入数据3、分析输入数据4、训练算法5、测试算法6、使用算法。
k-近 邻 算 法 (knn)
它的工作原理是:存在一个样本数据集合,也称作训练样本集,并且样本集中每个数据都存在标签,即我们知道样本集中每一数据 与所属分类的对应关系。输人没有标签的新数据后,将新数据的每个特征与样本集中数据对应的 特征进行比较,然后算法提取样本集中特征最相似数据(最近邻)的分类标签。一般来说,我们 只选择样本数据集中前k个最相似的数据,这就是&-近邻算法中&的出处,通常k是不大于20的整数。 最后,选择k个最相似数据中出现次数最多的分类,作为新数据的分类。

python实现

import pandas as pd
df = pd.read_csv('.csv')#读取数据
df.head()#显示前五列数据
df.info()#显示数据相关变量信息
df.describe()#显示各种统计数据
#数据可视化
import matplotlib.pyplot as plt
import seaborn as sns

plt.figure()#新建图片窗口
sns.countplot(x='variable', hue='target',data=df,palette='RdBu')#计量图
plt.xticks([0,1],['NO','Yes'])#x 轴刻度
plt.show()#显示图片

#训练算法
from sklearn.neighbors import KNeighborsClassifier

#选择特征和目标变量
y = df['target'].values
X = df.drop('target',axis=1).values#删除目标变量列

#建一个knn分类器 k=6
knn = KNeighborsClassifier(n_neighbors=6)
#fit
knn.fit(X,y)
#predict
y_pred = knn.predict(X)
new_prediction = knn.predict(X_nem)
print('prediction:{}'.format(new_prediction))
#测量训练效率
#选取训练集和测试集
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=42,stratify=y)#from sklearn.model_selection import train_test_split
knn.score(X_test,y_test)

#取不同k值的效率图:
# Setup arrays to store train and test accuracies
neighbors = np.arange(1, 9)
train_accuracy = np.empty(len(neighbors))
test_accuracy = np.empty(len(neighbors))

# Loop over different values of k
for i, k in enumerate(neighbors):
    # Setup a k-NN Classifier with k neighbors: knn
    knn = KNeighborsClassifier(n_neighbors=k)

    # Fit the classifier to the training data
    knn.fit(X_train,y_train)

    #Compute accuracy on the training set
    train_accuracy[i] = knn.score(X_train, y_train)

    #Compute accuracy on the testing set
    test_accuracy[i] = knn.score(X_test, y_test)

# Generate plot
plt.title('k-NN: Varying Number of Neighbors')
plt.plot(neighbors, test_accuracy, label = 'Testing Accuracy')
plt.plot(neighbors, train_accuracy, label = 'Training Accuracy')
plt.legend()
plt.xlabel('Number of Neighbors')
plt.ylabel('Accuracy')
plt.show()





2016-12-16 15:10:17 sinat_36164665 阅读数 252
  • 机器学习入门30天实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 系列课程包含Python机器学习库,机器学习经典算法原理推导,基于真实数据集案例实战3大模块。从入门开始进行机器学习原理推导,以通俗易懂为基础形象解读晦涩难懂的机器学习算法工作原理,案例实战中使用Python工具库从数据预处理开始一步步完成整个建模工作!具体内容涉及Python必备机器学习库、线性回归算法原理推导、Python实现逻辑回归与梯度下降、案例实战,信用卡欺诈检测、决策树与集成算法、支持向量机原理推导、SVM实例与贝叶斯算法、机器学习常规套路与Xgboost算法、神经网络。

    7608 人正在学习 去看看 唐宇迪
#-*-coding:utf-8-*-
from numpy import *
import operator
import matplotlib
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
def file2matrix(filename):
fr=open(filename)
arrayOLines=fr.readlines()#读取文件的所有内容转换成一个行的列表
numberOfLines=len(arrayOLines)
returnMat=zeros((numberOfLines,3))#生成一个numberoflines行3列全是0的矩阵
classLabelVector=[]
index=0
for line in arrayOLines:
line=line.strip()#去除两侧的空格
listFromLine=line.split('\t')#将字符串分割成序列
returnMat[index,:]=listFromLine[0:3]#选取前三个元素,存储在特征矩阵中
classLabelVector.append(int(listFromLine[-1]))#将列表的最后一列存储到向量classLabelVector中
index+=1
return returnMat,classLabelVector


def autoNorm(dataSet):
minVals=dataSet.min(0)#参数0使得函数可以从列中选取最小值
maxVals=dataSet.max(0)
ranges=maxVals-minVals
normDataSet=zeros(shape(dataSet))#创建一个和dataset一样大小的矩阵初始化为0
m=dataSet.shape[0]#返回dataset第一维的长度
normDataSet=dataSet-tile(minVals,(m,1))#tile函数将变量内容复制成同样大小的矩阵
normDataSet=normDataSet/tile(ranges,(m,1))
return normDataSet,ranges,minVals



def classify0(inX, dataSet, labels, k):    # #inX是你要输入的要分类的“坐标”,dataSet是上面createDataSet的array,
                                           #就是已经有的,分类过的坐标,label是相应分类的标签,k是KNN,k近邻里面的k  
    dataSetSize = dataSet.shape[0]   #shape函数返回读取矩阵第一维的长度
    diffMat = tile(inX, (dataSetSize,1)) - dataSet #前面用tile,把一行inX变成4行一模一样的
                                              #(tile有重复的功能,dataSetSize是重复4遍,
      #后面的1保证重复完了是4行,而不是一行里有四个一样的),
                                              #然后再减去dataSet,是为了求两点的距离,先要坐标相减,这个就是坐标相减  
    sqDiffMat = diffMat**2 #上一行得到了坐标相减,然后这里要(x1-x2)^2,要求乘方 
    sqDistances = sqDiffMat.sum(axis=1)  #axis=1是列相加,这样得到了(x1-x2)^2+(y1-y2)^2 
    distances = sqDistances**0.5 #开根号,这个之后才是距离  
    sortedDistIndicies = distances.argsort()  #argsort是排序,将元素按照由小到大的顺序返回下标,比如([3,1,2]),它返回的就是([1,2,0])    
    classCount={}          
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1  #get是取字典里的元素,
                       #如果之前这个voteIlabel是有的,那么就返回字典里这个voteIlabel里的值,
                       #如果没有就返回0(后面写的),这行代码的意思就是算离目标点距离最近的k个点的类别,
#这个点是哪个类别哪个类别就加1  
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
                                      #key=operator.itemgetter(1)的意思是按照字典里的第一个排序,
                                      #{A:1,B:2},要按照第1个(AB是第0个),即‘1’‘2’排序。reverse=True是降序排序  
    return sortedClassCount[0][0] #返回类别最多的类别

K临近算法实现

阅读数 166

没有更多推荐了,返回首页