残差网络Resnet50：花卉识别

最新推荐文章于 2024-05-14 19:37:00 发布
最新推荐文章于 2024-05-14 19:37:00 发布
阅读量359 收藏 11
点赞数 1
分类专栏： 深度学习 文章标签： 网络 神经网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45543594/article/details/131855036
版权

残差网络Resnet50

网络结构

由于卷积层的堆叠，前面的信息可能在之后被丢失，造成精度下降。为了防止这种情况，将前面的层和后面的层进行叠加，防止信息丢失
在这里插入图片描述

Resnet网络结构：
在这里插入图片描述

Resnet50网络结构：

levelinputstrideoutput
1224*224*37*7*642112*112*64
MaxPool112*112*64MaxPool256*56*64
256*56*641*1*64156*56*641
356*56*643*3*64156*56*64
456*56*641*1*256156*56*256
556*56*2561*1*64156*56*641
656*56*643*3*64156*56*64
756*56*641*1*256156*56*256
856*56*2561*1*64156*56*641
956*56*643*3*64156*56*64
1056*56*641*1*256156*56*256
1156*56*2561*1*128156*56*1282
1256*56*1283*3*128228*28*128
1328*28*1281*1*512128*28*512
1428*28*5121*1*128128*28*1282
1528*28*1283*3*128128*28*128
1628*28*1281*1*512128*28*512
1728*28*5121*1*128128*28*1282
1828*28*1283*3*128128*28*128
1928*28*1281*1*512128*28*512
2028*28*5121*1*128128*28*1282
2128*28*1283*3*128128*28*128
2228*28*1281*1*512128*28*512
2328*28*5121*1*256128*28*2563
2428*28*2563*3*256214*14*256
2514*14*2561*1*1024114*14*1024
2614*14*10241*1*256114*14*2563
2714*14*2563*3*256114*14*256
2814*14*2561*1*1024114*14*1024
2914*14*10241*1*256114*14*2563
3014*14*2563*3*256114*14*256
3114*14*2561*1*1024114*14*1024
3214*14*10241*1*256114*14*2563
3314*14*2563*3*256114*14*256
3414*14*2561*1*1024114*14*1024
3514*14*10241*1*256114*14*2563
3614*14*2563*3*256114*14*256
3714*14*2561*1*1024114*14*1024
3814*14*10241*1*256114*14*2563
3914*14*2563*3*256114*14*256
4014*14*2561*1*1024114*14*1024
4114*14*10241*1*512114*14*5124
4214*14*5123*3*51227*7*512
437*7*5121*1*204817*7*2048
447*7*20481*1*51217*7*5124
457*7*5123*3*51217*7*512
467*7*5121*1*204817*7*2048
477*7*20481*1*51217*7*5124
487*7*5123*3*51217*7*512
497*7*5121*1*204817*7*2048
AvgPool7*7*20481*1*2048
50FC1*1*20482048

以Resnet50为backbone、一个全连接层作为head，形成一个花卉检测的cnn网络结构

加载数据集并划分训练集

import torch
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
import numpy as np
from sklearn.model_selection import train_test_split
from torch.utils.data import Subset

# 数据预处理和增强
transform = transforms.Compose([
    transforms.Resize((224, 224)),    # 调整图像大小为 224x224像素
    transforms.ToTensor(),           # 转换为张量
    transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])   # 标准化
])

# 加载数据集
dataset = datasets.ImageFolder('flower', transform=transform)



# set_size = 200  # 设置要使用的数据集大小
# if len(dataset) > set_size:
#     dataset = Subset(dataset, range(set_size))

# 划分训练集和测试集
train_size = int(0.7 * len(dataset))
test_size = len(dataset) - train_size

train_dataset, test_dataset = torch.utils.data.random_split(dataset, [train_size, test_size])

# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=8, shuffle=False)

# 查看数据加载器的样本数量
print('训练集样本数量:', len(train_loader.dataset))
print('测试集样本数量:', len(test_loader.dataset))
class_labels = dataset.classes
print('花卉类别：',dataset.classes)

训练集样本数量: 3021
测试集样本数量: 1296
花卉类别： ['daisy', 'dandelion', 'rose', 'sunflower', 'tulip']

进行数据集的可视化


import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
# 归一化转为[0,255]
transfer=MinMaxScaler(feature_range=(0, 255)) 
def visualize_loader(batch,predicted=''): 
    # batch=[32*1*224*224,32]
    imgs=batch[0]
    fig, axes = plt.subplots(2, 4, figsize=(12, 6))
    labels=batch[1].numpy()
    # print(imgs.shape)
    if str(predicted)=='':
        predicted=labels
    for i, ax in enumerate(axes.flat):
        img=imgs[i].permute(1, 2, 0).numpy()
        img=np.clip(img, 0, 1)
        ax.imshow(img)
        title=class_labels[predicted[i]]
        color='black'
        if predicted[i]!=labels[i]:
            title+=        '('+str(class_labels[labels[i]])+')'
            color='red'
        ax.set_title(title,color=color )
        ax.axis('off')
    plt.tight_layout()
    plt.show()


# loader.shape=3000*[32*1*224*224,32]
for batch in train_loader:    
    break

visualize_loader(batch)

在这里插入图片描述

残缺块ResidualBlock和网络ResNet50

# 残缺块和ResNet50
import torch
import torch.nn as nn

# 残缺块
class ResidualBlock(nn.Module):
    def __init__(self, in_channels, out_channels, stride=1):
        super(ResidualBlock, self).__init__()      
        self.conv1 = nn.Conv2d(in_channels, in_channels//stride, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(in_channels//stride)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(in_channels//stride, in_channels//stride, kernel_size=3, stride=stride, padding=1, bias=False)
        self.bn2 = nn.BatchNorm2d(in_channels//stride)
        self.conv3 = nn.Conv2d(in_channels//stride, out_channels, kernel_size=3, stride=1, padding=1, bias=False)
        self.bn3 = nn.BatchNorm2d(out_channels)
        self.shortcut = nn.Sequential()
        # 将输入特征图通过1x1的卷积操作调整其通道数，使其与残差块的输出特征图具有相同的通道数，以便进行跳跃连接
        if stride != 1 or in_channels!=out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )
        
    
    def forward(self, x):
        residual = x
        
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        
        out = self.conv2(out)
        out = self.bn2(out)
        
        out = self.conv3(out)
        out = self.bn3(out)
        
        out += self.shortcut(residual)
        out = self.relu(out)
        
        return out

# ResNet50
class ResNet50(nn.Module):
    def __init__(self, num_classes=1000):
        super(ResNet50, self).__init__()
        
        self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, bias=False)
        self.bn1 = nn.BatchNorm2d(64)
        self.relu = nn.ReLU(inplace=True)
        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
        
        self.layer1 = self._make_layer(64, 256, blocks=3, stride=1)
        self.layer2 = self._make_layer(256, 512, blocks=4, stride=2)
        self.layer3 = self._make_layer(512, 1024, blocks=6, stride=2)
        self.layer4 = self._make_layer(1024, 2048, blocks=3, stride=2)
        
        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
        self.flatten = nn.Flatten()

    def _make_layer(self, in_channels, out_channels, blocks, stride):
        layers = []
        layers.append(ResidualBlock(in_channels, out_channels, stride))
        
        for _ in range(1, blocks):
            layers.append(ResidualBlock(out_channels, out_channels))
        
        return nn.Sequential(*layers)
    
    def forward(self, x):
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu(x)
        x = self.maxpool(x)

        x = self.layer1(x)
        x = self.layer2(x)
        x = self.layer3(x)
        x = self.layer4(x)
        
        x = self.avgpool(x)
        x = self.flatten(x)
        
        return x

CNN(Resnet50:backbone,Linear:head)

import torch
import torch.nn as nn
import torchvision.models as models

class CNN(nn.Module):
    def __init__(self, num_classes=5):
        super(CNN, self).__init__()
        
        # 骨干网络（ResNet-50）
        self.backbone = ResNet50()
        
        # 头部（Head）
        self.head = nn.Sequential(
            nn.ReLU(inplace=True),
            nn.Linear(2048, num_classes)
        )
    
    def forward(self, x):
        x = self.backbone(x)
        x = self.head(x)
        return x
model = CNN()
print(model)

CNN(
  (backbone): ResNet50(
    (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)
    (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
    (relu): ReLU(inplace=True)
    (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)
    (layer1): Sequential(
      (0): ResidualBlock(
        (conv1): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(64, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential(
          (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)
          (1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): ResidualBlock(
        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (2): ResidualBlock(
        (conv1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
    )
    (layer2): Sequential(
      (0): ResidualBlock(
        (conv1): Conv2d(256, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(128, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential(
          (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): ResidualBlock(
        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (2): ResidualBlock(
        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (3): ResidualBlock(
        (conv1): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
    )
    (layer3): Sequential(
      (0): ResidualBlock(
        (conv1): Conv2d(512, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(256, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential(
          (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): ResidualBlock(
        (conv1): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (2): ResidualBlock(
        (conv1): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (3): ResidualBlock(
        (conv1): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (4): ResidualBlock(
        (conv1): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (5): ResidualBlock(
        (conv1): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(1024, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
    )
    (layer4): Sequential(
      (0): ResidualBlock(
        (conv1): Conv2d(1024, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(512, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential(
          (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)
          (1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        )
      )
      (1): ResidualBlock(
        (conv1): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
      (2): ResidualBlock(
        (conv1): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn1): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (relu): ReLU(inplace=True)
        (conv2): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn2): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (conv3): Conv2d(2048, 2048, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
        (bn3): BatchNorm2d(2048, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
        (shortcut): Sequential()
      )
    )
    (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))
    (flatten): Flatten(start_dim=1, end_dim=-1)
  )
  (head): Sequential(
    (0): ReLU(inplace=True)
    (1): Linear(in_features=2048, out_features=5, bias=True)
  )
)

训练模型

import torch.optim as optim
import time
num_epochs=7
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.003)

for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    correct = 0
    total = 0
    start_time = time.time() 
    for images, labels in train_loader:
        images = images.to(device)
        labels = labels.to(device)
        
        # 前向传播
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        # 反向传播和优化
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
        
        # 统计准确率
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
        
        running_loss += loss.item()
    
    train_loss = running_loss / len(train_loader)
    train_accuracy = correct / total
    
    # 在测试集上评估模型
    model.eval()
    test_loss = 0.0
    correct = 0
    total = 0
    
    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            labels = labels.to(device)
            
            outputs = model(images)
            loss = criterion(outputs, labels)
            
            _, predicted = torch.max(outputs.data, 1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
            
            test_loss += loss.item()
    end_time=time.time()
    duration = int(end_time - start_time )
    m,s=duration//60,duration%60
    test_loss = test_loss / len(test_loader)
    test_accuracy = correct / total
    torch.save(model.state_dict(), 'FlowerRecognitionModel.pth')
    # 打印训练过程中的损失和准确率
    print(f"Epoch [{epoch+1}/{num_epochs}] :{m}minutes{s}seconds")
    print(f"     Train Loss: {train_loss:.4f}, Train Accuracy: {train_accuracy:.4f}") 
    print(f"     Test Loss: {test_loss:.4f}, Test Accuracy: {test_accuracy:.4f}")

Epoch [1/7] :3minutes5seconds
     Train Loss: 1.1862, Train Accuracy: 0.4826
     Test Loss: 1.1131, Test Accuracy: 0.5154
Epoch [2/7] :3minutes11seconds
     Train Loss: 1.1405, Train Accuracy: 0.5008
     Test Loss: 1.0442, Test Accuracy: 0.5409
Epoch [3/7] :3minutes11seconds
     Train Loss: 1.1196, Train Accuracy: 0.5167
     Test Loss: 1.1199, Test Accuracy: 0.5386
Epoch [4/7] :3minutes11seconds
     Train Loss: 1.0836, Train Accuracy: 0.5468
     Test Loss: 0.9931, Test Accuracy: 0.6119
Epoch [5/7] :3minutes10seconds
     Train Loss: 1.0372, Train Accuracy: 0.5922
     Test Loss: 0.9380, Test Accuracy: 0.6312
Epoch [6/7] :3minutes9seconds
     Train Loss: 0.9958, Train Accuracy: 0.6087
     Test Loss: 0.9079, Test Accuracy: 0.6535
Epoch [7/7] :3minutes9seconds
     Train Loss: 0.9515, Train Accuracy: 0.6316
     Test Loss: 0.8918, Test Accuracy: 0.6543

保存和加载模型

#保存模型
# torch.save(model.state_dict(), 'FlowerRecognitionModel.pth')

# 创建一个新的模型实例
model = CNN()
# 加载模型的参数
model.load_state_dict(torch.load('FlowerRecognitionModel.pth'))


<All keys matched successfully>

测试模型

for batch in test_loader:       
    break
imgs=batch[0]
outputs = model(imgs)
_, predicted = torch.max(outputs.data, 1)
predicted=predicted.numpy()


visualize_loader(batch,predicted)

在这里插入图片描述

有一定的准确度了，模型能差不多识别就好，因为资源问题，就没有一直练下去了。

Keep--Silent
关注
  • 1
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于深度学习的花卉识别算法研究
lf15619259662的博客
09-03 2863
花卉数据集一共包含了4万7千多张花卉的图片，花卉分为24类。采用了目前主流的23种图片分类模型进行训练，比如VGG系列模型，resnet系列模型，mobilenet系列模型，inception系列模型。评估了多种分类模型在计算量和分类准确度上的优缺点。
基于MindSpore的花卉识别实验（包含自己找花卉图片测试）
05-01
基于华为自研MindSpore深度学习框架构建网络模型，实现花卉识别实验。 包含自己找花卉图片测试；包含程序流程图 ；包含可运行源码、运行结果演示视频，本地MindSpore详细配置教程（私信可远程配置）；包含联系方式，购买可免费帮调试，自定义花卉识别实验。
SENet实战详解：使用SE-ReSNet50实现对植物幼苗的分类
热门推荐
AI浩
10-24 2万+
摘要 1、SENet概述 ​ Squeeze-and-Excitation Networks（简称 SENet）是 Momenta 胡杰团队（WMW）提出的新的网络结构，利用SENet，一举取得最后一届 ImageNet 2017 竞赛 Image Classification 任务的冠军，在ImageNet数据集上将top-5 error降低到2.251%，原先的最好成绩是2.991%。 作者在文中将SENet block插入到现有的多种分类网络中，都取得了不错的效果。作者的动机是希望显式地建模
卷积网络项目：实现识别鲜花四分类对比LeNet5、VGG16、ResNet18、ResNet34分类网络
最新发布
一只努力学习的小碗~
05-14 706
卷积网络项目：实现识别杏花、桃花、梨花、梅花四分类对比LeNet5、VGG16、ResNet18、ResNet34分类网络效果
论文解读：ResNet50
pangxing6491的博客
11-12 5309
https://zhuanlan.zhihu.com/p/165123650?utm_source=qq
对比ResNet和denseNet、efficientNet对5种花分类效果
liu24244的博客
05-19 5155
对比ResNet和denseNet、efficientNet对5种花分类效果 实现框架 keras 效果对比 在相同的图片增强以及超参，10epoch，三种模型的准确率和损失表现如下： resNet50与denseNet121，准确率差别不大，后者表现更稳定，收敛更快；两者的表现均比efficientNetB5要好。 准确率 损失值 所有代码 https://github.com/u19900101/keras-learning ...
残差网络resnet50的深度学习模型权重文件
11-15
残差网络resnet50的深度学习模型权重文件，可作为预训练模型，提升学习效率
基于resnet网络的花卉识别 jittor深度学习框架
05-10
基于ResNet网络的花卉识别摘要：ResNet网络模型建立的整体流程和框架通常包括数据处理、模型设计、训练配置、训练过程、模型保存。数据处理一般涉及到一下五个环节：读入数据、划分数据集、生成批次数据、训练样本集...
残差网络ResNet模块
04-21
ResNet网络结构模块，可直接使用，返回值一个是loss用于损失值优化，第二个softmax输出的是预测值用于测试
基于深度学习resnet50的垃圾图像识别 完整代码+数据 毕业设计 可直接运行
03-14
使用深度残差网络resnet50作为基石，在后续添加需要的层以适应不同的分类任务 模型的训练需要用生成器将数据集循环写入内存，同时图像增强以泛化模型 使用不包含网络输出部分的resnet50权重文件进行迁移学习，只训练...
ResNet-50模型图像分类示例
吴建明wujianming_110117
02-25 4919
ResNet-50模型图像分类示例 概述 计算机视觉是当前深度学习研究最广泛、落地最成熟的技术领域，在手机拍照、智能安防、自动驾驶等场景有广泛应用。从2012年AlexNet在ImageNet比赛夺冠以来，深度学习深刻推动了计算机视觉领域的发展，当前最先进的计算机视觉算法几乎都是深度学习相关的。深度神经网络可以逐层提取图像特征，并保持局部不变性，被广泛应用于分类、检测、分割、检索、识别、提升、重建等视觉任务中。 本文结合图像分类任务，介绍MindSpore如何应用于计算机视觉场景。 图像分类 图像分类是最基
利用50层ResNet实现手势数字的识别
07-23
利用50层ResNet实现手势数字的识别，准确率可达95%。。
度学习pytorch实战六：ResNet50网络图像分类篇自建花数据集图像分类（5类）超详细代码
qq_55433305的博客
06-12 1万+
1.数据集简介、训练集与测试集划分 2.模型相关知识 3.model.py——定义ResNet50网络模型 4.train.py——加载数据集并训练，训练集计算损失值loss，测试集计算accuracy，保存训练好的网络参数 5.predict.py——利用训练好的网络参数后，用自己找的图像进行分类测试
花朵识别系统Python实现，深度学习卷积神经网络算法
子午的博客
05-27 2502
花朵识别系统，基于Python实现，深度学习卷积神经网络，通过TensorFlow搭建卷积神经网络算法模型，并对数据集进行训练最后得到训练好的模型文件，并基于Django搭建可视化操作平台。
[零基础][最简单的教程]图像多分类问题的解决——基于resnet50的pytorch的实现
Gambler_Yushen的博客
03-16 5176
文章目录前言一、开始任务的前提条件二、深度学习通用框架三、修改代码前，使用者需要明确的问题1.图片分成三个集，并放在正确的位置2.明确你是几分类问题3.明确你是使用的模型网络四、图像分类通用pytorch框架——具体代码实现一、输入处理模块0.引入库1.数据增强2.加载数据集二、加载模型三、定义损失函数、优化器四、构建训练过程（训练、验证、测试）3.训练与验证4.训练与可视化展示5.测试总结 前言 文章的宗旨是使小白不懂原理也可以快速入手，傻瓜式操作。 整个文章的逻辑从所有深度学习的模型的通用框架开始介绍
使用 resnet50 网络训练多分类模型完整代码
weixin_46034990的博客
05-19 1万+
零、导包准备 import torch from torchvision import datasets, models, transforms import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader import time import numpy as np import matplotlib.pyplot as plt import os from tqdm import tq
【神经网络】(5) 卷积神经网络（ResNet50），案例：艺术画作10分类，附数据集
博观而约取，厚积而薄发
12-11 5941
各位同学好，今天和大家分享一下TensorFlow2.0中如何构建卷积神经网络ResNet-50，案例内容：现在收集了10位艺术大师的画作，采用卷积神经网络判断某一幅画是哪位大师画的。 数据集：https://pan.baidu.com/share/init?surl=cWMvsl37MOZdxnoOjSGoNQ 提取码： 2h5x 1. 数据加载 在文件夹中将图片按照训练集、验证集、测试集划分好之后，使用tf.keras.preprocessing.image_dataset_from_direc
SENet实战详解：使用SE-ReSNet50实现对植物幼苗的分类，从入门到精通的Python进阶学习笔记整理
始飞龙
03-30 899
import torch.nn.parallelimport torch.utils.dataimport torch.utils.data.distributedimport torchvision.transforms as transformsfrom dataset.dataset import SeedlingDatafrom torch.autograd import Variableimport pretrainedmodels3、设置全局参数设置使用GPU，设置学习率、BatchSize、e
【图像分类】基于OpenVINO实现PyTorch ResNet50图像分类
virobotics的博客
05-30 4226
前面博文给大家介绍了OpenVINO工具包及具体的安装，今天我们一起来看一下，如何使用LabVIEW OpenVINO工具包实现resnet50的推理部署
深度残差网络resnet
05-13
深度残差网络（ResNet）是由微软研究院提出的一种深度神经网络结构。传统的深度神经网络结构随着层数的增加，网络的训练难度和准确率都会遇到瓶颈，这是因为随着网络的加深，梯度消失和梯度爆炸问题会越来越严重，导致网络无法训练或训练效果不稳定。 ResNet采用了残差学习的思想，即在网络中添加“残差块”，使网络可以学习到残差（Residual）信息，从而避免了梯度消失和梯度爆炸问题。残差块的结构是通过跨层连接（shortcut connection）实现的，即将输入直接与输出相加，使网络可以在保证信息流畅的同时更深。 ResNet在ILSVRC2015比赛中，以3.57%的错误率夺得了ImageNet分类任务的冠军，并在其他任务上也取得了显著的效果，成为了深度学习领域的经典模型之一。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值