K近邻KNN代码知识

最新推荐文章于 2024-06-02 10:05:49 发布

CtrlZ1

最新推荐文章于 2024-06-02 10:05:49 发布

阅读量560

点赞数

分类专栏：机器学习深度学习代码知识文章标签：机器学习 KNN

本文链接：https://blog.csdn.net/qq_41076797/article/details/102677777

版权

机器学习深度学习代码知识专栏收录该内容

32 篇文章 23 订阅

订阅专栏

我们使用sklearn里封装好的KNN算法，

from sklearn.neighbors import KNeighborsClassifier

KNeighborsClassifier()

下面是它的参数设置及含义：

参数:
        n_neighbors: int, 可选参数(默认为 5)

                用于[kneighbors](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.kneighbors)查询的默认邻居的数量

        weights（权重）: str or callable(自定义类型), 可选参数(默认为 ‘uniform’)

                用于预测的权重函数。可选参数如下:

                       - ‘uniform’ : 统一的权重. 在每一个邻居区域里的点的权重都是一样的。

                       - ‘distance’ : 权重点等于他们距离的倒数。使用此函数，更近的邻居对于所预测的点的影响更大。

                       - [callable] : 一个用户自定义的方法，此方法接收一个距离的数组，然后返回一个相同形状并且包含权重的数组。

        algorithm（算法）: {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, 可选参数（默认为 'auto'）

                计算最近邻居用的算法：

                       - ‘ball_tree’ 使用算法[BallTree](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.BallTree.html#sklearn.neighbors.BallTree)

                       - ‘kd_tree’ 使用算法[KDTree](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KDTree.html#sklearn.neighbors.KDTree)

                       - ‘brute’ 使用暴力搜索.

                       - ‘auto’ 会基于传入[fit](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.fit)方法的内容，选择最合适的算法。

                注意 : 如果传入fit方法的输入是稀疏的，将会重载参数设置，直接使用暴力搜索。

         leaf_size（叶子数量）: int, 可选参数(默认为 30)

                传入BallTree或者KDTree算法的叶子数量。此参数会影响构建、查询BallTree或者KDTree的速度，以及存储BallTree或者KDTree所需要的内存大小。 此可选参数根据是否是问题所需选择性使用。

         p: integer, 可选参数(默认为 2)

                用于Minkowski metric（[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)）的超参数。p = 1, 相当于使用[曼哈顿距离](https://zh.wikipedia.org/wiki/%E6%9B%BC%E5%93%88%E9%A0%93%E8%B7%9D%E9%9B%A2) (l1)，p = 2, 相当于使用[欧几里得距离](https://zh.wikipedia.org/wiki/%E6%AC%A7%E5%87%A0%E9%87%8C%E5%BE%97%E8%B7%9D%E7%A6%BB)(l2)  对于任何 p ，使用的是[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)(l_p)

         metric（矩阵）: string or callable, 默认为 ‘minkowski’

                用于树的距离矩阵。默认为[闵可夫斯基空间](https://zh.wikipedia.org/wiki/%E9%96%94%E8%80%83%E6%96%AF%E5%9F%BA%E6%99%82%E7%A9%BA)，如果和p=2一块使用相当于使用标准欧几里得矩阵. 所有可用的矩阵列表请查询 DistanceMetric 的文档。

         metric_params（矩阵参数）: dict, 可选参数(默认为 None)

                给矩阵方法使用的其他的关键词参数。

         n_jobs: int, 可选参数(默认为 1)

                用于搜索邻居的，可并行运行的任务数量。如果为-1, 任务数量设置为CPU核的数量。不会影响[fit](http://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier.fit)方法。

方法：

Methods

`fit`(self, X, y)	Fit the model using X as training data and y as target values
`get_params`(self[, deep])	Get parameters for this estimator.
`kneighbors`(self[, X, n_neighbors, …])	Finds the K-neighbors of a point.
`kneighbors_graph`(self[, X, n_neighbors, mode])	Computes the (weighted) graph of k-Neighbors for points in X
`predict`(self, X)	Predict the class labels for the provided data
`predict_proba`(self, X)	Return probability estimates for the test data X.
`score`(self, X, y[, sample_weight])	Returns the mean accuracy on the given test data and labels.
`set_params`(self, \\params)	Set the parameters of this estimator.

fit(X,y): [source]

使用X作为训练数据，y作为目标值（标签）拟合模型

参数:
              X: {类似数组, 稀疏矩阵, BallTree, KDTree}
                 
                  待训练数据。如果是数组或者矩阵，形状为 [n_samples, n_features]，如果矩阵为’precomputed', 则形状为[n_samples, n_samples]。

              y: {类似数组, 稀疏矩阵}

                  形状为[n_samples] 或者 [n_samples, n_outputs]的目标值。

get_params(deep=True)[source]

获取估值器的参数.

参数:
              deep: boolean, 可选参数

                    如果为 True, 则返回估值器的参数，以及包含子目标的估值器。

返回值:
              params: Mapping string to any
                     
                    返回Map变量，内容为[参数值: 值, 参数值: 值, ........]。


如：print(clf.get_params())

{'algorithm': 'auto', 'leaf_size': 30, 'metric': 'minkowski', 'metric_params': None, 'n_jobs': 1, 'n_neighbors': 1, 'p': 2, 'weights': 'uniform'}

kneighbors(X=None,n_neighbors=None,return_distance=True)[source]

查询一个或几个点的K个邻居, 返回每个点的下标和到邻居的距离。

参数:
              X: 类似数组, 形状(n_query, n_features)或者(n_query, n_indexed) 。如果矩阵是‘precomputed’，形状为(n_query, n_indexed)

                  带查询的一个或几个点。如果没有提供，则返回每个有下标的点的邻居们。

              n_neighbors: int

                邻居数量 (默认为调用构造器时设定的n_neighboes的值).

              return_distance: boolean, 可选参数. 默认为 True.

                  如果为 False，则不会返回距离

返回值:
              dist: array

                  当return_distance =True时，返回到每个点的长度。

              ind: array

                  邻居区域里最近的几个点的下标。

例子：

在此案例中, 我们构建了一个NeighborsClassifier类。此类从数组中获取数据，并查询哪个点最接近于[1, 1, 1]

>>> samples = [[0., 0., 0.], [0., .5, 0.], [1., 1., .5]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh = NearestNeighbors(n_neighbors=1)
>>> neigh.fit(samples)
NearestNeighbors(algorithm='auto', leaf_size=30, ...)
>>> print(neigh.kneighbors([[1., 1., 1.]]))
(array([[ 0.5]]), array([[2]]...))

如你所见返回值为[[0.5]] 和 [[2]]。意思是此点是距离为0.5并且是样本中的第三个元素 (下标从0开始)。你可以尝试查询多个点：

>>> X = [[0., 1., 0.], [1., 0., 1.]]
>>> neigh.kneighbors(X, return_distance=False)
array([[1],     
       [2]]...)

kneighbors_graph(X=None,n_neighbors=None,mode=’connectivity’)[source]

计算在X数组中每个点的k邻居的（权重）图

参数:
              X: 类似数组, 形状(n_query, n_features)。如果矩阵是‘precomputed’，形状为(n_query, n_indexed)

                  一个或多个待查询点。如果没有提供，则返回每个有下标的点的邻居们。

              n_neighbors: int

                  邻居数量。(默认为调用构造器时设定的n_neighboes的值)。

              mode: {‘connectivity’, ‘distance’}, 可选参数

                  返回矩阵数据类型： ‘connectivity’ 会返回1和0组成的矩阵。 in ‘distance’ 会返回点之间的欧几里得距离。

返回值:
              A: CSR格式的稀疏矩阵，形状为 [n_samples, n_samples_fit]

                  n_samples_fit 是拟合过的数据中样例的数量，其中 A[i, j] 代表i到j的边的权重。

关联：
NearestNeighbors.radius_neighbors_graph

例子：


>>> X=[[0], [3], [1]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh=NearestNeighbors(n_neighbors=2)
>>> neigh.fit(X)
NearestNeighbors(algorithm='auto', leaf_size=30, ...)
>>> A=neigh.kneighbors_graph(X)
>>> A.toarray()array([[ 1.,  0.,  1.],
                      [ 0.,  1.,  1.],
                      [ 1.,  0.,  1.]])

predict(X)[source]

给提供的数据预测相应的类别标签

参数:
              X: 类似数组, 形状(n_query, n_features)。 如果矩阵是‘precomputed’，形状为(n_query, n_indexed) 

                  待测试样例。

返回值:
              y: 形状为 [n_samples] 或者 [n_samples, n_outputs]的数组

                  返回每个待测试样例的类别标签。

predict_proba(X)[source]

返回测试数据X的概率估值。

参数:
              X: 类似数组, 形状(n_query, n_features)。 如果矩阵是‘precomputed’，形状为(n_query, n_indexed) 

                  待测试样例。

返回值:
              p: 形状为[n_samples, n_classes]的数组，或者是n_outputs列表

                  输入样例的类别概率估值。其中类别根据词典顺序排序。

score(X, y, sample_weight=None)[source]

返回给定测试数据和标签的平均准确度。在多标签分类中，返回的是各个子集的准确度。

参数:
              X : 类似数组，形状为 (n_samples, n_features)

                  待测试样例

              y: 类似数组，形状为 (n_samples) 或者 (n_samples, n_outputs)

                  X对于的正确标签

              sample_weight: 类似数组，形状为 [n_samples], 可选参数

                  待测试的权重

返回值:
              score : float

                  self.predict(X) 关于y的平均准确率。

set_params(**params)[source]

设置估值器的参数。

此方法在单个估值器和嵌套对象（例如管道）中有效。而嵌套对象有着__形式的参数，方便更新各个参数。

返回值:
              self

关于方法的描述引用信息：

作者：吃着苹果写着代码
链接：https://www.jianshu.com/p/871884bb4a75
来源：简书

注意事项：

1.kNN算法的三要素：k值选择、距离度量和分类决策规则都会对分类结果产生重要影响。（可以通过交叉验证选择合适的参数）

k值选择：通常是不大于20的整数，通常由交叉验证选择最优的k.

距离度量：不同的距离度量方法所确定的k个邻近点是不同的，会对结果产生影响，一般选用欧氏距离。

分类决策规则：一般是多数表决，即k个邻居中多的说的算。可以根据不同距离的邻居对该样本产生的影响赋予不同的权重。

2.数据标准化：在开始实现算法之前，我们要考虑一个问题，不同特征的特征值范围可能有很大的差别，例如，我们要分辨一个人的性别，一个女生的身高是1.70m，体重是60kg，一个男生的身高是1.80m，体重是70kg，而一个未知性别的人的身高是1.81m, 体重是64kg，这个人与女生数据点的“距离”的平方 d^2 = ( 1.70 - 1.81 )^2 + ( 60 - 64 )^2 = 0.0121 + 16.0 = 16.0121，而与男生数据点的“距离”的平方d^2 = ( 1.80 - 1.81 )^2 + ( 70 - 64 )^2 = 0.0001 + 36.0 = 36.0001 。可见，在这种情况下，身高差的平方相对于体重差的平方基本可以忽略不计，但是身高对于辨别性别来说是十分重要的。为了解决这个问题，就需要将数据标准化（normalize），把每一个特征值除以该特征的范围，保证标准化后每一个特征值都在0~1之间。
原文链接：https://blog.csdn.net/albert201605/article/details/81265004

一份比较鲜明的代码

'''
    KNeighborsClassifier
'''
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
import pickle       #pickle模块
from sklearn.externals import joblib    #jbolib模块
from sklearn import preprocessing       #标准化数据模块
from sklearn.cross_validation import cross_val_score # K折交叉验证模块
import matplotlib.pyplot as plt


# 第一步： 加载数据集
iris = datasets.load_iris()            # 加载数据集
iris_X = iris.data
iris_y = iris.target

# 自己制造数据 ***　make_XXX
X, y = datasets.make_classification(n_samples=300, n_features=2, n_redundant=0,
    n_informative=2, random_state=22, n_clusters_per_class=1, scale=100)
# X, y = datasets.make_regression(n_samples=100, n_features=1, n_targets=1, noise=10)


# 第二步： 数据集标准化， 划分测试集、训练集
iris_X = preprocessing.scale(iris_X)    # 标准化数据
# 随机划分训练集和测试集 7:3
X_train, X_test, y_train, y_test = train_test_split(
                iris_X, iris_y, test_size=0.3, random_state=0)


# 第三步： 训练模型
knn = KNeighborsClassifier(n_neighbors=5)            # 训练模型
knn.fit(X_train, y_train)
print(knn.predict(X_test))            # 利用模型做预测
print(y_test)
print(knn.score(X_test, y_test))      # 模型打分

scores = cross_val_score(knn, iris_X, iris_y, cv=5, scoring='accuracy')
print(scores.mean())                # 使用K折交叉验证模块


# 第四步：建立测试参数集,调参，优化模型
k_range = range(1, 31)
k_scores = []

#藉由迭代的方式来计算不同参数对模型的影响，并返回交叉验证后的平均准确率
for k in k_range:
    knn = KNeighborsClassifier(n_neighbors=k)
    scores = cross_val_score(knn, iris_X, iris_y, cv=10, scoring='accuracy')     # 分类
    # loss = -cross_val_score(knn, X, y, cv=10, scoring='mean_squared_error')    # 回归
    k_scores.append(scores.mean())

#可视化数据
plt.plot(k_range, k_scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Cross-Validated Accuracy')
plt.show()


# 第五步： 保存模型
# 保存Model 方法一：(注:save文件夹要预先建立，否则会报错)  pickle 方法
with open('Model/Pickle/KNeighborsClassifier.pickle', 'wb') as f:
    pickle.dump(knn, f)

#读取Model
with open('Model/Pickle/KNeighborsClassifier.pickle', 'rb') as f:
    clf2 = pickle.load(f)
    print(clf2.predict(iris_X))         #测试读取后的Model


#保存Model 方法二：(注:save文件夹要预先建立，否则会报错) joblib 方法  优点：效率高
joblib.dump(knn, 'Model/Joblib/KNeighborsClassifier.pkl')

#读取Model
clf3 = joblib.load('Model/Joblib/KNeighborsClassifier.pkl')
print(clf3.predict(iris_X))           #测试读取后的Model
————————————————
版权声明：本文为CSDN博主「Luzaofa」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/Luzaofa/article/details/80357795

CtrlZ1

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
K近邻KNN代码知识

我们使用sklearn里封装好的KNN算法，from sklearn.neighbors import KNeighborsClassifierKNeighborsClassifier()下面是它的参数设置及含义：参数: n_neighbors: int, 可选参数(默认为 5) 用于[kneighbors](http://sc...
复制链接

扫一扫