def load_weights(dir):
if not os.path.isdir(dir):
print("Path %s is not a dir" % dir)
sys.exit(1)
print("-----------loading weights------------")
resnet50 = resnet.resnet50(pretrained=True)
resnet50.eval()
dic = resnet50.state_dict()
# numpy stores weights in output channel, input channel, h, w order
# we want to transpose to output channel, h, w, input channel order
for k in dic.keys():
weight = dic[k].cpu().detach().numpy()
weight = weight.astype(np.float32)
print("weight shape before transpose")
print("%s,%s,%d" % (k, str(weight.shape), len(weight.shape)))
if len(weight.shape) == 4:
weight = np.transpose(weight, (1, 2, 3, 0))
if len(weight.shape) == 2:
weight = np.transpose(weight, (1, 0))
print("weight shape after transpose")
print("%s,%s,%d" % (k, str(weight.shape), len(weight.shape)))
data = weight.tobytes()
path = os.path.join(dir, k.replace('.','_'))
with open(path + ".data", "wb") as f:
f.write(data)
with open(path + '_shape.data', 'wb') as f:
f.write(struct.pack('i', len(weight.shape)))
for i in list(reversed(range(len(weight.shape)))):
f.write(struct.pack('i', weight.shape[i]))
def create_model(model_name, num_classes=1000, pretrained=False, **kwargs):
if 'test_time_pool' in kwargs:
test_time_pool = kwargs.pop('test_time_pool')
else:
test_time_pool = True
if 'extra' in kwargs:
extra = kwargs.pop('extra')
else:
extra = True
if model_name == 'dpn68':
model = dpn68(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn68b':
model = dpn68b(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn92':
model = dpn92(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool, extra=extra)
elif model_name == 'dpn98':
model = dpn98(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn131':
model = dpn131(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'dpn107':
model = dpn107(
num_classes=num_classes, pretrained=pretrained, test_time_pool=test_time_pool)
elif model_name == 'resnet18':
model = resnet18(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet34':
model = resnet34(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet50':
model = resnet50(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet101':
model = resnet101(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'resnet152':
model = resnet152(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet121':
model = densenet121(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet161':
model = densenet161(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet169':
model = densenet169(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'densenet201':
model = densenet201(num_classes=num_classes, pretrained=pretrained, **kwargs)
elif model_name == 'inception_v3':
model = inception_v3(
num_classes=num_classes, pretrained=pretrained, transform_input=False, **kwargs)
else:
assert False, "Unknown model architecture (%s)" % model_name
return model
def main():
plt.ioff()
model = torch.nn.DataParallel(resnet50(pretrained=False)).cuda()
if args.checkpoint is not None:
model = copy_pretrained_model(model, args.checkpoint)
if args.center_only:
model = imagenet_wrapper(
model, std=[1.0, 1.0,
1.0]) #to do the normalization inside the forward pass
else:
model = imagenet_wrapper(model)
radius_train = torch.zeros(trainset_size)
radius_test = torch.zeros(testset_size)
sigma_train = torch.ones(trainset_size) * args.sig0_tr
sigma_test = torch.ones(testset_size) * args.sig0_ts
radius_train, radius_test = radius_train.to(device), radius_test.to(device)
sigma_train, sigma_test = sigma_train.to(device), sigma_test.to(device)
if args.path_sigma is not None: #loading test sigma to optimize for it
sigma_test = torch.load(args.path_sigma)
base_bath_save = f'scratch_exps/ImageNet/exps/{args.output_path}/sig0_tr_{args.sig0_tr}/sig0_ts_{args.sig0_tr}/lr_sig_{args.lr_sig}/iter_sig_tr_{args.iter_sig_tr}/iter_sig_ts_{args.iter_sig_ts}'
tensorboard_path = f'scratch_exps/ImageNet/tensorboard/{args.output_path}/sig0_tr_{args.sig0_tr}/sig0_ts_{args.sig0_tr}/lr_sig_{args.lr_sig}/iter_sig_tr_{args.iter_sig_tr}/iter_sig_ts_{args.iter_sig_ts}'
if not path.exists(base_bath_save):
os.makedirs(base_bath_save)
writer = SummaryWriter(tensorboard_path, flush_secs=10)
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
step_size=args.step_sz,
gamma=args.gamma)
best_acc = 0.0
for epoch in range(args.epochs):
writer.add_scalar('learning rate', optimizer.param_groups[0]['lr'],
epoch)
if epoch >= args.epoch_switch:
print(
'Switched to DS training, sigma train is {} and sigma test is {}'
.format(sigma_train.mean().item(),
sigma_test.mean().item()))
sigma_train = train(epoch,
model,
train_loader,
optimizer,
writer,
sigma_train,
args.lr_sig,
args.iter_sig_tr,
gaussian_num=args.gaussian_num,
lamda=args.lbd,
gamma=args.gam,
gaussian_num_ds=args.gaussian_num_ds)
test_acc, sigma_test = test(epoch, model, test_loader, writer,
sigma_test, args.lr_sig,
args.iter_sig_ts)
else:
print('Training with RS')
sigma_train = train(epoch,
model,
train_loader,
optimizer,
writer,
sigma_train,
args.lr_sig,
0,
gaussian_num=args.gaussian_num,
lamda=args.lbd,
gamma=args.gam)
test_acc, sigma_test = test(epoch, model, test_loader, writer,
sigma_test, args.lr_sig, 0)
scheduler.step()
print('Learing Rate: {}.'.format(optimizer.param_groups[0]['lr']))
if test_acc > best_acc:
best_flag = True
best_acc = test_acc
else:
best_flag = False
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'optimizer_param': optimizer.state_dict(),
},
base_bath_save,
best=best_flag)
#Optimizing sigma afterwards
print(
'Training has finished now we optimize for the sigmas. So far, sigma train is {} and sigma test is {}'
.format(sigma_train.mean().item(),
sigma_test.mean().item()))
sigma_test = optimize_sigma(model,
test_loader,
writer,
sigma_test,
args.lr_sig,
args.iter_sig_after,
flag='test',
radius=radius_test,
gaussian_num_ds=args.gaussian_num_ds)
# Saving the sigmas
torch.save(sigma_test, base_bath_save + '/sigma_test.pth')
print('everything is done, you should be happy now !')
def __init__(self, args):
super(MGN, self).__init__()
num_classes = args.num_classes
resnet = resnet50(pretrained=True)
self.backone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
resnet.layer3[0],
)
res_conv4 = nn.Sequential(*resnet.layer3[1:])
res_g_conv5 = resnet.layer4
res_p_conv5 = nn.Sequential(
Bottleneck(1024,
512,
downsample=nn.Sequential(
nn.Conv2d(1024, 2048, 1, bias=False),
nn.BatchNorm2d(2048))), Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
self.p1 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_g_conv5))
self.p2 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.p3 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
##########################################################################
# Note(zjs): make the kernel size flexible for input image shape
# if args.pool == 'max':
# pool2d = nn.MaxPool2d
# elif args.pool == 'avg':
# pool2d = nn.AvgPool2d
# else:
# raise Exception()
# # input shape (384, 128)
# self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4))
# self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8))
# self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8))
# self.maxpool_zp2 = pool2d(kernel_size=(12, 8))
# self.maxpool_zp3 = pool2d(kernel_size=(8, 8))
# input shape (256, 256)
# self.maxpool_zg_p1 = pool2d(kernel_size=(8, 8))
# self.maxpool_zg_p2 = pool2d(kernel_size=(16, 16))
# self.maxpool_zg_p3 = pool2d(kernel_size=(16, 16))
# self.maxpool_zp2 = pool2d(kernel_size=(8, 16))
# self.maxpool_zp3 = pool2d(kernel_size=(5, 16))
if args.pool == 'max':
pool2d = nn.AdaptiveMaxPool2d
elif args.pool == 'avg':
pool2d = nn.AdaptiveAvgPool2d
else:
raise Exception()
self.maxpool_zg_p1 = pool2d(output_size=(1, 1))
self.maxpool_zg_p2 = pool2d(output_size=(1, 1))
self.maxpool_zg_p3 = pool2d(output_size=(1, 1))
self.maxpool_zp2 = pool2d(output_size=(2, 1))
self.maxpool_zp3 = pool2d(output_size=(3, 1))
##########################################################################
reduction = nn.Sequential(nn.Conv2d(2048, args.feats, 1, bias=False),
nn.BatchNorm2d(args.feats), nn.ReLU())
self._init_reduction(reduction)
self.reduction_0 = copy.deepcopy(reduction)
self.reduction_1 = copy.deepcopy(reduction)
self.reduction_2 = copy.deepcopy(reduction)
self.reduction_3 = copy.deepcopy(reduction)
self.reduction_4 = copy.deepcopy(reduction)
self.reduction_5 = copy.deepcopy(reduction)
self.reduction_6 = copy.deepcopy(reduction)
self.reduction_7 = copy.deepcopy(reduction)
#self.fc_id_2048_0 = nn.Linear(2048, num_classes)
self.fc_id_2048_0 = nn.Linear(args.feats, num_classes)
self.fc_id_2048_1 = nn.Linear(args.feats, num_classes)
self.fc_id_2048_2 = nn.Linear(args.feats, num_classes)
self.fc_id_256_1_0 = nn.Linear(args.feats, num_classes)
self.fc_id_256_1_1 = nn.Linear(args.feats, num_classes)
self.fc_id_256_2_0 = nn.Linear(args.feats, num_classes)
self.fc_id_256_2_1 = nn.Linear(args.feats, num_classes)
self.fc_id_256_2_2 = nn.Linear(args.feats, num_classes)
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
def __init__(self, num_classes, pretrained=True):
resnet = resnet50(pretrained)
super(FurnitureRetinaNet50Classification,
self).__init__(resnet, num_classes=num_classes)
def main():
global best_acc
start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch
os.makedirs(args.save_dir, exist_ok=True)
# ######################################### Dataset ################################################
train_transforms = transforms.Compose([
# transforms.RandomResizedCrop(224),
transforms.RandomResizedCrop(
224, scale=(0.1, 1.0),
ratio=(0.8, 1.25)), # according to official open LTH
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
val_transforms = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
# #################### train / valid dataset ####################
train_dir = os.path.join(args.img_dir, 'train')
valid_dir = os.path.join(args.img_dir, 'val')
trainset = datasets.ImageFolder(root=train_dir, transform=train_transforms)
devset = datasets.ImageFolder(root=valid_dir, transform=val_transforms)
print('Total images in train, ', len(trainset))
print('Total images in valid, ', len(devset))
# #################### data loader ####################
trainloader = data.DataLoader(trainset,
batch_size=args.train_batch,
shuffle=True,
num_workers=args.workers)
devloader = data.DataLoader(devset,
batch_size=args.test_batch,
shuffle=False,
num_workers=args.workers)
# ######################################### Model ##################################################
print("==> creating model ResNet={}".format(args.depth))
if args.depth == 18:
model = resnet18(pretrained=False)
elif args.depth == 34:
model = resnet34(pretrained=False)
elif args.depth == 50:
model = resnet50(pretrained=False)
elif args.depth == 101:
model = resnet101(pretrained=False)
elif args.depth == 152:
model = resnet152(pretrained=False)
else:
model = resnet50(pretrained=False) # default Res-50
model.cuda(device_ids[0])
# ############################### Optimizer and Loss ###############################
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# ************* USE APEX *************
if USE_APEX:
print('Use APEX !!! Initialize Model with APEX')
model, optimizer = apex.amp.initialize(model,
optimizer,
loss_scale='dynamic',
verbosity=0)
# ****************** multi-GPU ******************
model = nn.DataParallel(model, device_ids=device_ids)
cudnn.benchmark = True
print(' Total params: %.2fM' %
(sum(p.numel() for p in model.parameters()) / 1000000.0))
# ############################### Resume ###############################
title = 'ImageNet'
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isfile(
args.resume), 'Error: no checkpoint directory found!'
args.save_dir = os.path.dirname(args.resume)
checkpoint = torch.load(args.resume)
best_acc = checkpoint['best_acc']
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(args.save_dir, 'log.txt'),
title=title,
resume=True)
else:
logger = Logger(os.path.join(args.save_dir, 'log.txt'), title=title)
logger.set_names([
'Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.',
'Valid Acc.'
])
# evaluate with random initialization parameters
if args.evaluate:
print('\nEvaluation only')
test_loss, test_acc = test(devloader, model, criterion, start_epoch,
use_cuda)
print(' Test Loss: %.8f, Test Acc: %.2f' % (test_loss, test_acc))
return
# save random initialization parameters
save_checkpoint({'state_dict': model.state_dict()},
False,
checkpoint=args.save_dir,
filename='init.pth.tar')
# ############################### Train and val ###############################
for epoch in range(start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
print('\nEpoch: [%d | %d] LR: %f' %
(epoch + 1, args.epochs, state['lr']))
# train in one epoch
train_loss, train_acc = train(trainloader, model, criterion, optimizer,
epoch, use_cuda)
# ######## acc on validation data each epoch ########
dev_loss, dev_acc = test(devloader, model, criterion, epoch, use_cuda)
# append logger file
logger.append([state['lr'], train_loss, dev_loss, train_acc, dev_acc])
# save model after one epoch
# Note: save all models after one epoch, to help find the best rewind
is_best = dev_acc > best_acc
best_acc = max(dev_acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': dev_acc,
'best_acc': best_acc,
'optimizer': optimizer.state_dict(),
},
is_best,
checkpoint=args.save_dir,
filename=str(epoch + 1) + '_checkpoint.pth.tar')
print('Best val acc:')
print(best_acc)
logger.close()
def main():
global best_acc
start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch
os.makedirs(args.save_dir, exist_ok=True)
# ######################################### Dataset ################################################
train_transforms = transforms.Compose([
# transforms.RandomResizedCrop(224),
transforms.RandomResizedCrop(224, scale=(0.1, 1.0), ratio=(0.8, 1.25)), # according to official open LTH
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
val_transforms = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
])
# #################### train / valid dataset ####################
train_dir = os.path.join(args.img_dir, 'train')
valid_dir = os.path.join(args.img_dir, 'val')
trainset = datasets.ImageFolder(root=train_dir, transform=train_transforms)
devset = datasets.ImageFolder(root=valid_dir, transform=val_transforms)
print('Total images in train, ', len(trainset))
print('Total images in valid, ', len(devset))
# #################### data loader ####################
trainloader = data.DataLoader(trainset, batch_size=args.train_batch,
shuffle=True, num_workers=args.workers)
devloader = data.DataLoader(devset, batch_size=args.test_batch,
shuffle=False, num_workers=args.workers)
# ######################################### Model ##################################################
print("==> creating model ResNet={}".format(args.depth))
if args.depth == 18:
model = resnet18(pretrained=False)
model_ref = resnet18(pretrained=False)
teacher_model = resnet18(pretrained=False)
elif args.depth == 34:
model = resnet34(pretrained=False)
model_ref = resnet34(pretrained=False)
teacher_model = resnet34(pretrained=False)
elif args.depth == 50:
model = resnet50(pretrained=False)
model_ref = resnet50(pretrained=False)
teacher_model = resnet50(pretrained=False)
elif args.depth == 101:
model = resnet101(pretrained=False)
model_ref = resnet101(pretrained=False)
teacher_model = resnet101(pretrained=False)
elif args.depth == 152:
model = resnet152(pretrained=False)
model_ref = resnet152(pretrained=False)
teacher_model = resnet152(pretrained=False)
else:
model = resnet50(pretrained=False) # default Res-50
model_ref = resnet50(pretrained=False) # default Res-50
teacher_model = resnet50(pretrained=False) # default Res-50
model.cuda(device_ids[0]) # model to train (student model)
model_ref.cuda(device_ids[0]) # pruned model
teacher_model.cuda(device_ids[0]) # teacher model, the last epoch of unpruned training model
# ############################### Optimizer and Loss ###############################
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=args.lr,
momentum=args.momentum, weight_decay=args.weight_decay)
# ************* USE APEX *************
if USE_APEX:
print('Use APEX !!! Initialize Model with APEX')
model, optimizer = apex.amp.initialize(model, optimizer, loss_scale='dynamic', verbosity=0)
# ****************** multi-GPU ******************
model = nn.DataParallel(model, device_ids=device_ids)
model_ref = nn.DataParallel(model_ref, device_ids=device_ids)
teacher_model = nn.DataParallel(teacher_model, device_ids=device_ids)
cudnn.benchmark = True
print(' Total params: %.2fM' % (sum(p.numel() for p in model.parameters()) / 1000000.0))
# ############################### Resume ###############################
# load pruned model (model_ref), use it to mute some weights of model
title = 'ImageNet'
if args.resume:
# Load checkpoint.
print('==> Getting reference model from checkpoint..')
assert os.path.isfile(args.resume), 'Error: no checkpoint directory found!'
checkpoint = torch.load(args.resume, map_location=lambda storage, loc: storage)
best_acc = checkpoint['best_acc']
start_epoch = args.start_epoch
model_ref.load_state_dict(checkpoint['state_dict'])
logger = Logger(os.path.join(args.save_dir, 'log_scratch.txt'), title=title)
logger.set_names(['EPOCH', 'Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.', 'Valid Acc.'])
# set some weights to zero, according to model_ref ---------------------------------
# ############## load Lottery Ticket (initialization parameters of un pruned model) ##############
if args.model:
print('==> Loading init model (Lottery Ticket) from %s' % args.model)
checkpoint = torch.load(args.model, map_location=lambda storage, loc: storage)
model.load_state_dict(checkpoint['state_dict'])
if 'init' in args.model:
start_epoch = 0
else:
start_epoch = checkpoint['epoch']
print('Start Epoch ', start_epoch)
for m, m_ref in zip(model.modules(), model_ref.modules()):
if isinstance(m, nn.Conv2d):
weight_copy = m_ref.weight.data.abs().clone()
mask = weight_copy.gt(0).float().cuda()
m.weight.data.mul_(mask)
# ############## load parameters of teacher model ##############
print('==> Loading teacher model (un-pruned) from %s' % args.teacher)
checkpoint = torch.load(args.teacher, map_location=lambda storage, loc: storage)
teacher_model.load_state_dict(checkpoint['state_dict'])
teacher_model.eval()
# ############################### Train and val ###############################
for epoch in range(start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
print('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.epochs, state['lr']))
num_parameters = get_conv_zero_param(model)
print('Zero parameters: {}'.format(num_parameters))
num_parameters = sum([param.nelement() for param in model.parameters()])
print('Parameters: {}'.format(num_parameters))
# train model
train_loss, train_acc = train(trainloader, model, teacher_model, optimizer, epoch, use_cuda)
# ######## acc on validation data each epoch ########
dev_loss, dev_acc = test(devloader, model, criterion, epoch, use_cuda)
# append logger file
logger.append([ epoch, state['lr'], train_loss, dev_loss, train_acc, dev_acc])
# save model after one epoch
# Note: save all models after one epoch, to help find the best rewind
is_best = dev_acc > best_acc
best_acc = max(dev_acc, best_acc)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': dev_acc,
'best_acc': best_acc,
'optimizer': optimizer.state_dict(),
}, is_best, checkpoint=args.save_dir, filename=str(epoch + 1)+'_checkpoint.pth.tar')
print('Best val acc:')
print(best_acc)
logger.close()
def __init__(self):
super(MGN, self).__init__()
#num_classes = 751
#num_classes = 4101
num_classes = opt.cls_num
feats = 256
if opt.backbone == 'resnet50':
resnet = resnet50(pretrained=True)
elif opt.backbone == 'resnet101':
resnet = resnet101(pretrained=True)
self.backbone1 = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
)
self.backbone2 = resnet.layer2
self.backbone3 = resnet.layer3[0]
res_conv4 = nn.Sequential(*resnet.layer3[1:])
#res_g_conv5 = resnet.layer4
res_p_conv5 = nn.Sequential(
Bottleneck(1024, 512, downsample=nn.Sequential(nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))),
Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
self.attc0 = ATTC(in_channels=256, out_channels=512)
self.atts0 = ATTS(in_channels=256, h=48, w=16)
self.attc1 = ATTC(in_channels=1024, out_channels=2048)
self.atts1 = ATTS(in_channels=1024, h=24, w=8)
self.attc2 = ATTC(in_channels=1024, out_channels=2048)
self.atts2 = ATTS(in_channels=1024, h=24, w=8)
self.attc3 = ATTC(in_channels=1024, out_channels=2048)
self.atts3 = ATTS(in_channels=1024, h=24, w=8)
self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5))
self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5))
self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5))
self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8))
self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8))
self.reduction = nn.Sequential(nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats), nn.ReLU())
self._init_reduction(self.reduction)
self.fc_id_2048_0 = nn.Linear(feats, num_classes)
self.fc_id_2048_1 = nn.Linear(feats, num_classes)
self.fc_id_2048_2 = nn.Linear(feats, num_classes)
self.fc_id_256_1_0 = nn.Linear(feats, num_classes)
self.fc_id_256_1_1 = nn.Linear(feats, num_classes)
self.fc_id_256_2_0 = nn.Linear(feats, num_classes)
self.fc_id_256_2_1 = nn.Linear(feats, num_classes)
self.fc_id_256_2_2 = nn.Linear(feats, num_classes)
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
def test_resnet(self):
# ResNet50 model
x = Variable(torch.randn(BATCH_SIZE, 3, 224, 224).fill_(1.0))
self.exportTest(toC(resnet50()), toC(x), atol=1e-6)
def create_model(model_name, num_classes=1000, pretrained=False, **kwargs):
if 'test_time_pool' in kwargs:
test_time_pool = kwargs.pop('test_time_pool')
else:
test_time_pool = True
if 'extra' in kwargs:
extra = kwargs.pop('extra')
else:
extra = True
if model_name == 'dpn68':
model = dpn68(num_classes=num_classes,
pretrained=pretrained,
test_time_pool=test_time_pool)
elif model_name == 'dpn68b':
model = dpn68b(num_classes=num_classes,
pretrained=pretrained,
test_time_pool=test_time_pool)
elif model_name == 'dpn92':
model = dpn92(num_classes=num_classes,
pretrained=pretrained,
test_time_pool=test_time_pool,
extra=extra)
elif model_name == 'dpn98':
model = dpn98(num_classes=num_classes,
pretrained=pretrained,
test_time_pool=test_time_pool)
elif model_name == 'dpn131':
model = dpn131(num_classes=num_classes,
pretrained=pretrained,
test_time_pool=test_time_pool)
elif model_name == 'dpn107':
model = dpn107(num_classes=num_classes,
pretrained=pretrained,
test_time_pool=test_time_pool)
elif model_name == 'resnet18':
model = resnet18(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'resnet34':
model = resnet34(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'resnet50':
model = resnet50(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'resnet101':
model = resnet101(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'resnet152':
model = resnet152(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'densenet121':
model = densenet121(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'densenet161':
model = densenet161(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'densenet169':
model = densenet169(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'densenet201':
model = densenet201(num_classes=num_classes,
pretrained=pretrained,
**kwargs)
elif model_name == 'inception_v3':
model = inception_v3(num_classes=num_classes,
pretrained=pretrained,
transform_input=False,
**kwargs)
else:
assert False, "Unknown model architecture (%s)" % model_name
return model
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
PY3 = False
else:
from io import BytesIO as StringIO
PY3 = True
import logging
from cloudpickle import CloudPickler
import os
import tempfile
import sys
from torchvision.models.resnet import resnet50
model = resnet50(pretrained=True)
model = model.cuda()
import io
from PIL import Image
from torch.autograd import Variable
import torchvision.transforms as transforms
import torch
min_img_size = 224
transform_pipeline = transforms.Compose([
transforms.Resize(min_img_size),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])
# -*- coding: utf-8 -*- # @Author : DevinYang([email protected]) import torch from torchtoolbox.tools import summary from torchvision.models.resnet import resnet50 from torchvision.models.mobilenet import mobilenet_v2 model1 = resnet50() model2 = mobilenet_v2() def test_summary(): summary(model1, torch.rand((1, 3, 224, 224)), True) summary(model2, torch.rand((1, 3, 224, 224)))
def __init__(self, args):
super(LMBN_r, self).__init__()
self.n_ch = 2
self.chs = 2048 // self.n_ch
# resnet = resnet50_ibn_a(last_stride=1, pretrained=True)
resnet = resnet50(pretrained=True)
self.backone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
resnet.layer3[0],
)
conv3 = nn.Sequential(*resnet.layer3[1:])
no_downsample_conv4 = nn.Sequential(
Bottleneck(1024,
512,
downsample=nn.Sequential(
nn.Conv2d(1024, 2048, 1, bias=False),
nn.BatchNorm2d(2048))), Bottleneck(2048, 512),
Bottleneck(2048, 512))
no_downsample_conv4.load_state_dict(resnet.layer4.state_dict())
self.global_branch = nn.Sequential(copy.deepcopy(conv3),
copy.deepcopy(resnet.layer4))
self.partial_branch = nn.Sequential(copy.deepcopy(conv3),
copy.deepcopy(no_downsample_conv4))
self.channel_branch = nn.Sequential(copy.deepcopy(conv3),
copy.deepcopy(no_downsample_conv4))
self.global_pooling = nn.AdaptiveMaxPool2d((1, 1))
self.partial_pooling = nn.AdaptiveAvgPool2d((2, 1))
self.channel_pooling = nn.AdaptiveMaxPool2d((1, 1))
self.avg_pooling = nn.AdaptiveAvgPool2d((1, 1))
reduction = BNNeck3(2048, args.num_classes, args.feats, return_f=True)
self.reduction_0 = copy.deepcopy(reduction)
self.reduction_1 = copy.deepcopy(reduction)
self.reduction_2 = copy.deepcopy(reduction)
self.reduction_3 = copy.deepcopy(reduction)
self.reduction_drop = copy.deepcopy(reduction)
self.shared = nn.Sequential(
nn.Conv2d(self.chs, args.feats, 1, bias=False),
nn.BatchNorm2d(args.feats), nn.ReLU(True))
self.weights_init_kaiming(self.shared)
self.reduction_ch_0 = BNNeck(args.feats,
args.num_classes,
return_f=True)
self.reduction_ch_1 = BNNeck(args.feats,
args.num_classes,
return_f=True)
# if args.drop_block:
# print('Using batch random erasing block.')
# self.batch_drop_block = BatchRandomErasing()
self.batch_drop_block = BatchFeatureErase_Top(2048, Bottleneck)
self.activation_map = args.activation_map
def test_resnet(self):
state_dict = model_zoo.load_url(model_urls['resnet50'], progress=False)
self.run_model_test(resnet50(), train=False, batch_size=BATCH_SIZE,
state_dict=state_dict, atol=1e-6)
def __init__(self, args):
super(MGN, self).__init__()
num_classes = args.num_classes
resnet = resnet50(pretrained=True)
self.backone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
resnet.layer3[0],
)
res_conv4 = nn.Sequential(*resnet.layer3[1:])
res_g_conv5 = resnet.layer4
res_p_conv5 = nn.Sequential(
Bottleneck(1024,
512,
downsample=nn.Sequential(
nn.Conv2d(1024, 2048, 1, bias=False),
nn.BatchNorm2d(2048))), Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
self.p1 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_g_conv5))
self.p2 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.p3 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
if args.pool == 'max':
pool2d = nn.MaxPool2d
elif args.pool == 'avg':
pool2d = nn.AvgPool2d
else:
raise Exception()
self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4))
self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8))
self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8))
self.maxpool_zp2 = pool2d(kernel_size=(8, 8))
self.maxpool_zp3 = pool2d(kernel_size=(6, 8)) #！！
reduction = nn.Sequential(nn.Conv2d(2048, args.feats, 1, bias=False),
nn.BatchNorm2d(args.feats), nn.ReLU())
self._init_reduction(reduction)
self.reduction_0 = copy.deepcopy(reduction)
self.reduction_1 = copy.deepcopy(reduction)
self.reduction_2 = copy.deepcopy(reduction)
self.reduction_3 = copy.deepcopy(reduction)
self.reduction_4 = copy.deepcopy(reduction)
self.reduction_5 = copy.deepcopy(reduction)
self.reduction_6 = copy.deepcopy(reduction)
self.reduction_7 = copy.deepcopy(reduction)
self.reduction_8 = copy.deepcopy(reduction)
self.reduction_9 = copy.deepcopy(reduction) #！！
#self.fc_id_2048_0 = nn.Linear(2048, num_classes)
self.fc_id_2048_0 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_2048_1 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_2048_2 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_256_1_0 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_256_1_1 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_256_1_2 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_256_2_0 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_256_2_1 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_256_2_2 = nn.Linear(args.feats, num_classes, bias=False)
self.fc_id_256_2_3 = nn.Linear(args.feats, num_classes,
bias=False) #！！
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_1_2)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
self._init_fc(self.fc_id_256_2_3) #！！
import torch
from torch import optim
from torchvision.models.resnet import resnet50
model = resnet50()
"""
model_load_param
load model parameters conclude two situations:
1 model structure is the same as .pkl.
2 model structure could is not totally same as .pkl.
"""
model_path = '/path/{}.pkl'
state_dict = torch.load(model_path)
# way1
model.load_state_dict(
{k: v
for k, v in state_dict.items() if k in model.state_dict()})
# way2: same as way1
# unexpectd key:本模型没有而加载的模型有的key
# missing key:本模型有而加载的模型没有的key
# strict=True/False: 当strict=True时，出现以上两个任何一个错误就会终止执行，当为false时，会忽略错误。
model.load_state_dict(state_dict, strict=False)
"""
optim
optim parameters required grad contains two situations:
1 optim all parameters with the same set.
2 optim per-layer with the different set.
"""
## python3 filter return a iterator.
optimizer = optim.Adam(list(
def test_resnet(self):
state_dict = model_zoo.load_url(model_urls['resnet50'], progress=False)
self.run_model_test(resnet50(), train=False, batch_size=BATCH_SIZE,
state_dict=state_dict, atol=1e-6)
def main():
modelname = "resnet50_onnx"
interface_filename = f"{modelname}.yaml"
model = resnet50(pretrained=True)
x_dummy = torch.rand((1, 3, 224, 224), device="cpu")
model.eval()
torch.onnx.export(
model,
x_dummy,
MODEL_FILEPATH,
export_params=True,
opset_version=10,
do_constant_folding=True,
input_names=["input"],
output_names=["output"],
verbose=False,
)
labels = load_labels(LABEL_FILEPATH)
preprocess = PytorchImagePreprocessTransformer()
image = Image.open(SAMPLE_IMAGE)
np_image = preprocess.transform(image)
print(np_image.shape)
preprocess_name = f"{modelname}_preprocess_transformer"
preprocess_filename = f"{preprocess_name}.pkl"
preprocess_filepath = os.path.join(MODEL_DIR, preprocess_filename)
dump_sklearn(preprocess, preprocess_filepath)
sess = rt.InferenceSession(MODEL_FILEPATH)
inp, out = sess.get_inputs()[0], sess.get_outputs()[0]
print(f"input name='{inp.name}' shape={inp.shape} type={inp.type}")
print(f"output name='{out.name}' shape={out.shape} type={out.type}")
pred_onx = sess.run([out.name], {inp.name: np_image})
postprocess = SoftmaxTransformer()
postprocess_name = f"{modelname}_softmax_transformer"
postprocess_filename = f"{postprocess_name}.pkl"
postprocess_filepath = os.path.join(MODEL_DIR, postprocess_filename)
dump_sklearn(postprocess, postprocess_filepath)
prediction = postprocess.transform(np.array(pred_onx))
print(prediction.shape)
print(labels[np.argmax(prediction[0])])
save_interface(
modelname,
os.path.join(MODEL_DIR, interface_filename),
[1, 3, 224, 224],
"float32",
[1, 1000],
"float32",
DATA_TYPE.IMAGE,
[{
preprocess_filepath: MODEL_RUNTIME.SKLEARN
}, {
MODEL_FILEPATH: MODEL_RUNTIME.ONNX_RUNTIME
}, {
postprocess_filepath: MODEL_RUNTIME.SKLEARN
}],
PREDICTION_TYPE.CLASSIFICATION,
"src.app.ml.resnet50_onnx.resnet50_predictor",
label_filepath=LABEL_FILEPATH,
)
def preprocess_noisyart_images(
net_selector,
im_resize,
crop, #divisor,
mean_sub,
std_norm,
range_255,
batch_size,
dataset_imgs_path=None,
feats_out_dir_path=None,
feats_out_append=None,
workers=0,
feature_layer=None,
verbose=False,
device=None,
seed=DEFAULT_SEED):
if seed is not None:
print(f"Using fixed seed = {seed}")
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
from torchvision.models.alexnet import alexnet
from torchvision.models.vgg import vgg16
from torchvision.models.vgg import vgg19
from torchvision.models.resnet import resnet50
from torchvision.models.resnet import resnet101
from torchvision.models.resnet import resnet152
dataset_imgs_path = DEFAULT_IMGS_PATH if dataset_imgs_path is None else dataset_imgs_path
feats_out_dir_path = str(
DEFAULT_FEATS_PATH
) if feats_out_dir_path is None else feats_out_dir_path
feats_out_append = "" if feats_out_append is None else '_' + feats_out_append
# divisor = assign_if_bool(divisor, case_true=255)
# rescale=1./divisor if divisor is not None else None
#
# print("divisor: {}".format(divisor))
# print("rescale: {}".format(rescale))
print('\n\n')
loader = get_loader(batch_size,
im_resize,
crop,
mean_sub,
std_norm,
range_255,
shuffle=False,
dataset_imgs_path=dataset_imgs_path,
verbose=True,
workers=workers)
#%%
#labels = [int(l) for f, l in loader.dataset.samples]
dir_path = dataset_imgs_path if dataset_imgs_path.endswith(
'/') else dataset_imgs_path + '/'
filenames = [f.split(dir_path)[1] for f, l in loader.dataset.samples]
class_indices = loader.dataset.class_to_idx
resize_str = '_r{}'.format(im_resize) if im_resize else ''
crop_str = '_c{}'.format(crop) if crop else ''
mean_sub_str = '_meansub' if mean_sub else ''
std_norm_str = '_stdnorm' if std_norm else ''
range_255_str = '_range255' if range_255 else ''
#divisor_str = '_div{}'.format(divisor) if divisor is not None else ''
#duplicate_seed_std = '_dseed{}'.format(duplicate_seeds) if duplicate_seeds else ''
def get_save_path(feat_net_name):
from os.path import join
return join(feats_out_dir_path, '{}{}{}{}{}{}{}'.\
format(feat_net_name, resize_str, crop_str, mean_sub_str, std_norm_str, range_255_str, feats_out_append))
savepath = get_save_path(net_selector)
print('After prediction, features will be saved in: ' + savepath)
#%%
# As an alternative to get layer outputs look here: https://www.stacc.ee/extract-feature-vector-image-pytorch/
if net_selector.startswith('resnet'):
if net_selector == 'resnet50':
net = resnet50(pretrained=True)
elif net_selector == 'resnet101':
net = resnet101(pretrained=True)
elif net_selector == 'resnet152':
net = resnet152(pretrained=True)
if feature_layer is None or feature_layer in ['pool', 'avgpool']:
net.fc = FakeLayer() # remove useless layers
#net.fc = nn.AdaptiveAvgPool2d(1024) # remove useless layers
else:
raise RuntimeError(
"resnet feature_layer can only be 'avgpool' ('pool' or None for short)"
)
elif net_selector.startswith('vgg'):
if net_selector == 'vgg16':
net = vgg16(pretrained=True)
elif net_selector == 'vgg19':
net = vgg19(pretrained=True)
default_feature_layer = 'fc7'
feature_layer = default_feature_layer if feature_layer is None else feature_layer # default layer is fc7
if feature_layer == 'fc6':
l_index = 0 # layer 0 is FC6, we wont layer 0 output -> remove the next layers (1 to last)
elif feature_layer == 'fc7':
l_index = 3 # layer 3 is FC7, we wont layer 3 output -> remove the next layers (4 to last)
else:
raise RuntimeError(
"vgg feature_layer can only be 'fc6' or 'fc7' (None for {})".
format(default_feature_layer))
for i in range(l_index + 1, len(net.classifier)):
net.classifier[i] = FakeLayer()
elif net_selector == 'alexnet':
net = alexnet(pretrained=True)
net.classifier = FakeLayer() # remove useless layers
print('Start prediction')
from progressbar import progressbar
preds = []
labels = []
# Fix for: RuntimeError: received 0 items of ancdata
import resource
rlimit = resource.getrlimit(resource.RLIMIT_NOFILE)
resource.setrlimit(resource.RLIMIT_NOFILE, (2048, rlimit[1]))
torch.multiprocessing.set_sharing_strategy('file_system')
from PIL import ImageFile, Image
ImageFile.LOAD_TRUNCATED_IMAGES = True # Allow read truncated files. Otherwise truncated file will except and kill!
Image.MAX_IMAGE_PIXELS = Image.MAX_IMAGE_PIXELS * 4 # Change the max pixel for 'decompressionBomb' warning
if device is not None and device is not 'cpu':
print("Using CUDA")
net.to(device)
net.eval()
suffix = '\n' if verbose else ''
for X, Y in progressbar(loader, suffix=suffix):
if verbose:
print("\nMax-Val: {}".format(X.max()))
print("Min-Val: {}".format(X.min()))
print("Mean: {}".format(X.mean()))
print("STD: {}\n".format(X.std()))
preds.append(net(X.to(device)).detach().cpu().numpy())
labels.append(Y)
else:
print("Using CPU")
for X, Y in progressbar(loader):
preds.append(net(X).detach().numpy())
labels.append(Y)
preds = np.vstack(preds)
labels = np.concatenate(labels)
#labels = np.array(labels)
print('Saving preds to: ' + savepath)
saved = False
while not saved:
try:
np.save(
savepath, {
'feats': preds,
'labels': labels,
'filenames': filenames,
'class_indices': class_indices
})
saved = True
except MemoryError as E:
import traceback
from time import sleep
traceback.print_exc()
print('\n\nMemory Error')
print("Waiting 30 seconds and will try again..")
import gc
gc.collect()
sleep(60.0)
elif args.model == 'resnet':
args.batch_size = 100
elif args.model == 'my_resnet':
args.batch_size = 18 #32
if args.model == 'SEC':
# model_url = 'https://download.pytorch.org/models/vgg16-397923af.pth' # 'vgg16'
model_path = 'models/vgg16-397923af.pth' # 'vgg16'
net = sec.SEC_NN(args.batch_size, args.num_classes, args.output_size, args.no_bg, flag_use_cuda)
#net.load_state_dict(model_zoo.load_url(model_url), strict = False)
net.load_state_dict(torch.load(model_path), strict = False)
elif args.model == 'resnet':
model_path = 'models/top_val_rec_my_resnet_23.pth' # 'models/resnet50_feat.pth'
net = resnet.resnet50(pretrained=False, num_classes=args.num_classes)
net.load_state_dict(torch.load(model_path), strict = False)
elif args.model == 'my_resnet':
model_path = 'models/resnet50_feat.pth'
net = my_resnet2.resnet50(pretrained=False, num_classes=args.num_classes)
net.load_state_dict(torch.load(model_path), strict = False)
if args.loss == 'BCELoss':
criterion = nn.BCELoss()
elif args.loss == 'MultiLabelSoftMarginLoss':
criterion = nn.MultiLabelSoftMarginLoss()
print(args)
def __init__(self, num_classes, pool='avg', feats=256):
"""
:param num_classes: 数据集的类别数目
:param pool: 使用什么池化方式
:param feats: 输出的特征维度
"""
super(MGN, self).__init__()
num_classes = num_classes
resnet = resnet50(pretrained=True)
self.backone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
resnet.layer3[0],
)
res_conv4 = nn.Sequential(*resnet.layer3[1:])
res_g_conv5 = resnet.layer4
res_p_conv5 = nn.Sequential(
Bottleneck(1024,
512,
downsample=nn.Sequential(
nn.Conv2d(1024, 2048, 1, bias=False),
nn.BatchNorm2d(2048))), Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
self.p1 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_g_conv5))
self.p2 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.p3 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
if pool == 'max':
pool2d = nn.MaxPool2d
elif pool == 'avg':
pool2d = nn.AvgPool2d
else:
raise Exception()
self.maxpool_zg_p1 = pool2d(kernel_size=(8, 4))
self.maxpool_zg_p2 = pool2d(kernel_size=(16, 8))
self.maxpool_zg_p3 = pool2d(kernel_size=(16, 8))
self.maxpool_zp2 = pool2d(kernel_size=(8, 8))
self.maxpool_zp3 = pool2d(kernel_size=(5, 8))
reduction = nn.Sequential(nn.Conv2d(2048, feats, 1, bias=False),
nn.BatchNorm2d(feats), nn.ReLU())
self._init_reduction(reduction)
self.reduction_0 = copy.deepcopy(reduction)
self.reduction_1 = copy.deepcopy(reduction)
self.reduction_2 = copy.deepcopy(reduction)
self.reduction_3 = copy.deepcopy(reduction)
self.reduction_4 = copy.deepcopy(reduction)
self.reduction_5 = copy.deepcopy(reduction)
self.reduction_6 = copy.deepcopy(reduction)
self.reduction_7 = copy.deepcopy(reduction)
# self.fc_id_2048_0 = nn.Linear(2048, num_classes)
self.fc_id_2048_0 = nn.Linear(feats, num_classes)
self.fc_id_2048_1 = nn.Linear(feats, num_classes)
self.fc_id_2048_2 = nn.Linear(feats, num_classes)
self.fc_id_256_1_0 = nn.Linear(feats, num_classes)
self.fc_id_256_1_1 = nn.Linear(feats, num_classes)
self.fc_id_256_2_0 = nn.Linear(feats, num_classes)
self.fc_id_256_2_1 = nn.Linear(feats, num_classes)
self.fc_id_256_2_2 = nn.Linear(feats, num_classes)
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
def __init__(self, p=0.7, mean_speed=25):
super(Net, self).__init__()
self.resnet = resnet.resnet50(pretrained=True, progress=True)
self.fc = nn.Linear(1000, 2)
self.fc.bias.data.fill_(mean_speed)
def __init__(self):
super(MGN, self).__init__()
resnet = resnet50(pretrained=True) # resnet50网络
self.backone = nn.Sequential(
resnet.conv1, # 64*112*112
resnet.bn1,
resnet.relu,
resnet.maxpool, # 64*56*56
)
res_conv2 = nn.Sequential(*resnet.layer1[1:]) # 256*56*56
res_conv3 = nn.Sequential(*resnet.layer1[1:], *resnet.layer2) # 512*28*28
res_conv4 = nn.Sequential(*resnet.layer1[1:], *resnet.layer2, *resnet.layer3) # 1024*14*14
res_g_conv3 = resnet.layer2 # p0 512*28*28
res_g_conv4 = resnet.layer3 # p4 1024*14*14
res_g_conv5 = resnet.layer4 # p1 2048*7*7
res_p_conv5 = nn.Sequential(
Bottleneck(1024, 512, downsample=nn.Sequential(nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))),
Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
self.p0 = nn.Sequential(copy.deepcopy(res_conv2), copy.deepcopy(res_g_conv3),
nn.Conv2d(512, 2048, 1, bias=False), nn.BatchNorm2d(2048), nn.ReLU())
self.p4 = nn.Sequential(copy.deepcopy(res_conv3), copy.deepcopy(res_g_conv4),
nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048), nn.ReLU())
self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5))
self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5))
self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5))
pool2d = nn.MaxPool2d
self.maxpool_zg_p4 = pool2d(kernel_size=(24, 8)) # part-4??????????????
self.maxpool_zg_p0 = pool2d(kernel_size=(48, 16)) # part-0
self.maxpool_zg_p1 = pool2d(kernel_size=(12, 4)) # part-1
self.maxpool_zg_p2 = pool2d(kernel_size=(24, 8)) # part-2
self.maxpool_zg_p3 = pool2d(kernel_size=(24, 8)) # part-3
self.maxpool_zp2 = pool2d(kernel_size=(12, 8)) # part-2 可以划分为2个
self.maxpool_zp3 = pool2d(kernel_size=(8, 8)) # part-3 可以划分分3个
reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU())
self._init_reduction(reduction)
self.reduction_0 = copy.deepcopy(reduction)
# print("p1降维----》", self.reduction_0)
self.reduction_1 = copy.deepcopy(reduction)
self.reduction_2 = copy.deepcopy(reduction)
self.reduction_3 = copy.deepcopy(reduction)
self.reduction_4 = copy.deepcopy(reduction)
self.reduction_5 = copy.deepcopy(reduction)
self.reduction_6 = copy.deepcopy(reduction)
self.reduction_7 = copy.deepcopy(reduction)
# p0,p4
self.reduction_p0 = copy.deepcopy(reduction)
# print("p0降维----》", self.reduction_p0)
self.reduction_p4 = copy.deepcopy(reduction)
# fc softmax loss
# self.fc_id_2048_0 = nn.Linear(2048, num_classes)
self.fc_id_2048_0 = nn.Linear(256, 751)
self.fc_id_2048_1 = nn.Linear(256, 751)
self.fc_id_2048_2 = nn.Linear(256, 751)
# p0 p4
self.fc_id_2048_3 = nn.Linear(256, 751)
# print("p0全连接------------->", self.fc_id_2048_3)
self.fc_id_2048_4 = nn.Linear(256, 751)
self.fc_id_256_1_0 = nn.Linear(256, 751)
self.fc_id_256_1_1 = nn.Linear(256, 751)
self.fc_id_256_2_0 = nn.Linear(256, 751)
self.fc_id_256_2_1 = nn.Linear(256, 751)
self.fc_id_256_2_2 = nn.Linear(256, 751)
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
# p0 p4
self._init_fc(self.fc_id_2048_3)
# print("debug2222222222")
self._init_fc(self.fc_id_2048_4)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
def __init__(self, output_class=7, model_path=None, resnet_type=34, drop_block=False, drop_prob=0.5, drop_pos=None, layer_depth=4, drop_block_size=7):
super(ResNetDropblock, self).__init__()
assert resnet_type in [18, 34, 50]
assert layer_depth in [1, 2, 3, 4]
if resnet_type == 18:
self.base = resnet18(pretrained=False, num_classes=1000)
# state_dict = torch.load('resnet18.pth')
if layer_depth == 4:
last_fc_in_channel = 512 * 1
elif layer_depth == 3:
last_fc_in_channel = 256 * 1
elif layer_depth == 2:
last_fc_in_channel = 128 * 1
else: # elif layer_depth == 1:
last_fc_in_channel = 64 * 1
elif resnet_type == 34:
self.base = resnet34(pretrained=False, num_classes=1000)
# state_dict = torch.load('resnet34.pth')
if layer_depth == 4:
last_fc_in_channel = 512 * 1
elif layer_depth == 3:
last_fc_in_channel = 256 * 1
elif layer_depth == 2:
last_fc_in_channel = 128 * 1
else: # elif layer_depth == 1:
last_fc_in_channel = 64 * 1
else: # elif resnet_type == 50:
self.base = resnet50(pretrained=False, num_classes=1000)
# state_dict = torch.load('resnet50.pth')
if layer_depth == 4:
last_fc_in_channel = 512 * 4
elif layer_depth == 3:
last_fc_in_channel = 256 * 4
elif layer_depth == 2:
last_fc_in_channel = 128 * 4
else: # elif layer_depth == 1:
last_fc_in_channel = 64 * 4
# self.base.load_state_dict(state_dict)
# def weight_init(m):
# if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):
# nn.init.xavier_uniform_(m.weight, gain=nn.init.calculate_gain('relu'))
# if m.bias is not None:
# nn.init.zeros_(m.bias)
#
# self.base.layer3.apply(weight_init)
# self.base.layer4.apply(weight_init)
self.base.fc = nn.Linear(in_features=last_fc_in_channel, out_features=output_class, bias=True)
if drop_block:
self.dropblock = LinearScheduler(
DropBlock2D(drop_prob=drop_prob, block_size=drop_block_size),
start_value=0.,
stop_value=drop_prob,
nr_steps=300
)
else:
self.dropblock = nn.Sequential()
self.drop_pos = drop_pos
self.layer_depth = layer_depth
if model_path is not None:
self.model_path = model_path
assert '.pth' in self.model_path or '.pkl' in self.model_path
self.init_weight()
def convert_model(maskrcnn_weight_path, maskrcnn_config_path):
model_name, ext = os.path.splitext(maskrcnn_weight_path)
target_path = model_name + "_converted" + ext
print("Converting", maskrcnn_weight_path,
"with config", maskrcnn_config_path,
"to", target_path)
if "R_50" in maskrcnn_weight_path:
target_net = "resnet50"
model = resnet50().state_dict()
elif "R_101" in maskrcnn_weight_path:
target_net = "resnet101"
model = resnet101().state_dict()
else:
raise RuntimeError("Could not recognize architecture from file name {0}".format(maskrcnn_weight_path))
maskrcnn_model = torch.load(maskrcnn_weight_path)
maskrcnn_model = maskrcnn_model["model"]
maskrcnn_cfg.merge_from_file(maskrcnn_config_path)
# create a map of prefix renamings
prefix_map = OrderedDict()
prefix_map["conv1."] = "module.backbone.body.stem.conv1."
prefix_map["bn1."] = "module.backbone.body.stem.bn1."
prefix_map["layer1."] = "module.backbone.body.layer1."
prefix_map["layer2."] = "module.backbone.body.layer2."
prefix_map["layer3."] = "module.backbone.body.layer3."
prefix_map["layer4."] = None
prefix_map["fc."] = None
new_model = OrderedDict()
num_added_tensors = 0
for k, v in model.items():
found = False
for prefix in prefix_map.keys():
if k.startswith(prefix):
found = prefix
if not found:
print("Layer {0} was not found in the prefix map".format(k))
continue
if prefix_map[found] is None:
# chop off these
continue
if k.endswith("num_batches_tracked"):
# skip these parameters
continue
layer_to_init_from = prefix_map[found] + k[len(found):]
if layer_to_init_from not in maskrcnn_model:
print("Layer {0} to init {1} was not found in the maskrcnn model".format(layer_to_init_from, k))
assert maskrcnn_model[layer_to_init_from].size() == v.size(), "Size {0} of the source {1} does not match size {2} of target {3}".format(maskrcnn_model[layer_to_init_from].size(), layer_to_init_from, v.size(), k )
new_model[k] = maskrcnn_model[layer_to_init_from].cpu()
num_added_tensors += 1
print("Converted {0} tensors".format(num_added_tensors))
# adjust the first layer convolution
assert new_model['conv1.weight'].size(1) == 3, "the first layer is of the wrong size: {}".format(new_model['conv1.weight'].size())
w = new_model['conv1.weight']
# deal with different normalization and BGR
# their normalization
# maskrcnn_cfg.INPUT.PIXEL_MEAN - can't deal mean mean easily
# maskrcnn_cfg.INPUT.PIXEL_STD / 255
for c in range(3):
w[:,c] = w[:,c] * 255.0 / maskrcnn_cfg.INPUT.PIXEL_STD[c]
# deal with BGR
if maskrcnn_cfg.INPUT.TO_BGR255:
# remap the first layer from BGR to RGB
w = torch.stack([w[:,2], w[:,1], w[:,0]], 1)
# pytorch normalization:
normalization = {}
normalization['mean'] = (0.485, 0.456, 0.406)
normalization['std'] = (0.229, 0.224, 0.225)
for c in range(3):
w[:,c] = w[:,c] * normalization['std'][c]
new_model['conv1.weight'] = w
print("saving model to {0}".format(target_path))
torch.save(new_model, target_path)
def __init__(self, num_classes):
super(MGN, self).__init__()
resnet = resnet50(pretrained=True)
# backbone
self.backbone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1, # res_conv2
resnet.layer2, # res_conv3
resnet.layer3[0], # res_conv4_1
)
# 3. Multiple Granularity Network 3.1. Network Architecture: The difference is that we employ no down-sampling
# operations in res_conv5_1 block.
# res_conv4x
res_conv4 = nn.Sequential(*resnet.layer3[1:])
# res_conv5 global
res_g_conv5 = resnet.layer4
# res_conv5 part
res_p_conv5 = nn.Sequential(
Bottleneck(1024,
512,
downsample=nn.Sequential(
nn.Conv2d(1024, 2048, 1, bias=False),
nn.BatchNorm2d(2048))), Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
# mgn part-1 global
self.p1 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_g_conv5))
# mgn part-2
self.p2 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
# mgn part-3
self.p3 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
# global max pooling
self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(12, 4))
self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8))
self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8))
# Figure 3: Notice that the 1 × 1 convolutions for dimension reduction and fully connected layers for identity
# prediction in each branch DO NOT share weights with each other.
# 4. Experiment 4.1 Implementation: Notice that different branches in the network are all initialized with the
# same pretrained weights of the corresponding layers after the res conv4 1 block.
# conv1 reduce
reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False),
nn.BatchNorm2d(256), nn.ReLU())
self._init_reduction(reduction)
self.reduction_0 = copy.deepcopy(reduction)
self.reduction_1 = copy.deepcopy(reduction)
self.reduction_2 = copy.deepcopy(reduction)
self.reduction_3 = copy.deepcopy(reduction)
self.reduction_4 = copy.deepcopy(reduction)
self.reduction_5 = copy.deepcopy(reduction)
self.reduction_6 = copy.deepcopy(reduction)
self.reduction_7 = copy.deepcopy(reduction)
# fc softmax loss
self.fc_id_2048_0 = nn.Linear(2048, num_classes)
self.fc_id_2048_1 = nn.Linear(2048, num_classes)
self.fc_id_2048_2 = nn.Linear(2048, num_classes)
self.fc_id_256_1_0 = nn.Linear(256, num_classes)
self.fc_id_256_1_1 = nn.Linear(256, num_classes)
self.fc_id_256_2_0 = nn.Linear(256, num_classes)
self.fc_id_256_2_1 = nn.Linear(256, num_classes)
self.fc_id_256_2_2 = nn.Linear(256, num_classes)
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
def build_resnet50(cfg):
backbone = resnet.resnet50(pretrained=True)
features = list(backbone.children(
))[:-2] # For ResNet-101 drop avg-pool and linear classifier
return features
def test_resnet(self):
# ResNet50 model
x = Variable(torch.randn(BATCH_SIZE, 3, 224, 224).fill_(1.0))
self.exportTest(toC(resnet50()), toC(x), atol=1e-6)
def __init__(self, num_classes, width_ratio=0.5, height_ratio=0.5):
super(BFE, self).__init__()
resnet = resnet50(pretrained=True)
resnet.fc = nn.Sequential()
self.model = resnet
self.model.layer4[0].downsample[0].stride = (1, 1)
self.model.layer4[0].conv2.stride = (1, 1)
# layer3 branch
self.bottleneck1 = Bottleneck(1024, 256)
self.PBN1 = PBN(1024,
num_classes,
do_reduction=True,
num_reduction=256)
# global branch
self.PBN2 = PBN(2048,
num_classes,
do_reduction=True,
num_reduction=256) # 到这来
# # part1 branch
# self.bottleneck2 = Bottleneck(2048, 512)
# self.PBN3 = PBN_modify(2048, num_classes, do_reduction=True, num_reduction=256)
# # part2 branch
# self.bottleneck3 = Bottleneck(2048, 512)
# self.PBN4 = PBN_modify(2048, num_classes, do_reduction=True, num_reduction=256)
# part1 branch
self.bottleneck2 = Bottleneck(2048, 512)
self.bt1 = Bottleneck(2048, 512)
self.bt2 = Bottleneck(2048, 512)
self.bt3 = Bottleneck(2048, 512)
self.PBN_l1 = PBN(2048,
num_classes,
do_reduction=True,
num_reduction=256)
self.PBN_l2 = PBN(2048,
num_classes,
do_reduction=True,
num_reduction=256)
self.PBN_l3 = PBN(2048,
num_classes,
do_reduction=True,
num_reduction=256)
# part2 branch
self.bottleneck3 = Bottleneck(2048, 512)
self.bt4 = Bottleneck(2048, 512)
self.bt5 = Bottleneck(2048, 512)
self.bt6 = Bottleneck(2048, 512)
self.PBN_l4 = PBN(2048,
num_classes,
do_reduction=True,
num_reduction=256)
self.PBN_l5 = PBN(2048,
num_classes,
do_reduction=True,
num_reduction=256)
self.PBN_l6 = PBN(2048,
num_classes,
do_reduction=True,
num_reduction=256)
def __init__(self):
super(MGN, self).__init__()
# num_classes = 767 # cuhk03
# num_classes = 702 # duke
num_classes = 751 # market
# num_classes = 1041 # msmt
feats = 256
#########################resnet50################################
resnet = resnet50(pretrained=True)
self.backbone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
resnet.layer3[0],
)
res_conv4 = nn.Sequential(*resnet.layer3[1:])
res_p_conv5 = nn.Sequential(
Bottleneck(1024,
512,
downsample=nn.Sequential(
nn.Conv2d(1024, 2048, 1, bias=False),
nn.BatchNorm2d(2048))), Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
self.p1 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.p2 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.p3 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.maxpool_zg_p1 = nn.AdaptiveMaxPool2d(
(1, 1)) # nn.MaxPool2d(kernel_size=(12, 4))
self.maxpool_h2 = nn.AdaptiveMaxPool2d((2, 1))
self.maxpool_h3 = nn.AdaptiveMaxPool2d((3, 1))
self.reduction_p1 = nn.Sequential(nn.Conv2d(2048, feats, 1,
bias=False),
nn.BatchNorm2d(feats)) # p1
self.reduction_p2 = nn.Sequential(nn.Conv2d(2048, feats, 1,
bias=False),
nn.BatchNorm2d(feats)) # p2
self.reduction_p2_s1 = nn.Sequential(
nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats)) # s2
self.reduction_p2_s2 = nn.Sequential(
nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats)) # s2
self.reduction_p2_c1 = nn.Sequential(
nn.Conv2d(1024, feats, 1, bias=False), nn.BatchNorm2d(feats)) # c2
self.reduction_p2_c2 = nn.Sequential(
nn.Conv2d(1024, feats, 1, bias=False), nn.BatchNorm2d(feats)) # c2
self.reduction_p3 = nn.Sequential(nn.Conv2d(2048, feats, 1,
bias=False),
nn.BatchNorm2d(feats)) # p3
self.reduction_p3_c1 = nn.Sequential(
nn.Conv2d(683, feats, 1, bias=False), nn.BatchNorm2d(feats)) # c3
self.reduction_p3_c2 = nn.Sequential(
nn.Conv2d(683, feats, 1, bias=False), nn.BatchNorm2d(feats)) # c3
self.reduction_p3_c3 = nn.Sequential(
nn.Conv2d(682, feats, 1, bias=False), nn.BatchNorm2d(feats)) # c3
self.reduction_p3_s1 = nn.Sequential(
nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats)) # s3
self.reduction_p3_s2 = nn.Sequential(
nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats)) # s3
self.reduction_p3_s3 = nn.Sequential(
nn.Conv2d(2048, feats, 1, bias=False), nn.BatchNorm2d(feats)) # s3
self._init_reduction(self.reduction_p1) # p1
self._init_reduction(self.reduction_p2) # p2
self._init_reduction(self.reduction_p2_s1)
self._init_reduction(self.reduction_p2_s2)
self._init_reduction(self.reduction_p2_c1)
self._init_reduction(self.reduction_p2_c2)
self._init_reduction(self.reduction_p3) # p3
self._init_reduction(self.reduction_p3_s1)
self._init_reduction(self.reduction_p3_s2)
self._init_reduction(self.reduction_p3_s3)
self._init_reduction(self.reduction_p3_c1)
self._init_reduction(self.reduction_p3_c2)
self._init_reduction(self.reduction_p3_c3)
self.fc_id_p1 = nn.Linear(feats, num_classes)
self.fc_id_p2 = nn.Linear(feats, num_classes)
self.fc_id_p2_s1 = nn.Linear(feats, num_classes)
self.fc_id_p2_s2 = nn.Linear(feats, num_classes)
self.fc_id_p2_c1 = nn.Linear(feats, num_classes)
self.fc_id_p2_c2 = nn.Linear(feats, num_classes)
self.fc_id_p3 = nn.Linear(feats, num_classes)
self.fc_id_p3_s1 = nn.Linear(feats, num_classes)
self.fc_id_p3_s2 = nn.Linear(feats, num_classes)
self.fc_id_p3_s3 = nn.Linear(feats, num_classes)
self.fc_id_p3_c1 = nn.Linear(feats, num_classes)
self.fc_id_p3_c2 = nn.Linear(feats, num_classes)
self.fc_id_p3_c3 = nn.Linear(feats, num_classes)
self._init_fc(self.fc_id_p1)
self._init_fc(self.fc_id_p2)
self._init_fc(self.fc_id_p2_s1)
self._init_fc(self.fc_id_p2_s2)
self._init_fc(self.fc_id_p2_c1)
self._init_fc(self.fc_id_p2_c2)
self._init_fc(self.fc_id_p3)
self._init_fc(self.fc_id_p3_s1)
self._init_fc(self.fc_id_p3_s2)
self._init_fc(self.fc_id_p3_s3)
self._init_fc(self.fc_id_p3_c1)
self._init_fc(self.fc_id_p3_c2)
self._init_fc(self.fc_id_p3_c3)
batch_size=batch_size,
num_workers=num_workers,
val_batch_size=batch_size,
pin_memory=True,
train_sampler="distributed",
val_sampler="distributed",
)
# Image denormalization function to plot predictions with images
img_denormalize = partial(denormalize, mean=mean, std=std)
# ##############################
# Setup Model
# ##############################
model = resnet50(pretrained=False)
# ##############################
# Setup Solver
# ##############################
num_epochs = 1
criterion = nn.CrossEntropyLoss()
le = len(train_loader)
base_lr = 0.1 * (batch_size * dist.get_world_size() / 256.0)
optimizer = optim.SGD(model.parameters(),
lr=base_lr,
momentum=0.9,
def get_architecture(arch: str,
dataset: str,
pytorch_pretrained: bool = False) -> torch.nn.Module:
""" Return a neural network (with random weights)
:param arch: the architecture - should be in the ARCHITECTURES list above
:param dataset: the dataset - should be in the datasets.DATASETS list
:return: a Pytorch module
"""
## ImageNet classifiers
if arch == "resnet18" and dataset == "imagenet":
model = torch.nn.DataParallel(
resnet18(pretrained=pytorch_pretrained)).cuda()
cudnn.benchmark = True
elif arch == "resnet34" and dataset == "imagenet":
model = torch.nn.DataParallel(
resnet34(pretrained=pytorch_pretrained)).cuda()
cudnn.benchmark = True
elif arch == "resnet50" and dataset == "imagenet":
model = torch.nn.DataParallel(
resnet50(pretrained=pytorch_pretrained)).cuda()
cudnn.benchmark = True
## Cifar classifiers
elif arch == "cifar_resnet20":
model = resnet_cifar(depth=20, num_classes=10).cuda()
elif arch == "cifar_resnet110":
model = resnet_cifar(depth=110, num_classes=10).cuda()
elif arch == "imagenet32_resnet110":
model = resnet_cifar(depth=110, num_classes=1000).cuda()
elif arch == "imagenet32_wrn":
model = WideResNet(depth=28, num_classes=1000, widen_factor=10).cuda()
# Cifar10 Models from https://github.com/kuangliu/pytorch-cifar
# The 14 models we use in the paper as surrogate models
elif arch == "cifar_wrn":
model = WideResNet(depth=28, num_classes=10, widen_factor=10).cuda()
elif arch == "cifar_wrn40":
model = WideResNet(depth=40, num_classes=10, widen_factor=10).cuda()
elif arch == "VGG16":
model = VGG('VGG16').cuda()
elif arch == "VGG19":
model = VGG('VGG19').cuda()
elif arch == "ResNet18":
model = ResNet18().cuda()
elif arch == "PreActResNet18":
model = PreActResNet18().cuda()
elif arch == "GoogLeNet":
model = GoogLeNet().cuda()
elif arch == "DenseNet121":
model = DenseNet121().cuda()
elif arch == "ResNeXt29_2x64d":
model = ResNeXt29_2x64d().cuda()
elif arch == "MobileNet":
model = MobileNet().cuda()
elif arch == "MobileNetV2":
model = MobileNetV2().cuda()
elif arch == "SENet18":
model = SENet18().cuda()
elif arch == "ShuffleNetV2":
model = ShuffleNetV2(1).cuda()
elif arch == "EfficientNetB0":
model = EfficientNetB0().cuda()
## Image Denoising Architectures
elif arch == "cifar_dncnn":
model = DnCNN(image_channels=3, depth=17, n_channels=64).cuda()
return model
elif arch == "cifar_dncnn_wide":
model = DnCNN(image_channels=3, depth=17, n_channels=128).cuda()
return model
elif arch == 'memnet':
model = MemNet(in_channels=3,
channels=64,
num_memblock=3,
num_resblock=6).cuda()
return model
elif arch == "imagenet_dncnn":
model = torch.nn.DataParallel(
DnCNN(image_channels=3, depth=17, n_channels=64)).cuda()
cudnn.benchmark = True
return model
elif arch == 'imagenet_memnet':
model = torch.nn.DataParallel(
MemNet(in_channels=3, channels=64, num_memblock=3,
num_resblock=6)).cuda()
cudnn.benchmark = True
return model
else:
raise Exception('Unknown architecture.')
normalize_layer = get_normalize_layer(dataset)
return torch.nn.Sequential(normalize_layer, model)
def __init__(self):
super(MGN, self).__init__()
num_classes = 1500
feats = 256
resnet = resnet50(pretrained=True)
self.backbone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1,
resnet.layer2,
resnet.layer3[0],
)
res_conv4 = nn.Sequential(*resnet.layer3[1:])
res_g_conv5 = resnet.layer4
res_p_conv5 = nn.Sequential(
Bottleneck(1024,
512,
downsample=nn.Sequential(
nn.Conv2d(1024, 2048, 1, bias=False),
nn.BatchNorm2d(2048))), Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
self.p1 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_g_conv5))
self.p2 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.p3 = nn.Sequential(copy.deepcopy(res_conv4),
copy.deepcopy(res_p_conv5))
self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(12, 4))
self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8))
self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8))
self.reduction = nn.Sequential(nn.Conv2d(2048, feats, 1, bias=False),
nn.BatchNorm2d(feats), nn.ReLU())
self._init_reduction(self.reduction)
self.fc_id_2048_0 = nn.Linear(feats, num_classes)
self.fc_id_2048_1 = nn.Linear(feats, num_classes)
self.fc_id_2048_2 = nn.Linear(feats, num_classes)
self.fc_id_256_1_0 = nn.Linear(feats, num_classes)
self.fc_id_256_1_1 = nn.Linear(feats, num_classes)
self.fc_id_256_2_0 = nn.Linear(feats, num_classes)
self.fc_id_256_2_1 = nn.Linear(feats, num_classes)
self.fc_id_256_2_2 = nn.Linear(feats, num_classes)
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
self.attention = CALayer(2048)
self.attention2 = SpatialAttn()
self.num = 1
def __init__(self, num_classes):
super(MGN, self).__init__()
resnet = resnet50(pretrained=True)
# backbone
self.backbone = nn.Sequential(
resnet.conv1,
resnet.bn1,
resnet.relu,
resnet.maxpool,
resnet.layer1, # res_conv2
resnet.layer2, # res_conv3
resnet.layer3[0], # res_conv4_1
)
# 3. Multiple Granularity Network 3.1. Network Architecture: The difference is that we employ no down-sampling
# operations in res_conv5_1 block.
# res_conv4x
res_conv4 = nn.Sequential(*resnet.layer3[1:])
# res_conv5 global
res_g_conv5 = resnet.layer4
# res_conv5 part
res_p_conv5 = nn.Sequential(
Bottleneck(1024, 512, downsample=nn.Sequential(nn.Conv2d(1024, 2048, 1, bias=False), nn.BatchNorm2d(2048))),
Bottleneck(2048, 512),
Bottleneck(2048, 512))
res_p_conv5.load_state_dict(resnet.layer4.state_dict())
# mgn part-1 global
self.p1 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_g_conv5))
# mgn part-2
self.p2 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5))
# mgn part-3
self.p3 = nn.Sequential(copy.deepcopy(res_conv4), copy.deepcopy(res_p_conv5))
# global max pooling
self.maxpool_zg_p1 = nn.MaxPool2d(kernel_size=(12, 4))
self.maxpool_zg_p2 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zg_p3 = nn.MaxPool2d(kernel_size=(24, 8))
self.maxpool_zp2 = nn.MaxPool2d(kernel_size=(12, 8))
self.maxpool_zp3 = nn.MaxPool2d(kernel_size=(8, 8))
# Figure 3: Notice that the 1 × 1 convolutions for dimension reduction and fully connected layers for identity
# prediction in each branch DO NOT share weights with each other.
# 4. Experiment 4.1 Implementation: Notice that different branches in the network are all initialized with the
# same pretrained weights of the corresponding layers after the res conv4 1 block.
# conv1 reduce
reduction = nn.Sequential(nn.Conv2d(2048, 256, 1, bias=False), nn.BatchNorm2d(256), nn.ReLU())
self._init_reduction(reduction)
self.reduction_0 = copy.deepcopy(reduction)
self.reduction_1 = copy.deepcopy(reduction)
self.reduction_2 = copy.deepcopy(reduction)
self.reduction_3 = copy.deepcopy(reduction)
self.reduction_4 = copy.deepcopy(reduction)
self.reduction_5 = copy.deepcopy(reduction)
self.reduction_6 = copy.deepcopy(reduction)
self.reduction_7 = copy.deepcopy(reduction)
# fc softmax loss
self.fc_id_2048_0 = nn.Linear(2048, num_classes)
self.fc_id_2048_1 = nn.Linear(2048, num_classes)
self.fc_id_2048_2 = nn.Linear(2048, num_classes)
self.fc_id_256_1_0 = nn.Linear(256, num_classes)
self.fc_id_256_1_1 = nn.Linear(256, num_classes)
self.fc_id_256_2_0 = nn.Linear(256, num_classes)
self.fc_id_256_2_1 = nn.Linear(256, num_classes)
self.fc_id_256_2_2 = nn.Linear(256, num_classes)
self._init_fc(self.fc_id_2048_0)
self._init_fc(self.fc_id_2048_1)
self._init_fc(self.fc_id_2048_2)
self._init_fc(self.fc_id_256_1_0)
self._init_fc(self.fc_id_256_1_1)
self._init_fc(self.fc_id_256_2_0)
self._init_fc(self.fc_id_256_2_1)
self._init_fc(self.fc_id_256_2_2)
# Optional config param: if set evaluation on train_eval_dataloader is run
train_eval_dataloader = get_basic_dataloader("train",
batch_size,
num_workers,
device=device,
data_augs=val_data_augs)
# Optional config param: if set evaluation on val_dataloader is run
val_dataloader = get_basic_dataloader("test",
batch_size,
num_workers,
device=device,
data_augs=val_data_augs)
# Required config param
model = resnet50(pretrained=False, num_classes=10)
model.avgpool = nn.AdaptiveAvgPool2d(1)
# Required config param
optimizer = optim.SGD(model.parameters(), lr=0.01)
# Required config param
criterion = nn.CrossEntropyLoss()
# Required config param
num_epochs = 50
# Optional config param
metrics = {
"precision": Precision(average=True),
"recall": Recall(average=True),
