• PyTorch搭建卷积神经网络（ResNet-50网络）进行图像分类实战（附源码和数据集）

    需要数据集和源码请点赞关注收藏后评论区留言~~~

    一、实验数据准备

    我们使用的是MIT67数据集，这是一个标准的室内场景检测数据集，一个有67个室内场景，每类包括80张训练图片和20张测试图片 读者可通过以下网址下载

    但是数据集较大，下载花费时间较长，所以建议私信我发给你们

    数据集

    将下载的数据集解压，主要使用Image文件夹，这个文件夹一共包含6700张图片，还有它们标签的txt文件

    大体流程分为以下几步

    二、数据预处理和准备

    1：数据集的读取

    2：重载data.Dataset类

    3：transforms数据预处理

    三、模型构建

    1：ResNet-50网络

    网络结构图如下

    2：bottleneck的实现

    结构图如下

     

    3：ResNet-50卷积层定义

    4：forward函数的实现

    5：预训练参数装载

    四、模型训练与结果评估

    1：训练类的实现

    2：优化器的定义

    3：学习率衰减

    4：训练

    训练过程如下

     最后 部分代码如下

    1.py

    1. import torch
    2. from torch.autograd import Variable as V
    3. import torchvision.models as models
    4. from torchvision import transforms as trn
    5. from torch.nn import functional as F
    6. import os
    7. import numpy as np
    8. from mymodels import *
    9. from PIL import Image
    10. import torch.utils.data as data
    11. from torch.utils.data import DataLoader
    12. from utils import *
    13. tmp_dir = '/home/yyh/tmpmit67'
    14. import torch.optim as optim
    15. import matplotlib.pyplot as plt
    16. import time
    17. import json
    18. def get_im_list(im_dir, file_path):
    19.     im_list = []
    20.     im_labels = []
    21.     im_origin = []
    22.     with open(file_path, 'r') as fi:
    23.         for line in fi:
    24.             im_list.append(im_dir + line.split()[0])
    25.             im_labels.append(int(line.split()[-1]))
    26.             im_origin.append(line.split()[0])
    27.             array = line.split('/')
    28.     return im_list, im_labels, im_origin
    29. ate(fi):
    30.             sname = line.strip()
    31.             sdict[sid] = sname
    32.     return sdict
    33. _sdict = sun397_sdict()
    34.  
    35.  
    36. arch = 'resnet50'
    37. # load the pre-trained weights
    38. model_file = '%s_places365.pth.tar' % arch
    39. if not os.access(model_file, os.W_OK):
    40.     weight_url = 'http://places2.csail.mit.edu/models_places365/' + model_file
    41.     os.system('wget ' + weight_url)
    42. model = resnet50(num_classes=365)
    43. checkpoint = torch.load(model_file, map_location=lambda storage, loc: storage)
    44. state_dict = {str.replace(k,'module.',''): v for k,v in checkpoint['state_dict'].items()}
    45. model.load_state_dict(state_dict)
    46. model.fc = torch.nn.Linear(2048,67)
    47. model.eval()
    48.  
    49.  
    50.  
    51.  
    52. """
    53. model = resnet50(num_classes=67)
    54. pretrained = torch.load("/home/yyh/fineTune/mit67_place/model_epoch_30.pth").module
    55. state_dict = pretrained.state_dict()
    56. model.load_state_dict(state_dict)
    57. model.eval()
    59. """
    60.  
    61.  
    62.  
    63.  
    64.  
    65. # load the image transformer
    66. transform_train = trn.Compose([
    67.         trn.Scale(256),
    68.         trn.RandomSizedCrop(224),
    69.         trn.RandomHorizontalFlip(),
    70.         trn.ToTensor(),
    71.         trn.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    72. ])
    73. transform_test = trn.Compose([
    74.         trn.Scale(256),
    75.         trn.CenterCrop(224),
    76.         trn.ToTensor(),
    77.         trn.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
    78. ])
    79. # load the class label
    80.  
    81. def default_loader(path):
    82.     return Image.open(path).convert('RGB')
    83. class MyDataset(data.Dataset):
    84.     def __init__(self, images, labels,loader=default_loader,transform=None):
    85.         self.images = images
    86.         self.labels = labels
    87.         self.loader = loader
    88.         self.transform = transform
    89.     def __getitem__(self, index):
    90.         img, target = self.images[index], self.labels[index]
    91.         #print(img)
    92.         img = self.loader(img)
    93.         if self.transform is not None:
    94.             img = self.transform(img)
    95.         #print(img)
    96.         return img, target
    97.     def __len__(self):
    98.         return len(self.images)
    99.  
    100. imdir = r'C:\Users\Admin\Desktop\MIT67\Images/'
    101. train_file = 'C:\Users\Admin\Desktop\MIT67\TrainImages.label'
    102. test_file = 'C:\Users\Admin\Desktop\MIT67\TestImages.label'
    103. #train_file = test_file
    104. train_list, train_labels,img_path= get_im_list(imdir, train_file)
    105. test_list, test_labels ,img_path_2= get_im_list(imdir, test_file)
    106. batch_size = 16
    107. net = model
    108. net.cuda()
    109.  
    110.  
    111.  
    112. #print(test_js)
    113.  
    114.  
    115. for i in range(0, len(train_list)):
    116.     path = img_path[i]
    117.     save = []
    118.     print(path)
    119.     json_name = (path.replace("/", "_")).replace(".jpg", ".json")
    120.     f_train = open("C:\Users\Admin\Desktop\rgbd_data\annotated_area/" + json_name)
    121.     train_js = json.load(f_train)
    122.     if len(train_js) == 0:
    123.         train_js.append( {"classname":"unknown","bbox":[0,0,223,223],"score":1})
    124.     for j in range(0, len(train_js)):
    125.         data, target = train_list[i], train_labels[i]
    126.         data = Image.open(data).convert('RGB')
    127.         json_data = train_js[j]["bbox"]
    128.         data = data.resize((224, 224), Image.ANTIALIAS)
    129.         print(json_data)
    130.         data = data.crop([json_data[0], json_data[1], json_data[2], json_data[3]])
    131.         data = data.resize((224, 224), Image.ANTIALIAS)
    132.         data = transform_test(data)
    133.         newdata = torch.zeros(1, 3, 224, 224)
    134.         newdata[0] = data
    135.         data = Variable(newdata).cuda()
    136.         output, record = net(data)
    137.         data = record.cpu().detach().numpy()
    138.         save.append(data)
    139.  
    140.     data = save[0]
    141.     for j in range(1, len(train_js)):
    142.         data += save[j]
    143.     data = data / len(train_js)
    144.     # print(data)
    145.     # target = Variable(target).cuda()
    146.  
    147.     # print(output)
    148.     # print(output["avgpool"].cpu().shape)
    149.     root = "/home/yyh/PycharmProjects/feature_extractor/loc_224_npy/" + path.split("/")[0]
    150.     if not os.path.exists(root):
    151.         os.makedirs(root)
    152.     dir = "/home/yyh/PycharmProjects/feature_extractor/loc_224_npy/" + path.replace(".jpg",".npy")
    153.     np.save(dir, data)
    154.     print(i)
    155.  
    156.  
    157. for i in range(0, len(test_list)):
    158.     path = img_path_2[i]
    159.     save = []
    160.     print(path)
    161.     json_name = (path.replace("/", "_")).replace(".jpg", ".json")
    162.     f_test = open("/home/yyh/rgbd_data/annotated_area/" + json_name)
    163.     test_js = json.load(f_test)
    164.     if len(test_js) == 0:
    165.         test_js.append( {"classname":"unknown","bbox":[0,0,223,223],"score":1})
    166.     for j in range(0, len(test_js)):
    167.         data, target = test_list[i], test_labels[i]
    168.         data = Image.open(data).convert('RGB')
    169.         json_data = test_js[j]["bbox"]
    170.         data = data.resize((224, 224), Image.ANTIALIAS)
    171.         print(json_data)
    172.         data = data.crop([json_data[0], json_data[1], json_data[2], json_data[3]])
    173.         data = data.resize((224, 224), Image.ANTIALIAS)
    174.         data = transform_test(data)
    175.         newdata = torch.zeros(1, 3, 224, 224)
    176.        tach().numpy()
    177.         save.append(data)
    178.  
    179.  
    180.     data = save[0]
    181.     for j in range(1, len(test_js)):
    182.         data += save[j]
    183.     data = data / len(test_js)
    184.     print(data)
    185.     root = "/home/yyh/PycharmProjects/feature_extractor/loc_224_npy/" + path.split("/")[0]
    186.     if not os.path.exists(root):
    187.         os.makedirs(root)
    188.     dir = "/home/yyh/PycharmProjects/feature_extractor/loc_224_npy/" + path.replace(".jpg",".npy")
    189.     np.save(dir, data)
    190.     print(i)
    191.  
    192.     #time.sleep(10)
    193.  
    194.  
    195.  
    196.  
    197.  
    198.  
    199.  
    200.  
    201. #print(net)
    202. #train_net = torch.nn.DataParallel(net, device_ids=[0])
    203. #optimizer = optim.SGD(params=train_net.parameters(), lr=0.001, momentum=0.9, weight_decay=1e-4)
    204. #scheduler = StepLR(optimizer, 30, gamma=0.1)
    205. #trainer = Trainer(train_net, optimizer, F.cross_entropy, save_dir="./mit67_imagenet_448")
    206. #trainer.loop(130, train_loader, test_loader, scheduler)

    2.py

    1. from pathlib import Path
    2. import torch
    3. from torch.autograd import Variable
    4. from torch.optim import Optimizer
    5. from torch import nn
    6. from tqdm import tqdm
    7. import torch.nn.functional as F
    8.  
    9.     expansion = 4
    10.  
    11.     def __init__(self, inplanes, planes, stride=1, downsample=None):
    12.         super(Bottleneck, self).__init__()
    13.         self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
    14.         self.bn1 = nn.BatchNorm2d(planes)
    15.         self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride,
    16.                                padding=1, bias=False)
    17.         self.bn2 = nn.BatchNorm2d(planes)
    18.         self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)
    19.         self.bn3 = nn.BatchNorm2d(planes * self.expansion)
    20.         self.relu = nn.ReLU(inplace=True)
    21.         self.downsample = downsample
    22.         self.stride = stride
    23.  
    24.     def forward(self, x):
    25.         residual = x
    26.  
    27.         out = self.conv1(x)
    28.         out = self.bn1(out)
    29.         out = self.relu(out)
    30.  
    31.         out = self.conv2(out)
    32.         out = self.bn self.conv3(out)
    33.         out = self.bn3(out)
    34.  
    35.         if self.downsample is not None:
    36.             residual = self.downsample(x)
    37.  
    38.         out += residual
    39.         out = self.relu(out)
    40.         return out
    41.  
    42.  
    43.     def __init__(self, block, layers, num_classes=1000):
    44.         self.inplanes = 64
    45.         super(ResNet, self).__init__()
    46.         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3,
    47.                                bias=False)
    48.         self.bn1 = nn.BatchNorm2d(64)
    49.         self.relu = nn.ReLU(inplace=True)
    50.         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
    51.         self.layer1 = self._make_layer(block, 64, layers[0])
    52.         self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
    53.         self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
    54.         self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
    55.         self.avgpool = nn.AvgPool2d(kernel_size=7, stride=1, padding=0)
    56.         self.fc = nn.Linear(512 * block.expansion, num_classes)
    57.  
    58.         for m in self.modules():
    59.             if isinstance(m, nn.Conv2d):
    60.                 nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
    61.             elif isant_(m.weight, 1)
    62.                 nn.init.constant_(m.bias, 0)
    63.  
    64.     def _make_layer(self, block, planes, blocks, stride=1):
    65.         downsample = None
    66.         if stride != 1 or self.inplanes != planes * block.expansion:
    67.             downsample = nn.Sequential(
    68.                 nn.Conv2d(self.inplanes, planes * block.expansion,
    69.                           kernel_size=1, stride=stride, bias=False),
    70.                 nn.BatchNorm2d(planes * block.expansion),
    71.             )
    72.  
    73.         layers = []
    74.         layers.append(block(self.inplanes, planes, stride, downsample))
    75.         self.inplanes = planes * block.expansion
    76.         for i in range(1, blocks):
    77.             layers.append(block(self.inplanes, planes))
    78.  
    79.         return nn.Sequential(*layers)
    80.  
    81.     def forward(self, x):
    82.         record = dict()
    83.         x = self.conv1(x)
    84.         x = self.bn1(x)
    85.         x = self.relu(x)
    86.         record["maxpool"] = x
    87.         x = self.maxpool(x)
    88.         x = self.layer1(x)
    89.         record["layer1"] = x
    90.         x = self.layer2(x)
    91.         record["layer2"] = x
    92.         x = self.layer3(x)
    93.         record["layer3"] = x
    94.         x = self.layer4(x)
    95.         record["layer4"] = x
    96.         x = selpool"] = x
    97.         x = self.fc(x)
    98.         return x,record["avgpool"]
    101. def rined=False, **kwargs):
    102.     """Constructs a ResNet-50 model.
    103.     Args:
    104.         pretrained (bool): If True, returns a model pre-trained on ImageNet
    105.     """
    106.     model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
    107.     return model

    3.py

    1. from pathlib import Path
    2. import torch
    3. from torch.autograd import Variable
    4. from torch.optim import Optimizer
    5. from torch import nn
    6. from tqdm import tqdm
    7.  
    8.  
    9. a.is_available()
    10.     torch.backends.cudnn.benchmark = True
    11.  
    12.     def __init__(self, model, optimizer, loss_f, save_dir=None, save_freq=10):
    13.         self.model = model
    14.         if self.cuda:
    15.             model.cuda()
    16.         self.optimizer = optimizer
    17.         self= save_dir
    18.         self.save_freq = save_freq
    19.  
    20.     def _iteration(self, data_loader, is_train=True):
    21.         loop_loss = []
    22.         accuracy = []
    23.         for data, target in tqdm(data_loader, ncols=80):
    24.             if self.cuda:
    25.                 data, target = data.cuda(), target.cuda()
    26.             output = self.model(data)
    27.             loss = self.loss_f(output, target)
    28.             loop_loss.append(loss.data.item() / len(data_loader))
    29.             accuracy.append((output.data.max(1)[1] == target.data).sum().item())
    30.             if is_train:
    31.                 self.optimizer.zero_grad()
    32.                 loss.backward()
    33.                 self.optimizer.step()
    34.         mode = "train" if is_train else "test"
    35.         #print(">>>[{}] loss: {:.2f}/accuracy: {:.2%}").format(mode,sum(loop_loss),float(sum(accuracy)) / float(len(data_loader.dataset)))
    36.         print(mode)
    37.         print(sum(loop_loss))
    38.         print(float(sum(accuracy)) / float(len(data_loader.dataset)))
    39.         
    40.         return loop_loss, accuracy
    41.  
    42.     def train(self, data_loader):
    43.         self.model.train()
    44.         with torch.enable_grad():
    45.             loss, correct = self._iteration(data_loader)
    46.  
    47.     def test(self, data_loader):
    48.         self.model.eval()
    49.         with torch.no_grad():
    50.             loss, correct = self._iteration(data_loader, is_train=False)
    51.  
    52.     def loop(self, epochs, train_data, test_data, scheduler=None):
    53.         for ep in range(1, epochs + 1):
    54.             if scheduler is not None:
    55.                 scheduler.step()
    56.             print("epochs: {}".format(ep))
    57.             self.train(train_data)
    58.             self.test(test_data)
    59.             if ep % self.save_freq == 0:
    60.                 self.save(ep)
    61.  
    62.     def save(self, epoch, **kwargs):
    63.         if self.save_dir is not None:
    64.             model_out_path = Path(self.save_dir)
    65.             state = self.model
    66.             if not model_out_path.exists():
    67.                 model_out_path.mkdir()
    68.             print(self.save_dir+ "model_epoch_{}.pth".format(epoch))
    69.             torch.save(state, self.save_dir+ "/model_epoch_{}.pth".format(epoch))
    70.  
    71.  
    72. class _LRScheduler(object):
    73.     def __init__(self, optimizer, last_epoch=-1):
    74.         if not isinstance(optimizer, Optimizer):
    75.             raise TypeError('{} is not an Optimizer'.format(
    76.                     type(optimizer).__name__))
    77.         self.optimizer = optimizer
    78.         if last_epoch == -1:
    79.             for group in optimizer.param_groups:
    80.                 group.setdefault('initial_lr', group['lr'])
    81.         else:
    82.             for i, group in enumerate(optimizer.param_groups):
    83.                 if 'initial_lr' not in group:
    84.                     raise KeyError("param 'initial_lr' is not specified "
    85.                                    "in param_groups[{}] when resuming an optimizer".format(i))
    86.         self.base_lrs = list(map(lambda group: group['initial_lr'], optimizer.param_groups))
    87.         self.step(last_epoch + 1)
    88.         self.last_epoch = last_epoch
    89.  
    90.     def get_lr(self):
    91.         raise NotImplementedError
    92.  
    93.     def step(self, epoch=None):
    94.         if epoch is None:
    95.         tep_size, gamma=0.1, last_epoch=-1):
    96.         self.step_size = step_size
    97.         self.gamma = gamma
    98.         super(StepLR, self).__init__(optimizer, last_epoch)
    99.  
    100.     def get_lr(self):
    101.         return [base_lr * self.gamma ** (self.last_epoch // self.step_size)
    102.                 for base_lr in self.base_lrs]
    103.

    创作不易 觉得有帮助请点赞关注收藏~~~

  • 相关阅读:
    Oracle 的LogMiner
    IDC TechScape中国数据安全发展路线图，美创两款产品获重点推荐
    MySQL数据库下载与安装使用
    校园快餐店网上订餐管理系统（JSP+MySQL+MyEclipse）
    餐厅预订APP多少钱一套？餐厅预订APP如何收费？
    计数与期望
    Shell 初始化配置指北 | Ubuntu
    VL3 奇偶校验
    基于java+ssm+easyui灵悟酒店系统
    基于图的路径搜索技术基础知识
  • 原文地址：https://blog.csdn.net/jiebaoshayebuhui/article/details/127797383