2018-05-25 20:23:18 songzhiren5560 阅读数 424
  • 机器学习& 深度学习 基础视频教程(人工智能AI方向)

    机器学习,深度学习基础教程入门视频培训教程,该课程主要包含机器学习基础,包括常用的数据集、训练集、样本、特征、矩阵、Numpy数组、Pandas的使用等;机器学习数学基础,包括线形代数基础、概率基础、信息论基础、最优化基础等;机器学习算法,包括简单线形回归和逻辑回归、决策树、KNN、SVM、层次聚类、密度聚类等。这是一门非常好的AI入门教程。

    663 人正在学习 去看看 Array老师

最近在学习《机器学习实战》

    kNN算法是从训练集中找到和新数据最接近的k条记录(欧氏距离),然后根据他们的主要分类来决定新数据的类别。该算法涉及3个主要因素:训练集、距离或相似的衡量、k的大小。

一、运行kNN算法

    kNN算法可以解决如下问题,样本如下:


span group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])  
labels = ['A','A','B','B']  

然后要判断[1.1,1.2],[0.1,0.2]属于哪一类,首先创建kNN.py文件导入数据


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

然后我们使用kNN算法

对待测样本点执行以下操作

1、计算待测点与样本点的欧氏距离;

2、按距离递增次序排列;

3、选择前k个点,计算其对应的标签,对标签次数按降序排列;

4、选择出现次数最多的标签作为kNN算法的预测结果

代码如下:


# K-近邻算法
def classify0(inX,dataSet,labels,k):
    dataSetSize = dataSet.shape[0]
    # 计算距离(欧氏距离)
    diffMat = numpy.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):
        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]

然后去当前文件目录下打开控制台启动python,进入Python交互式环境执行以下命令(这是一个简单的分类器)

>>>import kNN  
    >>> group,labels=kNN.createDataSet()  
    >>> kNN.classify0([1.1,1.2],group,labels,3)  
    'A'  
    >>> kNN.classify0([0.1,0.2],group,labels,3)  
    'B'  
    >>>  

二 运用kNN解决网站约会配对效果

数据集存放在文本文件datingTestSet.txt文件中,每个样本占据一行,一共1000行,主要包括了以下3个特征:

1、每年获得的飞行常客里程数

2、玩视频游戏所消耗时间

3、每周消费的冰淇淋公升数

2.1 从文本中解析数据并分析

将上述数据输入到分类器之前,需要将数据的格式处理为分类器可以接受的格式,在kNN.py中创建名为file2matrix函数,来处理输入格式问题,该程序如下:

# 将约会数据文本记录转化为numpy的解析程序
def file2matrix(filename):
    fr = open(filename)
    arrayOLines = fr.readlines()
    # 得到文件的行数
    numberOfLines = len(arrayOLines)
    # 创建返回Numpy的矩阵
    returnMat = numpy.zeros((numberOfLines, 3))
    classLabelVector = []
    index = 0
    # 解析文件数据到列表
    for line in arrayOLines:
        line = line.strip()
        listFromLine = line.split('\t')
        returnMat[index,:] = listFromLine[0:3]
        classLabelVector.append(int(listFromLine[-1]))
        index += 1
    return returnMat,classLabelVector

重新载入kNN.py(Python2版本是直接reload(kNN),但是Python3.6是 import importlib; importlib.reload(kNN))

再利用Matpoltlib可以创建散点图,观察数据分布:

>>> import kNN  
>>> datingDataMat,datingLabels = kNN.file2matrix('datingTestSet.txt')  
>>> import matplotlib  
>>> import matplotlib.pyplot as plt  
>>> fig=plt.figure()  
>>> ax=fig.add_subplot(111)  
>>> ax.scatter(datingDataMat[:,1],datingDataMat[:,2],15.0*array(datingLabels),15.0*array(datingLabels))   
>>> plt.show()

    这里使用datingDataMat矩阵第二和第三列数据方分别表示“玩游戏所耗时间百分比”和“每周消耗冰激凌公升数”。得到效果图如下:



2.2 归一化数据 

在进行测试之前我们需要对数据进行归一化处理,不然数值大的属性对距离计算的影响十分巨大,所以我们需要将数据值处理到0到1 之间或者-1到1 之间,利用如下公式:

newValue = (oldValue - min) / (max - min)

我们需要在kNN.py文件里添加函数autoNorm(),该函数自动将数值转化到0和1之间:

# 归一化特征值(约会数据)
def autoNorm(dataSet):
    # 取最小值和最大值并计算差值
    minVals = dataSet.min(0)
    maxVals = dataSet.max(0)
    ranges = maxVals - minVals
    # 建立一个1000*3的矩阵 值都是0
    normDataSet = numpy.zeros(numpy.shape(dataSet),dtype=float)
    # 取dataSet的维度 1000
    m = dataSet.shape[0]
    # 利用公式进行归一化( newVal = (oldVal - min)/ranges )
    normDataSet = dataSet - numpy.tile(minVals, (m, 1))
    normDataSet = normDataSet/numpy.tile(ranges,(m, 1))
    return normDataSet,ranges,minVals

在Python命令提示符下,重新加载kNN.py模块,执行autoNorm函数,检测执行效果

>>> import importlib
>>> importlib.reload(kNN)
<module 'kNN' from 'E:\\pyCharm\\workspace\\test1\\learning\\kNN.py'>
>>> norMat,ranges,minVals = kNN.autoNorm(datingDataMat)
[[  4.09200000e+04   8.32697600e+00   9.52796000e-01]
 [  1.44880000e+04   7.15346900e+00   1.67274800e+00]
 [  2.60520000e+04   1.44187100e+00   8.03968000e-01]
 ...,
 [  2.65750000e+04   1.06501020e+01   8.65471000e-01]
 [  4.81110000e+04   9.13452800e+00   7.26889000e-01]
 [  4.37570000e+04   7.88260100e+00   1.33129000e+00]]
[[  9.12730000e+04   2.09193490e+01   1.69436100e+00]
 [  9.12730000e+04   2.09193490e+01   1.69436100e+00]
 [  9.12730000e+04   2.09193490e+01   1.69436100e+00]
 ...,
 [  9.12730000e+04   2.09193490e+01   1.69436100e+00]
 [  9.12730000e+04   2.09193490e+01   1.69436100e+00]
 [  9.12730000e+04   2.09193490e+01   1.69436100e+00]]

2.3 测试算法

机器学习的算法最重要的是要保证算发的正确率,这个例子用90%作为训练样本,10%作为测试,因为数据是随机分布的,索引选择前10%的数据用来测试,在文件中创建datingClassTest函数:

# 分类器针对约会网站的测试代码
def datingClassTest():
    # 取10%的数据进行测试
    hoRatio = 0.10
    datingDataMat,datingLabels = file2matrix('datingTestSet2.txt')
    normMat,ranges,minVals = autoNorm(datingDataMat)
    m = normMat.shape[0]
    numTestVecs = int(m*hoRatio)
    errorCount = 0.0
    for i in range(numTestVecs):
        classifierResult = classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)
        print("the classfier came back with: %d,the real answer is : %d"%(classifierResult,datingLabels[i]))
        if (classifierResult != datingLabels[i]):
            errorCount += 1.0
    # 计算处理数据的错误率
    print("the total error rate is: %f"%(errorCount/float(numTestVecs)))

在Python命令提示符下,重新加载kNN.py模块,执行该函数,检测执行效果:

>>> import importlib
>>> importlib.reload(kNN)
<module 'kNN' from 'E:\\pyCharm\\workspace\\test1\\learning\\kNN.py'>
>>> kNN.datingClassTest()
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 3,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 3
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 3,the real answer is : 3
the classfier came back with: 2,the real answer is : 2
the classfier came back with: 1,the real answer is : 1
the classfier came back with: 3,the real answer is : 1
the total error rate is: 0.050000

由此可见,错误率为5%,可以改变函数datingClassSet内变量hoRatio和变量k的值,检测错误率是否随着变量值的变化而变化。依赖于分类算法、数据集和程序设置,分类器的输出结果都是不同的。

2.4 使用算法,构建完整系统

将下列代码加入kNN.py中,并重新载入:

# 约会网站预测函数
def calssifyPerson():
    resultList = ['not al all','is small doses','in large doses']
    percentTats = float(input("percentage of time spent playing video games?"))
    ffMiles = float(input("frequent flier miles earned per year?"))
    iceCream = float(input("liters of ice cream consumed per year?"))
    datingDataMat, datingLabels = file2matrix('datingTestSet2.txt')
    normMat, ranges, minVals = autoNorm(datingDataMat)
    inArr = numpy.array([ffMiles,percentTats,iceCream])
    classifierResult = classify0((inArr - minVals)/ranges,normMat,datingLabels,3)
    print("you will probably like this person:",resultList[classifierResult - 1])

    执行上述函数,输入摸个用户三个特征的值,并返回判断结果:

>>> import importlib
>>> importlib.reload(kNN)
<module 'kNN' from 'E:\\pyCharm\\workspace\\test1\\learning\\kNN.py'>
>>> kNN.calssifyPerson()
percentage of time spent playing video games?10
frequent flier miles earned per year?10000
liters of ice cream consumed per year?0.5
you will probably like this person: is small doses


2018-10-15 16:05:11 hliyang 阅读数 107
  • 机器学习& 深度学习 基础视频教程(人工智能AI方向)

    机器学习,深度学习基础教程入门视频培训教程,该课程主要包含机器学习基础,包括常用的数据集、训练集、样本、特征、矩阵、Numpy数组、Pandas的使用等;机器学习数学基础,包括线形代数基础、概率基础、信息论基础、最优化基础等;机器学习算法,包括简单线形回归和逻辑回归、决策树、KNN、SVM、层次聚类、密度聚类等。这是一门非常好的AI入门教程。

    663 人正在学习 去看看 Array老师
k-近邻算法:

(kNN —— k-Nearest Neighbors)
测量不同特征值之间的距离方法进行分类。
有一个样本数据集(每个样本都存在标签),输入没有标签的新数据后,将新数据的每个特征与样本集中数据对应的特征进行比较,提取样本集中特征最相似数据(最近邻)的分类标签。一般,只选择样本数据中前k个最相似的数据(k通常不大于20),选择其中分类出现次数最多的作为新数据的分类。

欧式距离公式:

计算两个向量点xA和xB之间的距离:
在这里插入图片描述
举例:如果数据集存在4个特征值,则(1,0,0,1)与(7,6,9,4)之间的距离为:
在这里插入图片描述

测试分类器的效果:

在这里插入图片描述

算法使用:

对要约会的人进行分类(不喜欢的人、魅力一般的人、极具魅力的人),
提取数据中的4个样本:
在这里插入图片描述
计算样本3和4的距离:
在这里插入图片描述
可以看出数字差值最大的属性对计算结果影响最大,而这种原因是“每年获得的飞行常客里程数”远大于其他特征值。但是这3中特征值是同等重要的,所以“每年获得的飞行常客里程数”不该如此严重影响计算结果。
解决方法:将不同取值范围的特征值进行归一化,处理到0到1/-1到1
在这里插入图片描述
min和max为数据集中对应特征的最小和最大值。

通常使用数据的90%作为训练样本来训练分类器,其余的10%来测试分类器,这是最原始的做法,还有其他一些高级方法。注意:10%的数据是随机选择的。

算法特点:

k-近邻算法是基于实例的学习,使用算法时必须有接近实际数据的训练样本数据,同时又必须对数据集中的每个数据计算距离值,所以十分耗时。

代码案例:

kNN算法应用实例(1、2)

2017-08-17 14:30:19 u012736685 阅读数 383
  • 机器学习& 深度学习 基础视频教程(人工智能AI方向)

    机器学习,深度学习基础教程入门视频培训教程,该课程主要包含机器学习基础,包括常用的数据集、训练集、样本、特征、矩阵、Numpy数组、Pandas的使用等;机器学习数学基础,包括线形代数基础、概率基础、信息论基础、最优化基础等;机器学习算法,包括简单线形回归和逻辑回归、决策树、KNN、SVM、层次聚类、密度聚类等。这是一门非常好的AI入门教程。

    663 人正在学习 去看看 Array老师

一、KNN(K近邻)概述

KNN一种基于距离的计算的分类和回归的方法。

其主要过程为:

  1. 计算训练样本和测试样本中每个样本点的距离(常见的距离度量有欧式距离,马氏距离等);
  2. 对上面所有的距离值进行排序(升序);
  3. 选前k个最小距离的样本;
  4. 根据这k个样本的标签进行投票,得到最后的分类类别;

优点:

  1. 理论成熟,思想简单,既可以用来做分类也可以用来做回归;
  2. 可用于非线性分类;
  3. 训练时间复杂度为O(n);
  4. 对数据没有假设,准确度高,对异常值不敏感;

缺点:

  1. 计算量大(体现在距离计算上);
  2. 样本不平衡问题(即有些类别的样本数量很多,而其它样本的数量很少)效果差;
  3. 需要大量内存;

二、实现——sklearn

1、sklearn.neighbors

与近邻法这一大类相关的类库都在sklearn.neighbors包之中。

KNN分类树的类是KNeighborsClassifier,KNN回归树的类是KNeighborsRegressor。

除此之外,还有KNN的扩展,即限定半径最近邻分类树的类RadiusNeighborsClassifier和限定半径最近邻回归树的类RadiusNeighborsRegressor, 以及最近质心分类算法NearestCentroid。

2、KNN分类的实现

(1)数据的随机生成

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from sklearn.datasets.samples_generator import make_classification
# X为样本特征,Y为样本类别输出, 共1000个样本,每个样本2个特征,输出有3个类别,没有冗余特征,每个类别一个簇
X, Y = make_classification(n_samples=1000, n_features=2, n_redundant=0,
                             n_clusters_per_class=1, n_classes=3)
plt.scatter(X[:, 0], X[:, 1], marker='o', c=Y)
plt.show()

结果如下图所示:
这里写图片描述

make_classification 函数

from sklearn.datasets.samples_generator import make_classification
sklearn.datasets.make_classification(n_samples=100, n_features=20, n_informative=2, n_redundant=2, n_repeated=0, n_classes=2, n_clusters_per_class=2, weights=None, flip_y=0.01, class_sep=1.0, hypercube=True,shift=0.0, scale=1.0, shuffle=True, random_state=None)  

通常用于分类算法。
n_features :特征个数= n_informative() + n_redundant + n_repeated
n_informative:多信息特征的个数
n_redundant:冗余信息,informative特征的随机线性组合
n_repeated :重复信息,随机提取n_informative和n_redundant 特征
n_classes:分类类别
n_clusters_per_class :某一个类别是由几个cluster构成的

(2)模型的拟合

用KNN来拟合模型,我们选择K=15,权重为距离远近。代码如下:

from sklearn import neighbors
clf = neighbors.KNeighborsClassifier(n_neighbors = 15 , weights='distance')
clf.fit(X, Y)

(3)模型的预测

from matplotlib.colors import ListedColormap
cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])
cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])

#确认训练集的边界
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
#生成随机数据来做测试集,然后作预测
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                         np.arange(y_min, y_max, 0.02))
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])

# 画出测试集数据
Z = Z.reshape(xx.shape)
plt.figure()
plt.pcolormesh(xx, yy, Z, cmap=cmap_light)

# 也画出所有的训练集数据
plt.scatter(X[:, 0], X[:, 1], c=Y, cmap=cmap_bold)
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.title("3-Class classification (k = 15, weights = 'distance')" )

结果如下图所示:
这里写图片描述

三、KNN源码

def classify0(inX, dataSet, labels, k):   
    dataSetSize = dataSet.shape[0] # the number of samples   

    # tile function is the same as "replicate" function of MATLAB  
    # 这个技巧就避免了循环语句  
    diffMat = tile(inX, (dataSetSize, 1)) - dataSet # replicate inX into dataSetSize * 1  
    sqDiffMat = diffMat**2  # 对应元素平方  
    sqDistances = sqDiffMat.sum(axis = 1)  # 按行求和  
    distances = sqDistances**0.5  # 开方求距离  

    sortedDistIndicies = distances.argsort()  # argsort函数返回的是数组值从小到大的索引值  
    classCount = {}   
    # 投票  
    for i in range(k):   
        voteIlabel = labels[sortedDistIndicies[i]] #排名第i近的样本的label  
        classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1  #get字典的元素,如果不存在key,则为0  
    # operator.itemgetter(1)按照value排序;也可以用 key = lambda asd:asd[1]  
    # 排序完,原classCount不变  
    sortedClassCount = sorted(classCount.iteritems(),  # 键值对  
                              key = operator.itemgetter(1), reverse = True)  #逆序排列   

    return sortedClassCount[0][0]  #输出第一个,也就是最近邻  
2018-11-08 19:59:56 qq_35868994 阅读数 248
  • 机器学习& 深度学习 基础视频教程(人工智能AI方向)

    机器学习,深度学习基础教程入门视频培训教程,该课程主要包含机器学习基础,包括常用的数据集、训练集、样本、特征、矩阵、Numpy数组、Pandas的使用等;机器学习数学基础,包括线形代数基础、概率基础、信息论基础、最优化基础等;机器学习算法,包括简单线形回归和逻辑回归、决策树、KNN、SVM、层次聚类、密度聚类等。这是一门非常好的AI入门教程。

    663 人正在学习 去看看 Array老师

KNN
数据集:第一个数据是此次数据集,第三个是实验说明
参考资料:《统计学习方法》、《机器学习实战》、大佬网站:[一个东北大学的大佬]
(https://cuijiahua.com/blog/2017/11/ml_1_knn.html)
个人原创,未经允许,禁止转载
个人邮箱1274351138@qq.com

  1. 数据预处理
    1.1首先第4列数据并不影响分类结果,所以将其剔除
    1.2数据集太过于奇葩,所以做了归一化处理
    1.3因为做的是分类,所以我想把值控制在0-1,所以采用的归一化方法是:(dataSet - min)/(max-min)
    1.4打乱数据集,因为本来的数据集是排序好的,而且有些数据太奇葩,所以事先将其打乱;一般会选取10%的数据作为测试集,但是显然我的数据太少了,所以我选择了打乱之后的前5行数据作为测试集,剩下的作为训练集(真心觉得数据是老师自己编写的)

  2. 算法
    2.1KNN算法网上百度一大推,这里我看的是李航老师的《统计学习方法》,推导写的很不错,推荐大家可以看一下,我就不写了(反正也是截图******滑稽******)
    2.2数据之间的距离,欧式距离,很好做的。
    2.3算法步骤(在这之前数据要先归一化):
    1)计算已知类别数据集中的点与当前点之间的距离
    2)按距离递增次序排序
    3)选取与当前点距离最小的k个点
    4)统计前k个点所在的类别出现的频率
    5)返回前k个点出现频率最高的类别作为当前点的预测分类

  3. 调试
    3.1hash 发现list不能hash,matrix也不能hash,调试了我好久,我太菜了
    3.2dict 我发现 还是"numpy ndarry"的格式好使,能迭代,能items()

import numpy as np
import matplotlib.pyplot as plt
import operator
import pandas as pd
from math import  sqrt
from matplotlib.font_manager import FontProperties
#################读取文件(数据预处理)#########################
def filematrix(filename):
    array0Lines = np.matrix(pd.read_csv(filename)) 			  ##读取文件
    returnMat = array0Lines[:, 1:3]  ##训练集
    number0Lines = array0Lines.shape[0]                       ##读取文件行数
    classLabelVector = []                                     ##训练集分类标签向量
    for line in array0Lines:                                  #遍历数据集,获取分类标签信息
        if line[:,0]==0:
            classLabelVector.append(0)
        elif line[:,0]==1:
            classLabelVector.append(1)
        elif line[:,0]==2:
            classLabelVector.append(2)
    return returnMat,np.matrix(classLabelVector).T            ##返回训练集和标签向量


####################数据可视化#########################
def showdatas(datingDataMat,datingLabels):

    """
    函数说明:可视化数据
    Parameters:
        datingDataMat - 特征矩阵
        datingLabels - 分类Label
    Returns:
        无
    """
    #不同类型数据的颜色
    LabelsColors = []                                          ##存放数据颜色的数组
    for i in datingLabels:
        if i == 0:
            LabelsColors.append('black')
        elif i == 1:
            LabelsColors.append('orange')
        elif i == 2:
            LabelsColors.append('red')
    fig,ax = plt.subplots(figsize=(10,6))
    #画图时要注意把matrix格式换成list格式,否则不能画图
    ax.scatter(datingDataMat[:,0].tolist(),datingDataMat[:,1].tolist(),color=LabelsColors,s=15,alpha=.5)
    """
    ###设置图列legend
    '0' = mlines.Line2D([], [], color='black', marker='.',markersize=6, label='0')
    '1' = mlines.Line2D([], [], color='orange', marker='.',markersize=6, label='1')
    '2' = mlines.Line2D([], [], color='red', marker='.',markersize=6, label='2')
    plt.legend(handles=[0,1,2])
    """
    plt.show()

###########归一化处理############
def autoNorm(dataSet):
    """
    函数说明:对数据进行归一化

    Parameters:
        dataSet - 特征矩阵
    Returns:
        normDataSet - 归一化后的特征矩阵
        ranges - 数据范围
        minVals - 数据最小值
    """
    #meanVals = dataSet.mean(0)                                    #数据平均值
    #stdVals = dataSet.std(0)
    minVals = dataSet.min(0)                                      #数据最小值
    maxVals = dataSet.max(0)                                      #数据最大值
    ranges = maxVals - minVals                                    #最大值和最小值的差距
    normDataSet = np.zeros(np.shape(dataSet))                     #用于存放归一化后的数据集
    m= dataSet.shape[0]                                           #返回数据集的行数
    ###归一化过程
    #normDataSet = dataSet-meanVals
    #normDataSet = normDataSet/stdVals
    normDataSet = dataSet - np.tile(minVals,(m,1))                #原始数据减去最小数据
    normDataSet = normDataSet/np.tile(ranges,(m,1))               #所得之差除以最大值最小值得差,得到归一化数据
    return normDataSet,ranges,minVals                             #返回归一化数据结果,数据范围,最小值

def classify(inX,dataSet,labels,k):
    dataSetSize = dataSet.shape[0]                                #返回dataSet的行数
    diffMat = np.tile(inX,(dataSetSize,1)) - dataSet              #测试矩阵-数据集
    sqDiffMat = np.multiply(diffMat,diffMat)
    sqDistances = sqDiffMat.sum(axis=1)                           #沿着列的方向相加
    distances = np.ravel(np.sqrt(sqDistances) )                   #欧式距离
    sortedDisIndices = distances.argsort()                        #返回distances中元素从小到大排序后的索引值
    classCount = {}                                               #空字典,用来记录类别次数
    for i in range(k):                                            #遍历
        voteIlabel = labels[sortedDisIndices[i]]                  #取出最近的K个点
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1 #存放出现的类别次数
        #根据字典的值进行降序排序
        sortedClassCount = sorted(classCount.items(),key=operator.itemgetter(1),reverse=True)
        return  sortedClassCount[0][0]                            #返回次数最多的类别

def datingClassTest():
    filename = "G:/shiyan1/shiyan1/Ex1.1_Challenger.csv"
    datingDataMat, datingLabels = filematrix(filename)            #训练集,标签,测试集
    normMat,ranges,minVals = autoNorm(datingDataMat)
    ###打乱数据集,并取前20个作为训练集
    index = np.arange(23)
    np.random.shuffle(index)
    dataSet = normMat[index]
    test = normMat[0:6,:]                                         #测试集
    numTestVecs = len(test)                                       #测试集个数
    m = np.shape(normMat)[0]                                      ##获得normMat的行数
    errorCount =0.0                                               ##分类错误计数
    for i in range (numTestVecs-1):
        classifierResult = classify(test[i,:],normMat[numTestVecs:m,:],np.ravel(datingLabels)[numTestVecs:m],5)     ##前numTestVecs 作为测试集,后m-numTestVecs作为训练集,这边注意要是list格式,否则不能迭代的
        print("分类结果:%d\t真实类别:%d"%(classifierResult,datingLabels[i]))
        if classifierResult!=datingLabels[i]:
            errorCount+=1.0
    print("错误率:%f%%"%(errorCount/float(numTestVecs)*100))

if __name__=='__main__':
    datingClassTest()
分类结果:0	真实类别:0
分类结果:0	真实类别:1
分类结果:0	真实类别:0
分类结果:0	真实类别:0
分类结果:0	真实类别:0
错误率:16.666667%

有一个数据错了,就是那个特别奇葩的数据。。。。。。。。。。。。。。。。。。。
果然数据处理才是烦的,还有python的一大堆格式问题。
希望有大佬能教教我,怎么画legend。

2019-08-01 10:11:29 qq_43751506 阅读数 21
  • 机器学习& 深度学习 基础视频教程(人工智能AI方向)

    机器学习,深度学习基础教程入门视频培训教程,该课程主要包含机器学习基础,包括常用的数据集、训练集、样本、特征、矩阵、Numpy数组、Pandas的使用等;机器学习数学基础,包括线形代数基础、概率基础、信息论基础、最优化基础等;机器学习算法,包括简单线形回归和逻辑回归、决策树、KNN、SVM、层次聚类、密度聚类等。这是一门非常好的AI入门教程。

    663 人正在学习 去看看 Array老师
KNN算法概述

    k近邻(简称KNN)算法是一种简单的分类与回归方法。它不需要数学基础,也没有很难公式推导,但是往往它的预测效果却很不错。工作机制:给定测试样本,基于某种距离度量找出训练集中与其最靠近的K个训练样本,然后基于这K个”邻居“的信息来预测。
    在分类任务中可使用“投票法”,即选择这K个样本中出现最多的类别标记。
    在回归任务中可使用“平均法”,即将这K个样本的实值输出标记的平均值作为预测结果。
    还可基于距离的远近进行加权平均或加权投票,距离越近的样本权重越大。
    K近邻是一种‘懒惰学习’的代表,因为它训练阶段仅仅只是把样本保存起来,训练的开销为零,待收到测试样本后再进行处理。
    特殊的,当K等于1时的分类器叫做“最近邻分类器”

KNN参数

    KNN有两个重要的参数会影响预测结果。
    第一个参数是K值的选择。如果选择较小的K值,这时,预测结果会对邻近的实例点非常敏感。如果邻近的实例点恰巧是噪声,预测就会出错。也就是容易发生过拟合。当选择较大的K值时,一些距离远的,不相似的训练实例也会起到预测作用,使预测发生错误。举个极端的例子,当K值等于训练样本数时,这时,无论测试集的输入是什么,它都将预测训练集中类别最多的点,这显然是不可取的。所以K值需要不断验证来选择。
    第二个参数是距离计算方法的选择。常见的距离度量方式是欧式距离和曼哈顿距离,也可以根据实际情况来选择合适的距离度量方法。

参考文献

《机器学习》周志华著
《统计学习方法 第二版》李航著

机器学习笔记-KNN

阅读数 76

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