def valid(args, dataloaders, models=None):
valid_source_dataloader = dataloaders['valid_source']
valid_target_dataloader = dataloaders['valid_target']
if models is None:
try:
load = torch.load(
f"./result/{args.source}2{args.target}/best_model.pth")
model = resnet(args)
#model = Model()
model.load_state_dict(load['M'])
except Exception as inst:
model = resnet(args)
model.eval()
model.to(args.device)
else:
model = models
model.eval()
src_accs = []
for i, (imgs, lbls) in enumerate(valid_source_dataloader):
bsize = imgs.size(0)
imgs, lbls = imgs.to(args.device), lbls.to(args.device)
output = model(imgs)
acc = accuracy_(output[:, :args.num_classes], lbls)
src_accs.append(acc)
print(f"\t [{i+1}/{len(valid_target_dataloader)}]", end=" \r")
tar_accs1 = []
tar_accs2 = []
for i, (imgs, lbls) in enumerate(valid_target_dataloader):
bsize = imgs.size(0)
imgs, lbls = imgs.to(args.device), lbls.to(args.device)
output = model(imgs)
acc = accuracy_(output[:, args.num_classes:], lbls)
tar_accs1.append(acc)
acc = accuracy_(
output[:, args.num_classes:] + output[:, :args.num_classes], lbls)
tar_accs2.append(acc)
print(f"\t [{i+1}/{len(valid_target_dataloader)}]", end=" \r")
mean_src_acc, mean_tar_acc1, mean_tar_acc2 = mean_(src_accs), mean_(
tar_accs1), mean_(tar_accs2)
#print(f"\t Valid, src acc:%.3f, tar acc:%.3f" % (mean_src_acc,
# mean_tar_acc))
return mean_src_acc, mean_tar_acc1, mean_tar_acc2
def bulid_bert_resnet_model(vocab,
inputs,
is_training,
bert_config=None,
resnet_config=None):
if bert_config is None:
bert_config = bert.BertConfig(len(vocab['Word']),
max_position_embeddings=512,
type_vocab_size=len(vocab['Entity']))
if resnet_config is None:
resnet_config = resnet.ResnetConfig()
def splits(datas, num, name='split_squeeze'):
with tf.variable_scope(name):
datas = tf.split(datas, num, axis=1)
outputs = []
for data in datas:
outputs.append(tf.squeeze(data, axis=1))
return outputs
input_ids, token_position_ids, token_type_ids, input_mask = splits(
inputs, 4)
model = bert.BertModel(bert_config,
is_training,
input_ids,
input_mask=input_mask,
token_type_ids=token_type_ids,
token_position_ids=token_position_ids)
bert_features = model.get_sequence_output()
resnet_features = resnet.resnet(bert_features, resnet_config)
features = tf.reduce_max(resnet_features, axis=1) # max_pool
logits = tf.layers.dense(features, len(vocab['Relation']), name='logits')
return logits
def _load_model(self):
print('loading model...')
if self.args.model == 'resnet':
from models.resnet import resnet
self.model = resnet(**self.args.model_args)
elif self.args.model == 'densenet':
from models.densenet import densenet
self.model = densenet(**self.args.model_args)
self.policies = self.model.parameters()
#self.model = torch.nn.DataParallel(self.model, device_ids=self.args.gpus).cuda()
if self.args.resume:
if os.path.isfile(self.args.resume):
print(("=> loading checkpoint '{}'".format(self.args.resume)))
checkpoint = torch.load(self.args.resume)
d = collections.OrderedDict()
for key, value in checkpoint['state_dict'].items():
tmp = key[7:]
d[tmp] = value
self.args.start_epoch = checkpoint['epoch']
#self.model.load_state_dict(checkpoint['state_dict'])
self.model.load_state_dict(d)
print(("=> loaded checkpoint '{}' (epoch {})".format(
self.args.phase, checkpoint['epoch'])))
else:
print(("=> no checkpoint found at '{}'".format(
self.args.resume)))
print('model load finished!')
def Model_Construct(args):
if args.arch.find('alexnet') == 0: ## the required model is vgg structure
model = alexnet(args)
return model
elif args.arch.find('resnet') == 0:
model = resnet(args)
return model
else:
raise ValueError('the request model is not exist')
def get_model(model, args):
if model == 'alexnet':
return alexnet()
if model == 'resnet':
return resnet(dataset=args.dataset)
if model == 'wideresnet':
return WideResNet(args.layers, args.dataset == 'cifar10' and 10 or 100,
args.widen_factor, dropRate=args.droprate, gbn=args.gbn)
if model == 'densenet':
return densenet()
def create_model(model_name, in_channels, out_channels):
if model_name == 'resnet':
model = resnet(in_channels=in_channels, out_channels=out_channels)
elif model_name == 'resnetS':
model = resnetS(in_channels=in_channels, out_channels=out_channels)
elif model_name == 'resnetSS':
model = resnetSS(in_channels=in_channels, out_channels=out_channels)
elif model_name == 'simple':
model = simple(in_channels=in_channels, out_channels = out_channels)
return model
def __init__(self,
n_channels,
n_classes,
court_img,
target_size,
court_poi=None,
bilinear=True,
resnet_name='resnetreg50',
resnet_pretrained=None,
warp_with_nearest=False,
img2input=False):
super(Reconstructor, self).__init__()
self.n_channels = n_channels
self.n_classes = n_classes
self.bilinear = bilinear
self.img2input = img2input
# UNet:
self.inc = DoubleConv(n_channels, 64)
self.down1 = Down(64, 128)
self.down2 = Down(128, 256)
self.down3 = Down(256, 512)
factor = 2 if bilinear else 1
self.down4 = Down(512, 1024 // factor)
self.up1 = Up(1024, 512 // factor, bilinear)
self.up2 = Up(512, 256 // factor, bilinear)
self.up3 = Up(256, 128 // factor, bilinear)
self.up4 = Up(128, 64, bilinear)
self.outc = OutConv(64, n_classes)
# UNet regressor that outputs the first 3x3 transformation matrix:
# self.conv_top = nn.Conv2d(1024 // factor, n_classes, kernel_size=1)
# self.unet_reg = Reconstructor.make_regressor(n_classes)
# ResNet regressor that outputs the second 3x3 transformation matrix:
in_classes = n_classes+3 if img2input else n_classes
self.resnet_reg = resnet(resnet_name, resnet_pretrained, in_classes)
# The court template image and court points of interest.
# This court template will be warped by the learnt transformation matrix:
self.court_img = court_img
self.court_poi = court_poi
# STN warper:
h, w = target_size[1], target_size[0]
if warp_with_nearest is False:
self.warper = kornia.HomographyWarper(h, w)
else:
# It seems mode='nearest' has a bug when used during training
self.warper = kornia.HomographyWarper(h, w, mode='nearest')
def init_model(model_path, num_class, model_name):
if 'lite' in model_name:
model = lite_faster_rcnn(num_class)
elif 'pva' in model_name:
model = pva_net(num_class)
elif 'resnet' in model_name:
model = resnet(num_class, num_layers=101)
#model = resnet(num_class, num_layers=101)
checkpoint = torch.load(model_path)
model.create_architecture()
model.load_state_dict(checkpoint['state_dict'])
model = model.cuda()
model.eval()
return model
def getModel(model):
if model == 'resnet18':
from models.resnet import resnet
net = resnet(groups=[1, 1, 1, 1],
depth=18,
width=[64, 128, 256, 512],
dataset="cifar100").cuda()
elif model == 'mobilenet':
from models.mobilenet import mobilenet
net = mobilenet(num_classes=100, cifar=True).cuda()
else:
print('check the name of the model')
sys.exit()
return net
def main():
global args, best_prec1
args = opts()
if args.arch.find('resnet') != -1:
model = resnet(args)
else:
raise ValueError('Unavailable model architecture!!!')
# define-multi GPU
model = torch.nn.DataParallel(model).cuda()
print(model)
if not os.path.isdir(args.log):
os.makedirs(args.log)
log = open(os.path.join(args.log, 'log.txt'), 'a')
state = {k: v for k, v in args._get_kwargs()}
log.write(json.dumps(state) + '\n')
log.close()
log = open(os.path.join(args.log, 'log.txt'), 'a')
log.write('\n-------------------------------------------\n')
log.write(time.asctime(time.localtime(time.time())))
log.write('\n-------------------------------------------')
log.close()
cudnn.benchmark = True
# process the data and prepare the dataloaders.
# source_train_loader, source_val_loader, target_train_dataset, val_loader, source_val_loader_cluster, val_loader_cluster = generate_dataloader(args)
source_train_loader_ce, source_train_dataset, target_train_loader_ce, target_train_dataset, source_val_loader, target_val_loader = generate_dataloader(
args)
if args.pseudo_type == 'cluster': ### the AO of CAN
clusering_labels_for_path = download_feature_and_pca_clustering(
0, source_val_loader, target_val_loader, model, args)
elif args.pseudo_type == 'lp':
clusering_labels_for_path = download_feature_and_pca_label_prob(
0, source_val_loader, target_val_loader, model, args)
else:
raise NotImplementedError
def main():
print("Start time: " + time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
global best_acc
start_epoch = args.start_epoch # start from epoch 0 or last checkpoint epoch
if not os.path.isdir(args.checkpoint):
mkdir_p(args.checkpoint)
# Data loading code
traindir = os.path.join(args.data, '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_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])),
batch_size=args.train_batch,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.test_batch,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# create model
model = resnet(
depth=args.depth,
recalibration_type=args.recalibration_type,
)
model = torch.nn.DataParallel(model).cuda()
cudnn.benchmark = True
print(model)
print(' Total params: %.4fM' %
(sum(p.numel() for p in model.parameters()) / 1000000.0))
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = set_optimizer(model, args)
# Resume
title = 'Resnet{}-{}'.format(args.depth, args.recalibration_type)
if args.resume:
# Load checkpoint.
print('==> Resuming from checkpoint..')
assert os.path.isfile(
args.resume), 'Error: no checkpoint directory found!'
args.checkpoint = 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.checkpoint, 'log.txt'),
title=title,
resume=True)
elif args.pretrained:
# Load checkpoint.
print('==> Start from pretrained checkpoint..')
assert os.path.isfile(
args.pretrained), 'Error: no checkpoint directory found!'
args.checkpoint = os.path.dirname(args.pretrained)
checkpoint = torch.load(args.pretrained)
model.load_state_dict(checkpoint['state_dict'])
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names([
'Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.',
'Valid Acc.', 'Train Acc.5', 'Valid Acc.5', 'Train Time',
'Test Time'
])
else:
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names([
'Learning Rate', 'Train Loss', 'Valid Loss', 'Train Acc.',
'Valid Acc.', 'Train Acc.5', 'Valid Acc.5', 'Train Time',
'Test Time'
])
if args.evaluate:
print('\nEvaluation only')
test_loss, test_acc, test_acc5, _ = test(val_loader, model, criterion,
start_epoch, use_cuda)
print(' Test Loss: %.8f, Test Acc: %.2f (Top-1), %.2f (Top-5)' %
(test_loss, test_acc, test_acc5))
return
# 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_loss, train_acc, train_acc5, train_time = train(
train_loader, model, criterion, optimizer, epoch, use_cuda)
test_loss, test_acc, test_acc5, test_time = test(
val_loader, model, criterion, epoch, use_cuda)
# append logger file
logger.append([
state['lr'], train_loss, test_loss, train_acc, test_acc,
train_acc5, test_acc5, train_time, test_time
])
# save model
is_best = test_acc > best_acc
best_acc = max(test_acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'acc': test_acc,
'best_acc': best_acc,
'optimizer': optimizer.state_dict(),
},
is_best,
checkpoint=args.checkpoint)
logger.close()
print('Best acc:')
print(best_acc)
print("Finish time: " + time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime()))
def main_worker(args):
global best_prec1, dtype
best_prec1 = 0
dtype = torch_dtypes.get(args.dtype)
torch.manual_seed(args.seed)
time_stamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
if args.evaluate:
args.results_dir = '/tmp'
if args.save is '':
args.save = time_stamp
save_path = path.join(args.results_dir, args.save)
args.distributed = args.local_rank >= 0 or args.world_size > 1
if args.distributed:
dist.init_process_group(backend=args.dist_backend,
init_method=args.dist_init,
world_size=args.world_size,
rank=args.local_rank)
args.local_rank = dist.get_rank()
args.world_size = dist.get_world_size()
if args.dist_backend == 'mpi':
# If using MPI, select all visible devices
args.device_ids = list(range(torch.cuda.device_count()))
else:
args.device_ids = [args.local_rank]
# if not (args.distributed and args.local_rank > 0):
if not path.exists(save_path):
makedirs(save_path)
dump_args(args, path.join(save_path, 'args.txt'))
setup_logging(path.join(save_path, 'log.txt'),
resume=args.resume is not '',
dummy=False)
results_path = path.join(save_path, 'results')
results = ResultsLog(results_path,
title='Training Results - %s' % args.save)
logging.info("saving to %s", save_path)
logging.debug("run arguments: %s", args)
logging.info("creating model %s", args.model)
if 'cuda' in args.device and torch.cuda.is_available():
torch.cuda.manual_seed_all(args.seed)
torch.cuda.set_device(args.device_ids[0])
cudnn.benchmark = True
else:
args.device_ids = None
# All parameters to the model should be passed via this dict.
model_config = {
'dataset': args.dataset,
'dp_type': args.dropout_type,
'dp_percentage': args.dropout_perc,
'dropout': args.drop_rate,
'device': args.device
}
if args.model_config is not '':
model_config = dict(model_config, **literal_eval(args.model_config))
# create Resnet model
model = resnet(**model_config)
logging.info("created model with configuration: %s", model_config)
num_parameters = sum([l.nelement() for l in model.parameters()])
logging.info("number of parameters: %d", num_parameters)
# # optionally resume from a checkpoint
# if args.evaluate:
# if not path.isfile(args.evaluate):
# parser.error('invalid checkpoint: {}'.format(args.evaluate))
# checkpoint = torch.load(args.evaluate, map_location="cpu")
# # Overrride configuration with checkpoint info
# args.model = checkpoint.get('model', args.model)
# args.model_config = checkpoint.get('config', args.model_config)
# # load checkpoint
# model.load_state_dict(checkpoint['state_dict'])
# logging.info("loaded checkpoint '%s' (epoch %s)",
# args.evaluate, checkpoint['epoch'])
#
# if args.resume:
# checkpoint_file = args.resume
# if path.isdir(checkpoint_file):
# results.load(path.join(checkpoint_file, 'results.csv'))
# checkpoint_file = path.join(
# checkpoint_file, 'model_best.pth.tar')
# if path.isfile(checkpoint_file):
# logging.info("loading checkpoint '%s'", args.resume)
# checkpoint = torch.load(checkpoint_file, map_location="cpu")
# if args.start_epoch < 0: # not explicitly set
# args.start_epoch = checkpoint['epoch']
# best_prec1 = checkpoint['best_prec1']
# model.load_state_dict(checkpoint['state_dict'])
# optim_state_dict = checkpoint.get('optim_state_dict', None)
# logging.info("loaded checkpoint '%s' (epoch %s)",
# checkpoint_file, checkpoint['epoch'])
# else:
# logging.error("no checkpoint found at '%s'", args.resume)
# else:
# optim_state_dict = None
# define loss function (criterion) and optimizer
loss_params = {}
if args.label_smoothing > 0:
loss_params['smooth_eps'] = args.label_smoothing
criterion = getattr(model, 'criterion', CrossEntropyLoss)(**loss_params)
criterion.to(args.device, dtype)
model.to(args.device, dtype)
# Batch-norm should always be done in float
if 'half' in args.dtype:
FilterModules(model, module=is_bn).to(dtype=torch.float)
# optimizer configuration
optim_regime = getattr(model, 'regime', [{
'epoch': 0,
'optimizer': args.optimizer,
'lr': args.lr,
'momentum': args.momentum,
'weight_decay': args.weight_decay
}])
optimizer = optim_regime if isinstance(optim_regime, OptimRegime) \
else OptimRegime(model, optim_regime, use_float_copy='half' in args.dtype)
# if optim_state_dict is not None:
# optimizer.load_state_dict(optim_state_dict)
trainer = Trainer(model,
criterion,
optimizer,
device_ids=args.device_ids,
device=args.device,
dtype=dtype,
distributed=args.distributed,
local_rank=args.local_rank,
mixup=args.mixup,
loss_scale=args.loss_scale,
grad_clip=args.grad_clip,
print_freq=args.print_freq,
adapt_grad_norm=args.adapt_grad_norm)
if args.tensorwatch:
trainer.set_watcher(filename=path.abspath(
path.join(save_path, 'tensorwatch.log')),
port=args.tensorwatch_port)
# Evaluation Data loading code
args.eval_batch_size = args.eval_batch_size if args.eval_batch_size > 0 else args.batch_size
val_data = DataRegime(getattr(model, 'data_eval_regime', None),
defaults={
'datasets_path': args.datasets_dir,
'name': args.dataset,
'split': 'val',
'augment': False,
'input_size': args.input_size,
'batch_size': args.eval_batch_size,
'shuffle': False,
'num_workers': args.workers,
'pin_memory': True,
'drop_last': False
})
if args.evaluate:
results = trainer.validate(val_data.get_loader())
logging.info(results)
return
# Training Data loading code
train_data_defaults = {
'datasets_path': args.datasets_dir,
'name': args.dataset,
'split': 'train',
'augment': True,
'input_size': args.input_size,
'batch_size': args.batch_size,
'shuffle': True,
'num_workers': args.workers,
'pin_memory': True,
'drop_last': True,
'distributed': args.distributed,
'duplicates': args.duplicates,
'autoaugment': args.autoaugment,
'cutout': {
'holes': 1,
'length': 16
} if args.cutout else None
}
if hasattr(model, 'sampled_data_regime'):
sampled_data_regime = model.sampled_data_regime
probs, regime_configs = zip(*sampled_data_regime)
regimes = []
for config in regime_configs:
defaults = {**train_data_defaults}
defaults.update(config)
regimes.append(DataRegime(None, defaults=defaults))
train_data = SampledDataRegime(regimes, probs)
else:
train_data = DataRegime(getattr(model, 'data_regime', None),
defaults=train_data_defaults)
logging.info('optimization regime: %s', optim_regime)
args.start_epoch = max(args.start_epoch, 0)
trainer.training_steps = args.start_epoch * len(train_data)
for epoch in range(args.start_epoch, args.epochs):
trainer.epoch = epoch
train_data.set_epoch(epoch)
val_data.set_epoch(epoch)
logging.info('\nStarting Epoch: {0}\n'.format(epoch + 1))
# train for one epoch
train_results = trainer.train(train_data.get_loader(),
chunk_batch=args.chunk_batch)
# evaluate on validation set
val_results = trainer.validate(val_data.get_loader())
# # save weights heatmap
# w = model._modules['layer3']._modules['5']._modules['conv2']._parameters['weight'].view(64, -1).cpu().detach().numpy()
# heat_maps_dir = 'C:\\Users\\Pavel\\Desktop\\targeted_dropout_pytorch\\pics\\experiment_0'
# plot = sns.heatmap(w, center=0)
# name = str(datetime.now()).replace(':', '_').replace('-', '_').replace('.', '_').replace(' ', '_') + '.png'
# plot.get_figure().savefig(path.join(heat_maps_dir, name))
# plt.clf()
if args.distributed and args.local_rank > 0:
continue
# remember best prec@1 and save checkpoint
is_best = val_results['prec1'] > best_prec1
best_prec1 = max(val_results['prec1'], best_prec1)
if args.drop_optim_state:
optim_state_dict = None
else:
optim_state_dict = optimizer.state_dict()
save_checkpoint(
{
'epoch': epoch + 1,
'model': args.model,
'config': args.model_config,
'state_dict': model.state_dict(),
'optim_state_dict': optim_state_dict,
'best_prec1': best_prec1
},
is_best,
path=save_path,
save_all=False)
logging.info('\nResults - Epoch: {0}\n'
'Training Loss {train[loss]:.4f} \t'
'Training Prec@1 {train[prec1]:.3f} \t'
'Training Prec@5 {train[prec5]:.3f} \t'
'Validation Loss {val[loss]:.4f} \t'
'Validation Prec@1 {val[prec1]:.3f} \t'
'Validation Prec@5 {val[prec5]:.3f} \t\n'.format(
epoch + 1, train=train_results, val=val_results))
values = dict(epoch=epoch + 1, steps=trainer.training_steps)
values.update({'training ' + k: v for k, v in train_results.items()})
values.update({'validation ' + k: v for k, v in val_results.items()})
results.add(**values)
results.plot(x='epoch',
y=['training loss', 'validation loss'],
legend=['training', 'validation'],
title='Loss',
ylabel='loss')
results.plot(x='epoch',
y=['training error1', 'validation error1'],
legend=['training', 'validation'],
title='Error@1',
ylabel='error %')
results.plot(x='epoch',
y=['training error5', 'validation error5'],
legend=['training', 'validation'],
title='Error@5',
ylabel='error %')
if 'grad' in train_results.keys():
results.plot(x='epoch',
y=['training grad'],
legend=['gradient L2 norm'],
title='Gradient Norm',
ylabel='value')
results.save()
def main():
args = parse_args()
img_path = args.img_path
save_dir = args.save_dir
if not os.path.isdir(save_dir):
os.mkdir(save_dir)
if 'lite' in args.network:
model = lite_faster_rcnn(args.classes)
elif 'pva' in args.network:
model = pva_net(args.classes)
elif 'resnet' in args.network:
model = resnet(args.classes, num_layers=101)
checkpoint = torch.load(args.model)
model.create_architecture()
model.load_state_dict(checkpoint['state_dict'])
model = model.cuda()
model = torch.nn.DataParallel(model).cuda()
model.eval()
imgs = glob(os.path.join(args.img_path, "*.*"))
print(args.img_path)
batch_size = 1
std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32)
mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32)
std = torch.from_numpy(std).cuda()
mean = torch.from_numpy(mean).cuda()
results_file = open("./outputs/resluts.csv", "a+")
for ix, img_name in enumerate(imgs):
#print(ix, img_name)
im = cv2.imread(img_name)
if im is None:
continue
import time
#start_t = time.clock()
data = prepareTestData(864, im, 32, 1440)
start_t = time.clock()
results = im_detect(data, model, batch_size, std, mean, args.classes)
end_t = time.clock()
print(ix, img_name, ' time consume is: ', end_t - start_t)
draw_img = im.copy()
#results_file = open("./output/resluts.csv","a+")
name = os.path.basename(img_name)
for boxes in results:
for box in boxes:
x1 = int(box[0])
y1 = int(box[1])
x2 = int(box[2])
y2 = int(box[3])
score = float(box[4])
label = int(box[5])
draw_label = ''
#if label < 7:
# draw_label = 'd'
#else:
# draw_label = 'd'
cv2.rectangle(draw_img, (x1, y1), (x2, y2),
(0, label * 6, 255), 1)
w = x2 - x1
h = y2 - y1
#cv2.putText(draw_img, '%.1f'%score+draw_label, (x1+(w>>1), y1+(h>>1)), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3)
#cv2.putText(draw_img, '%.1f'%score+str(label), (x1+(w>>1), y1+(h>>1)), cv2.FONT_HERSHEY_SIMPLEX, 1.2, (0, 0, 255), 3)
results_file.write(name + "," + class_list[label] + "," +
str(x1) + "," + str(x2) + "," + str(y1) +
"," + str(y2) + "\n")
cv2.imwrite(save_dir + '/' + name, draw_img)
def main():
global args, best_prec1
args = opts()
# ipdb.set_trace()
# args = parser.parse_args()
model_source, model_target = resnet(args)
# define-multi GPU
model_source = torch.nn.DataParallel(model_source).cuda()
model_target = torch.nn.DataParallel(model_target).cuda()
print('the memory id should be same for the shared feature extractor:')
print(id(model_source.module.resnet_conv)) # the memory is shared here
print(id(model_target.module.resnet_conv))
print('the memory id should be different for the different classifiers:')
print(id(model_source.module.fc)) # the memory id shared here.
print(id(model_target.module.fc))
# define loss function(criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
np.random.seed(1) ### fix the random data.
random.seed(1)
# optimizer = torch.optim.SGD(model.parameters(),
# To apply different learning rate to different layer
if args.meta_sgd:
meta_train_lr = []
for param in model_target.parameters():
meta_train_lr.append(
torch.FloatTensor(param.data.size()).fill_(
args.meta_train_lr).cuda())
if args.pretrained:
print('the pretrained setting of optimizer')
if args.auxiliary_dataset == 'imagenet':
optimizer = torch.optim.SGD([
{
'params': model_source.module.resnet_conv.parameters(),
'name': 'pre-trained'
},
{
'params': model_source.module.fc.parameters(),
'name': 'pre-trained'
},
{
'params': model_target.module.fc.parameters(),
'name': 'new-added'
},
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
elif args.auxiliary_dataset == 'l_bird':
optimizer = torch.optim.SGD([
{
'params': model_source.module.resnet_conv.parameters(),
'name': 'pre-trained'
},
{
'params': model_source.module.fc.parameters(),
'name': 'pre-trained'
},
{
'params': model_target.module.fc.parameters(),
'name': 'new-added'
},
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
else:
print('the from scratch setting of optimizer')
optimizer = torch.optim.SGD([
{
'params': model_source.module.resnet_conv.parameters(),
'name': 'new-added'
},
{
'params': model_source.module.fc.parameters(),
'name': 'new-added'
},
{
'params': model_target.module.fc.parameters(),
'name': 'new-added'
},
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
#optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
# raise ValueError('the resume function is not finished')
print("==> loading checkpoints '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
if args.meta_sgd:
meta_train_lr = checkpoint['meta_train_lr']
best_prec1 = checkpoint['best_prec1']
model_source.load_state_dict(checkpoint['source_state_dict'])
model_target.load_state_dict(checkpoint['target_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("==> loaded checkpoint '{}'(epoch {})".format(
args.resume, checkpoint['epoch']))
else:
raise ValueError('The file to be resumed from is not exited',
args.resume)
if not os.path.isdir(args.log):
os.makedirs(args.log)
log = open(os.path.join(args.log, 'log.txt'), 'w')
state = {k: v for k, v in args._get_kwargs()}
log.write(json.dumps(state) + '\n')
log.close()
cudnn.benchmark = True
# process the data and prepare the dataloaders.
dataloader_returned = generate_dataloader(args)
dataloader_number_returned = len(dataloader_returned)
print('the number of dataloader number returned is: ',
dataloader_number_returned)
if dataloader_number_returned != 2:
train_loader_source, val_loader_source, train_loader_target, val_loader_target = dataloader_returned
else:
train_loader_target, val_loader_target = dataloader_returned
train_loader_source = None
# train_loader, val_loader = generate_dataloader(args)
# test only
if args.test_only:
if dataloader_number_returned == 2:
validate(None, val_loader_target, model_source, model_target,
criterion, 0, args)
else:
validate(val_loader_source, val_loader_target, model_source,
model_target, criterion, 0, args)
# if args.auxiliary_dataset == 'imagenet':
# validate(val_loader_source, val_loader_target, model_source, model_target, criterion, 0, args)
# else:
# validate(None, val_loader_target, model_source, model_target, criterion, 0, args)
return
print('begin training')
if train_loader_source:
train_loader_source_batch = enumerate(train_loader_source)
else:
train_loader_source_batch = None
train_loader_target_batch = enumerate(train_loader_target)
for epoch in range(args.start_epoch, args.epochs):
# train for one epoch
if args.meta_sgd:
train_loader_source_batch, train_loader_target_batch, meta_train_lr = train(
train_loader_source, train_loader_source_batch,
train_loader_target, train_loader_target_batch, model_source,
model_target, criterion, optimizer, epoch, args, meta_train_lr)
else:
train_loader_source_batch, train_loader_target_batch = train(
train_loader_source, train_loader_source_batch,
train_loader_target, train_loader_target_batch, model_source,
model_target, criterion, optimizer, epoch, args, None)
# train(train_loader, model, criterion, optimizer, epoch, args)
# evaluate on the val data
if (epoch + 1) % args.test_freq == 0 or (epoch + 1) % args.epochs == 0:
if dataloader_number_returned == 2:
prec1 = validate(None, val_loader_target, model_source,
model_target, criterion, epoch, args)
else:
prec1 = validate(val_loader_source, val_loader_target,
model_source, model_target, criterion, epoch,
args)
# prec1 = 1
# record the best prec1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
if is_best:
log = open(os.path.join(args.log, 'log.txt'), 'a')
log.write(' \nTarget_T1 acc: %3f' % (best_prec1))
log.close()
if args.meta_sgd:
save_checkpoint(
{
'epoch': epoch + 1,
'meta_train_lr': meta_train_lr,
'arch': args.arch,
'source_state_dict': model_source.state_dict(),
'target_state_dict': model_target.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, is_best, args, epoch)
else:
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'source_state_dict': model_source.state_dict(),
'target_state_dict': model_target.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, is_best, args, epoch + 1)
def main():
global args, best_prec1
args = opts()
current_epoch = 0
# define base model
model = resnet(args)
# define multi-GPU
model = torch.nn.DataParallel(model).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
criterion_afem = AdaptiveFilteringEMLossForTarget(eps=args.eps).cuda()
np.random.seed(args.seed)
random.seed(args.seed)
torch.manual_seed(args.seed)
if torch.cuda.device_count() > 1:
torch.cuda.manual_seed_all(args.seed)
# apply different learning rates to different layers
lr_fe = args.lr * 0.1 if args.pretrained else args.lr
if args.arch.find('resnet') != -1:
params_list = [
{
'params': model.module.conv1.parameters(),
'lr': lr_fe
},
{
'params': model.module.bn1.parameters(),
'lr': lr_fe
},
{
'params': model.module.layer1.parameters(),
'lr': lr_fe
},
{
'params': model.module.layer2.parameters(),
'lr': lr_fe
},
{
'params': model.module.layer3.parameters(),
'lr': lr_fe
},
{
'params': model.module.layer4.parameters(),
'lr': lr_fe
},
{
'params': model.module.fc1.parameters()
},
{
'params': model.module.fc2.parameters()
},
]
if args.optimizer == 'sgd':
optimizer = torch.optim.SGD(params_list,
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=args.nesterov)
if args.lr_scheduler == 'dann':
lr_lambda = lambda epoch: 1 / pow(
(1 + 10 * epoch / args.epochs), 0.75)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer,
lr_lambda,
last_epoch=-1)
elif args.lr_scheduler == 'cosine':
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, T_max=args.epochs, eta_min=0, last_epoch=-1)
elif args.lr_scheduler == 'step':
lr_lambda = lambda epoch: args.gamma**(
epoch + 1 > args.decay_epoch[
1] and 2 or epoch + 1 > args.decay_epoch[0] and 1 or 0)
scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer,
lr_lambda,
last_epoch=-1)
else:
raise ValueError('Unavailable model architecture!!!')
if args.resume:
print("==> loading checkpoints '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
current_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
scheduler.load_state_dict(checkpoint['scheduler_state_dict'])
print("==> loaded checkpoint '{}'(epoch {})".format(
args.resume, checkpoint['epoch']))
if not os.path.isdir(args.log):
os.makedirs(args.log)
log = open(os.path.join(args.log, 'log.txt'), 'a')
state = {k: v for k, v in args._get_kwargs()}
log.write(json.dumps(state) + '\n')
log.close()
# start time
log = open(os.path.join(args.log, 'log.txt'), 'a')
log.write('\n-------------------------------------------\n')
log.write(time.asctime(time.localtime(time.time())))
log.write('\n-------------------------------------------')
log.close()
cudnn.benchmark = True
# process data and prepare dataloaders
train_loader_source, train_loader_target, val_loader_target, val_loader_source = generate_dataloader(
args)
if args.eval_only:
prec1 = evaluate(val_loader_target, model, criterion, -1, args)
print(' * Eval acc@1: {:.3f}'.format(prec1))
return
print('begin training')
train_loader_source_batch = enumerate(train_loader_source)
train_loader_target_batch = enumerate(train_loader_target)
batch_number = count_epoch_on_large_dataset(train_loader_target,
train_loader_source)
num_itern_total = args.epochs * batch_number
test_freq = int(num_itern_total / 200)
print('test_freq: ', test_freq)
args.start_epoch = current_epoch
cs_1 = Variable(
torch.cuda.FloatTensor(args.num_classes,
model.module.feat1_dim).fill_(0))
ct_1 = Variable(
torch.cuda.FloatTensor(args.num_classes,
model.module.feat1_dim).fill_(0))
cs_2 = Variable(
torch.cuda.FloatTensor(args.num_classes,
model.module.feat2_dim).fill_(0))
ct_2 = Variable(
torch.cuda.FloatTensor(args.num_classes,
model.module.feat2_dim).fill_(0))
for itern in range(args.start_epoch * batch_number, num_itern_total):
# train for one iteration
train_loader_source_batch, train_loader_target_batch, cs_1, ct_1, cs_2, ct_2 = train_compute_class_mean(
train_loader_source, train_loader_source_batch,
train_loader_target, train_loader_target_batch, model, criterion,
criterion_afem, optimizer, itern, current_epoch, cs_1, ct_1, cs_2,
ct_2, args)
# evaluate on target
if (itern + 1) % batch_number == 0 or (itern + 1) % test_freq == 0:
prec1 = evaluate(val_loader_target, model, criterion,
current_epoch, args)
# record the best prec1
is_best = prec1 > best_prec1
if is_best:
best_prec1 = prec1
log = open(os.path.join(args.log, 'log.txt'), 'a')
log.write(
'\n best acc: %3f'
% (best_prec1))
log.close()
# update learning rate
if (itern + 1) % batch_number == 0:
scheduler.step()
current_epoch += 1
# save checkpoint
save_checkpoint(
{
'epoch': current_epoch,
'arch': args.arch,
'model_state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'scheduler_state_dict': scheduler.state_dict(),
'best_prec1': best_prec1,
}, is_best, args)
if current_epoch > args.stop_epoch:
break
# end time
log = open(os.path.join(args.log, 'log.txt'), 'a')
log.write('\n * best acc: %3f' % best_prec1)
log.write('\n-------------------------------------------\n')
log.write(time.asctime(time.localtime(time.time())))
log.write('\n-------------------------------------------\n')
log.close()
def main():
global args, best_prec1
args = opts()
# args = parser.parse_args()
model = resnet(args.arch, args.pretrain, args)
# define-multi GPU
model = torch.nn.DataParallel(model).cuda()
#print(model)
# define loss function(criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
# optimizer = torch.optim.SGD(model.parameters(),
# To apply different learning rate to different layer
#print(model.module)
optimizer = torch.optim.SGD([{
'params': model.module.conv1.parameters(),
'name': 'pre-trained'
}, {
'params': model.module.bn1.parameters(),
'name': 'pre-trained'
}, {
'params': model.module.layer1.parameters(),
'name': 'pre-trained'
}, {
'params': model.module.layer2.parameters(),
'name': 'pre-trained'
}, {
'params': model.module.layer3.parameters(),
'name': 'pre-trained'
}, {
'params': model.module.layer4.parameters(),
'name': 'pre-trained'
}, {
'params': model.module.fc.parameters(),
'lr': args.lr * 10,
'name': 'new-added'
}],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
#optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("==> loading checkpoints '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("==> loaded checkpoint '{}'(epoch {})".format(
args.resume, checkpoint['epoch']))
else:
raise ValueError('The file to be resumed from is not exited',
args.resume)
else:
if not os.path.isdir(args.log):
os.makedirs(args.log)
log = open(os.path.join(args.log, 'log.txt'), 'w')
state = {k: v for k, v in args._get_kwargs()}
log.write(json.dumps(state) + '\n')
log.close()
cudnn.benchmark = True
# process the data and prepare the dataloaders.
train_loader, val_loader = generate_dataloader(args)
#test only
if args.test_only:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
# evaluate on the val data
prec1 = validate(val_loader, model, criterion, epoch, args)
# record the best prec1 and save checkpoint
is_best = prec1 > best_prec1
if is_best:
log = open(os.path.join(args.log, 'log.txt'), 'a')
log.write(" best result is %3f" % (prec1))
log.close()
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, epoch, is_best, args)
def main():
global args, best_prec1
# Check the save_dir exists or not
if not os.path.exists(args.save_dir):
os.makedirs(args.save_dir)
if args.arch == 'vgg':
model = vgg16_bn()
elif args.arch == 'alexnet':
model = alexnet(
num_classes=10) if args.dataset == 'cifar10' else alexnet(
num_classes=100)
elif args.arch == 'wide_resnet':
if args.dataset == 'cifar10':
model = wide_WResNet(num_classes=10, depth=16, dataset='cifar10')
else:
model = wide_WResNet(num_classes=100, depth=16, dataset='cifar100')
elif args.arch == 'resnet':
if args.dataset == 'cifar10':
model = resnet(num_classes=10, dataset='cifar10')
else:
model = resnet(num_classes=100, dataset='cifar100')
model.cuda()
cudnn.benchmark = True
# define loss function (criterion) and pptimizer
criterion = nn.CrossEntropyLoss().cuda()
if args.half:
model.half()
criterion.half()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# 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_prec1 = checkpoint['best_prec1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
print(("=> loaded checkpoint '{}' (epoch {})".format(
args.evaluate, checkpoint['epoch'])))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch)
# train for one epoch
cubic_train(model, criterion, optimizer, epoch)
# evaluate on validation set
prec1 = validate(val_loader, model, criterion)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'best_prec1': best_prec1,
},
is_best,
filename=os.path.join(args.save_dir,
'checkpoint_{}.tar'.format(epoch)))
logger.info("Loading teacher model from {}".format(args.teacher))
model_teacher = densenet.densenet(
num_classes=num_classes,
depth=args.depth_dense,
block=densenet.Bottleneck,
growthRate=args.growthRate,
compressionRate=args.compressionRate,
dropRate=args.drop,
)
checkpoint_path = args.teacher + "/model_best.pth.tar"
model_teacher.load_state_dict(torch.load(checkpoint_path)['state_dict'])
logger.info(model_teacher)
logger.info("Initializing student model...")
model = resnet.resnet(depth=args.depth,
num_classes=num_classes,
num_blocks=num_blocks)
logger.info(model)
if args.cuda:
model_teacher.cuda()
model.cuda()
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
def train(args, dataloaders):
train_source_dataloader = dataloaders['train_source']
train_target_dataloader = dataloaders['train_target']
# model
model = resnet(args).to(args.device)
#model = Model().to(args.device)
model.train()
# loss
Loss_Src_Class = DClassifierForTarget(nClass=args.num_classes).to(
args.device)
Loss_Tar_Class = DClassifierForSource(nClass=args.num_classes).to(
args.device)
Loss_Tar_EM = EMLossForTarget(nClass=args.num_classes).to(args.device)
BCE = nn.BCEWithLogitsLoss()
CE = nn.CrossEntropyLoss()
models = model
# optimizer
optimizer = torch.optim.SGD(
[
{
'params': model.conv1.parameters(),
'name': 'pre-trained'
},
{
'params': model.bn1.parameters(),
'name': 'pre-trained'
},
{
'params': model.layer1.parameters(),
'name': 'pre-trained'
},
{
'params': model.layer2.parameters(),
'name': 'pre-trained'
},
{
'params': model.layer3.parameters(),
'name': 'pre-trained'
},
{
'params': model.layer4.parameters(),
'name': 'pre-trained'
},
#{'params': model.fc.parameters(), 'name': 'pre-trained'}
{
'params': model.fc.parameters(),
'name': 'new-added'
}
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
nesterov=True)
'''
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay),
nesterov=True)
'''
# lr schedule
'''
steplr_after = StepLR(optimizer, step_size=10, gamma=1.0)
lr_scheduler = WarmupScheduler(optimizer, multiplier=1,
total_epoch=args.warmup_epochs,
after_scheduler=steplr_after)
'''
#############################################################
########################### Train ###########################
train_source_dataloader_iter = circle_iterator(train_source_dataloader)
train_target_dataloader_iter = circle_iterator(train_target_dataloader)
best_tar_acc = 0
for epoch in range(1, args.epochs + 1):
class_losses = []
generate_losses = []
len_dataloader = min(len(train_source_dataloader),
len(train_target_dataloader))
model.train()
for i in range(len_dataloader):
src_imgs, src_lbls = next(train_source_dataloader_iter)
tar_imgs, tar_lbls = next(train_target_dataloader_iter)
#for i,((src_imgs, src_lbls), (tar_imgs, tar_lbls)) in enumerate(
# zip(train_source_dataloader, train_target_dataloader)):
src_imgs, src_lbls = src_imgs.to(args.device),\
src_lbls.to(args.device)
tar_imgs, tar_lbls = tar_imgs.to(args.device),\
tar_lbls.to(args.device)
################### Train Domain_predictor ###################
src_lbls_tmp = src_lbls + args.num_classes
output = model(src_imgs)
loss_Cs_src = CE(output[:, :args.num_classes], src_lbls)
loss_Ct_src = CE(output[:, args.num_classes:], src_lbls)
loss_Cst_domain_part1 = Loss_Src_Class(output)
loss_Cst_category_Gen = 0.5 * CE(output, src_lbls) + \
0.5 * CE(output, src_lbls_tmp)
output = model(tar_imgs)
loss_Cst_domain_part2 = Loss_Tar_Class(output)
loss_Cst_domain_Gen = 0.5 * Loss_Tar_Class(output) + \
0.5 * Loss_Src_Class(output)
loss_em_tar = Loss_Tar_EM(output)
########################### Loss ############################
lamb = 2 / (1 + math.exp(-1 * 10 * epoch / args.epochs)) - 1
#lamb = 0.1
if args.flag == 'no_em':
C_loss = loss_Cs_src + loss_Ct_src + \
loss_Cst_domain_part1 + loss_Cst_domain_part2
G_loss = loss_Cst_category_Gen + \
lamb * (loss_Cst_domain_Gen)
elif args.flag == 'symnet':
lamb = 2 / (1 + math.exp(-1 * 1 * epoch / args.epochs)) - 1
#lamb = 2 / (1 + math.exp(-1 * 0.1 * epoch / args.epochs)) - 1
C_loss = loss_Cs_src + loss_Ct_src + \
loss_Cst_domain_part1 + loss_Cst_domain_part2
G_loss = loss_Cst_category_Gen + \
lamb * (loss_Cst_domain_Gen + loss_em_tar)
elif args.flag == 'test':
lamb = 2 / (1 + math.exp(-1 * 5 * epoch / args.epochs)) - 1
C_loss = (loss_Cs_src + loss_Ct_src) + \
loss_Cst_domain_part1 + loss_Cst_domain_part2
G_loss = loss_Cst_category_Gen + \
lamb * (loss_Cst_domain_Gen + loss_em_tar)
else:
raise ValueError('unrecognized flag:', args.flag)
'''
#nn.utils.clip_grad_norm_(model.parameters(), 0.01)
optimizer.zero_grad()
C_loss.backward(retain_graph=True)
optimizer.step()
optimizer.zero_grad()
G_loss.backward()
optimizer.step()
'''
#compute gradient and do SGD step
optimizer.zero_grad()
C_loss.backward(retain_graph=True)
temp_grad = []
for param in model.parameters():
temp_grad.append(param.grad.data.clone())
grad_for_classifier = temp_grad
optimizer.zero_grad()
G_loss.backward()
temp_grad = []
for param in model.parameters():
temp_grad.append(param.grad.data.clone())
grad_for_featureExtractor = temp_grad
#print(list(model.parameters())[-2:],len(list(model.parameters())))
#input()
count = 0
for param in model.parameters():
temp_grad = param.grad.data.clone()
temp_grad.zero_()
if count < 60: #159 #### feauter extrac of the ResNet-50
#60 #### Resnet18
#5層: 20
temp_grad = temp_grad + grad_for_featureExtractor[count]
else:
temp_grad = temp_grad + grad_for_classifier[count]
temp_grad = temp_grad
param.grad.data = temp_grad
count = count + 1
optimizer.step()
################### logging #####################
class_losses.append(C_loss.item())
generate_losses.append(G_loss.item())
wandb.log({
'class_loss': C_loss.item(),
'generate_loss': G_loss.item()
})
if i % 5 == 0:
print(" [%d/%d] Loss C:%.2f G:%.2f" %
(i + 1, len_dataloader, C_loss.item(), G_loss.item()),
end=' \r')
# lr scheduler update
#lr_scheduler.step()
# validating
valid_src_acc, valid_tar_acc, valid_tar_acc_mix = valid(
args, dataloaders, models)
wandb.log({
'valid_src_acc': valid_src_acc,
'valid_tar_acc': valid_tar_acc,
'valid_tar_acc_mix': valid_tar_acc_mix
})
print(f" Epoch %d, Loss C:%.3f G:%.3f"
", src_acc:%.3f tar_acc1:%.3f tar_acc2:%.3f " %
(epoch, mean_(class_losses), mean_(generate_losses),
valid_src_acc, valid_tar_acc, valid_tar_acc_mix))
if valid_tar_acc > 0.2 and best_tar_acc < valid_tar_acc:
best_tar_acc = valid_tar_acc
save_dir = f"./result/{args.source}2{args.target}/"
os.system(f"mkdir -p {save_dir}")
torch.save({'M': model.state_dict()}, f"{save_dir}/best_model.pth")
print("\t save best weight")
def test(args, model_epoch=None):
base_cfg = Config.fromfile(args.base_config)
det_cfg = Config.fromfile(args.config)
cfg = merge_config(base_cfg.model_cfg, det_cfg.model_cfg)
if model_epoch is not None:
cfg.model = os.path.join(cfg.TRAIN.save_dir,
cfg.TRAIN.model_name + model_epoch)
print(cfg.model)
if not os.path.exists(cfg.model):
return 0, 0, 0, 0, 0
gpus = ",".join('%s' % id for id in cfg.TEST.gpus)
os.environ['CUDA_VISIBLE_DEVICES'] = gpus
thresh = cfg.TEST.thresh # 0.8
nms_thresh = cfg.TEST.nms_thresh # 0.35
iou_thresh = cfg.TEST.iou_thresh
classes = len(cfg.class_list)
if 'lite' in cfg.MODEL.BACKBONE:
model = lite_faster_rcnn(cfg, classes)
elif 'pva' in cfg.MODEL.BACKBONE:
model = pva_net(classes)
elif 'resnet' in cfg.MODEL.BACKBONE:
model = resnet(classes, num_layers=101)
model.create_architecture(cfg)
checkpoint = torch.load(cfg.model)
model.load_state_dict(checkpoint['state_dict'])
if torch.cuda.is_available():
model = model.cuda()
print("using gpu...")
model.eval()
imgs = glob(os.path.join(cfg.TEST.img_path, "*.xml"))
# print(cfg.TEST.img_path)
batch_size = 1
std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32)
mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32)
std = torch.from_numpy(std).cuda()
mean = torch.from_numpy(mean).cuda()
total_image_nums = len(imgs)
for ix, img_name in enumerate(imgs):
img_name = img_name.replace(".xml", ".jpg")
# print(ix, img_name)
im = cv2.imread(img_name)
if im is None:
continue
import time
# start_t = time.clock()
data = prepareTestData(cfg.TEST.TEST_SCALE, im,
cfg.TEST.SCALE_MULTIPLE_OF, cfg.TEST.MAX_SIZE)
start_t = time.time()
results = im_detect(data, model, batch_size, std, mean, classes,
thresh, nms_thresh)
end_t = time.time()
# print(ix, "/", total_image_nums, img_name, ' time consume is: ',
# end_t - start_t, len(results))
print(ix, "/", total_image_nums, img_name, ' time consume is: ',
end_t - start_t)
xml_name = img_name.replace(".jpg", ".xml")
xml_dicts = xml2dict(cfg.rename_class_list, xml_name, cfg.class_list)
det_dicts = det_results2dict(results, cfg.class_list)
txt_name = os.path.basename(xml_name).replace('.xml', '.txt')
# os.remove("mAP/input/ground-truth/")
if not os.path.exists("mAP/input/ground-truth/"):
os.makedirs("mAP/input/ground-truth/")
# os.remove("mAP/input/detection-results/")
if not os.path.exists("mAP/input/detection-results/"):
os.makedirs("mAP/input/detection-results/")
# GT
with open("mAP/input/ground-truth/" + txt_name, 'w') as f:
for key in cfg.class_list:
if key == '__background__':
continue
if key == 'FC':
break
for gt_id, gt_box in enumerate(xml_dicts[key]):
f.write(key + " " + str(gt_box[0]) + " " + str(gt_box[1]) +
" " + str(gt_box[2]) + " " + str(gt_box[3]) + "\n")
f.close()
# DET results
with open("mAP/input/detection-results/" + txt_name, 'w') as f:
for key in cfg.class_list:
if key == '__background__':
continue
if key == 'FC':
break
for det_id, det_box in enumerate(det_dicts[key]):
f.write(key + " " + str(det_box[-1]) + " " +
str(det_box[0]) + " " + str(det_box[1]) + " " +
str(det_box[2]) + " " + str(det_box[3]) + "\n")
f.close()
def get_network(args, use_gpu=True):
""" return given network
"""
if args.net == 'vgg16':
net = torchvision.models.vgg16_bn(pretrained=args.bool_pretrained)
net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True)
elif args.net == 'vgg13':
net = torchvision.models.vgg13_bn(pretrained=args.bool_pretrained)
net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True)
elif args.net == 'vgg11':
net = torchvision.models.vgg11_bn(pretrained=args.bool_pretrained)
net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True)
elif args.net == 'vgg19':
net = torchvision.models.vgg19_bn(pretrained=args.bool_pretrained)
net.classifier[6] = nn.Linear(4096, args.num_classes, bias=True)
####effcientnet
elif args.net == 'efficientnet-b5':
from efficientnet_pytorch import EfficientNet
if args.bool_pretrained == True:
net = EfficientNet.from_pretrained('efficientnet-b5')
else:
net = EfficientNet.from_name('efficientnet-b5')
net._fc = nn.Linear(2048, args.num_classes, bias=True)
elif args.net == 'densenet121':
from models.densenet import densenet121
net = densenet121()
elif args.net == 'densenet161':
net = torchvision.models.densenet161(pretrained=args.bool_pretrained)
in_features = net.classifier.in_features
net.classifier = nn.Linear(in_features, args.num_classes, bias=True)
elif args.net == 'densenet169':
net = torchvision.models.densenet169(pretrained=args.bool_pretrained)
in_features = net.classifier.in_features
net.classifier = nn.Linear(in_features, args.num_classes, bias=True)
elif args.net == 'densenet201':
net = torchvision.models.densenet201(pretrained=args.bool_pretrained)
in_features = net.classifier.in_features
net.classifier = nn.Linear(in_features, args.num_classes, bias=True)
elif args.net == 'googlenet':
from models.googlenet import googlenet
net = googlenet()
elif args.net == 'inceptionv3':
from models.inceptionv3 import inceptionv3
net = inceptionv3()
elif args.net == 'inceptionv4':
from models.inceptionv4 import inceptionv4
net = inceptionv4()
elif args.net == 'inceptionresnetv2':
from models.inceptionv4 import inception_resnet_v2
net = inception_resnet_v2()
elif args.net == 'xception':
from models.xception import xception
net = xception()
################## ResNet ########################################################
elif args.net == 'resnet18':
from models.resnet import resnet
net = resnet(args.num_classes, 2, args.pretrained, args.net)
elif args.net == 'resnet34':
from models.resnet import resnet
net = resnet(args.num_classes, 2, args.pretrained, args.net)
elif args.net == 'resnet50':
from models.resnet import resnet
net = resnet(args.num_classes, 2, args.pretrained, args.net)
elif args.net == 'resnet101':
from models.resnet import resnet
net = resnet(args.num_classes, 2, args.pretrained, args.net)
elif args.net == 'resnet152':
from models.resnet import resnet
net = resnet(args.num_classes, 2, args.pretrained, args.net)
##################################################################################
elif args.net == 'preactresnet18':
from models.preactresnet import preactresnet18
net = preactresnet18()
elif args.net == 'preactresnet34':
from models.preactresnet import preactresnet34
net = preactresnet34()
elif args.net == 'preactresnet50':
from models.preactresnet import preactresnet50
net = preactresnet50()
elif args.net == 'preactresnet101':
from models.preactresnet import preactresnet101
net = preactresnet101()
elif args.net == 'preactresnet152':
from models.preactresnet import preactresnet152
net = preactresnet152()
##################################################################
elif args.net == 'se_resnext50':
from models.resnext import se_resnext
net = se_resnext(args.num_classes, 2, args.pretrained, args.net)
elif args.net == 'se_resnext101':
from models.resnext import se_resnext
net = se_resnext(args.num_classes, 2, args.pretrained, args.net)
#################################################################
elif args.net == 'shufflenet':
from models.shufflenet import shufflenet
net = shufflenet()
elif args.net == 'shufflenetv2':
from models.shufflenetv2 import shufflenetv2
net = shufflenetv2()
elif args.net == 'squeezenet':
from models.squeezenet import squeezenet
net = squeezenet()
elif args.net == 'mobilenet':
from models.mobilenet import mobilenet
net = mobilenet()
elif args.net == 'mobilenetv2':
from models.mobilenetv2 import mobilenetv2
net = mobilenetv2()
elif args.net == 'nasnet':
from models.nasnet import nasnet
net = nasnet()
elif args.net == 'attention56':
from models.attention import attention56
net = attention56()
elif args.net == 'attention92':
from models.attention import attention92
net = attention92()
#########################################################
elif args.net == 'se_resnet50':
from models.senet import seresnet
net = seresnet(args.num_classes, 2, args.pretrained, args.net)
elif args.net == 'se_resnet101':
from models.senet import seresnet
net = seresnet(args.num_classes, 2, args.pretrained, args.net)
elif args.net == 'se_resnet152':
from models.senet import seresnet
net = seresnet(args.num_classes, 2, args.pretrained, args.net)
else:
print('the network name you have entered is not supported yet')
sys.exit()
if use_gpu:
net = net.cuda()
return net
def training():
batch_size = 64
epochs = 200
fine_tune_epochs = 50
lr = 0.1
x_train, y_train, x_test, y_test, nb_classes = load_data(args.data)
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
y_train = keras.utils.to_categorical(y_train, nb_classes)
y_test = keras.utils.to_categorical(y_test, nb_classes)
datagen = ImageDataGenerator(horizontal_flip=True,
width_shift_range=5. / 32,
height_shift_range=5. / 32)
data_iter = datagen.flow(x_train,
y_train,
batch_size=batch_size,
shuffle=True)
if args.model == 'resnet':
model = resnet.resnet(nb_classes,
depth=args.depth,
wide_factor=args.wide_factor,
sparse_factor=args.sparse_factor)
save_name = 'resnet_{}_{}_{}'.format(args.depth, args.wide_factor,
args.data)
else:
model = VGGnet.vgg(nb_classes, sparse_factor=args.sparse_factor)
save_name = 'VGGnet_{}'.format(args.data)
opt = keras.optimizers.SGD(lr=lr, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
model.summary()
history = model.fit_generator(data_iter,
steps_per_epoch=x_train.shape[0] //
batch_size,
epochs=epochs,
callbacks=[onetenth_60_120_160(lr)],
validation_data=(x_test, y_test))
if not os.path.exists('./results/'):
os.mkdir('./results/')
plot_history(history, './results/', save_name)
save_history(history, './results/', save_name)
model.save_weights('./results/{}_weights.h5'.format(save_name))
freeze_SR_layer(model, args.prune_rate)
# todo: a little change
opt = keras.optimizers.SGD(lr=0.0001, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
model.save_weights('./results/{}_{}_weights.h5'.format(
save_name, 'fine_tuned'))
model.fit_generator(data_iter,
steps_per_epoch=x_train.shape[0] // batch_size,
epochs=fine_tune_epochs,
validation_data=(x_test, y_test))
# create compact model
if args.model == 'resnet':
model = resnet.resnet(nb_classes,
depth=args.depth,
wide_factor=args.wide_factor,
sparse_factor=args.sparse_factor,
prune_rate=args.prune_rate)
else:
model = VGGnet.vgg(nb_classes,
sparse_factor=args.sparse_factor,
prune_rate=args.prune_rate)
compact_model.summary()
set_compact_model_weights(model, compact_model)
opt = keras.optimizers.SGD(lr=0.0001, momentum=0.9, nesterov=True)
compact_model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
score = compact_model.evaluate(x_test, y_test, verbose=0)
print('loss: {}'.format(score[0]))
print('acc: {}'.format(score[1]))
compact_model.save_weights('./results/{}_{}_weights.h5'.format(
save_name, 'channel_pruned'))
def main():
args = parse_args()
base_cfg = Config.fromfile(args.base_config)
det_cfg = Config.fromfile(args.config)
cfg = merge_config(base_cfg.model_cfg, det_cfg.model_cfg)
gpus = ",".join('%s' % id for id in cfg.TEST.gpus)
os.environ['CUDA_VISIBLE_DEVICES'] = gpus
thresh = cfg.TEST.thresh
nms_thresh = cfg.TEST.nms_thresh
save_dir = cfg.TEST.save_dir
classes = len(cfg.class_list)
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
if 'lite' in cfg.MODEL.BACKBONE:
model = lite_faster_rcnn(cfg, classes)
elif 'pva' in cfg.MODEL.BACKBONE:
model = pva_net(classes)
elif 'resnet' in cfg.MODEL.BACKBONE:
model = resnet(classes, num_layers=101)
model.create_architecture(cfg)
checkpoint = torch.load(cfg.model)
model.load_state_dict(checkpoint['state_dict'])
if torch.cuda.is_available():
model = model.cuda()
print("using gpu...")
model.eval()
imgs = glob(os.path.join(cfg.TEST.img_path, "*.xml"))
print(cfg.TEST.img_path)
batch_size = 1
std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32)
mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32)
std = torch.from_numpy(std).cuda()
mean = torch.from_numpy(mean).cuda()
color_list = defaultdict(list)
for key in cfg.class_list:
bgr = (np.random.randint(10, 255), np.random.randint(
10, 255), np.random.randint(10, 255))
color_list[key].append(bgr)
total_image_nums = len(imgs)
undetected_sample = []
for ix, img_name in enumerate(imgs):
save_flag = 0
img_name = img_name.replace(".xml", cfg.image_postfix)
# print(ix, img_name)
im = cv2.imread(img_name)
image_cpy = im.copy()
xml_image = im.copy()
gt_image = im.copy()
if im is None:
continue
import time
# start_t = time.clock()
# if args.gama:
# im = adjust_gamma(im, 2.0)
data = prepareTestData(cfg.TEST.TEST_SCALE, im,
cfg.TEST.SCALE_MULTIPLE_OF, cfg.TEST.MAX_SIZE)
start_t = time.time()
results = im_detect(data, model, batch_size, std,
mean, cfg, nms_thresh)
end_t = time.time()
print(ix, "/", total_image_nums, img_name,
' time consume is: ', end_t - start_t, len(results))
# show undetected sample gt
xml_name = img_name.replace(cfg.image_postfix, ".xml")
if os.path.exists(xml_name):
xml_dicts = xml2dict(cfg.rename_class_list,
xml_name, cfg.class_list)
det_dicts = det_results2dict(results, cfg.class_list)
is_undetected = 0
for key in cfg.class_list:
if key == '__background__':
continue
is_match_gt = np.zeros(len(xml_dicts[key]))
is_match_det = np.zeros(len(det_dicts[key]))
for det_id, det_box in enumerate(det_dicts[key]):
max_iou, max_iou_id = 0, 0
for gt_id, gt_box in enumerate(xml_dicts[key]):
if abs(is_match_gt[gt_id]) > 0:
continue
iou = calc_iou(det_box[0:-1], gt_box[0:-1])
if iou > max_iou:
max_iou = iou
max_iou_id = gt_id
if max_iou > cfg.TEST.iou_thresh:
is_match_gt[max_iou_id] = 1.0
is_match_det[det_id] = 1.0
for object_id in range(len(is_match_gt)):
if is_match_gt[object_id] == 0:
# is_undetected += 1
# # show_gt_image
# if is_undetected == 1:
# xml_image = im.copy()
# xml_image_name = img_name.replace(".jpg", ".bmp")
# save_image_gt(xml_image, xml_image_name, color_list, save_dir,
# cfg.rename_class_list, xml_name, cfg.class_list)
gt_box = xml_dicts[key][object_id]
save_dir = cfg.TEST.save_dir
name = os.path.basename(xml_name).split(
".xml")[0] + "_" + str(object_id) + ".bmp"
dst_file = save_dir + '/undetected_sample/' + key + "/"
if not os.path.exists(dst_file):
os.makedirs(dst_file)
dst_file += name
image_roi = image_cpy[
gt_box[1]:gt_box[3], gt_box[0]:gt_box[2]]
if not os.path.exists(dst_file):
cv2.imwrite(dst_file, image_roi, [
int(cv2.IMWRITE_JPEG_QUALITY), 100])
g, b, r = color_list[key][0]
x1, x2 = gt_box[0], gt_box[2]
y1, y2 = gt_box[1], gt_box[3]
w = x2 - x1
h = y2 - y1
cv2.rectangle(
xml_image, (x1, y1), (x2, y2), (g, b, r), 1)
cv2.putText(xml_image, key, (x1 + w//2, y1 + h//2),
cv2.FONT_HERSHEY_COMPLEX, 1, (g, b, r), 1)
if save_flag == 0 or save_flag == 3:
if key in cfg.defect_class_list:
save_flag = 2
else:
save_flag = 3
for object_id in range(len(is_match_det)):
if is_match_det[object_id] == 0:
det_box = det_dicts[key][object_id]
save_dir = cfg.TEST.save_dir
name = os.path.basename(xml_name).split(
".xml")[0] + "_" + str(object_id) + ".bmp"
dst_file = save_dir + '/detected_sample_is_error/' + key + "/"
if not os.path.exists(dst_file):
os.makedirs(dst_file)
dst_file += name
image_roi = image_cpy[
int(det_box[1]):int(det_box[3]), int(det_box[0]):int(det_box[2])]
if not os.path.exists(dst_file):
cv2.imwrite(dst_file, image_roi, [
int(cv2.IMWRITE_JPEG_QUALITY), 100])
draw_img = im.copy()
save_xml = False
if save_xml:
imgFolderPath = os.path.dirname(img_name)
imgFolderName = os.path.split(imgFolderPath)[-1]
imgFileName = os.path.basename(img_name)
image = cv2.imread(img_name)
imageShape = [image.shape[0], image.shape[1], image.shape[2]]
writer = PascalVocWriter(imgFolderName, imgFileName,
imageShape, localImgPath=img_name)
writer.verified = False
if save_flag >= 2:
# show_gt_image
xml_path = img_name.replace(cfg.image_postfix, ".xml")
if os.path.exists(xml_path):
# save_image_gt
xml_image_name = os.path.basename(
img_name).replace(cfg.image_postfix, "_gt.bmp")
save_image_gt(gt_image, xml_image_name, color_list, save_dir,
cfg.rename_class_list, xml_path, cfg.class_list)
for boxes in results:
for box in boxes:
# for box_id, box in enumerate(boxes):
x1 = int(box[0])
y1 = int(box[1])
x2 = int(box[2])
y2 = int(box[3])
score = float(box[4])
label = int(box[5])
w = x2 - x1
h = y2 - y1
label_name = cfg.class_list[label]
if 0: # 'KP' == label_name and max(w, h) <= 16:
image_roi = im[y1:y2, x1:x2]
# saliency = cv2.saliency.StaticSaliencyFineGrained_create()
# (success, saliencyMap) = saliency.computeSaliency(
# cv2.cvtColor(image_roi, cv2.COLOR_RGB2LAB))
# saliencyMap = (saliencyMap * 255).astype("uint8")
# threshMap = cv2.threshold(saliencyMap.astype("uint8"), 0, 255,
# cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
image_gray = cv2.cvtColor(image_roi, cv2.COLOR_RGB2gray)
threshMap = cv2.threshold(image_gray, 0, 255,
cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
# cv2.imwrite(save_dir + 'horizon/' +
# str(box_id) + "_" + name.replace(".jpg", ".bmp"), image_roi, [
# int(cv2.IMWRITE_JPEG_QUALITY), 100])
cv2.imwrite(save_dir + '/' + "A0_" + name, image_roi)
cv2.imwrite(save_dir + '/' + "A1_" + name, image_gray)
cv2.imwrite(save_dir + '/' + "A2_" + name, threshMap)
# if label_name != 'HH':
# continue
# else:
# save_flag = 1
g, b, r = color_list[label_name][0]
# label * 50, label * 100, label * 150
if 1: # label_name in ["HH"]:
# save_flag = 1
cv2.rectangle(draw_img, (x1, y1), (x2, y2), (g, b, r), 1)
cv2.putText(draw_img, label_name, (x1 + w//2, y1 + h//2),
cv2.FONT_HERSHEY_COMPLEX, 1, (g, b, r), 1) # label*50, label*100, label*100
cv2.putText(draw_img, str(round(score, 3)), (x1 + w // 2 + 10, y1 + h // 2 + 10),
cv2.FONT_HERSHEY_COMPLEX, 1, (g, b, r), 1) # label * 50, label * 100, label * 100
# if save_xml:
# if 'M' == label_name or 'SL' == label_name or 'HH' == label_name:
# continue
# difficult = 0
# writer.addBndBox(x1, y1, x2, y2, label_name, difficult)
if save_xml:
writer.save(targetFile='./outputs/' +
name.replace(cfg.image_postfix, '.xml'))
if len(results) > 0 and save_flag >= 2:
name = os.path.basename(img_name)
cv2.imwrite(save_dir + '/' + name, draw_img)
name = os.path.basename(img_name).replace(
cfg.image_postfix, "_undetected.bmp")
if save_flag == 2:
if not os.path.exists(save_dir + '/FN_defect/'):
os.makedirs(save_dir + '/FN_defect/')
cv2.imwrite(save_dir + '/FN_defect/' + name, xml_image)
cv2.imwrite(save_dir + '/' + name, xml_image)
# hard_sample_dir = "/data/zhangcc/data/det_whiteshow_defect/1/hard_sample/"
# shutil.copy(img_name, hard_sample_dir +
# os.path.basename(img_name))
# xml_name_cpy = img_name.replace(".bmp", ".xml")
# shutil.copy(xml_name_cpy, hard_sample_dir +
# os.path.basename(xml_name_cpy))
elif save_flag == 3:
if not os.path.exists(save_dir + '/FN_device/'):
os.makedirs(save_dir + '/FN_device/')
cv2.imwrite(save_dir + '/FN_device/' + name, xml_image)
cv2.imwrite(save_dir + '/' + name, xml_image)
else:
# undetected_sample.append(name)
# shutil.copyfile(img_name, save_dir + 'undetected_sample/' + name)
# shutil.copyfile(img_name.replace(".jpg", ".xml"), save_dir + 'undetected_sample/' +
# name.replace(".jpg", ".xml"))
print('no object in this picture')
return undetected_sample
def load_trained_model(model_name, train_set, device=torch.device('cpu')):
""" Loads a pre-trained model from a state dict.
Assumes that your models are saved in 'bayesian-calibration/models'
and that your state dicts are saved in 'bayesian-calibration/models/checkpoints'
Args:
model_name: str ;
train_set: str ;
device: str; cpu by default
Returns:
A trained PyTorch model in eval mode.
"""
print('\nLoading pre-trained model')
print('----| Model: {} Train set: {}'.format(model_name, train_set))
train_set = train_set.lower()
if train_set.startswith('cifar'):
# Load local cifar-trained models
num_classes = {'cifar100': 100,
'cifar10': 10,
'cifar10imba': 10}
train_set = train_set.lower().strip()
model_name = model_name.lower().strip()
# Load the saved state dict
path_str = 'models/checkpoints/{}_{}.tar'.format(model_name, train_set)
checkpoint_path = pathlib.Path(path_str).resolve()
checkpoint = torch.load(checkpoint_path)
state_dict = checkpoint['state_dict']
if model_name == 'resnet-110':
from models.resnet import resnet
state_dict = _strip_parallel_model(state_dict)
model = resnet(num_classes=num_classes[train_set], depth=110, block_name='BasicBlock')
elif model_name == 'alexnet':
from models.alexnet import alexnet
state_dict = _strip_parallel_model(state_dict)
model = alexnet(num_classes=num_classes[train_set])
elif model_name == 'vgg19-bn':
from models.vgg import vgg19_bn
state_dict = _strip_parallel_model(state_dict)
model = vgg19_bn(num_classes=num_classes[train_set])
elif model_name == 'wrn-28-10':
from models.wrn import wrn
state_dict = _strip_parallel_model(state_dict)
model = wrn(num_classes=num_classes[train_set],
depth=28,
widen_factor=10,
dropRate=0.3)
else:
raise NotImplementedError
model.load_state_dict(state_dict)
elif train_set == 'imagenet':
# Thin wrapper to load PyTorch pretrained imagenet models
import torchvision.models as models
model = getattr(models, model_name)(pretrained=True)
else:
raise NotImplementedError
model.eval()
return model.to(device)
def main(args, model_epoch=None):
base_cfg = Config.fromfile(args.base_config)
det_cfg = Config.fromfile(args.config)
cfg = merge_config(base_cfg.model_cfg, det_cfg.model_cfg)
if model_epoch is not None:
cfg.model = os.path.join(cfg.TRAIN.save_dir,
cfg.TRAIN.model_name + model_epoch)
print(cfg.model)
if not os.path.exists(cfg.model):
return 0, 0, 0, 0, 0
gpus = ",".join('%s' % id for id in cfg.TEST.gpus)
os.environ['CUDA_VISIBLE_DEVICES'] = gpus
thresh = cfg.TEST.thresh # 0.8
nms_thresh = cfg.TEST.nms_thresh # 0.35
iou_thresh = cfg.TEST.iou_thresh
classes = len(cfg.class_list)
if 'lite' in cfg.MODEL.BACKBONE:
model = lite_faster_rcnn(cfg, classes)
elif 'pva' in cfg.MODEL.BACKBONE:
model = pva_net(classes)
elif 'resnet' in cfg.MODEL.BACKBONE:
model = resnet(classes, num_layers=101)
model.create_architecture(cfg)
checkpoint = torch.load(cfg.model)
model.load_state_dict(checkpoint['state_dict'])
if torch.cuda.is_available():
model = model.cuda()
print("using gpu...")
model.eval()
imgs = glob(os.path.join(cfg.TEST.img_path, "*.xml"))
# print(cfg.TEST.img_path)
batch_size = 1
std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32)
mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32)
std = torch.from_numpy(std).cuda()
mean = torch.from_numpy(mean).cuda()
all_detections = []
gt_box_num_datasets = dict.fromkeys(cfg.class_list, 0)
det_box_num_datasets = dict.fromkeys(cfg.class_list, 0)
undetected_sample = []
undetected_sample_size = defaultdict(list)
precsion_dicts = det_init_dict(cfg.class_list, 0)
recall_dicts = det_init_dict(cfg.class_list, 0)
TP = det_init_dict(cfg.class_list, 0)
FP = det_init_dict(cfg.class_list, 0)
FN = det_init_dict(cfg.class_list, 0)
total_image_nums = len(imgs)
for ix, img_name in enumerate(tqdm(imgs)):
img_name = img_name.replace(".xml", ".jpg")
# print(ix, img_name)
im = cv2.imread(img_name)
if im is None:
continue
import time
# start_t = time.clock()
data = prepareTestData(cfg.TEST.TEST_SCALE, im,
cfg.TEST.SCALE_MULTIPLE_OF, cfg.TEST.MAX_SIZE)
start_t = time.time()
results = im_detect(data, model, batch_size, std, mean, cfg,
nms_thresh)
end_t = time.time()
# print(ix, "/", total_image_nums, img_name, ' time consume is: ',
# end_t - start_t)
if 1: # len(results) > 0:
xml_name = img_name.replace(".jpg", ".xml")
xml_dicts = xml2dict(cfg.rename_class_list, xml_name,
cfg.class_list)
det_dicts = det_results2dict(results, cfg.class_list)
small_object_size = cfg.TEST.small_object_size
for key in cfg.class_list:
if key == '__background__':
continue
ignore_gt_box_num_per_cls = dict.fromkeys(cfg.class_list, 0)
ignore_det_box_num_per_cls = dict.fromkeys(cfg.class_list, 0)
is_match_gt = np.zeros(len(xml_dicts[key]))
is_match_det = np.zeros(len(det_dicts[key]))
for gt_id, gt_box in enumerate(xml_dicts[key]):
gt_s0 = gt_box[3] - gt_box[1]
gt_s1 = gt_box[2] - gt_box[0]
if gt_s0 < small_object_size or gt_s1 < small_object_size:
ignore_gt_box_num_per_cls[key] += 1.0
is_match_gt[gt_id] = -1.0
gt_box_num = len(
xml_dicts[key]) - ignore_gt_box_num_per_cls[key]
gt_box_num_datasets[key] += gt_box_num
# print(xml_name, key, gt_box_num, gt_box_num_datasets[key])
for det_id, det_box in enumerate(det_dicts[key]):
det_s0 = det_box[3] - det_box[1]
det_s1 = det_box[2] - det_box[0]
if det_s0 < small_object_size or det_s1 < small_object_size:
ignore_det_box_num_per_cls[key] += 1.0
is_match_det[det_id] = -1.0
continue
max_iou, max_iou_id = 0, 0
for gt_id, gt_box in enumerate(xml_dicts[key]):
if abs(is_match_gt[gt_id]) > 0:
continue
iou = calc_iou(det_box[0:-1], gt_box[0:-1])
if iou > max_iou:
max_iou = iou
max_iou_id = gt_id
if gt_id == len(xml_dicts[key]) - 1:
if max_iou > iou_thresh:
is_match_gt[max_iou_id] = 1.0
is_match_det[det_id] = 1.0
det_box_num = len(
det_dicts[key]) - ignore_det_box_num_per_cls[key]
det_box_num_datasets[key] += det_box_num
for object_id in range(len(is_match_gt)):
if is_match_gt[object_id] == 0:
gt_box = xml_dicts[key][object_id]
gt_s0 = gt_box[3] - gt_box[1]
gt_s1 = gt_box[2] - gt_box[0]
undetected_sample_size[key].append(
(os.path.basename(xml_name), object_id, gt_s0,
gt_s1))
# print(img_name, len(
# xml_dicts[key]) - ignore_gt_box_num_per_cls[key])
# save_dir = cfg.TEST.save_dir
# name = os.path.basename(img_name)
# shutil.copyfile(img_name, save_dir +
# 'undetected_sample/' + name)
# shutil.copyfile(img_name.replace(".jpg", ".xml"), save_dir + 'undetected_sample/' +
# name.replace(".jpg", ".xml"))
tp = np.sum(is_match_det)
fp = np.sum(abs(is_match_det - 1))
fn = np.sum(abs(is_match_gt - 1))
TP[key][0] += tp
FP[key][0] += fp
FN[key][0] += fn
recall_cls = np.sum(is_match_gt)
recall_dicts[key].append(recall_cls)
if gt_box_num > 0 and recall_cls / gt_box_num < 1.0 and not (
xml_name in undetected_sample):
undetected_sample.append(xml_name)
precision_cls = np.sum(is_match_gt)
precsion_dicts[key].append(precision_cls)
# if ix > 100:
# break
avg_precision = 0.0
avg_recall = 0.0
avg_fscore = 0.0
cls_num = 0.0
for key in cfg.defect_class_list:
# print("recall: ", np.sum(recall_dicts[key]),
# "gt_box_num_datasets: ", gt_box_num_datasets[key],
# "det_box_num_datasets: ", det_box_num_datasets[key])
# recall_per_cls, precision_per_cls = 0, 0
# if gt_box_num_datasets[key] > 0:
# cls_num = cls_num + 1
# recall_per_cls = np.sum(
# recall_dicts[key]) / gt_box_num_datasets[key]
# if det_box_num_datasets[key] > 0:
# precision_per_cls = np.sum(
# precsion_dicts[key]) / det_box_num_datasets[key]
recall_per_cls = TP[key][0] / (TP[key][0] + FN[key][0])
precision_per_cls = TP[key][0] / (TP[key][0] + FP[key][0])
fscore_per_cls = 2 * recall_per_cls * precision_per_cls / (
recall_per_cls + precision_per_cls)
cls_num = cls_num + 1
if gt_box_num_datasets[key] > 0:
print("class_name: ", key, "recall_per_cls: ", recall_per_cls,
"precision_per_cls: ", precision_per_cls, "fscore_per_cls: ",
fscore_per_cls, "gt_box_num_datasets: ",
gt_box_num_datasets[key], "det_box_num_datasets: ",
det_box_num_datasets[key])
avg_recall += recall_per_cls
avg_precision += precision_per_cls
avg_fscore += fscore_per_cls
avg_recall = avg_recall / cls_num
avg_precision = avg_precision / cls_num
avg_fscore = avg_fscore / cls_num
undetected_ratio = len(undetected_sample) / len(imgs)
print("avg_recall: ", avg_recall)
print("avg_precision: ", avg_precision)
print("avg_fscore: ", avg_fscore)
print("undetected_ratio: ", undetected_ratio)
# print("undetected_sample: ", undetected_sample)
with open("undetected_sample_size.txt", 'w') as f:
for key in undetected_sample_size.keys():
for undetected_gt_size in undetected_sample_size[key]:
# print("key: ", key, undetected_gt_size)
f.write("key: " + key + " " + str(undetected_gt_size) + "\n")
if key in cfg.defect_class_list:
save_dir = cfg.TEST.save_dir
name = undetected_gt_size[0]
src_file = save_dir + name.replace(".xml", ".jpg")
dst_file = save_dir + 'undetected_sample/' + \
name.replace(".xml", ".jpg")
if not os.path.exists(dst_file) and os.path.exists(
src_file):
shutil.copyfile(src_file, dst_file)
src_file = save_dir + name.replace(".xml", ".bmp")
dst_file = save_dir + 'undetected_sample/' + name.replace(
".xml", ".bmp")
if not os.path.exists(dst_file) and os.path.exists(
src_file):
shutil.copyfile(src_file, dst_file)
f.close()
# with open("undetected_sample.txt", 'w') as f:
# for key in undetected_sample_size.keys():
# for undetected_gt_size in undetected_sample_size[key]:
# f.write(str(undetected_gt_size[0]) + "\n")
# f.close()
return avg_recall, avg_precision, avg_fscore, undetected_ratio, 1
import torch
import time
import numpy as np
from models.efficientnet import efficientnet
from models.vgg import vgg
import torch.nn as nn
from models.resnet import resnet
vgg16 = vgg(False, 'vgg16', 1000, False)
vgg16.classifier = nn.Sequential(*list(vgg16.classifier.children())[:-1])
resnet50 = resnet(False, 'resnet50', 1000, False)
resnet50 = nn.Sequential(*list(resnet50.children())[:-1])
resnet101 = resnet(False, 'resnet101', 1000, False)
resnet101 = nn.Sequential(*list(resnet101.children())[:-1])
models = {
'efficientnetb0': efficientnet(False, 'b0', 1000, False, 1280),
'efficientnetb1': efficientnet(False, 'b1', 1000, False, 1280),
'efficientnetb4': efficientnet(False, 'b4', 1000, False, 1280),
'vgg16': vgg16,
'resnet50': resnet50,
'resnet101': resnet101
}
batch_sizes = [1, 10, 25]
patch_sizes = [168, 224]
devices = ['cpu', 'cuda']
for key, model in models.items():
print('==> model: {}'.format(key))
for dev in devices:
def training():
batch_size = 64
epochs = 200
fine_tune_epochs = 30
lr = 0.1
x_train, y_train, x_test, y_test, nb_classes = load_data(args.data)
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
y_train = keras.utils.to_categorical(y_train, nb_classes)
y_test = keras.utils.to_categorical(y_test, nb_classes)
datagen = ImageDataGenerator(horizontal_flip=True,
width_shift_range=5. / 32,
height_shift_range=5. / 32)
data_iter = datagen.flow(x_train,
y_train,
batch_size=batch_size,
shuffle=True)
if args.model == 'resnet':
model = resnet.resnet(nb_classes,
depth=args.depth,
wide_factor=args.wide_factor)
save_name = 'resnet_{}_{}_{}'.format(args.depth, args.wide_factor,
args.data)
elif args.model == 'densenet':
model = densenet.densenet(nb_classes,
args.growth_rate,
depth=args.depth)
save_name = 'densenet_{}_{}_{}'.format(args.depth, args.growth_rate,
args.data)
elif args.model == 'inception':
model = inception.inception_v3(nb_classes)
save_name = 'inception_{}'.format(args.data)
elif args.model == 'vgg':
model = vggnet.vgg(nb_classes)
save_name = 'vgg_{}'.format(args.data)
else:
raise ValueError('Does not support {}'.format(args.model))
model.summary()
learning_rate_scheduler = LearningRateScheduler(schedule=schedule)
if args.model == 'vgg':
callbacks = None
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
else:
callbacks = [learning_rate_scheduler]
model.compile(loss='categorical_crossentropy',
optimizer=keras.optimizers.SGD(lr=lr,
momentum=0.9,
nesterov=True),
metrics=['accuracy'])
# pre-train
history = model.fit_generator(data_iter,
steps_per_epoch=x_train.shape[0] //
batch_size,
epochs=epochs,
callbacks=callbacks,
validation_data=(x_test, y_test))
if not os.path.exists('./results/'):
os.mkdir('./results/')
save_history(history, './results/', save_name)
model.save_weights('./results/{}_weights.h5'.format(save_name))
# prune weights
# save masks for weight layers
masks = {}
layer_count = 0
# not compress first convolution layer
first_conv = True
for layer in model.layers:
weight = layer.get_weights()
if len(weight) >= 2:
if not first_conv:
w = deepcopy(weight)
tmp, mask = prune_weights(w[0],
compress_rate=args.compress_rate)
masks[layer_count] = mask
w[0] = tmp
layer.set_weights(w)
else:
first_conv = False
layer_count += 1
# evaluate model after pruning
score = model.evaluate(x_test, y_test, verbose=0)
print('val loss: {}'.format(score[0]))
print('val acc: {}'.format(score[1]))
# fine-tune
for i in range(fine_tune_epochs):
for _ in range(x_train.shape[0] // batch_size):
X, Y = data_iter.next()
# train on each batch
model.train_on_batch(X, Y)
# apply masks
for layer_id in masks:
w = model.layers[layer_id].get_weights()
w[0] = w[0] * masks[layer_id]
model.layers[layer_id].set_weights(w)
score = model.evaluate(x_test, y_test, verbose=0)
print('val loss: {}'.format(score[0]))
print('val acc: {}'.format(score[1]))
# save compressed weights
compressed_name = './results/compressed_{}_weights'.format(args.model)
save_compressed_weights(model, compressed_name)
def main():
global args, best_prec1
args = opts()
# args = parser.parse_args()
model = resnet(args)
# define-multi GPU
model = torch.nn.DataParallel(model).cuda()
print(model)
# define loss function(criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
# optimizer = torch.optim.SGD(model.parameters(),
# train with stanford dogs from scratch
if args.new_fc:
optimizer = torch.optim.SGD(
[
{
'params': model.module.conv1.parameters(),
'lr': args.lr,
'name': 'pre-trained'
},
{
'params': model.module.bn1.parameters(),
'lr': args.lr,
'name': 'pre-trained'
},
{
'params': model.module.layer1.parameters(),
'lr': args.lr,
'name': 'pre-trained'
},
{
'params': model.module.layer2.parameters(),
'lr': args.lr,
'name': 'pre-trained'
},
{
'params': model.module.layer3.parameters(),
'lr': args.lr,
'name': 'pre-trained'
},
{
'params': model.module.layer4.parameters(),
'lr': args.lr,
'name': 'pre-trained'
},
# {'params': model.module.fc.parameters(), 'lr': args.lr, 'name': 'pre-trained'}
{
'params': model.module.fc.parameters(),
'lr': args.lr,
'name': 'new-added'
}
],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
else:
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("==> loading checkpoints '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
# args.start_epoch = checkpoint['epoch']
# best_prec1 = checkpoint['best_prec1']
model_state_dict = checkpoint['target_state_dict']
model_state_dict_tmp = copy.deepcopy(model_state_dict)
if args.new_fc:
model_state_dict_init = model.state_dict()
for k_tmp in model_state_dict_tmp.keys():
if k_tmp.find('.resnet_conv') != -1:
k = k_tmp.replace('.resnet_conv', '')
model_state_dict[k] = model_state_dict.pop(k_tmp)
if args.new_fc:
# initialize fc layer
if k_tmp.find('.fc') != -1:
model_state_dict[k_tmp] = model_state_dict_init[k_tmp]
model.load_state_dict(model_state_dict)
# optimizer.load_state_dict(checkpoint['optimizer'])
print("==> loaded checkpoint '{}'(epoch {})".format(
args.resume, checkpoint['epoch']))
else:
raise ValueError('The file to be resumed from is not exited',
args.resume)
# else:
if not os.path.isdir(args.log):
os.makedirs(args.log)
log = open(os.path.join(args.log, 'log.txt'), 'w')
state = {k: v for k, v in args._get_kwargs()}
log.write(json.dumps(state) + '\n')
log.close()
cudnn.benchmark = True
# process the data and prepare the dataloaders.
train_loader, val_loader = generate_dataloader(args)
#test only
if args.test_only:
validate(val_loader, model, criterion, -1, args)
return
for epoch in range(args.start_epoch, args.epochs):
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
# evaluate on the val data
prec1 = validate(val_loader, model, criterion, epoch, args)
# record the best prec1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
if is_best:
log = open(os.path.join(args.log, 'log.txt'), 'a')
log.write(' \nTop1 acc: %3f' % (best_prec1))
log.close()
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, is_best, args)
batch_num = args.hessian_batch_size // args.mini_hessian_batch_size
if batch_num == 1:
for inputs, labels in train_loader:
hessian_dataloader = (inputs, labels)
break
else:
hessian_dataloader = []
for i, (inputs, labels) in enumerate(train_loader):
hessian_dataloader.append((inputs, labels))
if i == batch_num - 1:
break
# get model
model = resnet(num_classes=10,
depth=20,
residual_not=args.residual,
batch_norm_not=args.batch_norm)
if args.cuda:
model = model.cuda()
model = torch.nn.DataParallel(model)
criterion = nn.CrossEntropyLoss() # label loss
###################
# Get model checkpoint, get saving folder
###################
if args.resume == '':
raise Exception("please choose the trained model")
model.load_state_dict(torch.load(args.resume))
######################################################
def main():
args = parse_args()
img_path = args.img_path
save_dir = args.save_dir
args.classes = len(class_list)
if not os.path.isdir(save_dir):
os.mkdir(save_dir)
if 'lite' in args.network:
model = lite_faster_rcnn(args.classes)
elif 'pva' in args.network:
model = pva_net(args.classes)
elif 'resnet' in args.network:
model = resnet(args.classes, num_layers=101)
checkpoint = torch.load(args.model)
model.create_architecture()
model.load_state_dict(checkpoint['state_dict'])
model = model.cuda()
model = torch.nn.DataParallel(model).cuda()
model.eval()
imgs = glob(os.path.join(args.img_path, "*.jpg"))
print(args.img_path)
batch_size = 1
std = np.array(cfg.TRAIN.BBOX_NORMALIZE_STDS, dtype=np.float32)
mean = np.array(cfg.TRAIN.BBOX_NORMALIZE_MEANS, dtype=np.float32)
std = torch.from_numpy(std).cuda()
mean = torch.from_numpy(mean).cuda()
for ix, img_name in enumerate(imgs):
#print(ix, img_name)
im = cv2.imread(img_name)
name = os.path.basename(img_name)
if im is None:
continue
import time
#start_t = time.clock()
if args.gama:
im = adjust_gamma(im, 2.0)
data = prepareTestData(640, im, 32, 1440)
start_t = time.clock()
results = im_detect(data, model, batch_size, std, mean, args.classes)
end_t = time.clock()
print(ix, img_name, ' time consume is: ', end_t - start_t)
draw_img = im.copy()
save_xml = False
if save_xml:
imgFolderPath = os.path.dirname(img_name)
imgFolderName = os.path.split(imgFolderPath)[-1]
imgFileName = os.path.basename(img_name)
image = cv2.imread(img_name)
imageShape = [image.shape[0], image.shape[1], image.shape[2]]
writer = PascalVocWriter(imgFolderName,
imgFileName,
imageShape,
localImgPath=img_name)
writer.verified = False
save_flag = 0
for boxes in results:
for box in boxes:
x1 = int(box[0])
y1 = int(box[1])
x2 = int(box[2])
y2 = int(box[3])
score = float(box[4])
label = int(box[5])
w = x2 - x1
h = y2 - y1
label_name = class_list[label]
if label_name != 'HH':
continue
else:
save_flag = 1
cv2.rectangle(draw_img, (x1, y1), (x2, y2),
(label * 50, label * 100, label * 100), 1)
cv2.putText(draw_img, label_name, (x1 + w // 2, y1 + h // 2),
cv2.FONT_HERSHEY_COMPLEX, 1,
(label * 50, label * 100, label * 100), 1)
cv2.putText(draw_img, str(round(score, 3)),
(x1 + w // 2 + 10, y1 + h // 2 + 10),
cv2.FONT_HERSHEY_COMPLEX, 1,
(label * 50, label * 100, label * 100), 1)
#if save_xml:
# if 'M' == label_name or 'SL' == label_name or 'HH' == label_name:
# continue
# difficult = 0
# writer.addBndBox(x1, y1, x2, y2, label_name, difficult)
if save_xml:
writer.save(targetFile='./outputs/' +
name.replace('.jpg', '.xml'))
if len(results) > 0 and save_flag:
cv2.imwrite(save_dir + '/' + name, draw_img)
