pytorch pre-training model training using Imagenet
1、loading models
#loading using resnet50 as an example import torchvision as p model = .resnet50(pretrained=True)
At this point, once the data model is loaded, we have to think about how to utilize it, but before that you have to understand the structure of the model you loaded.
2. Handling of disaggregated data
If it is used to process categorized data:
You only need to replace the last fully-connected category for output.
= ((2048,num_classes)) ######
3. Backbone as a model
If you need to be the bacbone of the model to be made, such as RCNN, Semantic Segment, etc., at this point you have to preload these models to come, using one of the following FCN8-Semantic Cuts as an example:
Here.modelIt's the same as before.Resnet50model that has pretrained Imageset dataset
class FCN():
def __init__(self):
super(FCN,self).__init__()
self.layer1 = nn.Conv2d(256,nClasses,1,stride=1,padding=0,bias=True)
= nn.ConvTranspose2d(nClasses,nClasses,2,stride=2,padding=0,bias=True)
self.layer2 = nn.Conv2d(128,nClasses,1,stride=1,padding=0,bias=True)
= nn.ConvTranspose2d(nClasses,nClasses,8,stride=8,padding=0,bias=True)
for m in ():
if isinstance(m,nn.Conv2d) or isinstance(m,nn.ConvTranspose2d):
#().normal_(0,0.01)
.xavier_uniform()
().zero_()
def forward(self,x,model):
x = model.conv1(x)
x = model.bn1(x)
x = (x)
x = (x)
x = model.layer1(x)
x1 = model.layer2(x)
x2 = model.layer3(x1)
#(x)#20
x = model.layer4(x2)
x = (x)#20
skip = self.layer1(x2)
y = skip + x
c = (y)
#### 40
v = self.layer2(x1)
y = c+v
x = (y)
return xOf course there are other ways to write, such as directly inside the class constructor, you first take out the back is also very simple:
values = []
for m in ():
(m)
#()PyTorch ImageNet example
import argparse
import os
import shutil
import time
import torch
import as nn
import
import as cudnn
import
import
import as transforms
import as datasets
import as models
model_names = sorted(name for name in models.__dict__
if () and not ("__")
and callable(models.__dict__[name]))
parser = (description='PyTorch ImageNet Training')
parser.add_argument('data', metavar='DIR',
help='path to dataset')
parser.add_argument('--arch', '-a', metavar='ARCH', default='resnet18',
choices=model_names,
help='model architecture: ' +
' | '.join(model_names) +
' (default: resnet18)')
parser.add_argument('-j', '--workers', default=4, type=int, metavar='N',
help='number of data loading workers (default: 4)')
parser.add_argument('--epochs', default=90, type=int, metavar='N',
help='number of total epochs to run')
parser.add_argument('--start-epoch', default=0, type=int, metavar='N',
help='manual epoch number (useful on restarts)')
parser.add_argument('-b', '--batch-size', default=256, type=int,
metavar='N', help='mini-batch size (default: 256)')
parser.add_argument('--lr', '--learning-rate', default=0.1, type=float,
metavar='LR', help='initial learning rate')
parser.add_argument('--momentum', default=0.9, type=float, metavar='M',
help='momentum')
parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float,
metavar='W', help='weight decay (default: 1e-4)')
parser.add_argument('--print-freq', '-p', default=10, type=int,
metavar='N', help='print frequency (default: 10)')
parser.add_argument('--resume', default='', type=str, metavar='PATH',
help='path to latest checkpoint (default: none)')
parser.add_argument('-e', '--evaluate', dest='evaluate', action='store_true',
help='evaluate model on validation set')
parser.add_argument('--pretrained', dest='pretrained', action='store_true',
help='use pre-trained model')
best_prec1 = 0
def main():
global args, best_prec1
args = parser.parse_args()
# create model
if :
print("=> using pre-trained model '{}'".format())
model = models.__dict__[](pretrained=True)
else:
print("=> creating model '{}'".format())
model = models.__dict__[]()
if ('alexnet') or ('vgg'):
= ()
()
else:
model = (model).cuda()
# define loss function (criterion) and optimizer
criterion = ().cuda()
optimizer = ((), ,
momentum=,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if :
if ():
print("=> loading checkpoint '{}'".format())
checkpoint = ()
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})"
.format(, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format())
= True
# Data loading code
traindir = (, 'train')
valdir = (, 'val')
normalize = (mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_loader = (
(traindir, ([
(224),
(),
(),
normalize,
])),
batch_size=args.batch_size, shuffle=True,
num_workers=, pin_memory=True)
val_loader = (
(valdir, ([
(256),
(224),
(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=, pin_memory=True)
if :
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, ):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint({
'epoch': epoch + 1,
'arch': ,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer' : optimizer.state_dict(),
}, is_best)
def train(train_loader, model, criterion, optimizer, epoch):
batch_time = AverageMeter()
data_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to train mode
()
end = ()
for i, (input, target) in enumerate(train_loader):
# measure data loading time
data_time.update(() - end)
target = (async=True)
input_var = (input)
target_var = (target)
# compute output
output = model(input_var)
loss = criterion(output, target_var)
# measure accuracy and record loss
prec1, prec5 = accuracy(, target, topk=(1, 5))
([0], (0))
(prec1[0], (0))
(prec5[0], (0))
# compute gradient and do SGD step
optimizer.zero_grad()
()
()
# measure elapsed time
batch_time.update(() - end)
end = ()
if i % args.print_freq == 0:
print('Epoch: [{0}][{1}/{2}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Data {data_time.val:.3f} ({data_time.avg:.3f})\t'
'Loss {:.4f} ({:.4f})\t'
'Prec@1 {:.3f} ({:.3f})\t'
'Prec@5 {:.3f} ({:.3f})'.format(
epoch, i, len(train_loader), batch_time=batch_time,
data_time=data_time, loss=losses, top1=top1, top5=top5))
def validate(val_loader, model, criterion):
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
()
end = ()
for i, (input, target) in enumerate(val_loader):
target = (async=True)
input_var = (input, volatile=True)
target_var = (target, volatile=True)
# compute output
output = model(input_var)
loss = criterion(output, target_var)
# measure accuracy and record loss
prec1, prec5 = accuracy(, target, topk=(1, 5))
([0], (0))
(prec1[0], (0))
(prec5[0], (0))
# measure elapsed time
batch_time.update(() - end)
end = ()
if i % args.print_freq == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {:.4f} ({:.4f})\t'
'Prec@1 {:.3f} ({:.3f})\t'
'Prec@5 {:.3f} ({:.3f})'.format(
i, len(val_loader), batch_time=batch_time, loss=losses,
top1=top1, top5=top5))
print(' * Prec@1 {:.3f} Prec@5 {:.3f}'
.format(top1=top1, top5=top5))
return
def save_checkpoint(state, is_best, filename=''):
(state, filename)
if is_best:
(filename, 'model_best.')
class AverageMeter(object):
"""Computes and stores the average and current value"""
def __init__(self):
()
def reset(self):
= 0
= 0
= 0
= 0
def update(self, val, n=1):
= val
+= val * n
+= n
= /
def adjust_learning_rate(optimizer, epoch):
"""Sets the learning rate to the initial LR decayed by 10 every 30 epochs"""
lr = * (0.1 ** (epoch // 30))
for param_group in optimizer.param_groups:
param_group['lr'] = lr
def accuracy(output, target, topk=(1,)):
"""Computes the precision@k for the specified values of k"""
maxk = max(topk)
batch_size = (0)
_, pred = (maxk, 1, True, True)
pred = ()
correct = ((1, -1).expand_as(pred))
res = []
for k in topk:
correct_k = correct[:k].view(-1).float().sum(0)
(correct_k.mul_(100.0 / batch_size))
return res
if __name__ == '__main__':
main()summarize
The above is a personal experience, I hope it can give you a reference, and I hope you can support me more.