基于Python机器学习实现的花卉识别

目录

1. 问题分析 3
2. 问题求解 3
   2.1. 数据预处理 3
   2.1.1. 预处理流程 3
   2.1.2. 预处理实现 4
   2.2. 降维可视化 4
   2.2.1. 降维流程分析 4
   2.2.2. PCA 方法降维 4
   从图中给出的结果得到各个阶段的用时 6
   2.2.3. t-SNE 方法求解 7
3. 随机产生初始解，得到在低维空间中的映射样本 7
4. 通过梯度下降和动量法对结果进行更新 7
5. 算法在达到指定的迭代步数时，停止迭代 7
   2.2.3.3.t-SNE 实现结果 7
   2.2.4. LDA 方法求解 10
   2.2.4.1. LDA 算法原理 10
   2.2.4.2. LDA 实现过程 10
6. 则降维后的结果为 = 10
   2.2.4.3. LDA 实现结果 10
   2.2.4.4. LDA 模型性能 12
   从图中给出的结果得到各个阶段的用时 12
   2.2.5. 自编码器方法求解 13
   2.2.5.1 .自编码器算法原理 13
   2.2.5.2 .自编码器实现过程 13
   2.2.5.3 .自编码器实现结果 14
   2.2.5.4 .自编码器模型性能 15
   2.2.6. 不同降维可视化方法比较和分析 16
   2.2.6.1 .不同降维可视化方法比较 16
   2.2.6.2 .不同降维可视化方法分析 16
   2.3. 聚类分析 16
   2.3.1. 聚类流程分析 16
   2.3.2. 聚类评价标准说明 17
   2.3.2.1 .标准化后的互信息 17
   2.3.2.2 .调整后的兰德系数 17
   2.3.2.3.Fowlkes-Mallows 分数 17
   2.3.2.4.准确率 17
   2.3.3. K-Means 方法聚类 17
   2.3.3.1.K-Means 聚类原理 17
   2.3.3.2.K-Means 聚类实现过程 18
7. 初始划分 K 个聚类，选择中心点 18
   2.3.3.3.K-Means 聚类结果 18
   2.3.3.4.K-Means 聚类性能 18
   2.3.4. K-Means++方法聚类 18
   2.3.4.1.K-Means++聚类原理 18
   2.3.4.2.K-Means++聚类实现过程 18
   2.3.4.3.K-Means++聚类结果 19
   2.3.4.4.K-Means++聚类性能 19
   2.3.5. SOM 方法聚类 19
   2.3.5.1. SOM 聚类原理 19
   2.3.5.2. SOM 聚类实现过程 19
   2.3.5.3. SOM 聚类结果 20
   2.3.5.4. SOM 聚类性能 20
   2.3.6. PCA+K-Means 方法聚类 20
   2.3.7. PCA+K-Means++方法聚类 20
   2.3.8. PCA+SOM 方法聚类 21
   2.3.9. 聚类方法对比和总结 21
   2.4. 深度学习和非深度学习识别分类 22
   2.4.1. 非深度学习识别分类 22
   2.4.1.1 .数据处理 22
8. PCA 降维原理：在降维中已经做过说明，这里不再阐述 22
   2.4.1.3 .实现过程 22
   2.4.1.4 .实验结果 22
   2.4.1.5 .模型性能 23
   2.4.2. 深度学习识别分类 23
   2.4.2.1 .数据处理 23
   2.4.2.2 .算法原理 23
   2.4.2.3 .实现过程 25
   2.4.2.4 .实验结果与模型性能结果 25
   2.4.2.5 .模型性能分析 26
9. 总结 26
   1.问题分析
   本次任务以花卉识别为题，借用机器学习方法，完成降维可视化、聚类分析、识别分类等任务。
   降维可视化是在以 PCA、tSNE 等方法，将花卉数据进行降维，得到降维后的二维图像， 这样便可以将其在平面上展示出来。聚类分析是利用合适的聚类方法，对花卉数据进行聚类， 将聚类之后的结果与标签进行对应，讨论不同聚类方法的结果。使用非深度学习和深度学习的方法，对已经标注完成但是可能含有误标数据的花卉样本进行分类，得到最终的花卉识别准确率。
   2.问题求解
   2.1.数据预处理
   2.1.1.预处理流程
   给定的数据集为 jpg 格式的数据，由于读取 jpg 格式的图片比较慢，所以将 jpg 格式存储在 numpy 的多维数组中，将提取出的多维数组存储在磁盘中，并且在下一次读取数据时， 先判断是否存在已经打包好的多维数组文件。如果存在，那么直接读取多维数组的数据；如果不存在，那么读取源文件，并将数据存到多维数组中，再存到磁盘里，供下次使用。
   这次实验中，我分别针对降维可视化、聚类以及图片分类问题做了研究。在读入图片数据方面，我才用了事先将图片存为 numpy 数组的方式加速数据读取；降维可视化中，我采用了 PCA、t-SNE、LDA、自编码器等四种方式进行，本文转载自http://www.biyezuopin.vip/onews.asp?id=16710其中，有监督的降维方法 LDA 的降维后的图片分类效果很好，而其余的非监督方法则相对比较差；在聚类问题中，我采用了 K-
   Means、K-Means++、SOM 的方法进行聚类，之后我又结合了降维方法，对上面的三种聚类方法进行了加速，最终取得了和直接聚类相似的聚类效果、同时大大提升了运算效率；在图像分类问题中，在非深度学习方法中，我使用了 SVM 进行多分类任务，考虑到 SVM 的分类效率，我先对数据进行了降维，由于其中需要调整两个参数，我采用了两重循环遍历的方法对两个参数进行了调整，最后发现当降维数为 256、SVM 分类器的惩罚系数设为 16 时， 取得的分类效果最好，能够达到 55.5%；在深度学习方法中，我采用了 resnet50 进行分类， 在数据处理阶段，加入了 resize 和随机水平翻转的方式对数据进行增强，同时我才用了 SAM 优化器，得到了泛化能力很好的网络结果。
   从这次实验中，我又系统地回顾了模式识别过程课上学习到的各种降维、聚类以及分类方法，有了很大的收获。

from MyData import MyData
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from time import time
# PCA降维
if (__name__=="__main__"):
    # 是否显示降维结果
    show_plot = False
    # 是否显示各个阶段的用时
    show_plot_Time = True
    # 记录各个关键时刻的时间
    keyTime = []

    keyTime.append(time())

    data = MyData()
    pictures,labels=data.getData()
    vectorPictures=pictures.reshape((-1,3*80*80))

    keyTime.append(time())

    # 降到二维
    model = PCA(n_components=2)
    model.fit(vectorPictures)
    
    keyTime.append(time())

    result = model.transform(vectorPictures)

    keyTime.append(time())
    if(show_plot):
        x_min = np.min(result[:,0])
        x_max = np.max(result[:,0])
        y_min = np.min(result[:,1])
        y_max = np.max(result[:,1])
        plt.figure(1)
        for i in range(8):
            indexLabel = labels==i
            tmpResult = result[indexLabel]
            tmpLabel = labels[indexLabel]
            plt.subplot(2,4,i+1)
            plt.scatter(tmpResult[:,0],tmpResult[:,1],s=1)
            plt.axis([x_min-0.1*(x_max-x_min),x_max+0.1*(x_max-x_min),y_min-0.1*(y_max-y_min),y_max+0.1*(y_max-y_min)])
            plt.title(data.Flowers[i])
        plt.show()
        plt.figure(2)
        legends = []
        for i in range(8):
            indexLabel = labels==i
            tmpResult = result[indexLabel]
            tmpLabel = labels[indexLabel]
            plt.scatter(tmpResult[:,0],tmpResult[:,1],s=1)
        
        plt.legend(data.Flowers)
        plt.axis([x_min-0.1*(x_max-x_min),x_max+0.1*(x_max-x_min),y_min-0.1*(y_max-y_min),y_max+0.1*(y_max-y_min)])
        plt.show()

    keyTime.append(time())

    model = PCA(n_components=3)
    model.fit(vectorPictures)

    keyTime.append(time())

    result = model.transform(vectorPictures)

    keyTime.append(time())
    if(show_plot):
        x_min = np.min(result[:,0])
        x_max = np.max(result[:,0])
        y_min = np.min(result[:,1])
        y_max = np.max(result[:,1])
        z_min = np.min(result[:,2])
        z_max = np.max(result[:,2])
        f=plt.figure(1)
        
        for i in range(8):
            indexLabel = labels==i
            tmpResult = result[indexLabel]
            tmpLabel = labels[indexLabel]
            
            ax=plt.subplot(2,4,i+1,projection='3d')
            # ax=Axes3D(f)
            ax.scatter(tmpResult[:,0],tmpResult[:,1],tmpResult[:,2],s=1)
            ax.set_zlim3d(z_min-0.1*(z_max-z_min),z_max+0.1*(z_max-z_min))
            ax.set_xlim3d(x_min-0.1*(x_max-x_min),x_max+0.1*(x_max-x_min))
            ax.set_ylim3d(y_min-0.1*(y_max-y_min),y_max+0.1*(y_max-y_min))
            
            plt.title(data.Flowers[i])

        plt.show()
        plt.figure(2)
        ax=plt.subplot(projection='3d')
        legends = []
        for i in range(8):
            indexLabel = labels==i
            tmpResult = result[indexLabel]
            tmpLabel = labels[indexLabel]
            ax.scatter(tmpResult[:,0],tmpResult[:,1],tmpResult[:,2],s=1)
        
        plt.legend(data.Flowers)
        ax.set_zlim3d(z_min-0.1*(z_max-z_min),z_max+0.1*(z_max-z_min))
        ax.set_xlim3d(x_min-0.1*(x_max-x_min),x_max+0.1*(x_max-x_min))
        ax.set_ylim3d(y_min-0.1*(y_max-y_min),y_max+0.1*(y_max-y_min))
        plt.show()
    
    print(keyTime)

    if(show_plot_Time):
        tmp_KeyTime = np.array(keyTime)
        # plt.plot(tmp_KeyTime)
        # plt.show()
        yticks = np.diff(tmp_KeyTime)
        plt.plot(yticks)
        plt.yticks(yticks,yticks)
        plt.show()