我们使用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