def __init__(self, mode=None, backbone='vgg16'):
super().__init__()
self.mode = mode
if self.mode == 'nlt':
if backbone == 'vgg16':
print('backbone is vgg16')
self.encoder = vgg16(nlt=True)
self.decoder = decoder(feature_channel=512, nlt=True)
elif backbone == 'ResNet50':
print('backbone is ResNet50')
self.encoder = ResNet50(nlt=True)
self.encoder.load_state_dict(torch.load(
'/media/D/ht/PyTorch_Pretrained/resnet50-19c8e357.pth'),
strict=False)
self.decoder = decoder(feature_channel=1024, nlt=True)
else:
if backbone == 'vgg16':
self.encoder = vgg16(pretrained=True, nlt=False)
self.decoder = decoder(feature_channel=512)
elif backbone == 'ResNet50':
self.encoder = ResNet50(nlt=False)
self.encoder.load_state_dict(torch.load(
'/media/D/ht/PyTorch_Pretrained/resnet50-19c8e357.pth'),
strict=False)
self.decoder = decoder(feature_channel=1024, nlt=False)
def get_model(train_model):
if train_model == 'resnet18':
return resnet.resnet18()
elif train_model == 'resnet34':
return resnet.resnet34()
elif train_model == 'resnet50':
return resnet.resnet50()
elif train_model == 'resnet101':
return resnet.resnet101()
elif train_model == 'resnet152':
return resnet.resnet152()
elif train_model == 'resnet18_copy':
return resnet_copy.resnet18()
elif train_model == 'resnet34_copy':
return resnet_copy.resnet34()
elif train_model == 'resnet50_copy':
return resnet_copy.resnet50()
elif train_model == 'resnet101_copy':
return resnet_copy.resnet101()
elif train_model == 'resnet152':
return resnet_copy.resnet152()
elif train_model == 'vgg11':
return vgg11()
elif train_model == 'vgg13':
return vgg13()
elif train_model == 'vgg16':
return vgg16()
elif train_model == 'vgg19':
return vgg19()
elif train_model == 'nin':
return nin()
elif train_model == 'googlenet':
return googlenet()
def get_model(args):
model = vgg.vgg16(pretrained=True,
num_classes=args.num_classes,
att_dir=args.att_dir,
training_epoch=args.epoch)
model = torch.nn.DataParallel(model).cuda()
param_groups = model.module.get_parameter_groups()
optimizer = optim.SGD([{
'params': param_groups[0],
'lr': args.lr
}, {
'params': param_groups[1],
'lr': 2 * args.lr
}, {
'params': param_groups[2],
'lr': 10 * args.lr
}, {
'params': param_groups[3],
'lr': 20 * args.lr
}],
momentum=0.9,
weight_decay=args.weight_decay,
nesterov=True)
return model, optimizer
def __init__(self, opt):
self.opt = opt
self.device = torch.device(
'cuda:0' if torch.cuda.is_available() else 'cpu')
if opt.net == 'vgg':
self.net = vgg.vgg16(num_classes=opt.n_classes)
elif opt.net == 'normal':
self.net = Net(num_classes=opt.n_classes)
elif opt.net == 'att':
self.net = AttNet(num_classes=opt.n_classes)
elif opt.net == 'vgg_att':
self.net = VGGAttNet(num_classes=opt.n_classes)
else:
raise ValueError('[%s] cannot be used!' % opt.net)
self.net = self.net.to(self.device)
if not opt.is_train:
self.load_network(self.opt.which_epoch)
else:
if self.opt.resume_train:
self.load_network(self.opt.which_epoch)
self.cls_criterion = nn.CrossEntropyLoss()
if opt.training_type == 'att_consist':
self.mask_criterion = nn.MSELoss()
self.optimizer = optim.SGD(self.net.parameters(),
lr=0.001,
momentum=0.9)
def _get_vgg16(self, pretrained=True):
model = vgg16(pretrained=pretrained)
model.classifier[6] = nn.Linear(in_features=4096,
out_features=125,
bias=True)
return model
def __init__(self, opt):
super(FeatureLoss, self).__init__()
self.opt = opt
self.isTrain = opt.isTrain
self.vgg = VGG.vgg16(pretrained = True)
self.Tensor = torch.cuda.FloatTensor if use_gpu else torch.Tensor
self.input_A = self.Tensor(opt.batchSize, opt.input_nc, opt.fineSize, opt.fineSize)
self.input_B = self.Tensor(opt.batchSize, opt.output_nc, opt.fineSize, opt.fineSize)
# Assuming norm_type = batch
norm_layer = functools.partial(nn.BatchNorm2d, affine=True)
# model of Generator Net is unet_256
self.GeneratorNet = Generator(opt.input_nc, opt.output_nc, 8, opt.ngf, norm_layer=norm_layer,use_dropout = not opt.no_dropout)
if use_gpu:
self.GeneratorNet.cuda(0)
self.GeneratorNet.apply(init_weights)
if self.isTrain:
use_sigmoid = opt.no_lsgan
# model of Discriminator Net is basic
self.DiscriminatorNet = Discriminator(opt.input_nc+ opt.output_nc, opt.ndf, n_layers = 3, norm_layer = norm_layer, use_sigmoid = use_sigmoid)
if use_gpu:
self.DiscriminatorNet.cuda(0)
self.DiscriminatorNet.apply(init_weights)
if not self.isTrain or opt.continue_train:
self.load_network(self.GeneratorNet, 'Generator', opt.which_epoch)
if self.isTrain:
self.load_network(self.DiscriminatorNet, 'Discriminator', opt.which_epoch)
if self.isTrain:
self.fake_AB_pool = ImagePool(opt.pool_size)
self.learning_rate = opt.lr
# defining loss functions
self.criterionGAN = GANLoss(use_lsgan = not opt.no_lsgan, tensor=self.Tensor)
self.criterionL1 = torch.nn.L1Loss()
self.criterionFV = loss_FV.FeatureVectorLoss()
self.MySchedulers = [] # initialising schedulers
self.MyOptimizers = [] # initialising optimizers
self.generator_optimizer = torch.optim.Adam(self.GeneratorNet.parameters(), lr=self.learning_rate, betas = (opt.beta1, 0.999))
self.discriminator_optimizer = torch.optim.Adam(self.DiscriminatorNet.parameters(), lr=self.learning_rate, betas = (opt.beta1, 0.999))
self.MyOptimizers.append(self.generator_optimizer)
self.MyOptimizers.append(self.discriminator_optimizer)
def lambda_rule(epoch):
lr_l = 1.0 - max(0, epoch - opt.niter)/float(opt.niter_decay+1)
return lr_l
for optimizer in self.MyOptimizers:
self.MySchedulers.append(lr_scheduler.LambdaLR(optimizer, lr_lambda = lambda_rule))
# assuming opt.lr_policy == 'lambda'
print('<============ NETWORKS INITIATED ============>')
print_net(self.GeneratorNet)
if self.isTrain:
print_net(self.DiscriminatorNet)
print('<=============================================>')
def get_network(args):
if args.net == 'vgg16':
from models.vgg import vgg16
model_ft = vgg16(args.num_classes, export_onnx=args.export_onnx)
elif args.net == 'alexnet':
from models.alexnet import alexnet
model_ft = alexnet(num_classes=args.num_classes,
export_onnx=args.export_onnx)
elif args.net == 'mobilenet':
from models.mobilenet import mobilenet_v2
model_ft = mobilenet_v2(pretrained=True, export_onnx=args.export_onnx)
elif args.net == 'vgg19':
from models.vgg import vgg19
model_ft = vgg19(args.num_classes, export_onnx=args.export_onnx)
else:
if args.net == 'googlenet':
from models.googlenet import googlenet
model_ft = googlenet(pretrained=True)
elif args.net == 'inception':
from models.inception import inception_v3
model_ft = inception_v3(args,
pretrained=True,
export_onnx=args.export_onnx)
elif args.net == 'resnet18':
from models.resnet import resnet18
model_ft = resnet18(pretrained=True, export_onnx=args.export_onnx)
elif args.net == 'resnet34':
from models.resnet import resnet34
model_ft = resnet34(pretrained=True, export_onnx=args.export_onnx)
elif args.net == 'resnet101':
from models.resnet import resnet101
model_ft = resnet101(pretrained=True, export_onnx=args.export_onnx)
elif args.net == 'resnet50':
from models.resnet import resnet50
model_ft = resnet50(pretrained=True, export_onnx=args.export_onnx)
elif args.net == 'resnet152':
from models.resnet import resnet152
model_ft = resnet152(pretrained=True, export_onnx=args.export_onnx)
else:
print("The %s is not supported..." % (args.net))
return
if args.net == 'mobilenet':
num_ftrs = model_ft.classifier[1].in_features
model_ft.classifier[1] = nn.Linear(num_ftrs * 4, args.num_classes)
else:
num_ftrs = model_ft.fc.in_features
model_ft.fc = nn.Linear(num_ftrs, args.num_classes)
net = model_ft
return net
def get_network(args,cfg):
""" return given network
"""
# pdb.set_trace()
if args.net == 'lenet5':
net = LeNet5().cuda()
elif args.net == 'alexnet':
net = alexnet(pretrained=args.pretrain, num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg16':
net = vgg16(pretrained=args.pretrain, num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg13':
net = vgg13(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg11':
net = vgg11(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg19':
net = vgg19(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg16_bn':
net = vgg16_bn(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg13_bn':
net = vgg13_bn(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg11_bn':
net = vgg11_bn(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'vgg19_bn':
net = vgg19_bn(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net =='inceptionv3':
net = inception_v3().cuda()
# elif args.net == 'inceptionv4':
# net = inceptionv4().cuda()
# elif args.net == 'inceptionresnetv2':
# net = inception_resnet_v2().cuda()
elif args.net == 'resnet18':
net = resnet18(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda(args.gpuid)
elif args.net == 'resnet34':
net = resnet34(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'resnet50':
net = resnet50(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda(args.gpuid)
elif args.net == 'resnet101':
net = resnet101(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'resnet152':
net = resnet152(pretrained=args.pretrain,num_classes=cfg.PARA.train.num_classes).cuda()
elif args.net == 'squeezenet':
net = squeezenet1_0().cuda()
else:
print('the network name you have entered is not supported yet')
sys.exit()
return net
def __init__(self,
rnn_dim,
embed_dim,
embed_matrix: np.array = None,
vgg_layer='fc2'):
self.coco = COCODataset()
self.vgg = vgg16(path=os.path.join(CONFIG.COCO_PATH,
'vgg16_weights.npz'),
from_tf_check_point=False)
self.vgg_feature_name = vgg_layer
self.cnn_dim = self.vgg.get_layer_shape(
self.vgg_feature_name).as_list()[-1]
# self.cnn_dim = 512
self.word_to_idx = self.coco.word_to_idx
self.idx_to_word = self.coco.idx_to_word
self.vocab_size = CONFIG.VOCAB_SIZE
self.null_idx = self.word_to_idx['<NULL>']
self.start_idx = self.word_to_idx['<START>']
self.end_idx = self.word_to_idx['<END>']
self.embed_dim = embed_dim
self.rnn_dim = rnn_dim
self.embed_matrix = embed_matrix
# Suppose the caption is :
# <START> i play basketball ... as Klay <END> # length 17
# Then the input is
# <START> i play basketball ... as Klay # length 16
# And the desired output is
# i play basketball ... as Klay <END> # length
# If the caption is padded with <NULL>, then <NULL> is not accounted in loss function,
# thus we need a mask too indicate the <NULL> token
self.time_span = CONFIG.TIME_SPAN - 1
self.params = {}
self.graph = tf.Graph()
self.sess = tf.Session(graph=self.graph)
with self.graph.as_default():
with tf.name_scope('Captioning'):
self.setup()
self.build_graph()
def train_without_augmentation_ck():
model = vgg16()
(X_train, Y_train), (X_test, Y_test), (X_validation, Y_validation) = ck()
if load_weights:
model.load_weights('model_vgg_16_ck.h5')
history = model.fit(X_train,
Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
validation_data=(X_validation, Y_validation),
shuffle=True)
predictions = model.predict(X_test, batch_size=batch_size, verbose=1)
evaluates = model.evaluate(X_test, Y_test)
historic(history)
confusion_matrix(predictions, Y_test)
if save_weights:
model.save_weights('model_vgg_16_ck.h5')
def get_network(args):
""" return given network
"""
if args.task == 'cifar10':
nclass = 10
elif args.task == 'cifar100':
nclass = 100
#Yang added none bn vggs
if args.net == 'vgg11':
from models.vgg import vgg11
net = vgg11(num_classes=nclass)
elif args.net == 'vgg13':
from models.vgg import vgg13
net = vgg13(num_classes=nclass)
elif args.net == 'vgg16':
from models.vgg import vgg16
net = vgg16(num_classes=nclass)
elif args.net == 'vgg19':
from models.vgg import vgg19
net = vgg19(num_classes=nclass)
elif args.net == 'resnet18':
from models.resnet import resnet18
net = resnet18(num_classes=nclass)
elif args.net == 'resnet34':
from models.resnet import resnet34
net = resnet34(num_classes=nclass)
elif args.net == 'resnet50':
from models.resnet import resnet50
net = resnet50(num_classes=nclass)
elif args.net == 'resnet101':
from models.resnet import resnet101
net = resnet101(num_classes=nclass)
elif args.net == 'resnet152':
from models.resnet import resnet152
net = resnet152(num_classes=nclass)
else:
print('the network name you have entered is not supported yet')
sys.exit()
if args.gpu: #use_gpu
net = net.cuda()
return net
def get_model(args):
model = vgg.vgg16(num_classes=args.num_classes)
model = torch.nn.DataParallel(model).cuda()
pretrained_dict = torch.load(args.restore_from)['state_dict']
model_dict = model.state_dict()
print(model_dict.keys())
print(pretrained_dict.keys())
pretrained_dict = {k: v for k, v in pretrained_dict.items() if k in model_dict.keys()}
print("Weights cannot be loaded:")
print([k for k in model_dict.keys() if k not in pretrained_dict.keys()])
model_dict.update(pretrained_dict)
model.load_state_dict(model_dict)
return model
def train_without_augmentation():
model = vgg16(lr=0.0001, dropout_in=0.25, dropout_out=0.5)
(X_train, Y_train), (X_test, Y_test), (X_validation,
Y_validation) = fer2013()
if load_weights:
model.load_weights('model_vgg_16_eq.h5')
history = model.fit(X_train,
Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
validation_data=(X_validation, Y_validation),
shuffle=True)
if save_weights:
model.save_weights('vgg16_fer2013_np.h5')
predictions = model.predict(X_test, batch_size=batch_size, verbose=1)
evaluates = model.evaluate(X_test, Y_test)
historic(history)
confusion_matrix(predictions, Y_test)
def main():
args = parse_args()
use_cuda = not args.cpu and torch.cuda.is_available()
device = torch.device(f"cuda:{args.gpu}" if use_cuda else "cpu")
torch.manual_seed(args.seed)
trainset, testset, trainloader, testloader = stl10(args.batch_size)
model = vgg.vgg16(not args.deterministic, device, False).to(device)
saved_state = torch.load(args.saved_model)
if args.saved_model[-4:] == '.tar':
saved_state = saved_state['model_state_dict']
model.load_state_dict(saved_state)
criterion = torch.nn.CrossEntropyLoss()
test_loss, pct_right = test(args, model, device, testloader, criterion, 10)
print(f'test loss: {test_loss}, correct: {100*pct_right}')
def get_network(args):
if args.net == 'vgg16':
from models.vgg import vgg16
net = vgg16()
elif args.net == 'vgg11':
from models.vgg import vgg11
net = vgg11()
elif args.net == 'vgg13':
from models.vgg import vgg13
net = vgg13()
elif args.net == 'vgg19':
from models.vgg import vgg19
net = vgg19()
return net
def prune_vgg(num_classes: int,
model,
pruning_strategy,
cuda=True,
dataparallel=False):
cfg, cfg_mask = _calculate_channel_mask(model, pruning_strategy, cuda=cuda)
if isinstance(model.classifier, nn.Sequential):
pruned_model = vgg16_linear(num_classes=num_classes, cfg=cfg)
elif isinstance(model.classifier, nn.Linear):
pruned_model = vgg16(num_classes=num_classes, cfg=cfg)
if cuda:
pruned_model.cuda()
if dataparallel:
pruned_model.feature = torch.nn.DataParallel(pruned_model.feature)
assign_model(model, pruned_model, cfg_mask)
return pruned_model, cfg
pass
def test_forward_pass_vgg16(self):
# This is not really a test. Just printing out chapes of tensors.
# Input shape in SSD paper (300x300) is different from VGG paper (224x224)
# Here we'll find dimensions of output of each layer of VGG-16 and compare with architecture in SSD paper
# Turns out, SSD paper expects base model output shape 512x38x38 while VGG-16 from torchvision
# outputs 512x37x37 on the same input size.
# MaxPool2d layer reduces the output dimension if the input dimension is odd/
batch_size = 4
num_channels = 3
image_size = (300, 300)
base_model = vgg16(pretrained=True)
input = torch.zeros((batch_size, num_channels, image_size[0], image_size[1]), dtype=torch.float32)
x = input
for f in list(base_model.features.modules())[1:]:
x = f(x)
print(f)
print(x.shape)
def get_model(model_type, use_gpu):
if model_type == 'vgg16':
from models.vgg import vgg16
model = vgg16()
elif model_type == 'resnet50':
from models.resnet import resnet50
model = resnet50()
elif model_type == 'resnet18':
from models.resnet import resnet18
model = resnet18()
elif model_type == 'googlenet':
from models.googlenet import googlenet
model = googlenet()
else:
print('this model is not supported')
sys.exit()
if use_gpu:
model = model.cuda()
return model
def train_with_augmentation_ck():
datagen = ImageDataGenerator(rotation_range=10., horizontal_flip=True)
model = vgg16(lr=0.00005)
(X_train, Y_train), (X_test, Y_test), (X_validation, Y_validation) = ck()
if load_weights:
model.load_weights('model_vgg_16_eq.h5')
history = model.fit_generator(datagen.flow(X_train,
Y_train,
batch_size=batch_size),
samples_per_epoch=2000,
nb_epoch=nb_epoch,
validation_data=(X_validation, Y_validation))
predictions = model.predict(X_test, batch_size=batch_size, verbose=1)
historic(history)
confusion_matrix(predictions, Y_test)
if save_weights:
model.save_weights('model_vgg_16_ft_ck.h5')
def get_model(args):
model = vgg16(pretrained=True, delta=args.delta)
model = torch.nn.DataParallel(model).cuda()
param_groups = model.module.get_parameter_groups()
optimizer = optim.SGD([{
'params': param_groups[0],
'lr': args.lr
}, {
'params': param_groups[1],
'lr': 2 * args.lr
}, {
'params': param_groups[2],
'lr': 10 * args.lr
}, {
'params': param_groups[3],
'lr': 20 * args.lr
}],
momentum=0.9,
weight_decay=args.weight_decay,
nesterov=True)
return model, optimizer
def main_worker(gpu, ngpus_per_node, args):
global best_acc1
args.gpu = gpu
if args.gpu is not None:
print('Use GPU: {} for training'.format(args.gpu))
if args.distributed:
if args.dist_url == 'env://' and args.rank == -1:
args.rank = int(os.environ['RANK'])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group( #需要nccl、url、节点数、gpu的总数
backend=args.dist_backend,
init_method=args.dist_url,
world_size=args.world_size,
rank=args.rank,
)
# create model
print(
"=> rank_id '{}', world_size '{}'".format(args.rank,
args.world_size), )
print("=> creating model '{}'".format(args.model))
if args.model == 'resnet50':
model = resnet50()
elif args.model == 'vgg16':
model = vgg16()
else:
raise ValueError("Only support resnet50 and vgg16.")
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
# args.batch_size = int(args.batch_size / ngpus_per_node)
# args.workers = int(args.workers / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(
model,
device_ids=[args.gpu],
)
else:
model.cuda()
# DistributedDataParallel will divide and allocate
# batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
else:
# DataParallel will divide and allocate batch_size
# to all available GPUs
if args.model.startswith('alexnet') or args.model.startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
# optimizer = get_optimizer(model, params, args.lr)
optimizer = torch.optim.SGD(
model.parameters(),
lr=args.lr,
momentum=args.momentum,
nesterov=False,
)
cudnn.benchmark = True #将cudnn.benchmark设置为true，可显著提升速度
# Data loading code
train_dir = os.path.join(args.data_dir, 'train')
# valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(
mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225],
)
train_dataset = datasets.ImageFolder(
train_dir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]),
)
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset, )
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
num_workers=args.workers,
pin_memory=True,
sampler=train_sampler,
)
# val_loader = torch.utils.data.DataLoader(
# datasets.ImageFolder(valdir, transforms.Compose([
# transforms.Resize(256),
# transforms.CenterCrop(224),
# transforms.ToTensor(),
# normalize,
# ])),
# batch_size=args.batch_size, shuffle=False,
# num_workers=args.workers, pin_memory=True)
# if args.evaluate:
# validate(val_loader, model, criterion, args)
# return
for epoch in range(args.num_epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
def get_model(args, model_path=None):
"""
:param args: super arguments
:param model_path: if not None, load already trained model parameters.
:return: model
"""
if args.scratch: # train model from scratch
pretrained = False
model_dir = None
print("=> Loading model '{}' from scratch...".format(args.model))
else: # train model with pretrained model
pretrained = True
model_dir = os.path.join(args.root_path, args.pretrained_models_path)
print("=> Loading pretrained model '{}'...".format(args.model))
if args.model.startswith('resnet'):
if args.model == 'resnet18':
model = resnet18(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'resnet34':
model = resnet34(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'resnet50':
model = resnet50(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'resnet101':
model = resnet101(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'resnet152':
model = resnet152(pretrained=pretrained, model_dir=model_dir)
model.fc = nn.Linear(model.fc.in_features, args.num_classes)
elif args.model.startswith('vgg'):
if args.model == 'vgg11':
model = vgg11(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'vgg11_bn':
model = vgg11_bn(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'vgg13':
model = vgg13(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'vgg13_bn':
model = vgg13_bn(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'vgg16':
model = vgg16(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'vgg16_bn':
model = vgg16_bn(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'vgg19':
model = vgg19(pretrained=pretrained, model_dir=model_dir)
elif args.model == 'vgg19_bn':
model = vgg19_bn(pretrained=pretrained, model_dir=model_dir)
model.classifier[6] = nn.Linear(model.classifier[6].in_features, args.num_classes)
elif args.model == 'alexnet':
model = alexnet(pretrained=pretrained, model_dir=model_dir)
model.classifier[6] = nn.Linear(model.classifier[6].in_features, args.num_classes)
# Load already trained model parameters and go on training
if model_path is not None:
checkpoint = torch.load(model_path)
model.load_state_dict(checkpoint['model'])
return model
import argparse
from utils import load_data
WIN_SIZE = 40
NUM_CLS = 2
parser = argparse.ArgumentParser()
parser.add_argument("--test_map_path", type=str)
parser.add_argument("--pred_path", type=str)
parser.add_argument("--model_path", type=str)
args = parser.parse_args()
TEST_MAP_PATH = args.test_map_path
PRED_PATH = args.pred_path
STRIDE = 20
model = vgg16()
model.load_weights(args.model_path)
test_data, img_names = load_data.load_all_data(MAP_PATH,
'',
WIN_SIZE,
20,
flip=False)
test_data = preprocess_input(test_data.astype('float64'))
pred = model.predict(test_data)
map_img = cv2.imread(MAP_PATH)
res = np.zeros((map_img.shape[0], map_img.shape[1]))
for i in range(pred.shape[0]):
if pred[i, 0] > 0.99:
idx = img_names[i].split('_')
print("Length of validation set: ", len(valset))
train_loader = DataLoader(trainset,
batch_size=batch_size,
shuffle=True,
num_workers=4)
val_loader = DataLoader(valset,
batch_size=batch_size,
shuffle=True,
num_workers=4)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model_name = args.backbone
if model_name == "vgg16":
model = vgg16(architecture_type="cam",
pretrained=True,
num_classes=n_classes,
large_feature_map=False)
elif model_name == "resnet18":
model = resnet18('cam', num_classes=n_classes)
elif model_name == "squeezenet1_1":
model = squeezenet1_1(num_classes=n_classes)
print(model)
checkpoint = torch.load(args.checkpoint_path, map_location=torch.device('cpu'))
model.load_state_dict(checkpoint)
root = args.dataset_path + 'val/'
masks_root = args.masks_path
import glob
filename = [
glob.glob(root + i + "/*.jpg") for i in object_categories
def get_model(class_num):
if (MODEL_TYPE == 'alexnet'):
model = alexnet.alexnet(pretrained=FINETUNE)
elif (MODEL_TYPE == 'vgg'):
if (MODEL_DEPTH_OR_VERSION == 11):
model = vgg.vgg11(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 13):
model = vgg.vgg13(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 16):
model = vgg.vgg16(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 19):
model = vgg.vgg19(pretrained=FINETUNE)
else:
print('Error : VGG should have depth of either [11, 13, 16, 19]')
sys.exit(1)
elif (MODEL_TYPE == 'squeezenet'):
if (MODEL_DEPTH_OR_VERSION == 0 or MODEL_DEPTH_OR_VERSION == 'v0'):
model = squeezenet.squeezenet1_0(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 1 or MODEL_DEPTH_OR_VERSION == 'v1'):
model = squeezenet.squeezenet1_1(pretrained=FINETUNE)
else:
print('Error : Squeezenet should have version of either [0, 1]')
sys.exit(1)
elif (MODEL_TYPE == 'resnet'):
if (MODEL_DEPTH_OR_VERSION == 18):
model = resnet.resnet18(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 34):
model = resnet.resnet34(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 50):
model = resnet.resnet50(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 101):
model = resnet.resnet101(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 152):
model = resnet.resnet152(pretrained=FINETUNE)
else:
print(
'Error : Resnet should have depth of either [18, 34, 50, 101, 152]'
)
sys.exit(1)
elif (MODEL_TYPE == 'densenet'):
if (MODEL_DEPTH_OR_VERSION == 121):
model = densenet.densenet121(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 169):
model = densenet.densenet169(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 161):
model = densenet.densenet161(pretrained=FINETUNE)
elif (MODEL_DEPTH_OR_VERSION == 201):
model = densenet.densenet201(pretrained=FINETUNE)
else:
print(
'Error : Densenet should have depth of either [121, 169, 161, 201]'
)
sys.exit(1)
elif (MODEL_TYPE == 'inception'):
if (MODEL_DEPTH_OR_VERSION == 3 or MODEL_DEPTH_OR_VERSION == 'v3'):
model = inception.inception_v3(pretrained=FINETUNE)
else:
print('Error : Inception should have version of either [3, ]')
sys.exit(1)
else:
print(
'Error : Network should be either [alexnet / squeezenet / vgg / resnet / densenet / inception]'
)
sys.exit(1)
if (MODEL_TYPE == 'alexnet' or MODEL_TYPE == 'vgg'):
num_ftrs = model.classifier[6].in_features
feature_model = list(model.classifier.children())
feature_model.pop()
feature_model.append(nn.Linear(num_ftrs, class_num))
model.classifier = nn.Sequential(*feature_model)
elif (MODEL_TYPE == 'resnet' or MODEL_TYPE == 'inception'):
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, class_num)
elif (MODEL_TYPE == 'densenet'):
num_ftrs = model.classifier.in_features
model.classifier = nn.Linear(num_ftrs, class_num)
return model
shuffle=True,
num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=True,
transform=transform)
testloader = torch.utils.data.DataLoader(testset,
batch_size=4,
shuffle=False,
num_workers=2)
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse',
'ship', 'truck')
net = vgg.vgg16(deformable=deform, num_classes=10)
PATH = './cifar_net2.pth' if deform else './cifar_net.pth'
net.load_state_dict(torch.load(PATH))
net.to(device)
correct = 0
total = 0
with torch.no_grad():
for data in testloader:
images, labels = data[0].to(device), data[1].to(device)
outputs = net(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
def __init__(self):
super(FeatureVectorLoss, self).__init__()
self.loss = nn.L1Loss()
self.model = VGG.vgg16()
def main():
global args, best_err1
args = parser.parse_args()
# TensorBoard configure
if args.tensorboard:
configure('%s_checkpoints/%s'%(args.dataset, args.expname))
# CUDA
os.environ['CUDA_DEVICE_ORDER'] = "PCI_BUS_ID"
os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_ids)
if torch.cuda.is_available():
cudnn.benchmark = True # https://discuss.pytorch.org/t/what-does-torch-backends-cudnn-benchmark-do/5936
kwargs = {'num_workers': 2, 'pin_memory': True}
else:
kwargs = {'num_workers': 2}
# Data loading code
if args.dataset == 'cifar10':
normalize = transforms.Normalize(mean=[0.4914, 0.4822, 0.4465],
std=[0.2023, 0.1994, 0.2010])
elif args.dataset == 'cifar100':
normalize = transforms.Normalize(mean=[0.5071, 0.4865, 0.4409],
std=[0.2634, 0.2528, 0.2719])
elif args.dataset == 'cub':
normalize = transforms.Normalize(mean=[0.4862, 0.4973, 0.4293],
std=[0.2230, 0.2185, 0.2472])
elif args.dataset == 'webvision':
normalize = transforms.Normalize(mean=[0.49274242, 0.46481857, 0.41779366],
std=[0.26831809, 0.26145372, 0.27042758])
else:
raise Exception('Unknown dataset: {}'.format(args.dataset))
# Transforms
if args.augment:
train_transform = transforms.Compose([
transforms.RandomResizedCrop(args.train_image_size),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
else:
train_transform = transforms.Compose([
transforms.RandomResizedCrop(args.train_image_size),
transforms.ToTensor(),
normalize,
])
val_transform = transforms.Compose([
transforms.Resize(args.test_image_size),
transforms.CenterCrop(args.test_crop_image_size),
transforms.ToTensor(),
normalize
])
# Datasets
num_classes = 10 # default 10 classes
if args.dataset == 'cifar10':
train_dataset = datasets.CIFAR10('./data/', train=True, download=True, transform=train_transform)
val_dataset = datasets.CIFAR10('./data/', train=False, download=True, transform=val_transform)
num_classes = 10
elif args.dataset == 'cifar100':
train_dataset = datasets.CIFAR100('./data/', train=True, download=True, transform=train_transform)
val_dataset = datasets.CIFAR100('./data/', train=False, download=True, transform=val_transform)
num_classes = 100
elif args.dataset == 'cub':
train_dataset = datasets.ImageFolder('/media/ouc/30bd7817-d3a1-4e83-b7d9-5c0e373ae434/DuAngAng/datasets/CUB-200-2011/train/',
transform=train_transform)
val_dataset = datasets.ImageFolder('/media/ouc/30bd7817-d3a1-4e83-b7d9-5c0e373ae434/DuAngAng/datasets/CUB-200-2011/test/',
transform=val_transform)
num_classes = 200
elif args.dataset == 'webvision':
train_dataset = datasets.ImageFolder('/media/ouc/30bd7817-d3a1-4e83-b7d9-5c0e373ae434/LiuJing/WebVision/info/train',
transform=train_transform)
val_dataset = datasets.ImageFolder('/media/ouc/30bd7817-d3a1-4e83-b7d9-5c0e373ae434/LiuJing/WebVision/info/val',
transform=val_transform)
num_classes = 1000
else:
raise Exception('Unknown dataset: {}'.format(args.dataset))
# Data Loader
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batchsize, shuffle=True, **kwargs)
val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False, **kwargs)
# Create model
if args.model == 'AlexNet':
model = alexnet(pretrained=False, num_classes=num_classes)
elif args.model == 'VGG':
use_batch_normalization = True # default use Batch Normalization
if use_batch_normalization:
if args.depth == 11:
model = vgg11_bn(pretrained=False, num_classes=num_classes)
elif args.depth == 13:
model = vgg13_bn(pretrained=False, num_classes=num_classes)
elif args.depth == 16:
model = vgg16_bn(pretrained=False, num_classes=num_classes)
elif args.depth == 19:
model = vgg19_bn(pretrained=False, num_classes=num_classes)
else:
raise Exception('Unsupport VGG detph: {}, optional depths: 11, 13, 16 or 19'.format(args.depth))
else:
if args.depth == 11:
model = vgg11(pretrained=False, num_classes=num_classes)
elif args.depth == 13:
model = vgg13(pretrained=False, num_classes=num_classes)
elif args.depth == 16:
model = vgg16(pretrained=False, num_classes=num_classes)
elif args.depth == 19:
model = vgg19(pretrained=False, num_classes=num_classes)
else:
raise Exception('Unsupport VGG detph: {}, optional depths: 11, 13, 16 or 19'.format(args.depth))
elif args.model == 'Inception':
model = inception_v3(pretrained=False, num_classes=num_classes)
elif args.model == 'ResNet':
if args.depth == 18:
model = resnet18(pretrained=False, num_classes=num_classes)
elif args.depth == 34:
model = resnet34(pretrained=False, num_classes=num_classes)
elif args.depth == 50:
model = resnet50(pretrained=False, num_classes=num_classes)
elif args.depth == 101:
model = resnet101(pretrained=False, num_classes=num_classes)
elif args.depth == 152:
model = resnet152(pretrained=False, num_classes=num_classes)
else:
raise Exception('Unsupport ResNet detph: {}, optional depths: 18, 34, 50, 101 or 152'.format(args.depth))
elif args.model == 'MPN-COV-ResNet':
if args.depth == 18:
model = mpn_cov_resnet18(pretrained=False, num_classes=num_classes)
elif args.depth == 34:
model = mpn_cov_resnet34(pretrained=False, num_classes=num_classes)
elif args.depth == 50:
model = mpn_cov_resnet50(pretrained=False, num_classes=num_classes)
elif args.depth == 101:
model = mpn_cov_resnet101(pretrained=False, num_classes=num_classes)
elif args.depth == 152:
model = mpn_cov_resnet152(pretrained=False, num_classes=num_classes)
else:
raise Exception('Unsupport MPN-COV-ResNet detph: {}, optional depths: 18, 34, 50, 101 or 152'.format(args.depth))
else:
raise Exception('Unsupport model'.format(args.model))
# Get the number of model parameters
print('Number of model parameters: {}'.format(sum([p.data.nelement() for p in model.parameters()])))
if torch.cuda.is_available():
model = model.cuda()
# Optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("==> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_err1 = checkpoint['best_err1']
model.load_state_dict(checkpoint['state_dict'])
print("==> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("==> no checkpoint found at '{}'".format(args.resume))
print(model)
# Define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss()
if torch.cuda.is_available():
criterion = criterion.cuda()
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# Train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# Evaluate on validation set
err1 = validate(val_loader, model, criterion, epoch)
# Remember best err1 and save checkpoint
is_best = (err1 <= best_err1)
best_err1 = min(err1, best_err1)
print("Current best accuracy (error):", best_err1)
save_checkpoint({
'epoch': epoch+1,
'state_dict': model.state_dict(),
'best_err1': best_err1,
}, is_best)
print("Best accuracy (error):", best_err1)
def main(set_,batch_size,model_str, base,io_scale,n_scale,interaction,n,epoch, init_rate,decay, gamma, step_size,save_dir):
params = Params(set_,batch_size,model_str, base,io_scale,n_scale,interaction,n,epoch, init_rate,decay, gamma, step_size)
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
downscale_kern = BesselConv2d(base,n_scales=n_scale).to(device)
n_train = 10000
n_test = 10000
num_process =8
resize= None
if set_ == "cifar":
resize= ["resize",2]
if "dss" in model_str or 'deform' in model_str or 'final' in model_str:
down = [downscale_kern,n_scale]
else:
down = None
resize= None
train_gen = dataset.get_gen_rand(set_,"train", batch_size,downscale_kern=down,n=n_train, resize=resize)
test_gen = dataset.get_gen_rand(set_,"test" ,batch_size,downscale_kern=down,n=n_test, resize=resize)
with mlflow.start_run():
output_dir = './log'
t_list = []
# MLflow log parameters
for key, value in vars(params).items():
mlflow.log_param(key, value)
output_dir = dirpath = tempfile.mkdtemp()
writer = SummaryWriter(output_dir)
print("Writing TensorBoard events locally to %s\n" % output_dir)
#load model
if set_ == "MNIST":
if model_str == 'dss_v1':
model = dss.DSS_plain(base,io_scale,n,interaction)
elif model_str =='dss_v2':
model = dss.DSS_plain_2(base,io_scale,n,interaction)
elif model_str == "deform":
model = dss2.deform_dss(base,io_scale[0],n,10)
elif model_str == "deform2":
model = dss2.deform_dss2(base,io_scale[0],n,10)
elif set_ == "cifar":
if model_str == 'dss_v1':
model = dss.DSS_cifar(base,io_scale,n,interaction)
elif model_str =='dss_v2':
model = dss.DSS_2_cifar(base,io_scale,n,interaction)
elif model_str =="cnn":
model = vgg.vgg16()
elif model_str == "deform":
model = dss2.deform_dss_cifar(base,io_scale[0],n,10)
elif model_str == "deform_res":
model = dcn.deform_ResNet101()
model = model.to(device)
model = nn.DataParallel(model,device_ids=[0])
#model.share_memory()
# For multiprocessing
#mp.set_start_method('spawn')
#num_gpus = torch.cuda.device_count()
#rank = int(os.environ['RANK'])
#dist.init_process_group(backend='nccl')
print(model,flush=True)
model_param = model.parameters()
print("Number of parameters = ",sum([np.prod(p.size()) for p in model_param]),flush=True)
enter = 0
# train/val model
for e in range(1,epoch+1):
print("Epoch: %d" % (e),flush=True)
start = time.time()
model = funcs.train_network(model,train_gen,init_rate, step_size, gamma,decay, n_train,batch_size,e,writer)
end = time.time()
t_list.append(end-start)
acc, _ = funcs.test_network(model, test_gen, n_test, batch_size,e,writer)
if e > 3 and acc < 0.2:
enter = 1
break
avg_time = sum(t_list)/len(t_list)
#test model
if enter == 0:
for s in [1,1.1,1.5,2.0,2.5,3.0]:
print("Test for scale by %2.3f"%(1/s), flush=True)
if set_ =="cifar":
sc_test_gen = dataset.get_gen(set_,"test", batch_size, 1/s,n_test,down, resize=resize)
else:
sc_test_gen = dataset.get_gen(set_,"test", batch_size, 1/s,n_test,down)
model = model.to(device)
acc,_ = funcs.test_network(model, sc_test_gen, n_test, batch_size,-1,writer,val=False)
print("Average time taken for one epoch =",str(avg_time),flush= True)
torch.save(model, str(save_dir))
train=False,
download=True,
transform=transform_test)
testloader = torch.utils.data.DataLoader(testset,
batch_size=100,
shuffle=False,
num_workers=2)
num_classes = 100
else:
raise "only support dataset CIFAR10 or CIFAR100"
if args.model == "lenet":
net = lenet.LeNet(num_classes=num_classes)
elif args.model == "vgg16":
net = vgg.vgg16(num_classes=num_classes, pretrained=args.pretrain)
elif args.model == "vgg16_bn":
net = vgg.vgg16_bn(num_classes=num_classes, pretrained=args.pretrain)
elif args.model == "resnet18":
net = resnet.resnet18(num_classes=num_classes, pretrained=args.pretrain)
elif args.model == "resnet34":
net = resnet.resnet18(num_classes=num_classes, pretrained=args.pretrain)
elif args.model == "resnet50":
net = resnet.resnet50(num_classes=num_classes, pretrained=args.pretrain)
elif args.model == "resnetv2_18":
net = resnet_v2.resnet18(num_classes=num_classes, pretrained=args.pretrain)
elif args.model == "resnetv2_34":
net = resnet_v2.resnet18(num_classes=num_classes, pretrained=args.pretrain)
elif args.model == "resnetv2_50":
