当前位置：首页 > news >正文

深度学习——基于卷积神经网络实现食物图像分类【4】（使用最优模型）

news 2025/9/9 15:18:29

引言

本文将详细介绍如何使用PyTorch框架构建一个完整的食物图像分类系统，包含数据预处理、模型构建、训练优化以及模型保存等关键环节。与上一篇博客介绍的版本相比，本版本增加了使用最优模型这一流程。

一、环境准备

首先，我们需要导入必要的Python库：

import torch
import torchvision.models as models
from torch import nn
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import numpy as np
import os

这些库中：

torch和torchvision是PyTorch的核心库
Dataset和DataLoader用于数据加载和处理
transforms提供图像预处理功能
PIL用于图像处理
numpy用于数值计算

二、数据预处理

数据预处理是深度学习项目中至关重要的一环。PyTorch提供了transforms模块来方便地进行图像预处理：

data_transforms = {'train': transforms.Compose([transforms.Resize([300,300]),transforms.RandomRotation(45),transforms.CenterCrop(256),transforms.RandomHorizontalFlip(p=0.5),transforms.RandomVerticalFlip(p=0.5),transforms.ColorJitter(brightness=0.2, contrast=0.1, saturation=0.1, hue=0.1),transforms.RandomGrayscale(p=0.1),transforms.ToTensor(),transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),'valid': transforms.Compose([transforms.Resize([256,256]),transforms.ToTensor(),transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])]),
}

训练集预处理说明：

Resize([300,300])：将图像调整为300×300像素
RandomRotation(45)：随机旋转图像（-45°到45°之间）
CenterCrop(256)：从中心裁剪256×256的区域
RandomHorizontalFlip(p=0.5)：以50%概率水平翻转图像
RandomVerticalFlip(p=0.5)：以50%概率垂直翻转图像
ColorJitter：随机调整亮度、对比度、饱和度和色调
RandomGrayscale(p=0.1)：以10%概率将图像转为灰度
ToTensor()：将PIL图像转为PyTorch张量
Normalize：标准化处理（使用ImageNet的均值和标准差）

验证集预处理说明：

验证集的预处理相对简单，只包括调整大小、转为张量和标准化，因为验证阶段不需要数据增强。

三、自定义数据集类

PyTorch的Dataset类允许我们自定义数据加载方式。我们创建了一个food_dataset类：

class food_dataset(Dataset):def __init__(self, file_path, transform=None):self.file_path = file_pathself.imgs = []self.labels = []self.transform = transformwith open(self.file_path) as f:samples = [x.strip().split(' ') for x in f.readlines()]for img_path, label in samples:self.imgs.append(img_path)self.labels.append(label)def __len__(self):return len(self.imgs)def __getitem__(self, idx):image = Image.open(self.imgs[idx])if self.transform:image = self.transform(image)label = self.labels[idx]label = torch.from_numpy(np.array(label, dtype=np.int64))return image, label

这个类的主要功能：

__init__：初始化函数，读取包含图像路径和标签的文本文件
__len__：返回数据集大小
__getitem__：根据索引返回图像和对应的标签

四、设备选择

PyTorch支持在CPU、GPU（CUDA）和苹果M系列芯片（MPS）上运行。我们使用以下代码自动选择可用设备：

device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")

五、CNN模型构建

我们构建了一个简单的CNN模型，包含三个卷积块和一个全连接层：

class CNN(nn.Module):def __init__(self):super(CNN, self).__init__()self.conv1 = nn.Sequential(nn.Conv2d(3, 16, 5, 1, 2),nn.ReLU(),nn.MaxPool2d(kernel_size=2),)self.conv2 = nn.Sequential(nn.Conv2d(16, 32, 5, 1, 2),nn.ReLU(),nn.MaxPool2d(kernel_size=2),)self.conv3 = nn.Sequential(nn.Conv2d(32, 64, 5, 1, 2),nn.ReLU(),nn.MaxPool2d(kernel_size=2),)self.out = nn.Linear(64*32*32, 20)def forward(self, x):x = self.conv1(x)x = self.conv2(x)x = self.conv3(x)x = x.view(x.size(0), -1)output = self.out(x)return output

模型结构说明：

conv1：输入3通道，输出16通道，5×5卷积核，ReLU激活，2×2最大池化
conv2：输入16通道，输出32通道，同上结构
conv3：输入32通道，输出64通道，同上结构
out：全连接层，将64×32×32的特征图映射到20个类别

六、模型加载与评估

1. 加载预训练模型

model = CNN().to(device)
model.load_state_dict(torch.load("best2025-04.pth"))
model.eval()

2. 准备测试数据

test_data = food_dataset(file_path='test.txt', transform=data_transforms['valid'])
test_dataloader = DataLoader(test_data, batch_size=1, shuffle=True)

3. 测试函数

result = []
labels = []def Test_true(dataloader, model):model.eval()with torch.no_grad():for X, y in dataloader:X, y = X.to(device), y.to(device)pred = model.forward(X)result.append(pred.argmax(1).item())labels.append(y.item())Test_true(test_dataloader, model)

4. 计算准确率

from sklearn.metrics import accuracy_score
accuracy = accuracy_score(labels, result)
print(f"准确率：{accuracy:.2%}")

七、完整代码

import torch
import torchvision.models as models
from torch import nn
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import numpy as np
import osdata_transforms = { #字典'train':transforms.Compose([            #对图片预处理的组合transforms.Resize([300,300]),   #对数据进行改变大小transforms.RandomRotation(45),  #随机旋转，-45到45之间随机选transforms.CenterCrop(256),     #从中心开始裁剪[256,256]transforms.RandomHorizontalFlip(p=0.5),#随机水平翻转，p是指选择一个概率翻转，p=0.5表示百分之50transforms.RandomVerticalFlip(p=0.5),#随机垂直翻转transforms.ColorJitter(brightness=0.2,contrast=0.1,saturation=0.1,hue=0.1),transforms.RandomGrayscale(p=0.1),#概率转换成灰度率，3通道就是R=G=Btransforms.ToTensor(),#数据转换为tensortransforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])#标准化，均值，标准差]),'valid':transforms.Compose([transforms.Resize([256,256]),transforms.ToTensor(),transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])  # 标准化，均值，标准差]),
}#Dataset是用来处理数据的
class food_dataset(Dataset):        # food_dataset是自己创建的类名称，可以改为你需要的名称def __init__(self,file_path,transform=None):    #类的初始化，解析数据文件txtself.file_path = file_pathself.imgs = []self.labels = []self.transform = transformwith open(self.file_path) as f: #是把train.txt文件中的图片路径保存在self.imgssamples = [x.strip().split(' ') for x in f.readlines()]for img_path,label in samples:self.imgs.append(img_path)  #图像的路径self.labels.append(label)   #标签，还不是tensor# 初始化：把图片目录加到selfdef __len__(self):  #类实例化对象后，可以使用len函数测量对象的个数return  len(self.imgs)#training_data[1]def __getitem__(self, idx):    #关键，可通过索引的形式获取每一个图片的数据及标签image = Image.open(self.imgs[idx])  #读取到图片数据，还不是tensor，BGRif self.transform:                  #将PIL图像数据转换为tensorimage = self.transform(image)   #图像处理为256*256，转换为tensorlabel = self.labels[idx]    #label还不是tensorlabel = torch.from_numpy(np.array(label,dtype=np.int64))    #label也转换为tensorreturn image,label'''判断当前设备是否支持GPU，其中mps是苹果m系列芯片的GPU'''
device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu"
print(f"Using {device} device")   #字符串的格式化，CUDA驱动软件的功能：pytorch能够去执行cuda的命令
# 神经网络的模型也需要传入到GPU，1个batch_size的数据集也需要传入到GPU，才可以进行训练''' 定义神经网络  类的继承这种方式'''
class CNN(nn.Module): #通过调用类的形式来使用神经网络，神经网络的模型，nn.mdouledef __init__(self): #输入大小：(3,256,256)super(CNN,self).__init__()  #初始化父类self.conv1 = nn.Sequential( #将多个层组合成一起，创建了一个容器，将多个网络组合在一起nn.Conv2d(              # 2d一般用于图像，3d用于视频数据（多一个时间维度），1d一般用于结构化的序列数据in_channels=3,      # 图像通道个数，1表示灰度图（确定了卷积核 组中的个数）out_channels=16,     # 要得到多少个特征图，卷积核的个数kernel_size=5,      # 卷积核大小 3×3stride=1,           # 步长padding=2,          # 一般希望卷积核处理后的结果大小与处理前的数据大小相同，效果会比较好),                      # 输出的特征图为(16,256,256)nn.ReLU(),  # Relu层，不会改变特征图的大小nn.MaxPool2d(kernel_size=2),    # 进行池化操作(2×2操作),输出结果为(16,128,128))self.conv2 = nn.Sequential(nn.Conv2d(16,32,5,1,2),  #输出(32,128,128)nn.ReLU(),  #Relu层  (32,128,128)nn.MaxPool2d(kernel_size=2),    #池化层，输出结果为(32,64,64))self.conv3 = nn.Sequential(nn.Conv2d(32, 64, 5, 1, 2),  # 输出(64,64,64)nn.ReLU(),  # Relu层  (64,64,64)nn.MaxPool2d(kernel_size=2),  # 池化层，输出结果为(64,32,32))self.out = nn.Linear(64*32*32,20)  # 全连接层得到的结果def forward(self,x):   #前向传播，你得告诉它 数据的流向 是神经网络层连接起来，函数名称不能改x = self.conv1(x)x = self.conv2(x)x = self.conv3(x)x = x.view(x.size(0),-1)    # flatten操作，结果为：(batch_size,32 * 64 * 64)output = self.out(x)return output
# 提取模型的2种方法：
#   1、读取参数的方法
model = CNN().to(device) #初始化模型，w都是随机初始化的
model.load_state_dict(torch.load("best2025-04.pth"))
#   2、读取完整模型的方法，无需提前创建model
#   model = CNN().to(device)
#   model = torch.load('best.pt')#w,b,cnn
# 模型保存的对不对？
model.eval() #固定模型参数和数据，防止后面被修改
print(model)test_data = food_dataset(file_path='test.txt', transform = data_transforms['valid'])
test_dataloader = DataLoader(test_data,batch_size=1,shuffle=True)result = [] #保存的预测的结果
labels = [] #真实结果def Test_true(dataloader,model):model.eval()        #测试，w就不能再更新with torch.no_grad():   #一个上下文管理器，关闭梯度计算。当你确认不会调用Tensor.backward()的时候for X,y in dataloader:X,y = X.to(device),y.to(device)pred = model.forward(X) #预测之后的结果result.append(pred.argmax(1).item())labels.append(y.item())
Test_true(test_dataloader,model)
print('预测值：\t',result)
print('真实值：\t',labels)from sklearn.metrics import accuracy_score
accuracy = accuracy_score(labels,result)
print(f"准确率：{accuracy:.2%}")