def resnet101(pretrained_model=None, **kwargs):
model = ResNet(Bottleneck, [3, 4, 23, 3], **kwargs)
if pretrained_model is not None:
model = load_model(model, pretrained_model)
# model.load_state_dict(load_url(model_urls['resnet101']), strict=False)
return model
def resnet50(pretrained_model=None, **kwargs):
model = ResNet(Bottleneck, [3, 4, 6, 3], **kwargs)
if pretrained_model is not None:
model = load_model(model, pretrained_model)
# model.load_state_dict(load_url(model_urls['resnet50'], map_location=torch.device('cpu')), strict=False)
return model
def resnet18(pretrained_model=None, **kwargs):
model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)
if pretrained_model is not None:
model = load_model(model, pretrained_model)
# model.load_state_dict(load_url(model_urls['resnet18']), strict=False)
return model
def run(self, model_path, model_indice, log_file):
"""There are four evaluation modes:
1.only eval a .pth model: -e *.pth
2.only eval a certain epoch: -e epoch
3.eval all epochs in a given section: -e start_epoch-end_epoch
4.eval all epochs from a certain started epoch: -e start_epoch-
"""
if '.pth' in model_indice:
models = [
model_indice,
]
elif "-" in model_indice:
start_epoch = int(model_indice.split("-")[0])
end_epoch = model_indice.split("-")[1]
models = os.listdir(model_path)
models.remove("epoch-last.pth")
models.remove("tensorboard")
models.remove('imgs')
models.remove("config.json")
sorted_models = [None] * len(models)
model_idx = [0] * len(models)
for idx, m in enumerate(models):
print(m)
num = m.split(".")[0].split("-")[1]
model_idx[idx] = num
sorted_models[idx] = m
model_idx = np.array([int(i) for i in model_idx])
down_bound = model_idx >= start_epoch
up_bound = [True] * len(sorted_models)
if end_epoch:
end_epoch = int(end_epoch)
assert start_epoch < end_epoch
up_bound = model_idx <= end_epoch
bound = up_bound * down_bound
model_slice = np.array(sorted_models)[bound]
models = [os.path.join(model_path, model) for model in model_slice]
else:
models = [
os.path.join(model_path, 'epoch-%s.pth' % model_indice),
]
results = open(log_file, 'a')
# link_file(log_file, log_file_link)
for model in models:
logger.info("Load Model: %s" % model)
self.val_func = load_model(self.network, model)
result_line = self.multi_process_evaluation()
results.write('Model: ' + model + '\n')
results.write(result_line)
results.write('\n')
results.flush()
results.close()
def restore_checkpoint(self):
t_start = time.time()
if self.distributed:
# tmp = torch.load(self.continue_state_object,
# map_location=lambda storage, loc: storage.cuda(
# self.local_rank))
tmp = torch.load(self.continue_state_object, map_location=torch.device('cpu'))
else:
tmp = torch.load(self.continue_state_object)
t_ioend = time.time()
self.state.model = load_model(self.state.model, tmp['model'],
True)
self.state.optimizer.load_state_dict(tmp['optimizer'])
self.state.epoch = tmp['epoch'] + 1
self.state.iteration = tmp['iteration']
del tmp
t_end = time.time()
self.logger.info(
"Load checkpoint from file {}, "
"Time usage:\n\tIO: {}, restore snapshot: {}".format(
self.continue_state_object, t_ioend - t_start, t_end - t_ioend))
def xception39(pretrained_model=None, **kwargs):
model = Xception(Block, [4, 8, 4], [16, 32, 64], **kwargs)
if pretrained_model is not None:
model = load_model(model, pretrained_model)
return model
def resnet152(pretrained_model=None, **kwargs):
model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs)
if pretrained_model is not None:
model = load_model(model, pretrained_model)
return model
def resnet34(pretrained_model=None, **kwargs):
model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)
if pretrained_model is not None:
model = load_model(model, pretrained_model)
return model