机器学习-第二章 KNN算法

标题 第二章 KNN算法

目录
KNN算法简介
KNN思想、分类和回归问题处理流程
KNN算法API介绍
分类、回归实现
距离度量
常用距离计算方法
特征预处理
归一化 标准化鸢尾花识别案例
超参数选择方法
交叉验证、网格搜索、手写数字识别

学习目标
1.理解k近邻算法的思想
2.知道k近邻算法分类流程
3.知道k近邻算法回归流程4

1.KNN算法简介

KNN算法思想：如果一个样本在特征空间中的k个最相似的样本中的大多数属于某一个类别，则该样本也属于这个类别

2.k近邻算法
样本相似性：样本都是属于一个任务数据集的。样本距离越近则越相似。
利用k近邻算法预测电影类型。
欧氏距离：对应维度差值平方和，开平方根


3.K值选择
k值小了，过拟合–数据量少，容易学到脏数据
用较小领域中的训练实例进行预测
容易受异常点影响
k值减小就意味着整体模型变得复杂，容易发生过拟合
k值大了，欠拟合–模型变得简单
用较大领域中的训练实例进行预测
受到样本均衡的问题
k值增大就意味着整体模型变得简单，容易发生欠拟合
举例：K=N，N为训练样本，无论实例输入什么，只会按训练集只能怪最多的类别选择

4.解决的问题
分类问题、回归问题
1.相同点：都是有监督学习，欧氏距离
2.不同：
分类–投票 --标签不连续
回归–均值–标签连续
3.算法思想：若一个样本在特征空间中的k个最相似的样本大多数属于某个类别，则该样本也属于这个类别
总结

2. KNN算法API

k nearest neighbor
学习目标掌握分类api/回归api
1.分类API

""" KNN算法介绍（K Nearest Neighbors），k近邻算法 原理： 基于欧氏距离计算 测试集和每个训练集之间的距离，然后更具距离升序排序，找到近邻的k个样本 基于k个样本投票，票数多的就作为最终预测结果---》分类问题 基于k个样本计算平均值，作为最终预测结果---》回归问题 实现思路 1.分类问题 适用于：有特征、有笔阿斯哦钱，且标签是不连续的--练得 2.回归问题 适用于：有特征、有标签、且标签是连续的 KNN算法分类问题 思路如下是 1.计算测试集和每个训练样本之间的距离 2.基于距离进行升序pair 3.找到最近的k个样本 4.k个样本进行投票 5.票数多的结果，作为预测结果 代码实现思路 1导包 2.准备数据集（训练集和测试集） 3.创建（KNN分类模型）模型对象 4.模型训练 5.模型预测 """ # 1导包 from sklearn.neighbors import KNeighborsClassifier # 2.准备数据集（训练集和测试集） # train ：训练集 # test：测试集 # neighbors：最近邻的邻居数 x_train = [[0], [1], [2], [3]] #训练集的特征数据 y_train = [0, 0, 1, 1] #训练集的标签数据 x_test = [[5]] #测试集的特征数据 # 3.创建（KNN分类模型）模型对象 # estimator ：估计其，模型对象，也可以用变量名model做接收 estimator = KNeighborsClassifier(n_neighbors=4) # 0 estimator = KNeighborsClassifier(n_neighbors=3) # 1 # 4.模型训练 # 传入：训练集的特征数据、训练集的标签数据 estimator.fit(x_train, y_train) # 5.模型预测 # 传入：测试集的特征数据，获取到预测结果（测试集的标签，y_test） y_pre = estimator.predict(x_test) # 6.打印数据结果 print(f'预测结果为：{y_pre}')

2.回归API

""" KNN算法介绍（K Nearest Neighbors），k近邻算法 原理： 基于欧氏距离计算 测试集和每个训练集之间的距离，然后更具距离升序排序，找到近邻的k个样本 基于k个样本投票，票数多的就作为最终预测结果---》分类问题 基于k个样本计算平均值，作为最终预测结果---》回归问题 实现思路 1.分类问题 适用于：有特征、有笔阿斯哦钱，且标签是不连续的--练得 2.回归问题 适用于：有特征、有标签、且标签是连续的 KNN算法回归问题 思路如下是 1.计算测试集和每个训练样本之间的距离 2.基于距离进行升序排序 3.找到最近的k个样本 4.基于k个样本的标签计算平均值 5.将上述计算出来的平均值，作为最终的预测结果 代码实现思路 1导包 2.准备数据集（训练集和测试集） 3.创建（KNN分类模型）模型对象 4.模型训练 5.模型预测 总结： k值过小，容易受到异常值影响，且会导致模型学到大量的“脏特征”，导致出现：过拟合 k值过大，模型会变得简单，容易发生欠拟合。 """ # 1导包 from sklearn.neighbors import KNeighborsRegressor #KNN算法的回归模型 # 2.准备数据集（训练集和测试集） # 开根号： 14.53 14.28 1 2.236 # 平方和：211 204 1 5 # 差值：（3,11,9）（2,10,10）（0,1,0）（1,0,2） # k=3 0.2 0.3 0.4 均值 0.3 x_train = [[0,0,1], [1,1,0],[3,10,10],[4,11,12]] #训练集的特征数据，因为特可以有多个特征，所以是一个二维数组 y_train = [0.1, 0.2, 0.3, 0.4] #训练集的标签数据，因为标签是连续的，所以是一个一维数组 x_test = [[3,11,10]] #测试集的特征数据 # x_test = [[3,110003,10333]] #k过大 # 3.创建（KNN分类模型）模型对象 estimator =KNeighborsRegressor(n_neighbors=3) # estimator =KNeighborsRegressor(n_neighbors=4) # 4.模型训练 # 传入：训练集的特征数据、训练集的标签数据 estimator.fit(x_train, y_train) # 5.模型预测 y_pre = estimator.predict(x_test) #特征需要传入一个二维数组 # 6.打印数据结果 print("预测结果：", y_pre)

3.距离度量

1.欧氏距离
常见距离公式
两点在空间中的距离一般指的都是欧式距离
欧氏距离=对应维度差值平方和，开平方根
二维平面 d=
三维空间
n维空间

2.曼哈顿距离 也称为城市街区距离
欧氏距离=对应维度差值平方和，开平方根
曼哈顿距离=对应维度差值的绝对值之和

只能横平竖直的走 （0,0）（6,6） 曼哈顿距离：6+6=12 欧氏距离：6*6+6*6 开根 =6*1.414=8.46

3.切比雪夫距离
国际象棋中，可以横竖斜着走
=对应维度值差值的绝对值，求最大值
（1,2）（5,5）
5-1=4 5-2=3 4>3 =4
4.闵式距离
不是一种新的距离的度量方式
是对多个距离公式的概括性表述

4.特征预处理

1.为什么做归一化、标准化
特征的单位或者大小相差太大，或者某个特征的方差相比其他的特征要大出几个数量及，容易影响（支配）目标结果，使得一些模型（算法）无法学到其他特征。

归一化：

API：
1.sklearn.preprocessing.MinMaxScaler
feature_range 缩放区间
2.fit_transform（x） 训练加转换 适合第一次 训练集
transform 适合训练集

""" 案例：演示特征预处理 --归一化 回顾：特征工程目的 和 步骤 目的： 利用专业的背景知识和技巧处理数据，用于提升模型的性能 步骤 1.特征提取 2.特征预处理 归一化 标准化 3.特征降维 4.特征选择 5.特征组合 特征预处理之 归一化介绍： 目的： 防止因为量纲单位问题，导致特征列的放差值相差较大，影响模型最终结果 所以通过公式把 哥猎德值 映射到【0,1】区间 公式： x'=（当前值-该列最小值）/（该列最大值-该列最小值） x''=x'*（mx-mi）+mi 公式解析： x‘ 基于公式算出来的结果 x’‘ 最终的结果 mx 区间的最大值 mi 区间的最小值 弊端 容易受到最大值和最小值的影响，所以他一般用于处理小数据集 """ #导包 from sklearn.preprocessing import MinMaxScaler #归一化对象 # 1.准备数据集（归一化之前的原数据） x_train = [[90,2,10,40],[60,4,15,45],[75,3,13,46]] # 2.创建归一化对象 # 参数 feature_range=(0,1) 指定归一化后的数据区间 # 默认区间是【0,1】，如果就是这个区间，可以省略不写 # transfer = MinMaxScaler(feature_range=(3,5)) transfer = MinMaxScaler() #3.对原数据集进行归一化处理 x_train_new = transfer.fit_transform(x_train) # 4.打印处理后的数据 print("归一化处理后的数据为：", x_train_new)

标准化
数据标准化 ：通过对原始数据进行标准化 ，转换为均值为0标准 差为1的正态分布的数据
正态分布：
是一种改成分布，也叫高斯分布，钟形分布
正态分布记作N（μ，σ）
μ决定了其位置，标准差决定了分布的幅度
μ=0， σ=1，正态分布是标准正态分布
方差

API

""" 案例：演示特征预处理 --标准化 回顾：特征工程目的 和 步骤 目的： 利用专业的背景知识和技巧处理数据，用于提升模型的性能 步骤 1.特征提取 2.特征预处理 归一化 标准化 3.特征降维 4.特征选择 5.特征组合 特征预处理之 标准化介绍： 目的： 防止因为量纲单位问题，导致特征列的方差值相差较大，影响模型最终结果 所以通过公式把 各列的值 映射到 均值为0 标准差为1 的 正态分布序列 公式： x'=（当前值-该列平均值）/ 该列的标准差 应用场景 适用于大数据集的处理 结论： 无论是归一化还是标准化，目的都是为了解决量纲单位问题，导致模型评估较低等问题 回顾： 方差计算公式：该列每个值和该列均值的差的平方和的平均值 标准差：方差开平方根 """ #导包 from sklearn.preprocessing import StandardScaler #标准化对象 # 1.准备数据集（标准化之前的原数据） x_train = [[90,2,10,40],[60,4,15,45],[75,3,13,46]] # 2.创建标准化对象 transfer = StandardScaler() #3.对原数据集进行归一化处理 x_train_new = transfer.fit_transform(x_train) # 4.打印处理后的数据 print("标准化处理后的数据为：", x_train_new) # 5.打印数据集的均值和方差和标准差 print("数据集的均值为：", transfer.mean_) print("数据集的方差为：", transfer.var_) print("数据集的标准差为：", transfer.std_)

5. 案例：利用KNN算法对鸢尾花分类

花萼 sepal 长和宽
花瓣 petal 长和宽
0 1 2 三种鸢尾花

""" 案例：通过KNN算法 实现 鸢尾花 的 分类 回顾：机器学习的研发流程 1.加载数据 2.数据预处理 3.特征工程 提取 预处理 4.模型训练 5.模型评估 6.模型预测 """ """ ============== ==== ==== ======= ===== ==================== Min Max Mean SD Class Correlation ============== ==== ==== ======= ===== ==================== sepal length: 4.3 7.9 5.84 0.83 0.7826 sepal width: 2.0 4.4 3.05 0.43 -0.4194 petal length: 1.0 6.9 3.76 1.76 0.9490 (high!) petal width: 0.1 2.5 1.20 0.76 0.9565 (high!) ============== ==== ==== ======= ===== ==================== """ #导包 from sklearn.datasets import load_iris #加载鸢尾花测试集的 import seaborn as sns import pandas as pd import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split #分割训练集和测试集的 from sklearn.preprocessing import StandardScaler #数据标准化的 from sklearn.neighbors import KNeighborsClassifier #KNN算法 分类对象 from sklearn.metrics import accuracy_score #模型评估的 计算模型预测的准确率 # 1. 定义函数 加载鸢尾花数据集，并查看数据集 def dm01_loadiris(): #1.加载鸢尾花数据集 iris_data = load_iris() # 2. 查看数据集 # print(f'数据集{iris_data}') #字典 # print(f'数据集类型{type(iris_data)}') #<class 'sklearn.utils._bunch.Bunch'> # 3. 查看数据集所有的键 print(f'数据集所有的键{iris_data.keys()}') #数据集所有的键dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module']) # 4. 查看数据集的键对应的值 # print(f'具体的数据：{iris_data.data[:5]}') #有150条数据，每条数据有四个特征，我们只看前五条 # print(f'具体标签：{iris_data.target[:5]}') #有150条数据，每条数据有1个标签，我们只看前五条 print(f'具体的数据：{iris_data.data}') #有150条数据，每条数据有四个特征 print(f'具体标签：{iris_data.target}') #有150条数据，每条数据有1个标签 print(f'标签名称：{iris_data.target_names}') #['setosa' 'versicolor' 'virginica'] print(f'数据集的特征名称：{iris_data.feature_names}') #['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'] # print(f'数据集的描述：{iris_data.DESCR}') # print(f'数据集的frame：{iris_data.frame} ') #None # print(f'数据集的filename：{iris_data.filename}') #iris.csv # print(f'数据集的data_module：{iris_data.data_module}') #klearn.datasets.data # 2.定义函数，绘制数据集的散点图 def dm02_show_iris(): # 1. 加载鸢尾花数据集 irir_data = load_iris() # 2. 把鸢尾花的数据集转换成DataFrame irir_df = pd.DataFrame(data=irir_data.data, columns=irir_data.feature_names) # 3. 给数据集添加标签 irir_df['label']=irir_data.target print(irir_df) # 4. 通过seaborn绘制散点图 # 参1:数据集 参2：x轴 参3：y轴 参4：标签 参5：是否显示回归线 sns.lmplot(data=irir_df,x='sepal length (cm)', y='sepal width (cm)', hue='label', fit_reg=True) # 5. 设置标题 显式 plt.title('iris_data') plt.tight_layout () #自动调整子图参数，以使得整个图像边界紧贴着子图 plt.show() # 3.定义函数 切分训练集和测试集 def dm03_split_train_test(): # 1. 加载鸢尾花数据集. iris_data = load_iris() # 2. 数据的预处理 ：从150个特征和标签中，按照8:2的比例，切分训练集和测试集. # random_state:随机种子相同，训练集和测试集的切分结果相同 # 返回值：训练集的特征数据、测试集的特征数据、训练集的标签数据、测试集的标签数据 x_train, x_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, test_size=0.2, random_state=22) # 3. 打印切割后的结果 print(f'训练集特征数据：{x_train},个数：{len(x_train)}') #120条，每条数据有4个特征 print(f'训练集标签数据：{y_train},个数：{len(y_train)}') #120条，每条数据有1个标签 print(f'测试集特征数据：{x_test},个数：{len(x_test)}') #30条，每条数据有4个特征 print(f'测试集标签数据：{y_test},个数：{len(y_test)}') #30条，每条数据有1个标签 # 4.定义函数，实现鸢尾花完整案例 --》加载数据集，数据预处理，特征工程，模型训练，模型评估，模型预测 def dm04_iris_test(): # 1. 加载数据集 iris_data = load_iris() # 2. 数据预处理 x_train, x_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, test_size=0.2, random_state=22) # 3.特征工程 # 思考一：特征提取：因为源数据是4个特征，所以不需要进行特征提取 # 思考二：特征预处理：因为源数据是连续的，所以不需要进行特征预处理，但是加入代码更完善 # 3.1 创建标准化对象 transfer = StandardScaler() # 3.2 对数据列进行标准化处理 x_train = transfer.fit_transform(x_train) x_test = transfer.transform(x_test) # 4.模型训练 # 4.1 创建模型对象 estimator = KNeighborsClassifier(n_neighbors=5) # 4.2 具体的模型训练动作 estimator.fit(x_train, y_train) # 5.模型预测 #场景1： 对刚才切分的30条测试集进行预测 # 5.1直接预测，预测结果保存在y_pre中 y_pre = estimator.predict(x_test) # 5.2打印预测结果 print(f'预测结果：{y_pre}') # 场景2：对新数据集进行测试 #5.1 自定义测试数据集 my_data =[[7.8,2.1,3.9,1.6]] # 5.2 对数据集进行标准化处理 my_data = transfer.transform(my_data) #只有第一次是fit_transform # 5.3 预测新数据集 y_pre_new = estimator.predict(my_data) print(f'预测结果：{y_pre_new}') # 5.4 查看数据集，每种分类的预测结果 y_pre_proba = estimator.predict_proba(my_data) print(f'预测概率：{y_pre_proba}') #预测概率：[[0. 0.6 0.4]] --->对应的0分类的概率为0 1分类的概率为0.6 2分类的概率为0.4 # 6.模型评估 # 方式一：直接评估，基于：训练集的特征 和 训练集的标签 print(f'准确率：{estimator.score(x_test, y_test)}') #准确率：0.93 # 方式二：基于：测试集的特征 和 测试集的标签 print(f'准确率：{accuracy_score(y_test, y_pre)}') #准确率：0.93 # 5.测试 if __name__ == '__main__': # dm01_loadiris() # dm02_show_iris() # dm03_split_train_test() dm04_iris_test()

6.超参数训练方法

1.什么是交叉验证
是一种数据集的分割方法，将训练集划分为n份，拿一份做验证集（测试集）、其他n-1份做训练集

2.交叉验证法原理：将数据集划分为cv=4 份
第一次：把第一份做验证集，其他数据做训练
第二次: 把第二份做验证集，其他数据做训练
…训练四次 做四次评估
使用训练集+验证集多次评估，取平均值做交叉验证为模型得分
若k=5模型得分最好，再使用全部训练集（训练集+验证集）对k=5模型在训练一遍，再使用测试集对k=5模型做评估。

3.网格搜索
为什么需要网格搜索？
模型有很多超参，能力存在很大差异。需要手动产生很多超参数组合，来训练模型
每组超参数都蚕蛹交叉验证评估，最后选出最优参数组合建立模型

• 网格搜索时模型调参的有力工具
• 只需要将若干参数传给网格搜索对象，它自动帮我们完成不同超参数的组合、模型训练、模型评估，最终返回一组最优参数

API
sklearn.model_selection.GridSearchCV(estimator,param_grid=None,cv=None)
estimator：估计器对象
param_grid:估计器参数
cv：几折
fit：输入训练数据
score：准确率
结果分析
bestscore_:

""" 交叉验证解释 原理 把数据分成n份，例如4份，也叫4折交叉验证 第一次：把第一份数据作为测试集，其他座位训练集，训练模型，模型预测，获取准确率--》准确率1 第2次：把第2份数据作为测试集，其他座位训练集，训练模型，模型预测，获取准确率--》准确率2 第3次：把第3份数据作为测试集，其他座位训练集，训练模型，模型预测，获取准确率--》准确率3 第4次：把第4份数据作为测试集，其他座位训练集，训练模型，模型预测，获取准确率--》准确率4 然后计算上述四次准确率的平均值 作为：模型的最终准确率 假设第四次最好--准确率最高，则：用全部数据（训练集+测试集）训练模型，再次用测试集对模型测试 目的： 为了让模型的最终验证结果更准确 网格搜索 目的/作用 寻找最优超参 原理： 接受超参可能出现的值，然后针对超参的每个值进行交叉验证，获取最优 超参数组合 超参数： 需要用户手动录入数据，不同超参数组合，肯呢个会影响模型的最终测评结果 大白话解释 """ #导包 from sklearn.datasets import load_iris #加载鸢尾花测试集的 import seaborn as sns import pandas as pd import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt from sklearn.model_selection import train_test_split,GridSearchCV #分割训练集和测试集的,寻找最优超参的（网格搜索+交叉验证） from sklearn.preprocessing import StandardScaler #数据标准化的 from sklearn.neighbors import KNeighborsClassifier #KNN算法 分类对象 from sklearn.metrics import accuracy_score #模型评估的 计算模型预测的准确率 # 1 . 定义函数 加载鸢尾花数据集，并查看数据集 iris_data = load_iris() # 2. 数据预处理 x_train, x_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, test_size=0.2, random_state=22) # 3. 特征工程 # 3.1 创建标准化对象 transfer = StandardScaler() # 3.2 对数据列进行标准化处理 x_train = transfer.fit_transform(x_train) x_test = transfer.transform(x_test) # 4 模型训练 # 4.1 创建模型对象 KNN estimator = KNeighborsClassifier(n_neighbors=5) # 4.2 定义字典，记录超参出现的情况 param_dict = {'n_neighbors':[i for i in range(1,11)]} # 4.3 创建GridSearchCV对象--》寻找最优超参，使用网格搜索+交叉验证 # 参数1：要计算最优超参的模型对象 # 参数2：该模型超参可能出现的值 # 参数3：交叉验证的次数，这里的4折表示，每个超参组合，都进行4次交叉验证。这里共计4*10=40次交叉验证 # 返回值 ：estimator->处理后的超参对象 estimator = GridSearchCV(estimator, param_grid=param_dict, cv=4) # 4.4 具体的模型训练 estimator.fit(x_train, y_train) # 4.5 打印最优超参组合 print(f'最优超参组合：{estimator.best_params_}') print(f'最优超参组合对应的准确率：{estimator.best_score_}') print(f'模型预测结果：{estimator.predict(x_test)}') print(f'模型预测结果：{estimator.cv_results_}') print(f'模型预测结果：{estimator.best_estimator_}') # 5.模型评估 # 5.1 获取最优超参的模型对象 # estimator = estimator.best_estimator_ estimator = KNeighborsClassifier(n_neighbors=3) # 5.2 模型训练 estimator.fit(x_train, y_train) # 5.3 模型预测 y_pre = estimator.predict(x_test) # 5.4 模型评估 print(f'准确率：{accuracy_score(y_test, y_pre)}')

7. 利用KNN算法手写数字识别

1.数据介绍 train.csv 和 test.csv 包含从0-9的手写数字识别
2.每个图片2828,784个像素
0–纯黑
1–纯白
代码实现
1.加载数据
2.拿到特征、标签
3.特征reshape 2828

""" 案例：演示KNN算法 识别图片 即：手写数字识别案例 介绍： 每张图片都是由28*28像素组成的，即：我们的csv文件中的每一行都有784个像素点，表示图片（每个像素的颜色）。 最终构成图像 """ import matplotlib.pyplot as plt import pandas as pd from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier import joblib from collections import Counter # 忽略警告 import warnings warnings.filterwarnings('ignore',module='sklearn') #参1：忽略警告 警告级别 参2：模块名称 参3：过滤条件 # 1.定义函数，接受用户传入的所有，展示该索引对应的图片 def show_digit(idx): # 1.读取数据集 获取元数据 df = pd.read_csv('./data/手写数字识别.csv') # print(df) #(42000行*785列) # 2.判断传入的索引是否越界 if idx > len(df)-1 or idx<0: print('索引越界！') return # 3.走这里，说明没有越界，就正常获取数据 x = df.iloc[:,1:] #,前所有行 ，后第一列后 y = df.iloc[:,0] #4.查看数据传入的索引对应的图片 是几？ print(f'该图片对应的数字式：{y.iloc[idx]}') #5.查看下 用户传入的索引对应的图片的形状 print(x.iloc[idx].shape) print(x.iloc[idx].values) # 6. 把（784，）转换成（28,28） x=x.iloc[idx].values.reshape(28,28) print(x) # 7. 具体的绘制灰度图的动作 plt.imshow(x,cmap='spring_r') #灰度图 plt.axis('off') # 不显示坐标轴 plt.show() #2.[掌握] 定义函数，训练模型，并保存训练好的模型 def train_model(): # 1. 加载数据集 df = pd.read_csv('./data/手写数字识别.csv') # 2. 数据预处理 #2.1 拆分出特征列 x = df.iloc[:,1:] # 2.2 拆分出标签列 y = df.iloc[:,0] # 2.3 打印特征和标签的形状 print(x.shape) # (42000, 784) print(y.shape) # (42000,) print(f'y的标签值分布：{Counter(y)}') # 2.4 对特征列（拆分前）进行 归一化. # x = x/255.0 x = x # 2.5 拆分训练集和测试集. # 参1：特征列 参2：标签列 参3：测试集所占比例 参4：随机数种子 参5：参考y轴比例进行切分，保持数据均衡 x_train, x_test, y_train, y_test = train_test_split(x,y,test_size=0.2,random_state=0,stratify=y) # 3.模型训练 # 3.1 创建模型对象 estimator = KNeighborsClassifier(n_neighbors=3) # 3.2 模型训练 estimator.fit(x_train,y_train) # 4.模型评估 print(f'准确率：{estimator.score(x_test,y_test)}') print(f'准确率：{accuracy_score(y_test,estimator.predict(x_test))}') #alt+enter 自动导包 # 5.保存模型 # 参数1：模型对象 参数2：保存的文件名 joblib.dump(estimator,'./my_model/手写数字识别.pkl') #pickle文件：python（pandas）的独有文件格式 print('模型保存成功！') #3.定义函数，测试模型 def test_model(): #pytest # 1.加载图片 x = plt.imread('./data/demo.png') #28*28 # 2.绘制图片 plt.imshow(x,cmap='gray') # plt.axis('off') #不显示坐标轴 # plt.show() #3.加载模型 estimator = joblib.load('./my_model/手写数字识别.pkl') print('模型加载成功！') # 4.模型预测 # print(x.shape) # print(x.reshape(1,784).shape) # print(x.reshape(1,-1).shape) #4.2 具体的转换动作 # x = x.reshape(1,-1)/255.0 x = x.reshape(1,-1) # 4.3 模型预测 print(f'预测结果为：{estimator.predict(x)}') #4. if __name__ == '__main__': # show_digit(9) # train_model() test_model()