Anne Hathaway
在Windows上安装Python
Python官网：https://www.python.org/
我的电脑是64位的，安装3.x版本选择Windows x86-64 executable installer，由于2.x和3.x版本不兼容，考虑到2.x版本的代码要修改后才能运行，所以我选择的是2.x版本：Windows x86-64 MSI installer
注意选上pip和Add python.exe to Path，然后一路点“Next”即可完成安装。
默认会安装到C:\Python27目录下，然后打开命令提示符窗口，敲入python后，看到上面的画面，就说明Python安装成功！
如果出现：‘python’不是内部或外部命令，也不是可运行的程序或批处理文件
这是因为Windows会根据一个Path的环境变量设定的路径去查找python.exe，如果没找到，就会报错。如果在安装时漏掉了勾选Add python.exe to Path，那就要手动把python.exe所在的路径C:\Python27添加到Path中
Python把环境变量配置在path所有变量的最前面 导致在加载windows系统的变量的前面所以不起作用，需要重启 ，但是你只需要把变量移到最后面就不需要重启。
Python 3 安装jupyter notebook
python3 -m pip install --upgrade pip
python3 -m pip install jupyter
Python 2 安装jupyter notebook
python -m pip install --upgrade pip
python -m pip install jupyter
启动 Jupyter Notebook
jupyter notebook
安装numpy
因为要有很多的矩阵计算，所以要安装numpy包
下载地址：点击打开链接
- 根据自己安装的python版本选择安装包，intel平台的就选择win32：numpy-1.14.3+mkl-cp27-cp27m-win32.whl
- 将下载的安装包拷贝在Python安装目录下C:\Python27\Scripts
- 将Scripts这个文件夹的地址拷贝下来，然后“右击计算机-属性-高级系统设置-环境变量-系统变量-path-编辑它”将刚才的路径粘贴进去。
- 进入DOS，输入pip版本号 install +numpy的路径+文件名
例如我的是pip2.7 install C:\Python27\Scripts\numpy-1.14.3+mkl-cp27-cp27m-win32.whl - 安装成功就会提示successfully installed
安装的过程中出现了意想不到的错误：第二个按照提示升级pip即可，但是第一个错误是怎么回事呢？
原来我所安装的python所支持的whl 文件类型是win32，并不是你操作系统是64位的就选amd64的，所以重新下载一个win32的numpy包就好了。
安装Matplotlib
跟安装numpy一样，找到Matplotlib包，下载到Python安装目录下C:\Python27\Scripts，通过cmd安装：pip2.7 install C:\Python27\Scripts\matplotlib-2.2.2-cp27-cp27m-win32.whl
安装 pandas
pip2.7 install C:\Python27\Scripts\pandas-0.23.0-cp27-cp27m-win32.whl
安装 seaborn
pip install seaborn
安装 scipy
pip2.7 install C:\Python27\Scripts\scipy-1.1.0-cp27-cp27m-win32.whl
安装 sklearn
pip2.7 install C:\Python27\Scripts\scikit_learn-0.19.1-cp27-cp27m-win32.whl
欧式距离应用
川菜馆排行榜
------------------------------------------------------
| 红烧肉 | 水煮牛肉 | 夫妻肺片 | 麻婆豆腐|
------------------------------------------------------
灶神 | | | | |
------------------------------------------------------
食神 | | | | |
------------------------------------------------------
赌神 | | | | |
------------------------------------------------------
吃货 | | | | |
------------------------------------------------------
引入数据
import numpy as np
Restr_1 = [[3.5, 3.0, 3.0, 4.0],
[2.0, 2.5, 2.5, 3.5],
[3.0, 3.5, 3.0, 4.5],
[4.0, 3.0, 3.5, 4.0]]
Restr_2 = [[4.5, 4.0, 4.0, 4.5],
[3.0, 3.5, 3.5, 4.5],
[4.0, 3.5, 4.0, 4.0],
[4.5, 4.0, 4.5, 4.5]]
Restr_3 = [[1.5, 2.0, 2.0, 2.5],
[1.0, 1.5, 1.5, 1.5],
[2.0, 2.5, 2.0, 2.0],
[1.5, 2.0, 2.5, 2.5]]
欧氏距离公式
def euclidean_score(param1, param2):
subtracted_diff = np.subtract(param1, param2)
squared_diff = np.square( subtracted_diff)
eu_dist = np.sqrt(np.sum(squared_diff))
return eu_dist , 1 / (1 + eu_dist)
R12, r12= euclidean_score(Restr_1,Restr_2)
R13, r13= euclidean_score(Restr_1,Restr_3)
R23, r23= euclidean_score(Restr_2,Restr_3)
R12=3.4641016151377544
R13=5.916079783099616
R23=8.717797887081348
KNN
from numpy import *
import operator
import time
import matplotlib.pyplot as plt
def kNN(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()
"""
print(distances)
print(diffMat)
print(sqDiffMat)
print(sqDistances)
print('index')
print(sortedDistIndicies)
"""
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]
# kNN Example
group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])
labels = ['A','A','B','B']
将数据可视化
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(group[:2,0],group[:2,1], s=70, color='b')
ax.scatter(group[2:4,0],group[2:4,1], s=70, color='r')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
kNN([0.3,0.2],group,labels,3)
#out：'B' 说明[0.3,0.2]这个点属于B类
请根据前例，对下表中的电影数据采用kNN算法进行分类：
group = array([[3.0,104.0],[2.0,100.0],[1,81],[101,10.0],[99,5],[98,2.0]])
labels = ['Romance','Romance','Romance','Action','Action','Action']
kNN([18,90],group,labels,3)
#out：'Romance'
对文件中的数据进行分析，归类
from numpy import *
import matplotlib.pyplot as plt
def file2matrix(filename):
fr = open(filename)
numberOfLines = len(fr.readlines()) #get the number of lines in the file
returnMat = zeros((numberOfLines,3)) #prepare matrix to return
classLabelVector = [] #prepare labels return
fr = open(filename)
index = 0
for line in fr.readlines():
line = line.strip()
listFromLine = line.split('\t')
returnMat[index,:] = listFromLine[0:3]
classLabelVector.append(int(listFromLine[-1]))
index += 1
return returnMat,classLabelVector
datingDataMat,datingLabels = file2matrix('datingTestSet2.txt')
plt.figure(num=None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')
plt.scatter(datingDataMat[:,1], datingDataMat[:,2], 15.0*array(datingLabels), 15.0*array(datingLabels))
plt.xlabel('Percentage of Time Spent Playing Video Games')
plt.ylabel('Liters of Ice Cream Consumed Per Week')
plt.show()
plt.scatter(datingDataMat[:,0], datingDataMat[:,1], 15.0*array(datingLabels), 15.0*array(datingLabels))
plt.xlabel('Frequent Flyer Miles Earned Per Year')
plt.ylabel('Liters of Ice Cream Consumed Per Week')
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import NullFormatter # useful for `logit` scale
# Fixing random state for reproducibility
np.random.seed(19680801)
# make up some data in the interval ]0, 1[
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))
# plot with various axes scales
plt.figure(1)
# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)
# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)
# symmetric log
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthreshy=0.01)
plt.title('symlog')
plt.grid(True)
# logit
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
# Format the minor tick labels of the y-axis into empty strings with
# `NullFormatter`, to avoid cumbering the axis with too many labels.
plt.gca().yaxis.set_minor_formatter(NullFormatter())
# Adjust the subplot layout, because the logit one may take more space
# than usual, due to y-tick labels like "1 - 10^{-3}"
plt.subplots_adjust(top=0.92, bottom=0.08, left=0.10, right=0.95, hspace=0.25,
wspace=0.35)
plt.show()
Apriori算法应用
根据Apriori算法编写apriori.py
from numpy import *
def loadDataSet():
return [[1, 3, 4], [2, 3, 5], [1, 2, 3, 5], [2, 5]]
def createC1(dataSet):
C1 = []
for transaction in dataSet:
#print(transaction)
for item in transaction:
#print(item)
if not [item] in C1:
#print("C1 before:")
#print(C1)
C1.append([item])
#print("C1 now:")
#print(C1)
C1.sort()
return map(frozenset, C1)#use frozen set so we
#can use it as a key in a dict
def scanD(D, Ck, minSupport):
ssCnt = {}
for tid in D:
for can in Ck:
if can.issubset(tid):
#print("ssCnt before:")
#print(ssCnt)
if not can in ssCnt: ssCnt[can]=1
else: ssCnt[can] += 1
#print("ssCnt now:")
#print(ssCnt)
numItems = float(len(list(D)))
print("numItems:")
print(numItems)
retList = []
supportData = {}
for key in ssCnt:
print(key)
support = ssCnt[key]/numItems
if support >= minSupport:
retList.insert(0,key)
supportData[key] = support
print(support)
return retList, supportData
def aprioriGen(Lk, k): #creates Ck
retList = []
lenLk = len(Lk)
for i in range(lenLk):
for j in range(i+1, lenLk):
L1 = list(Lk[i])[:k-2]; L2 = list(Lk[j])[:k-2]
L1.sort(); L2.sort()
if L1==L2: #if first k-2 elements are equal
retList.append(Lk[i] | Lk[j]) #set union
return retList
def apriori(dataSet, minSupport = 0.5):
C1 = createC1(dataSet)
D = list(map(set, dataSet))
L1, supportData = scanD(D, C1, minSupport)
L = [L1]
k = 2
while (len(L[k-2]) > 0):
Ck = aprioriGen(L[k-2], k)
Lk, supK = scanD(D, Ck, minSupport)#scan DB to get Lk
supportData.update(supK)
L.append(Lk)
k += 1
return L, supportData
def generateRules(L, supportData, minConf=0.7): #supportData is a dict coming from scanD
bigRuleList = []
for i in range(1, len(L)):#only get the sets with two or more items
for freqSet in L[i]:
H1 = [frozenset([item]) for item in freqSet]
if (i > 1):
rulesFromConseq(freqSet, H1, supportData, bigRuleList, minConf)
else:
calcConf(freqSet, H1, supportData, bigRuleList, minConf)
return bigRuleList
def calcConf(freqSet, H, supportData, brl, minConf=0.7):
prunedH = [] #create new list to return
for conseq in H:
conf = supportData[freqSet]/supportData[freqSet-conseq] #calc confidence
if conf >= minConf:
print(freqSet-conseq,'-->',conseq,'conf:',conf)
brl.append((freqSet-conseq, conseq, conf))
prunedH.append(conseq)
return prunedH
def rulesFromConseq(freqSet, H, supportData, brl, minConf=0.7):
m = len(H[0])
if (len(freqSet) > (m + 1)): #try further merging
Hmp1 = aprioriGen(H, m+1)#create Hm+1 new candidates
Hmp1 = calcConf(freqSet, Hmp1, supportData, brl, minConf)
if (len(Hmp1) > 1): #need at least two sets to merge
rulesFromConseq(freqSet, Hmp1, supportData, brl, minConf)
def pntRules(ruleList, itemMeaning):
for ruleTup in ruleList:
for item in ruleTup[0]:
print(itemMeaning[item])
print(" -------->")
for item in ruleTup[1]:
print(itemMeaning[item])
print("confidence: %f" % ruleTup[2])
print(" ") #print a blank line
引入数据
import apriori
dataSet = [["cakes", "beer", "bread"],
["cakes", "beer", "bread", "donuts"],
["beer", "bread", "pizza"],
["cakes", "bread", "donuts", "pizza"],
["donuts", "pizza"]]
C1 = apriori.createC1(dataSet)
list(C1)
C2 = [frozenset({'cakes', 'beer'}),
frozenset({'cakes', 'beer', 'bread'}),
frozenset({'cakes', 'beer', 'bread', 'donuts'})]
C3 =[frozenset({'beer', 'bread'}),
frozenset({'cakes', 'beer', 'bread'}),
frozenset({'cakes', 'beer', 'bread', 'donuts'}),
frozenset({'beer', 'bread', 'pizza'})]
D = list(map(set, dataSet))
D
计算支持度计数
L2, suppData = apriori.scanD(D, C2, 0)
L2
numItems:
5.0
frozenset({'beer', 'cakes'})
0.4
frozenset({'beer', 'bread', 'cakes'})
0.4
frozenset({'donuts', 'beer', 'bread', 'cakes'})
0.2
决策树应用
根据决策树算法编写trees.py
from math import log
import operator
def calcShannonEnt(dataSet):
numEntries = len(dataSet)
labelCounts = {}
for featVec in dataSet: #the the number of unique elements and their occurance
currentLabel = featVec[-1]
if currentLabel not in labelCounts.keys(): labelCounts[currentLabel] = 0
labelCounts[currentLabel] += 1
shannonEnt = 0.0
for key in labelCounts:
prob = float(labelCounts[key])/numEntries
shannonEnt -= prob * log(prob,2) #log base 2
return shannonEnt
def splitDataSet(dataSet, axis, value):
retDataSet = []
for featVec in dataSet:
if featVec[axis] == value:
reducedFeatVec = featVec[:axis] #chop out axis used for splitting
reducedFeatVec.extend(featVec[axis+1:])
retDataSet.append(reducedFeatVec)
return retDataSet
def chooseBestFeatureToSplit(dataSet):
numFeatures = len(dataSet[0]) - 1 #the last column is used for the labels
baseEntropy = calcShannonEnt(dataSet)
bestInfoGain = 0.0; bestFeature = -1
for i in range(numFeatures): #iterate over all the features
featList = [example[i] for example in dataSet]#create a list of all the examples of this feature
uniqueVals = set(featList) #get a set of unique values
newEntropy = 0.0
for value in uniqueVals:
subDataSet = splitDataSet(dataSet, i, value)
prob = len(subDataSet)/float(len(dataSet))
newEntropy += prob * calcShannonEnt(subDataSet)
infoGain = baseEntropy - newEntropy #calculate the info gain; ie reduction in entropy
print("#", i)
print("infoGain: ", infoGain)
print(" ")
if (infoGain > bestInfoGain): #compare this to the best gain so far
bestInfoGain = infoGain #if better than current best, set to best
bestFeature = i
return bestFeature #returns an integer
def majorityCnt(classList):
classCount={}
for vote in classList:
if vote not in classCount.keys(): classCount[vote] = 0
classCount[vote] += 1
sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
return sortedClassCount[0][0]
def createTree(dataSet,labels):
classList = [example[-1] for example in dataSet]
if classList.count(classList[0]) == len(classList):
return classList[0]#stop splitting when all of the classes are equal
if len(dataSet[0]) == 1: #stop splitting when there are no more features in dataSet
return majorityCnt(classList)
bestFeat = chooseBestFeatureToSplit(dataSet)
bestFeatLabel = labels[bestFeat]
myTree = {bestFeatLabel:{}}
del(labels[bestFeat])
featValues = [example[bestFeat] for example in dataSet]
uniqueVals = set(featValues)
for value in uniqueVals:
subLabels = labels[:] #copy all of labels, so trees don't mess up existing labels
myTree[bestFeatLabel][value] = createTree(splitDataSet(dataSet, bestFeat, value),subLabels)
return myTree
def classify(inputTree,featLabels,testVec):
firstStr = list(inputTree.keys())[0]
secondDict = inputTree[firstStr]
featIndex = featLabels.index(firstStr)
key = testVec[featIndex]
valueOfFeat = secondDict[key]
if isinstance(valueOfFeat, dict):
classLabel = classify(valueOfFeat, featLabels, testVec)
else: classLabel = valueOfFeat
return classLabel
def storeTree(inputTree,filename):
import pickle
fw = open(filename,'w')
pickle.dump(inputTree,fw)
fw.close()
def grabTree(filename):
import pickle
fr = open(filename)
return pickle.load(fr)
读取文件数据，通过决策树算法进行决策树构建
import trees
fr = open('lenses.txt')
lenses = [inst.strip().split('\t') for inst in fr.readlines()]
# 选择分类
lensesLabels = ['age', 'prescript', 'astigmatic', 'tearRate']
# 构建决策树
lensesTree = trees.createTree(lenses, lensesLabels)
可视化决策树
import matplotlib.pyplot as plt
decisionNode = dict(boxstyle="sawtooth", fc="0.8")
leafNode = dict(boxstyle="round4", fc="0.8")
arrow_args = dict(arrowstyle="<-")
def getNumLeafs(myTree):
numLeafs = 0
firstStr = list(myTree.keys())[0] ###
secondDict = myTree[firstStr]
for key in secondDict.keys():
if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes
numLeafs += getNumLeafs(secondDict[key])
else: numLeafs +=1
return numLeafs
def getTreeDepth(myTree):
maxDepth = 0
firstStr = list(myTree.keys())[0] ###
secondDict = myTree[firstStr]
for key in secondDict.keys():
if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes
thisDepth = 1 + getTreeDepth(secondDict[key])
else: thisDepth = 1
if thisDepth > maxDepth: maxDepth = thisDepth
return maxDepth
def plotNode(nodeTxt, centerPt, parentPt, nodeType):
createPlot.ax1.annotate(nodeTxt, xy=parentPt, xycoords='axes fraction',
xytext=centerPt, textcoords='axes fraction',
va="center", ha="center", bbox=nodeType, arrowprops=arrow_args )
def plotMidText(cntrPt, parentPt, txtString):
xMid = (parentPt[0]-cntrPt[0])/2.0 + cntrPt[0]
yMid = (parentPt[1]-cntrPt[1])/2.0 + cntrPt[1]
createPlot.ax1.text(xMid, yMid, txtString, va="center", ha="center", rotation=30)
def plotTree(myTree, parentPt, nodeTxt):#if the first key tells you what feat was split on
numLeafs = getNumLeafs(myTree) #this determines the x width of this tree
depth = getTreeDepth(myTree)
firstStr = list(myTree.keys())[0] #the text label for this node should be this
cntrPt = (plotTree.xOff + (1.0 + float(numLeafs))/2.0/plotTree.totalW, plotTree.yOff)
plotMidText(cntrPt, parentPt, nodeTxt)
plotNode(firstStr, cntrPt, parentPt, decisionNode)
secondDict = myTree[firstStr]
plotTree.yOff = plotTree.yOff - 1.0/plotTree.totalD
for key in secondDict.keys():
if type(secondDict[key]).__name__=='dict':#test to see if the nodes are dictonaires, if not they are leaf nodes
plotTree(secondDict[key],cntrPt,str(key)) #recursion
else: #it's a leaf node print the leaf node
plotTree.xOff = plotTree.xOff + 1.0/plotTree.totalW
plotNode(secondDict[key], (plotTree.xOff, plotTree.yOff), cntrPt, leafNode)
plotMidText((plotTree.xOff, plotTree.yOff), cntrPt, str(key))
plotTree.yOff = plotTree.yOff + 1.0/plotTree.totalD
#if you do get a dictonary you know it's a tree, and the first element will be another dict
def createPlot(inTree):
fig = plt.figure(1, facecolor='white')
fig.clf()
axprops = dict(xticks=[], yticks=[])
createPlot.ax1 = plt.subplot(111, frameon=False, **axprops) #no ticks
#createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses
plotTree.totalW = float(getNumLeafs(inTree))
plotTree.totalD = float(getTreeDepth(inTree))
plotTree.xOff = -0.5/plotTree.totalW; plotTree.yOff = 1.0;
plotTree(inTree, (0.5,1.0), '')
plt.show()
#def createPlot():
# fig = plt.figure(1, facecolor='white')
# fig.clf()
# createPlot.ax1 = plt.subplot(111, frameon=False) #ticks for demo puropses
# plotNode('a decision node', (0.5, 0.1), (0.1, 0.5), decisionNode)
# plotNode('a leaf node', (0.8, 0.1), (0.3, 0.8), leafNode)
# plt.show()
def retrieveTree(i):
listOfTrees =[{'no surfacing': {0: 'no', 1: {'flippers': {0: 'no', 1: 'yes'}}}},
{'no surfacing': {0: 'no', 1: {'flippers': {0: {'head': {0: 'no', 1: 'yes'}}, 1: 'no'}}}}
]
return listOfTrees[i]
#createPlot(thisTree)
import treePlotter
treePlotter.createPlot(lensesTree)
tree.png
K-Means与KNN应用
1.利用任意编程语言实现K-Means算法和KNN算法;
-
使用K-Means算法对以上实验数据中前6部电影进行分簇；
-
输入表2中最后的“待分类电影”数据，根据前一步的分簇结果对其分簇
某电影分类镜头统计数据
-
根据K-Means算法编写K-Means.py
from numpy import *
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 dataMat
def distEclud(vecA, vecB):
return sqrt(sum(power(vecA - vecB, 2))) #la.norm(vecA-vecB)
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
m = shape(dataSet)[0]
clusterAssment = mat(zeros((m,2)))#create mat to assign data points
#to a centroid, also holds SE of each point
centroids = createCent(dataSet, k)
clusterChanged = True
while clusterChanged:
clusterChanged = False
for i in range(m):#for each data point assign it to the closest centroid
minDist = 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):#recalculate centroids
ptsInClust = dataSet[nonzero(clusterAssment[:,0].A==cent)[0]]#get all the point in this cluster
centroids[cent,:] = mean(ptsInClust, axis=0) #assign centroid to mean
return centroids, clusterAssment
2.装载数据
import kMeans
import numpy as np
dataMat= np.mat([[3,104],[2,100],[1,81],[101,10],[99,5],[98,2],[18,90]])
- 用K-Means算法对以上实验数据进行分簇
kMeans.distEclud(dataMat[0],dataMat[1])
myCentroids, clustAssing = kMeans.kMeans(dataMat,2)
4.显示分簇
A = np.asarray(dataMat[:,0])
B = np.asarray(dataMat[:,1])
CX = np.asarray(myCentroids[:,0])
CY = np.asarray(myCentroids[:,1])
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(111)
ax.scatter(A, B, s=50, color='b')
ax.scatter(CX, CY, s=1000, marker = '+', color='r')
plt.xlabel('X')
plt.ylabel('Y')
plt.show()
5.编写KNN算法对最后的“待分类电影”进行分类
from numpy import *
import operator
import time
import matplotlib.pyplot as plt
def kNN(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]
labels = ['Romance','Romance','Romance','Action','Action','Action']
kNN([18,90],group,labels,3)
分类结果：'Romance'
网友评论