第三章k邻近算法（大数据）2020/3/3

第三章

1.距离度量的python程序

#第三章：

import math
from itertools import combinations
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt


#做距离度量：
p_values = (0.25, 0.5, 1, 2, 4,100)
def hua(x,p):
    '''
    画出x与原点(0,0)之间的距离为1的点的图像
    :param x:
    :param p:
    :return:
    '''
    y=(1-abs(x)**p)**(1/p)
    plt.plot(x,y,x,-y)
    ax=plt.gca()
    ax.set_aspect(1)
#若要多个图片在一张图中显示则将plt.show()放到最后
def L(x1,x2,p):
    '''
    计算x1与x2两点之间的距离度量
    :param x1:
    :param x2:
    :param p:
    :return:
    '''
    if len(x1)==len(x2) &len(x1)>1:
        sum=0
        for i in range(len(x1)-1):
            L1=math.pow(abs(x1[i]-x2[i]),p)
            sum+=L1
        resault=math.pow(sum,1/p)

    else:
        resault=0
    return resault

for i in range(len(p_values)-1):
    x=np.arange(-1,1+1e-5,1/128.0)
    p=p_values[i]
    hua(x,p)
plt.show()

for i in range(len(p_values)-1):
    x1 = [5, 1]
    x2 = [4, 4]
    #x3 =
    print(L(x1,x2,p_values[i]))

2.$KNN$算法

#第三章：
import math
from itertools import combinations
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from collections import Counter
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']

df.iloc[0:5]
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()
data = np.array(df.iloc[:100, [0, 1, -1]])
X, y = data[:,:-1], data[:,-1]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
#将原始数据按照比例分割为“测试集”和“训练集”
#X_train,X_test, y_train, y_test =sklearn.model_selection.train_test_split(train_data,train_target,test_size=0.4, random_state=0,stratify=y_train)
# train_data：所要划分的样本特征集
# train_target：所要划分的样本结果
# test_size：样本占比，如果是整数的话就是样本的数量
# random_state：是随机数的种子。
# 随机数种子：其实就是该组随机数的编号，在需要重复试验的时候，保证得到一组一样的随机数。比如你每次都填1，其他参数一样的情况下你得到的随机数组是一样的。但填0或不填，每次都会不一样。
#stratify是为了保持split前类的分布
#stratify=X就是按照X所占的比例分配
#stratify=y就是按照y所占的比例分配

'''
以上目的为得到训练和测试的数据
'''
class KNN:
    def __init__(self,X_train,y_train,n_neighbors=3,p=2):
        self.n=n_neighbors
        self.p=p
        self.X_train=X_train
        self.y_train=y_train
    def predict(self,X):
        #取出n个点
        knn_list=[]
        for i in range(self.n):
            dist=np.linalg.norm(X-self.X_train[i],ord=self.p)
            #x:数据，ord:范数类型
            #np.linalg.norm：求范数
            #此函数此处是求X,self.X_train的p=2时的距离度量
            knn_list.append((dist,self.y_train[i]))
            #knn_list中放（X,self.X_train的距离度量，对应的y训练集）
            for i in range(self.n,len(self.X_train)):
                max_index=knn_list.index(max(knn_list,key=lambda x:x[0]))
                #取得knn_list列表中dist的最大值在列表中的位置
                dist = np.linalg.norm(X - self.X_train[i], ord=self.p)
                if knn_list[max_index][0] > dist:
                    knn_list[max_index] = (dist, self.y_train[i])
                #统计
                knn=[k[-1] for k in knn_list]
                #knn数组中是knn_list数组中的self.y_train数据
                count_pairs=Counter(knn)
                max_count=sorted(count_pairs,key=lambda x:x)[-1]
                #排序sorted：建立一个新的list
                #得到value最大的元组即票数最多的点
                return max_count
    def score(self,X_test,y_test):
        right_count=0
        n=10
        for X,y in zip(X_test,y_test):
            label=self.predict(X)
            if label==y:#表示预测正确
                right_count+=1
        return right_count/len(X_test)
clf = KNN(X_train, y_train)
score=clf.score(X_test, y_test)
print('score:',score)
test_point = [6.0, 3.0]
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.plot(test_point[0], test_point[1], 'bo', label='test_point')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.legend()
plt.show()

train_test_split函数讲解
np.linalg.norm函数讲解

3.$KNN调用sklearn库中的回归模型python程序$

import matplotlib.pyplot as plt
from sklearn import neighbors
import numpy as np
np.random.seed(0)
X=np.sort(5*np.random.rand(40,1),axis=0)
T=np.linspace(0,5,500)[:,np.newaxis]
#np.linspace(start,stop,num)指定的间隔内返回均匀间隔的数字。
#np.newaxis:插入新维度
#[:,np.newaxis]：列扩展的二维数组
#[np.newaxis ,:]：行扩展的二维数组
y=np.sin(X).ravel()
#np.sin(X):返回正弦值
#numpy.ravel():展平的数组元素
y[::5]+=1*(0.5-np.random.rand(8))
#增加噪声，在y的数组中每隔5个元素选一个元素
plt.plot(X,y)
n_neighbors=5
#临近点的个数
for i,weights in enumerate(['uniform','distance']):
    #将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，此处：(0, 'uniform'), (1, 'distance')
    #此处的for循环主要是为了令KNeighborsRegressor取'uniform'/'distance'
    # i:0/1,weight:'uniform'/'distance'
    knn=neighbors.KNeighborsRegressor(n_neighbors,weights=weights)
    #K近邻(回归)模型:KNeighborsRegressor
    #weights :主要用于标识每个样本的近邻样本的权重,所以此处由于for循环一次weights=uniform,一次weights=distance
    #默认的"uniform"，意味着所有最近邻样本权重都一样，在做预测时一视同仁
    #如果是"distance"，则权重和距离成反比例，即距离预测目标更近的近邻具有更高的权重，
    #K近邻(分类)模型:KNeighborsClassifier
    y_=knn.fit(X,y).predict(T)
    plt.subplot(2, 1, i + 1)
    plt.scatter(X, y, c='k', label='data')
    plt.plot(T, y_, c='g', label='prediction')
    plt.axis('tight')
    plt.legend()
    plt.title("KNeighborsRegressor (k = %i, weights = '%s')" % (n_neighbors,
                                                                weights))
plt.tight_layout()
plt.show()

'''
 sklearn.neighbors.KNeighborsClassifier

- n_neighbors: 临近点个数
- p: 距离度量
- algorithm: 近邻算法，可选{'auto', 'ball_tree', 'kd_tree', 'brute'}
- weights: 确定近邻的权重
'''

3.$KNN调用sklearn库中的分类模型python程序$

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import neighbors, datasets
irisData = datasets.load_iris()
irisData.data[0:5,:]

X = irisData.data[:, :2]
y = irisData.target
X[:10,:]
n_neighbors = 15
#n_neighbors: 临近点个数
step=0.01

for weights in ['uniform','distance']:
    classifiter=neighbors.KNeighborsClassifier(n_neighbors,weights=weights)
    classifiter.fit(X,y)
    print('KNN classifier accuracy-"%s" - %.3f'%(weights,classifiter.score(X,y)))
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    x_grid,y_grid=np.meshgrid(np.arange(x_min,x_max,step=step),np.arange(y_min,y_max,step=step))
    #numpy.meshgrid():返回list,有两个元素,第一个元素是X轴的取值,第二个元素是Y轴的取值
    # X轴的取值为np.arange(x_min,x_max,step=step)数组内的元素，
    # Y轴的取值为np.arange(y_min,y_max,step=step)数组内的元素。
    z=classifiter.predict(np.c_[x_grid.ravel(),y_grid.ravel()])
    #np.c_是按行连接两个矩阵
    #numpy.ravel(a, order='C') 展开数组元素
    z=z.reshape(x_grid.shape)
    plt.figure()
    plt.pcolormesh(x_grid,y_grid,z,cmap=ListedColormap(['lightblue', 'lightgreen', 'lightyellow']))
    #plt.pcolormesh:创建一个带有不规则矩形网格的伪彩色图,直观表现出分类边界.
    #根据z的值，来选择cmap中相应的颜色。因为z是三种值，所以就有了三种颜色。
    plt.scatter(X[:, 0], X[:, 1], c=y,
                edgecolor='k', s=20)
    plt.xlim(x_grid.min(), x_grid.max())
    #xlim：设置x轴的数值显示范围。
    plt.ylim(y_grid.min(), y_grid.max())
    plt.title("KNN 3-Class Classification (k = %d, weights = '%s')"
              % (n_neighbors, weights))

plt.show()