基于卷积神经网络的花卉识别-毕业设计

基于卷积神经网络的花卉识别

（一）简介

基于卷积神经网络的花卉识别系统是在pytorch框架下实现的，系统中有两个模型可选resnet50模型和VGG16模型，这两个模型可用于模型效果对比。该系统涉及的技术栈有，UI界面：python + pyqt5，前端界面：python flask + vue

该项目是在pycharm和anaconda搭建的虚拟环境执行，pycharm和anaconda安装和配置可观看教程：

???作者简介：机器学习，深度学习，卷积神经网络处理，图像处理
??B站项目实战：https://space.bilibili.com/364224477
?? 如果文章对你有帮助的话，欢迎评论 ??点赞???? 收藏 ??加关注+
???♂代码获取：@个人主页

（二）项目介绍

1. pycharm打开项目界面如下

2. 数据集

3.GUI界面（技术栈：pyqt5+python）

4.前端界面（技术栈：vue+python）

5. 核心代码

class MainProcess:
    def __init__(self, train_path, test_path, model_name):
        self.train_path = train_path
        self.test_path = test_path
        self.model_name = model_name
        self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
 
        def main(self, epochs):
        # 记录训练过程
        log_file_name = './results/vgg16训练和验证过程.txt'
        # 记录正常的 print 信息
        sys.stdout = Logger(log_file_name)
 
        print("using {} device.".format(self.device))
        # 开始训练，记录开始时间
        begin_time = time()
        # 加载数据
        train_loader, validate_loader, class_names, train_num, val_num = self.data_load()
        print("class_names: ", class_names)
        train_steps = len(train_loader)
        val_steps = len(validate_loader)
        # 加载模型
        model = self.model_load()  # 创建模型
 
        # 网络结构可视化
        x = torch.randn(16, 3, 224, 224)  # 随机生成一个输入
        model_visual_path = 'results/vgg16_visual.onnx'  # 模型结构保存路径
        torch.onnx.export(model, x, model_visual_path)  # 将 pytorch 模型以 onnx 格式导出并保存
        # netron.start(model_visual_path)  # 浏览器会自动打开网络结构
 
        # load pretrain weights
        # download url: https://download.pytorch.org/models/vgg16-397923af.pth
        model_weight_path = "models/vgg16-pre.pth"
        assert os.path.exists(model_weight_path), "file {} does not exist.".format(model_weight_path)
        model.load_state_dict(torch.load(model_weight_path, map_location='cpu'))
 
        # 更改Vgg16模型的最后一层
        model.classifier[-1] = nn.Linear(4096, len(class_names), bias=True)
 
        # 将模型放入GPU中
        model.to(self.device)
        # 定义损失函数
        loss_function = nn.CrossEntropyLoss()
        # 定义优化器
        params = 
        optimizer = optim.Adam(params=params, lr=0.0001)
 
        train_loss_history, train_acc_history = [], []
        test_loss_history, test_acc_history = [], []
        best_acc = 0.0
 
        for epoch in range(0, epochs):
            # 下面是模型训练
            model.train()
            running_loss = 0.0
            train_acc = 0.0
            train_bar = tqdm(train_loader, file=sys.stdout)
            # 进来一个batch的数据，计算一次梯度，更新一次网络
            for step, data in enumerate(train_bar):
                images, labels = data  # 获取图像及对应的真实标签
                optimizer.zero_grad()  # 清空过往梯度
                outputs = model(images.to(self.device))  # 得到预测的标签
                train_loss = loss_function(outputs, labels.to(self.device))  # 计算损失
                train_loss.backward()  # 反向传播，计算当前梯度
                optimizer.step()  # 根据梯度更新网络参数
 
                # print statistics
                running_loss += train_loss.item()
                predict_y = torch.max(outputs, dim=1)[1]  # 每行最大值的索引
                # torch.eq()进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False
                train_acc += torch.eq(predict_y, labels.to(self.device)).sum().item()
                train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
                                                                         epochs,
                                                                         train_loss)
            # 下面是模型验证
            model.eval()  # 不启用 BatchNormalization 和 Dropout，保证BN和dropout不发生变化
            val_acc = 0.0  # accumulate accurate number / epoch
            testing_loss = 0.0
            with torch.no_grad():  # 张量的计算过程中无需计算梯度
                val_bar = tqdm(validate_loader, file=sys.stdout)
                for val_data in val_bar:
                    val_images, val_labels = val_data
                    outputs = model(val_images.to(self.device))
 
                    val_loss = loss_function(outputs, val_labels.to(self.device))  # 计算损失
                    testing_loss += val_loss.item()
 
                    predict_y = torch.max(outputs, dim=1)[1]  # 每行最大值的索引
                    # torch.eq()进行逐元素的比较，若相同位置的两个元素相同，则返回True；若不同，返回False
                    val_acc += torch.eq(predict_y, val_labels.to(self.device)).sum().item()
 
            train_loss = running_loss / train_steps
            train_accurate = train_acc / train_num
            test_loss = testing_loss / val_steps
            val_accurate = val_acc / val_num
 
            train_loss_history.append(train_loss)
            train_acc_history.append(train_accurate)
            test_loss_history.append(test_loss)
            test_acc_history.append(val_accurate)
 
            print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
                  (epoch + 1, train_loss, val_accurate))
            if val_accurate &gt; best_acc:
                best_acc = val_accurate
                torch.save(model.state_dict(), self.model_name)
 
        # 记录结束时间
        end_time = time()
        run_time = end_time - begin_time
        print('该循环程序运行时间：', run_time, "s")
        # 绘制模型训练过程图
        self.show_loss_acc(train_loss_history, train_acc_history,
                           test_loss_history, test_acc_history)
        # 画热力图
        self.heatmaps(model, validate_loader, class_names)

该系统可以训练自己的数据集，训练过程也比较简单，只需指定自己数据集中训练集和测试集的路径，训练后模型名称和指定训练的轮数即可

编程之家

基于卷积神经网络的花卉识别-毕业设计

基于卷积神经网络的花卉识别

（一）简介

（二）项目介绍

1. pycharm打开项目界面如下

2. 数据集

3.GUI界面（技术栈：pyqt5+python）

4.前端界面（技术栈：vue+python）

5. 核心代码

训练结束后可输出以下结果：

a. 训练过程的损失曲线

b. 模型训练过程记录，模型每一轮训练的损失和精度数值记录

c. 模型结构

模型评估可输出：

a. 混淆矩阵

b. 测试过程和精度数值

（三）资源获取方式