机器学习之KNN算法(二)

最新推荐文章于 2024-03-29 22:18:52 发布
最新推荐文章于 2024-03-29 22:18:52 发布
阅读量3.2k 收藏 2
点赞数 2
分类专栏： 近邻算法 文章标签： 近邻算法 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57021623/article/details/124227343
版权 
import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier

加载样本数据

  • matplotlib读取图片
  • 将每一张图片转化为一组数组

在这里插入图片描述

bmp1 = plt.imread('digits/0/0_1.bmp')
# 查看形状
display(bmp1.shape)
# 显示
plt.imshow(bmp1)

(28, 28)





<matplotlib.image.AxesImage at 0x5d80c50>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wPyO982s-1650167688362)(output_2_2.png)]

# 改变显示的颜色
bmp1 = plt.imread('digits/0/0_1.bmp')
# 查看形状
display(bmp1.shape)
# 显示
plt.imshow(bmp1,cmap='gray')

(28, 28)





<matplotlib.image.AxesImage at 0x5dfdeb0>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qURvt6vA-1650167688364)(output_3_2.png)]

尝试将两张图片转化为2行 28*28列

bmp2 = plt.imread('digits/0/0_2.bmp')
digits =[]
# 把二维数组变成一维数组
digits.append(bmp1.ravel())  # bmp1.reshape(-1)
digits.append(bmp2.ravel())

digits = np.array(digits)
digits.shape

(2, 784)

尝试将数组中某一张图片进行显示

plt.imshow(digits[0].reshape(28,28),cmap='gray')

<matplotlib.image.AxesImage at 0x4ca1e90>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iBLhAv9j-1650167688367)(output_7_1.png)]

批量化读取所有的图片

  • 样式数据：每一张图片的一维数组
  • 标签：文件目录文件
data = []  # 完成的目标 (5000,784)
target = [] # 完成的目标(5000,)

for label in range(10):
    for index in range(1,501):
        bmp_filename = f'digits/{label}/{label}_{index}.bmp'
        bmp = plt.imread(bmp_filename)
        data.append(bmp.ravel())
        target.append(label)
        
# 将list转化为ndarray
data = np.array(data)
target = np.array(target)

display(data.shape,target.shape)

(5000, 784)



(5000,)

创建分类模型

  • KNN 分类
  • 邻近数量：5，7，9，11
  • weights: uniform,distance # 权重
knn = KNeighborsClassifier(n_neighbors=7)
"""
KNeighborsClassifier(
    n_neighbors=5,
    weights='uniform',
    algorithm='auto',
    leaf_size=30,
    p=2,
    metric='minkowski',
    metric_params=None,
    n_jobs=None,
    **kwargs,
)
"""

from sklearn.model_selection import train_test_split as split

X_train,X_test,y_train,y_test = split(data,target,test_size=0.2)

拆分数据的训练

knn.fit(X_train,y_train)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                     metric_params=None, n_jobs=None, n_neighbors=7, p=2,
                     weights='uniform')

knn.score(X_test,y_test)

0.93

# n_neighbors=5
knn.set_params(n_neighbors=5)
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

0.929

# n_neighbors=9
knn.set_params(n_neighbors=9)
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

0.922

knn.set_params(n_neighbors=9,weights='distance')
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

0.926

knn.set_params(n_neighbors=11)
knn.fit(X_train,y_train)
knn.score(X_test,y_test)

0.917

重新训练全部样式

knn.fit(data,target)

KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
                     metric_params=None, n_jobs=None, n_neighbors=11, p=2,
                     weights='distance')

import os

加载测试样本

test1 = plt.imread('digits/test/4.bmp')
test1.shape

(28, 28, 3)

plt.imshow(test1.mean(axis=-1))

<matplotlib.image.AxesImage at 0xada3b30>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Bd0Hrtzs-1650167688370)(output_26_1.png)]

# 加灰度 
plt.imshow(test1.mean(axis=-1),cmap='gray')

<matplotlib.image.AxesImage at 0xaddf710>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y2Cp272r-1650167688372)(output_27_1.png)]

test_data = []
test_target = []
for filename in os.listdir('digits/test'):
    print(filename)
    bmp_file = f'digits/test/{filename}'
    bmp =plt.imread(bmp_file)
    # bmp是三维数组(28,28,3) 最后一个维度的数据(3)是颜色值。 (r,g,b)
    # 对最内层的维度进行平均计算，得出一个单颜色值(0-255),即降维
    test_data.append(bmp.mean(axis=-1).ravel())
    
    # os.path.split() 分隔目录与文件名
    # os.path.splitext() 将文件名的名称和扩展名分隔出来
    
    label,ext_name = os.path.splitext(filename)
    test_target.append(label)
    
test_data = np.array(test_data)
test_target = np.array(test_target)

display(test_data.shape,test_target.shape)

4.bmp
5.bmp
6.bmp
7.bmp
8.bmp
9.bmp



(6, 784)



(6,)

test_target

array(['4', '5', '6', '7', '8', '9'], dtype='<U1')

test_data[0].shape

(784,)

test_data

array([[255., 255., 255., ..., 255., 255., 255.],
       [255., 255., 255., ..., 255., 255., 255.],
       [255., 255., 255., ..., 255., 255., 255.],
       [255., 255., 255., ..., 255., 255., 255.],
       [255., 255., 255., ..., 255., 255., 255.],
       [255., 255., 255., ..., 255., 255., 255.]])

预测测试数据集的结果

y_ = knn.predict(test_data)

y_

array([4, 4, 5, 1, 0, 5])

可视化的方式显示预测结果

plt.figure(figsize=(10,12))
for i,test_bmp in enumerate(test_data):
    # 两行三列
    plt.subplot(2,3,i+1)
    plt.imshow(test_bmp.reshape(28,28),cmap='gray')
    plt.title(f'True:{test_target[i]} Pred:{y_[i]}',size=20)
    plt.axis('off')   # 关闭坐标轴
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sI8fL50H-1650167688376)(output_36_0.png)]

读取手写的数字

  • filename: digits/test/4_2.bmp
    在这里插入图片描述
    在这里插入图片描述
test_4_2 = plt.imread('digits/test/4_2.bmp')
test_4_2.shape

(28, 28, 4)

y_2  =knn.predict(test_4_2.mean(axis=-1).reshape(1,-1))
display(y_2)

array([1])

from pandas import Series

D:\yingyong\Anaconda3\lib\importlib\_bootstrap.py:219: RuntimeWarning: numpy.ufunc size changed, may indicate binary incompatibility. Expected 112 from C header, got 124 from PyObject
  return f(*args, **kwds)

Series(test_4_2.ravel()).unique()

array([255,   0], dtype=uint64)

Series(bmp1.ravel()).unique()

array([255, 204,  96,   2, 205, 207,  17,   3,  18, 201,  28,  16,  22,
       198, 249, 245, 195,  31,  53, 171, 133,  92, 159,  66,  88,  65,
       141,  27, 208, 176,   0,  87,  76, 243, 180, 134, 234,  12, 217,
        90,  47, 248,  77,  15, 184, 236, 227,  60, 192,  57,  59, 179,
         9, 143, 107, 170,  25, 230, 120,  69,  32, 124,  30, 110,  82,
       169,  93,   6, 109, 226, 199,  26,  40, 125,  56, 127, 114, 218],
      dtype=uint64)

随机从训练集中抽取5000个数字图片

index = np.arange(5000)
index

array([   0,    1,    2, ..., 4997, 4998, 4999])

np.random.permutation(index)# 随机打乱

array([4660, 2679, 3913, ...,  525, 3990,  146])

# 测试50个
test_index = np.random.randint(5000,size=50)

data[test_index].shape

(50, 784)

y_ = knn.predict(data[test_index])

target[test_index]

array([3, 3, 7, 8, 4, 7, 4, 3, 7, 3, 6, 5, 9, 7, 1, 8, 8, 2, 1, 5, 6, 2,
       5, 7, 9, 3, 0, 3, 9, 2, 6, 0, 0, 6, 0, 8, 6, 7, 6, 2, 1, 0, 4, 9,
       9, 8, 5, 0, 4, 5])

y_

array([3, 3, 7, 8, 4, 7, 4, 3, 7, 3, 6, 5, 9, 7, 1, 8, 8, 2, 1, 5, 6, 2,
       5, 7, 9, 3, 0, 3, 9, 2, 6, 0, 0, 6, 0, 8, 6, 7, 6, 2, 1, 0, 4, 9,
       9, 8, 5, 0, 4, 5])

test_label = target[test_index]
test_label[test_label == y_].size / test_label.size

1.0

test_index = np.random.randint(5000,size=50)
y_ = knn.predict(data[test_index])
test_label = target[test_index]
test_label[test_label == y_].size / test_label.size

1.0

test_index = np.random.randint(1000,size=50)
y_ = knn.predict(data[test_index])
test_label = target[test_index]
test_label[test_label == y_].size / test_label.size

1.0

plt.figure(figsize=(30,20))
i =1 
for index in test_index:
    plt.subplot(5,10,i)
    
    plt.imshow(X_test[index].reshape(28,28),cmap='gray')
    plt.axis('off')
    plt.title(f'T:{y_test[index]} P:{y_[i-1]}',size=30)
    i += 1
    
plt.show()

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w3lOflJn-1650167688380)(output_54_0.png)]

通过mean()方式实现降维效果
a = np.array(
    [
        [
            [3,4,5],
            [5,6,7],
            [3,6,9]
        ],
        [
            [1,2,5],
            [3,5,7],
            [6,8,9]
        ]
    ]
)
a.shape   # 两个，三行三列

(2, 3, 3)

# 2 --->（3+1）/ 2       3 --->（4+2）/ 2       5 --->（5+5）/ 2    
# 4 --->（5+3）/ 2       5.5 --->（6+5）/ 2     7 --->（7+7）/ 2
# 4.5 --->（3+6）/ 2     7 --->（6+8）/ 2       9--->（9+9）/ 2
a.mean(axis=0)

array([[2. , 3. , 5. ],
       [4. , 5.5, 7. ],
       [4.5, 7. , 9. ]])

# 3.66666667 --->（3+5+3）/ 3    5.33333333  --->（4+6+6）/ 3    7.  --->（5+7+9）/ 3
# 3.33333333 --->（1+3+6）/ 3    5.  --->（2+5+8）/ 3    7.  --->（5+7+9）/ 3
a.mean(axis=1)

array([[3.66666667, 5.33333333, 7.        ],
       [3.33333333, 5.        , 7.        ]])

# 4. --->（3+4+5）/ 3             6.  --->（5+6+7）/ 3      6.  --->（3+6+9）/ 2 
# 2.66666667 --->（1+2+5）/ 3     5.--->（3+5+7）/ 3        7.66666667 --->（6+8+9）/ 2 

a.mean(axis=-1)

array([[4.        , 6.        , 6.        ],
       [2.66666667, 5.        , 7.66666667]])
今晚务必早点睡
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
机器学习--K近邻算法（KNN）（2）
u010671028的博客
11-18 938
一、简介 K-Nearest-Neighbor 算法是一种常用的监督学习算法，它没有显式的训练过程，是‘懒惰学习’的显著代表，此类学习算法仅在训练阶段将训练集保存起来，训练时间开销为0，待收到测试样本后在进行处理 二、工作机制 给定测试样本，基于某种距离度量找出训练集种与其最靠近的k个训练样本，然后基于这k个‘邻居’的信息来进行预测。 在分类任务中，可使用“投票法”，即选择这k个样本中出现类别最多的标记作为预测结果；在回归任务中使用“平均法”，将这k个样本的实值输出标记的平均值作为预测结果；还可以基于距离远
机器学习——KNN算法（二）
碎片
05-25 372
接着上次的KNNsua
鸢尾花数据集-数据分析.pdf
12-24
鸢尾花数据集-数据分析 from sklearn import datasets import pandas as pd import matplotlib.pyplot as plt import numpy as np # 获取鸢尾花数据集 lris_df = datasets.load_iris() # 输⼊特征 lris_df.data # ⽬标特征 lris_df.target data_DF = pd.DataFrame(lris_df.data) target_DF = pd.DataFrame(lris_df.target) # dataframe按列拼接 join_DF = pd.concat([data_DF,target_DF],axis=1) # 修改列名 join_DF.columns=['sepal-length','sepal-width','petal-length','petal-width','class'] # 查看数据分布 x_axis = lris_df.data[:,0] y_axis = lris_df.data[:,2] plt.scatter(x_axis,y_axis,c=lris_df.target) plt.show() # 输⼊特征直⽅图分布 join_DF.iloc[:,0:4].hist() plt.show() # 箱线图 join_DF.iloc[:,0:4].plot(kind='box',subplots=True,layout=(2,2),sharex=False,sharey=False) plt.show() ft_DF = join_DF.iloc[:,0:4] # 相关系数 ft_DF.corr() x_val=ft_DF['petal-width'] y_val=ft_DF['petal-length'] plt.scatter(x_val,y_val) data_array = join_DF.values from sklearn import model_selection # 数据集划分 X = data_array[:,0:4] Y = data_array[:,4] validation_size = 0.2 seed = 6 X_train,X_validation,Y_train,Y_validation = model_selection.train_test_split(X,Y,test_size=validation_size,random_state=seed) # KNN分类 from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier() knn.fit(X_train,Y_train) knn.fit(X_train,Y_train) print(knn.score(X_validation,Y_validation)) # K折交叉验证 from sklearn.model_selection import cross_val_score scores = cross_val_score(knn,X,Y,cv=5,scoring='accuracy') print(scores) from sklearn.model_selection import KFold dfold = model_selection.KFold(n_splits=10,random_state=7) from sklearn import model_selection import matplotlib.pyplot as plt X=lris_df.data Y=lris_df.target k_range = range(1,31) k_scores = [] for k in k_range: knn = KNeighborsClassifier(n_neighbors=k) #调整K值 scores = model_selection.cross_val_score(knn,X,Y,cv=10,scoring='accuracy') 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()
knn分类iris数据
12-21
knn分类iris数据 题目 Sklearn中的datasets方法导入iris鸢尾花训练样本并用train_test_split产生测试样本，用KNN分类并输出分类精度。 data = sklearn.datasets.iris.data label = sklearn.datasets.iris.target 输出 代码 from sklearn import datasets from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split from sklea
【KNN算法详解（用法，优缺点，适用场景）及应用】
Oona_01的博客
03-29 599
我们可以看到在图中11点更接近于5点和1点，所以其体重应该更接近于5点和1点的值，也就是在72-77之间，这样我们就可以大致得到11点的体重值。K值小，相当于用较小的领域中的训练实例进行预测，只要与输入实例相近的实例才会对预测结果，模型变得复杂，只要改变一点点就可能导致分类结果出错，泛化性不佳。K值大，相当于用较大的领域中的训练实例进行预测，与输入实例较远的实例也会对预测结果产生影响，模型变得简单，可能预测出错。K=N，模型太简单，输出的分类就是所有类中数量最多的，距离都没有产生作用。
k最近邻（kNN）分类器：使用kNN的多类分类-matlab开发
05-31
功能1. kNNeighbors.predict（_） 2. kNNeighbors.find(_) 描述1. 返回一个或多个测试实例的估计标签。 2. 返回 k 个最近的训练实例的索引和各自的距离。 使用鸢尾花数据集的示例 加载fisheriris X = 测量值； Y = 物种； Xnew = [min(X);mean(X);max(X)]; k = 5； 公制 = '欧几里得'; mdl = kNNeighbors(k,metric); mdl = mdl.fit(X,Y); Ypred = mdl.predict(Xnew) Ypred = 'setosa' '杂色' '弗吉尼亚' Ynew = {'versicolor';'versicolor';'virginica'}; 准确率=accuracy_score（Ypred，Ynew） 精度= 0.6667 请
产品经理算法篇——KNN
01-20
步骤 ： 计算测试数据与各个训练数据之间的距离 按照距离递增排序 选取距离最小的k个点 确定前k个点所在类别的出现频率 返回前k个点出现频率最高的类别作为预测分类 试验： 0、数据引入 import numpy as np import pandas as pd #引入sklearn中的数据 from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split #引入计算准确率公式 from sklearn.metrics import accuracy_score ir
【机器学习】分类算法 - KNN算法（K-近邻算法）KNeighborsClassifier
热门推荐
wangyuxiang946的博客
08-22 1万+
K-近邻算法的核心思想是根据「邻居」来「推断」你的类别。
机器学习之K-近邻算法（KNN）
liuqihang11的博客
08-28 1484
0 参考资料 [1]【机器学习实战-完整版合集】《菊安酱的机器学习实战》完整版全集，首次大公开！！！_哔哩哔哩_bilibili [2]深入浅出KNN算法（二） sklearn KNN实践 - zzzzMing - 博客园 (cnblogs.com) [3]利用K近邻（回归）KNeighborsRegressor进行回归训练并预测_小臭猪的大臭猪的博客-CSDN博客 [4]特征工程学习笔记_liuqihang11的博客-CSDN博客 1 KNN算法概述 k-近邻算法（k-Nearest ...
简单的实现KNN算法
weixin_30867015的博客
08-14 1039
0：导引 K-近邻算法（KNN） ### 如何进行电影分类 众所周知，电影可以按照题材分类，然而题材本身是如何定义的?由谁来判定某部电影属于哪 个题材?也就是说同一题材的电影具有哪些公共特征?这些都是在进行电影分类时必须要考虑的问 题。没有哪个电影人会说自己制作的电影和以前的某部电影类似，但我们确实知道每部电影在风格 上的确有可能会和同题材的电影相近。那么动作片具有哪些共有特征，使...
机器学习之模型选择与调优
weixin_44953902的博客
07-18 722
什么是交叉验证（cross validation） 将拿到的训练数据，分成训练和验证集。以下图为例：将数据分成4份，其中一份作为验证集。然后经过4次（组）的测试，每次都更换不同的验证集。即得到4组模型的结果，取平均值作为最终结果。又称4折交叉验证。 分析 之前将数据分为测试集和训练集，为了让那个训练的结果更加准确： 训练集：训练集+验证集 测试集：测试集 为什么需要交叉验证 交叉验证的目的：为...
机器学习入门：KNN（K近邻算法）简介
分享日常的学习，开展的项目，编写的软件，解决的问题等~
02-11 2891
本篇博客属于机器学习入门系列博客，主要讲述 KNN （K近邻算法） 的基本原理和 Python 代码实现，KNN由于思想极度简单，应用数学知识比较少，效果好等优点，常用来作为入门机器学习的第一课，可以完整的解释机器学习算法使用过程中的很多细节问题，更加完整的刻画机器学习应用的流程。 KNN 算法 K-Nearest-Neighbors ，中文翻译为 K近邻算法。主要思想就是假设样本在特征空间中...
机器学习（KNN算法）
wo4754090的博客
06-03 392
1.KNN工作原理 简单地说，谷近邻算法采用测量不同特征值之间的距离方法进行分类。 存在一个样本数据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一数据与所属分类的对应关系。输人没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据（最近 邻）的分类标签。一般来说，我们只选择样本数据集中前k个最相似的数据，这
机器学习之KNN算法
01-06
kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来...
机器学习-kNN算法
12-15
包含基于Python实现的kNN代码，可在Pycharm中直接运行，包含约会网站的配对改进程序以及手写体识别系统
python机器学习之KNN分类算法
09-20
主要为大家详细介绍了python机器学习之KNN分类算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
机器学习实战 - k近邻算法（KNN算法）总结
04-12
机器学习实战 - k近邻算法（KNN算法）总结 适合机器学习实战入门新手 K-近邻算法，又称为 KNN 算法，是数据挖掘技术中原理最简单的算法。 KNN 的工作原理：给定一个已知类别标签的数据训练集，输入没有标签的新数据...
机器学习算法之KNN算法实现.zip
最新发布
04-20
机器学习算法 机器学习算法之KNN算法实现
python实现KNN算法
qq_43934014的博客
10-14 924
用python实现KNN算法 算法设计 在使用自带的sklearn实现knn算法时，需要先引入sklearn包中的类，继而再取得knn分类器，使用内置函数调整knn的要素（邻居个数，分类决策规则），，使用fit（）对训练集进行训练，调用knn.predict()去预测新输入的类别，调用knn.score()计算预测的准确率。 在使用原生python实现KNN算法时，首先要解决的问题就是计算输入x与...
头哥机器学习之knn算法
04-18
头哥机器学习是一个知名的机器学习教育平台，提供了丰富的机器学习算法和实践案例。其中，K最近邻算法（K-nearest neighbors，简称KNN）是一种常用的分类和回归算法。 KNN算法的基本思想是：对于一个未知样本，通过...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今晚务必早点睡

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值