Pytorch实现图像分类-水果数据集分类--深度学习大作业

目次
1.概述 
2.计划
3.实现
4.实验 

5.总结

---

1.概述 

本次深度学习大作业，我利用AlexNet模子对"Fruits-360"数据会合的两部门水果和蔬菜图片举行分类
2.计划

模子计划：Alexnet网络

• 卷积层部门：构建了一系列卷积层、激活函数、最大池化层以及Dropout层，这一系列操作旨在从原始图像中提取丰富的特征。
  
• 全连接层部门：通过计算得到的特征图尺寸动态设置全连接层的输入巨细，计划了多层全连接网络，包罗ReLU激活、Dropout正则化，最后输出层针对数据集的类别数量（本例中为2）举行调整。
  

由于输入图像数据为RGB图像，在模子的计划时调整，并在计划全连接层时引入了动态尺寸计算方法，保证了模子的通用性和顺应性。
3.实现

 代码如下：

2. import torch
3. import torch.nn as nn
4. import torchvision
5. import torchvision.transforms as transforms
6. from torch.utils.data import DataLoader
7. import torch.nn.functional as F
8. from torch import nn, optim
10. # 数据预处理
11. image_size = (224, 224)
12. data_transforms = transforms.Compose([
13.     transforms.RandomHorizontalFlip(),
14.     transforms.Resize(image_size),
15.     transforms.ToTensor(),
16.     transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
17. ])
19. #导入数据集
20. import torchvision.datasets as datasets
21. train_data=datasets.ImageFolder (root='fruits-360-original-size/fruits-360-original-size/Training',transform=data_transforms)
22. test_data=datasets.ImageFolder (root='fruits-360-original-size/fruits-360-original-size/Test',transform=data_transforms)
23. # print(train_data.classes)
24. # print('..............')
25. # print(test_data.classes)
27. #DataLoader
29. batchsize=10#每个批次（batch）中包含的样本数量
30. train_loader = DataLoader(train_data, batch_size=batchsize, shuffle=True, num_workers=1)
31. test_loader = DataLoader(test_data, batch_size=batchsize, shuffle=False, num_workers=1)  # 测试时不需打乱数据
34. #创建模型
36. class AlexNet(nn.Module):
37.     def __init__(self):
38.         super(AlexNet, self).__init__()
39.         self.conv = nn.Sequential(
40.             nn.Conv2d(3, 96, 5, 1, 2),#输入通道数，输出通道数，卷积核大小，步长，填充（！！！rgb图像所以是三个通道，开始没注意以为灰度图像）
41.             nn.ReLU(),
42.             nn.MaxPool2d(3, 2),
43.             nn.Conv2d(96, 256, 5, 1, 2),
44.             nn.ReLU(),
45.             nn.MaxPool2d(3, 2),
46.             nn.Conv2d(256, 384, 3, 1, 1),
47.             nn.ReLU(),
48.             nn.Conv2d(384, 384, 3, 1, 1),
49.             nn.ReLU(),
50.             nn.Conv2d(384, 256, 3, 1, 1),
51.             nn.ReLU(),
52.             nn.MaxPool2d(3, 2)
53.         )
54.         # 计算全连接层输入大小
55.         self.fc_input_size = self._get_fc_input_size()
56.         self.fc = nn.Sequential(
57.             nn.Linear(self.fc_input_size, 4096),
58.             nn.ReLU(),
59.             nn.Dropout(0.5),#随机丢弃
60.             nn.Linear(4096, 4096),
61.             nn.ReLU(),
62.             nn.Dropout(0.5),
63.             nn.Linear(4096, 2)#修改为2因为输出只有两个类
64.         )
66.     def forward(self, img):
67.         # 通过卷积层前向传播，img是输入图像张量
68.         feature = self.conv(img)
69.         feature = feature.view(img.size(0), -1)#展平
70.         # 通过全连接层（fc）进行前向传播，得到最终的输出
71.         output = self.fc(feature)
72.         return output
73.    
74.     #动态计算全连接层（FC层）所需要的输入尺寸
75.     def _get_fc_input_size(self):
76.         # 创建一个与训练/测试时相同尺寸和通道数的随机张量，用于通过卷积层
77.         x = torch.randn(1, 3, image_size[0], image_size[1])# 其中3对应RGB图像的通道数，image_size是从外部传入的图像预处理后的尺寸，默认为(224, 224)
78.         x = self.conv(x)
79.         return x.view(-1).size(0)#展平后的向量长度
81. # 实例化模型、损失函数和优化器
82. model = AlexNet().to(device="cuda" if torch.cuda.is_available() else "cpu")
83. criterion = nn.CrossEntropyLoss()
84. optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
86. # 训练函数
87. def train(model, device, train_loader, optimizer, criterion):
88.     model.train()
89.     # 遍历训练数据加载器中的每个批次
90.     for batch_idx, (data, target) in enumerate(train_loader):
91.         data, target = data.to(device), target.to(device)#这样更快
92.         # 梯度清零，防止梯度累积
93.         optimizer.zero_grad()
94.         output = model(data)#预测输出
95.    
96.         loss = criterion(output, target)
97.         loss.backward()
98.         optimizer.step()
99.         # 每10个batch打印一次训练信息
100.         if (batch_idx + 1) % 10 == 0 or (batch_idx + 1) == len(train_loader):
101.             print(f'训练轮次: {epoch + 1}/{num_epochs} 损失: {loss.item():.6f}')
103. # 测试函数
104. def test(model, device, test_loader):
105.     model.eval()
106.     test_loss = 0
107.     correct = 0
108.     #避免在测试过程中计算和存储梯度，节省内存并加速计算
109.     with torch.no_grad():
110.         for data, target in test_loader:
111.             data, target = data.to(device), target.to(device)
112.             output = model(data)
113.             test_loss += criterion(output, target).item()  # 累加批次损失
114.             pred = output.argmax(dim=1, keepdim=True)  # 获取预测概率最大的类别索引
115.             correct += pred.eq(target.view_as(pred)).sum().item()#累加预测正确的数量
117.     test_loss /= len(test_loader.dataset)  # 平均损失
118.     # 打印测试结果，包括平均损失、正确预测的总数、总样本数以及准确率
119.     print(f'\n测试集: 平均损失: {test_loss:.6f}, 正确: {correct}/{len(test_loader.dataset)} ({100. * correct / len(test_loader.dataset):.2f}%)\n')
121. # 主训练循环
122. num_epochs = 10  # 设置训练轮数
123. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
124. model.to(device)
126. for epoch in range(num_epochs):
127.     print(f'第{epoch + 1}轮训练开始')
128.     train(model, device, train_loader, optimizer, criterion)
129.     test(model, device, test_loader)

复制代码

4.实验 

实验过程：首先对数据举行预处理，然后导入数据聚集和数据加载，然后对模子举行构造，然后对模子举行训练和测试
实验结果如下：

 


5.总结

      在实验中由于利用AlexNet网络对RGB图像举行图像分类，所以不是灰度图像的输入通道为1，而是改成3，一开始没想到这点，然后对于模子的输出来说，由于我是在电脑上跑的，内存不太够，我对于Fruits-360数据集举行删减，最后剩下两个类别，所以模子的输出应该改成2，然后还有一些训练过程中的错误，实现了深度学习的图像分类，锻炼了实践能力以及综合能力
 
 


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。