def main():
args = parser.parse_args()
if not args.checkpoint:
args.pretrained = True
# create model
model = create_model(
args.model,
num_classes=args.num_classes,
in_chans=3,
pretrained=args.pretrained,
checkpoint_path=args.checkpoint)
model.eval()
x = torch.randn((1, 3, args.img_size or 224, args.img_size or 224), requires_grad=True)
torch_out = torch.onnx._export(model, x, args.output, export_params=True)
onnx_model = onnx.load(args.output)
caffe2_backend = onnx_caffe2.prepare(onnx_model)
B = {onnx_model.graph.input[0].name: x.data.numpy()}
c2_out = caffe2_backend.run(B)[0]
np.testing.assert_almost_equal(torch_out.data.numpy(), c2_out, decimal=5)
def _model_and_score_and_evaluate(active_fragments: str, test_fragments: str, test_activity: str,
num: int, output_directory: str, maximal_num: int):
inputoutput_utils.create_parent_directory(output_directory + "/scorefiles/0")
inputoutput_utils.create_parent_directory(output_directory + "/activities/0")
with open(output_directory + "/configurationfiles/configuration" + str(maximal_num) + "_" + str(num) + ".json", "r",
encoding="utf-8") as input_file:
for new_line in input_file:
line = json.loads(new_line)
if os.path.isfile(output_directory + "/evaluations/" + line["evaluation"]):
continue
new_model = model_factory.create_model(line["model_name"])
model = new_model.create_model(active_fragments, "", "", "",
line)
new_model.score_model(model, test_fragments, "",
output_directory + "/scorefiles/score" + line["evaluation"])
# run add_activity
activity = add_activity.read_activity(test_activity)
add_activity.add_activity_and_write_to_json(output_directory + "/scorefiles/score" + line["evaluation"],
activity,
output_directory + "/activities/activity" + line["evaluation"])
# run compute_evaluation
score_act = compute_evaluation.read_file_with_score_and_activity(output_directory + "/activities/activity"
+ line["evaluation"])
activity = compute_evaluation.sort_activity(score_act)
compute_evaluation.evaluation(activity, output_directory + "/evaluations/" + line["evaluation"])
def main():
args = parser.parse_args()
#args.model ='dpn92'
#args.checkpoint_path ='/root/share/data/models/reference/imagenet/dualpathnet/DPN-92_5k_to_1k'
args.model = 'dpn98'
args.checkpoint_path = '/root/share/data/models/reference/imagenet/dualpathnet/DPN-98_1k'
if 'dpn' not in args.model:
print('Error: Can only convert DPN models.')
exit(1)
if not has_mxnet:
print('Error: Cannot import MXNet module. Please install.')
exit(1)
model = model_factory.create_model(args.model,
num_classes=1000,
pretrained=False)
model_prefix = args.model
if model_prefix in ['dpn107', 'dpn68b', 'dpn92']:
model_prefix += '-extra'
checkpoint_base = os.path.join(args.checkpoint_path, model_prefix)
convert_from_mxnet(model, checkpoint_base)
output_checkpoint = os.path.join(args.checkpoint_path,
model_prefix + '.pth')
torch.save(model.state_dict(), output_checkpoint)
def _main():
configuration = _read_configuration()
with open(configuration["model"], "r", encoding="utf-8") as input_stream:
model_content = json.load(input_stream)
model = model_factory.create_model(
model_content["configuration"]["model_name"])
model.score_model(model_content, configuration["fragments"],
configuration["descriptors"], configuration["output"])
def load_trained_model(self, train_data):
p = join(self.logdir, 'trained_model*')
files = glob.glob(p)
best_trained_model_path = max(files, key=getctime)
trained_model = create_model(train_data)
trained_model.load_state_dict(
torch.load(best_trained_model_path, map_location=FLAGS.device))
trained_model.to(FLAGS.device)
return trained_model
def _main():
configuration = _read_configuration()
with open(configuration["configuration"], "r", encoding="utf-8") as input_stream:
model_configuration = json.load(input_stream)
model_name = model_configuration["model_name"]
new_model = model_factory.create_model(model_name)
model = new_model.create_model(configuration["active_fragments"], configuration["inactive_fragments"],
configuration["active_descriptors"], configuration["inactive_descriptors"],
model_configuration)
inputoutput_utils.create_parent_directory(configuration["output"])
new_model.save_to_json_file(configuration["output"], model)
def train(train_data, val_data, saver):
train_data.init_node_feats(FLAGS.init_type, FLAGS.device)
val_data.init_node_feats(FLAGS.init_type, FLAGS.device)
model = create_model(train_data)
model = model.to(FLAGS.device)
pytorch_total_params = sum(p.numel() for p in model.parameters())
print("Number params: ", pytorch_total_params)
moving_avg = MovingAverage(FLAGS.validation_window_size,
FLAGS.validation_metric != 'loss')
pyg_graph = train_data.get_pyg_graph(FLAGS.device)
optimizer = torch.optim.Adam(
model.parameters(),
lr=FLAGS.lr,
)
for epoch in range(FLAGS.num_epochs):
t = time.time()
model.train()
model.zero_grad()
loss, preds_train = model(pyg_graph, train_data)
loss.backward()
optimizer.step()
loss = loss.item()
if COMET_EXPERIMENT:
COMET_EXPERIMENT.log_metric("loss", loss, epoch + 1)
with torch.no_grad():
val_loss, preds_val = model(pyg_graph, val_data)
val_loss = val_loss.item()
eval_res_val = eval(preds_val, val_data)
print("Epoch: {:04d}, Train Loss: {:.5f}, Time: {:.5f}".format(
epoch, loss,
time.time() - t))
print("Val Loss: {:.5f}".format(val_loss))
print("Val Results: ...")
pprint(eval_res_val)
eval_res_val["loss"] = val_loss
if COMET_EXPERIMENT:
COMET_EXPERIMENT.log_metrics(eval_res_val,
prefix="validation",
step=epoch + 1)
if len(moving_avg.results) == 0 or moving_avg.best_result(
eval_res_val[FLAGS.validation_metric]):
saver.save_trained_model(model, epoch + 1)
moving_avg.add_to_moving_avg(eval_res_val[FLAGS.validation_metric])
if moving_avg.stop():
break
best_model = saver.load_trained_model(train_data)
return best_model, model
def main():
args = parser.parse_args()
if not args.checkpoint:
args.pretrained = True
else:
args.pretrained = False
# create model
print("==> Creating PyTorch {} model".format(args.model))
model = create_model(args.model,
num_classes=args.num_classes,
in_chans=3,
pretrained=args.pretrained,
checkpoint_path=args.checkpoint)
model.eval()
x = torch.randn((1, 3, args.img_size or 224, args.img_size or 224),
requires_grad=True)
model(x) # run model once before export trace
print("==> Exporting model to ONNX format at '{}'".format(args.output))
input_names = ["input0"]
output_names = ["output0"]
torch_out = torch.onnx._export(model,
x,
args.output,
export_params=True,
verbose=False,
input_names=input_names,
output_names=output_names)
print("==> Loading and checking exported model from '{}'".format(
args.output))
onnx_model = onnx.load(args.output)
onnx.checker.check_model(onnx_model) # assuming throw on error
print("==> Passed")
print("==> Loading model into Caffe2 backend and comparing forward pass.".
format(args.output))
caffe2_backend = onnx_caffe2.prepare(onnx_model)
B = {onnx_model.graph.input[0].name: x.data.numpy()}
c2_out = caffe2_backend.run(B)[0]
np.testing.assert_almost_equal(torch_out.data.numpy(), c2_out, decimal=5)
print("==> Passed")
def main():
args = parser.parse_args()
if 'dpn' not in args.model:
print('Error: Can only convert DPN models.')
exit(1)
import model_factory
model = model_factory.create_model(args.model,
num_classes=1000,
pretrained=False)
model_prefix = args.model
if model_prefix in ['dpn107', 'dpn68b', 'dpn92']:
model_prefix += '-extra'
checkpoint_base = os.path.join(args.checkpoint_path, model_prefix)
convert_from_mxnet(model, checkpoint_base)
output_checkpoint = os.path.join(args.checkpoint_path,
model_prefix + '.pth')
torch.save(model.state_dict(), output_checkpoint)
def _main():
# run extract_fragments
configuration = _read_configuration()
with open(configuration["model_configuration"], "r", encoding="utf-8") as input_stream:
model_configuration = json.load(input_stream)
try:
new_model = model_factory.create_model(model_configuration["model_name"])
except:
print("Model does not exist!")
exit(1)
if "kekule" not in model_configuration:
model_configuration["kekule"] = False
else:
model_configuration["kekule"] = bool(model_configuration["kekule"])
if "isomeric" not in model_configuration:
model_configuration["isomeric"] = False
else:
model_configuration["isomeric"] = bool(model_configuration["isomeric"])
if "fragments" not in model_configuration:
model_configuration["fragments"] = "ecfp.6"
parsed_types = []
for item in model_configuration["fragments"].split(","):
item_split = item.split(".")
if item_split[0] != "ap":
if not len(item_split) == 2:
logging.error("Invalid fragment type: %s", item)
logging.info("Expected format {TYPE}.{SIZE} or ap")
exit(1)
parsed_types.append({
"name": item_split[0],
"size": int(item_split[1])
})
else:
parsed_types.append({
"name": item_split[0],
})
model_configuration["fragments"] = parsed_types
extraction_options = {
"kekule": model_configuration["kekule"],
"isomeric": model_configuration["isomeric"],
"fragments": model_configuration["fragments"]
}
input_files = [configuration["input_actives"], configuration["input_inactives"],
configuration["test"]]
directory = configuration["directory"]
fragments_output_files = [directory+"/fragmentsa.json", directory+"/fragmentsi.json",
directory+"/fragmentst.json"]
for file in fragments_output_files:
inputoutput_utils.create_parent_directory(file)
extract_fragments.extract_fragments(input_files, configuration["input_type"],
fragments_output_files, extraction_options)
# run extract_descriptors
descriptors_output_files = [directory+"/descriptorsa.csv", directory+"/descriptorsi.csv",
directory+"/descriptorst.csv"]
for file in descriptors_output_files:
inputoutput_utils.create_parent_directory(file)
if (model_configuration["model_name"] == "descriptors_model") |\
((model_configuration["model_name"] == "linear_regression_model") and (int(model_configuration["molecules"]) == 0)):
compute_descriptors.compute_descriptors(fragments_output_files, descriptors_output_files,
True)
else:
compute_descriptors.compute_descriptors(fragments_output_files, descriptors_output_files, False)
# run create_model and score_molecules
model = new_model.create_model(directory+"/fragmentsa.json", directory+"/fragmentsi.json",
directory+"/descriptorsa.csv", directory+"/descriptorsi.csv",
model_configuration)
new_model.score_model(model, directory+"/fragmentst.json",
directory+"/descriptorst.csv", directory+"/score.json")
# run add_activity
activity = add_activity.read_activity(configuration["activity"])
add_activity.add_activity_and_write_to_json(directory + "/score.json", activity,
directory + "/activity.json")
# run compute_evaluation
score_act = compute_evaluation.read_file_with_score_and_activity(directory + "/activity.json")
activity = compute_evaluation.sort_activity(score_act)
compute_evaluation.evaluation(activity, configuration["output"])
def main():
args = parser.parse_args()
test_time_pool = False
if 'dpn' in args.model and args.img_size > 224 and not args.no_test_pool:
test_time_pool = True
# create model
num_classes = 1000
model = model_factory.create_model(
args.model,
num_classes=num_classes,
pretrained=args.pretrained,
test_time_pool=test_time_pool)
print('Model %s created, param count: %d' %
(args.model, sum([m.numel() for m in model.parameters()])))
# optionally resume from a checkpoint
if args.restore_checkpoint and os.path.isfile(args.restore_checkpoint):
print("=> loading checkpoint '{}'".format(args.restore_checkpoint))
checkpoint = torch.load(args.restore_checkpoint)
if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:
model.load_state_dict(checkpoint['state_dict'])
else:
model.load_state_dict(checkpoint)
print("=> loaded checkpoint '{}'".format(args.restore_checkpoint))
elif not args.pretrained:
print("=> no checkpoint found at '{}'".format(args.restore_checkpoint))
exit(1)
if args.multi_gpu:
model = torch.nn.DataParallel(model).cuda()
else:
model = model.cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
cudnn.benchmark = True
transforms = model_factory.get_transforms_eval(
args.model,
args.img_size)
dataset = Dataset(
args.data,
transforms)
loader = data.DataLoader(
dataset,
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
for i, (input, target) in enumerate(loader):
target = target.cuda(async=True)
input_var = torch.autograd.Variable(input, volatile=True).cuda()
target_var = torch.autograd.Variable(target, volatile=True).cuda()
# compute output
output = model(input_var)
loss = criterion(output, target_var)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.data[0], input.size(0))
top1.update(prec1[0], input.size(0))
top5.update(prec5[0], input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i, len(loader), batch_time=batch_time, loss=losses,
top1=top1, top5=top5))
print(' * Prec@1 {top1.avg:.3f} ({top1a:.3f}) Prec@5 {top5.avg:.3f} ({top5a:.3f})'.format(
top1=top1, top1a=100-top1.avg, top5=top5, top5a=100.-top5.avg))
def main():
args = parser.parse_args()
if not args.checkpoint and not args.pretrained:
args.pretrained = True
# create model
model = create_model(args.model,
num_classes=args.num_classes,
in_chans=3,
pretrained=args.pretrained,
checkpoint_path=args.checkpoint)
print('Model %s created, param count: %d' %
(args.model, sum([m.numel() for m in model.parameters()])))
data_config = resolve_data_config(model, args)
criterion = nn.CrossEntropyLoss()
if not args.no_cuda:
if args.num_gpu > 1:
model = torch.nn.DataParallel(model,
device_ids=list(range(
args.num_gpu))).cuda()
else:
model = model.cuda()
criterion = criterion.cuda()
loader = create_loader(Dataset(args.data,
load_bytes=args.tf_preprocessing),
input_size=data_config['input_size'],
batch_size=args.batch_size,
use_prefetcher=not args.no_cuda,
interpolation=data_config['interpolation'],
mean=data_config['mean'],
std=data_config['std'],
num_workers=args.workers,
crop_pct=data_config['crop_pct'],
tensorflow_preprocessing=args.tf_preprocessing)
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
model.eval()
end = time.time()
with torch.no_grad():
for i, (input, target) in enumerate(loader):
if not args.no_cuda:
target = target.cuda()
input = input.cuda()
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec1.item(), input.size(0))
top5.update(prec5.item(), input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print(
'Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f}, {rate_avg:.3f}/s) \t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i,
len(loader),
batch_time=batch_time,
rate_avg=input.size(0) / batch_time.avg,
loss=losses,
top1=top1,
top5=top5))
print(
' * Prec@1 {top1.avg:.3f} ({top1a:.3f}) Prec@5 {top5.avg:.3f} ({top5a:.3f})'
.format(top1=top1,
top1a=100 - top1.avg,
top5=top5,
top5a=100. - top5.avg))
test_dataset = Dataset(data_json=data_path + "test_1.json",
with_label=False,
transform=transforms)
# get data loader
print('getting data loader...')
test_dataloader = data.DataLoader(test_dataset,
batch_size=config["test_batch_size"],
shuffle=False,
num_workers=args.workers,
pin_memory=True)
# define model
model = model_factory.create_model(args.model,
num_classes=num_classes,
pretrained=False)
model = torch.nn.DataParallel(model).cuda()
# load checkpoint
if not os.path.isfile(config['checkpoint']):
print("=> no checkpoint found at '{}'".format(config['checkpoint']))
print("=> loading checkpoint '{}'".format(config['checkpoint']))
checkpoint = torch.load(config['checkpoint'])
model.load_state_dict(checkpoint['state_dict'])
print("=> loaded checkpoint:")
print('Epoch: [{0}][{1}]\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
def main():
args = parser.parse_args()
transforms = model_factory.get_transforms_iceberg(args.model,
args.img_size)
train_dataset = Dataset(data_json=data_path + "train_1.json",
with_label=True,
transform=None)
val_dataset = Dataset(data_json=data_path + "val_1.json",
with_label=True,
transform=None)
train_dataloader = data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_dataloader = data.DataLoader(val_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
num_train = train_dataloader.__len__()
log_file = open(
args.output_dir + str(args.model) + "_pretrained" +
str(args.pretrained) + "_lr" + str(args.lr_schedule) + "_bs" +
str(args.batch_size) + "_size" + str(args.img_size) + ".log", "w")
# configuration
config = {
'train_batch_size':
args.batch_size,
'val_batch_size':
10,
'img_size':
args.img_size,
'arch':
args.model,
'pretrained':
args.pretrained,
'ckpt_title':
"_lr" + str(args.lr_schedule) + "_bs" + str(args.batch_size) +
"_size" + str(args.img_size),
'optimizer':
'Adam',
'lr_schedule_idx':
args.lr_schedule,
'lr_schedule':
get_lr_schedule(args.lr_schedule),
'weight_decay':
1e-5,
'resume':
None,
'start_epoch':
0,
'epochs':
args.num_epochs,
'print_freq':
args.print_freq,
'validate_freq':
num_train - 1,
'save_freq':
num_train - 1,
'log_file':
log_file,
'best_val_prec1':
0
}
# create model
num_classes = 2
if args.model.endswith('sigmoid'):
num_classes = 1
model = model_factory.create_model(args.model,
num_classes=num_classes,
pretrained=False,
test_time_pool=args.test_time_pool)
# resume from a checkpoint
if args.restore_checkpoint and os.path.isfile(args.restore_checkpoint):
print("=> loading checkpoint '{}'".format(args.restore_checkpoint))
checkpoint = torch.load(args.restore_checkpoint)
print('Epoch: [{0}] iter: [{1}]\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
checkpoint['epoch'],
checkpoint['iter'],
loss=checkpoint['loss'],
top1=checkpoint['top1'],
top5=checkpoint['top5']))
config = checkpoint['config']
# set to resume mode
config['resume'] = args.restore_checkpoint
print(config)
config['log_file'] = open(
args.output_dir + str(config['arch']) + "_lr" +
str(config['lr_schedule_idx']) + "_bs" +
str(config['train_batch_size']) + "_size" +
str(config['img_size']) + ".log", "a+")
elif args.pretrained is True:
print("using pretrained model")
original_model = args.model
if args.model.endswith('sigmoid'):
original_model = args.model.rsplit('_', 1)[0]
pretrained_model = model_factory.create_model(
original_model,
num_classes=1000,
pretrained=args.pretrained,
test_time_pool=args.test_time_pool)
pretrained_state = pretrained_model.state_dict()
model_state = model.state_dict()
fc_layer_name = 'fc'
if args.model.startswith('dpn') or args.model.startswith('vgg'):
fc_layer_name = 'classifier'
for name, state in pretrained_state.items():
if not name.startswith(fc_layer_name):
model_state[name].copy_(state)
else:
print("please use pretrained model")
# exit(1)
if args.multi_gpu:
model = torch.nn.DataParallel(model).cuda()
else:
model = model.cuda()
# define loss function (criterion) and optimizer
criterion = torch.nn.CrossEntropyLoss().cuda()
if args.model.endswith('sigmoid'):
criterion = torch.nn.BCELoss().cuda()
# get trainer
Trainer = get_trainer(train_dataloader, val_dataloader, model, criterion,
config)
# Run!
Trainer.run()
def validate(model_name, args):
# create model
model = create_model(
model_name,
num_classes=args.num_classes,
pretrained=args.pretrained,
checkpoint_path=args.checkpoint)
param_count = sum([m.numel() for m in model.parameters()])
print('Model %s created, param count: %d' % (args.model, param_count))
data_config = resolve_data_config(model, args)
criterion = nn.CrossEntropyLoss()
if not args.no_cuda:
if args.num_gpu > 1:
model = torch.nn.DataParallel(model, device_ids=list(range(args.num_gpu))).cuda()
else:
model = model.cuda()
criterion = criterion.cuda()
loader = create_loader(
Dataset(args.data),
input_size=data_config['input_size'],
batch_size=args.batch_size,
use_prefetcher=not args.no_cuda,
interpolation=data_config['interpolation'],
mean=data_config['mean'],
std=data_config['std'],
num_workers=args.workers,
crop_pct=data_config['crop_pct'])
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
model.eval()
end = time.time()
with torch.no_grad():
for i, (input, target) in enumerate(loader):
if not args.no_cuda:
target = target.cuda()
input = input.cuda()
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec1.item(), input.size(0))
top5.update(prec5.item(), input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f}, {rate_avg:.3f}/s) \t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i, len(loader), batch_time=batch_time,
rate_avg=input.size(0) / batch_time.avg,
loss=losses, top1=top1, top5=top5))
results = OrderedDict(model=model_name,
top1=round(top1.avg, 3), top1_err=round(100 - top1.avg, 3),
top5=round(top5.avg, 3), top5_err=round(100 - top5.avg, 3),
loss=round(losses.avg, 4), param_count=round(param_count / 1e6, 2))
print(' * Prec@1 {:.3f} ({:.3f}) Prec@5 {:.3f} ({:.3f})'.format(
results['top1'], results['top1_err'], results['top5'], results['top5_err']))
return results
def main():
args = parser.parse_args()
# create model
num_classes = 1000
model = model_factory.create_model(
args.model,
num_classes=num_classes,
pretrained=args.pretrained,
test_time_pool=args.test_time_pool)
# resume from a checkpoint
if args.restore_checkpoint and os.path.isfile(args.restore_checkpoint):
print("=> loading checkpoint '{}'".format(args.restore_checkpoint))
checkpoint = torch.load(args.restore_checkpoint)
if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:
model.load_state_dict(checkpoint['state_dict'])
else:
model.load_state_dict(checkpoint)
print("=> loaded checkpoint '{}'".format(args.restore_checkpoint))
elif not args.pretrained:
print("=> no checkpoint found at '{}'".format(args.restore_checkpoint))
exit(1)
if args.multi_gpu:
model = torch.nn.DataParallel(model).cuda()
else:
model = model.cuda()
transforms = model_factory.get_transforms_eval(
args.model,
args.img_size)
dataset = Dataset(
args.data,
transforms)
loader = data.DataLoader(
dataset,
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
model.eval()
batch_time = AverageMeter()
end = time.time()
top5_ids = []
for batch_idx, (input, _) in enumerate(loader):
input = input.cuda()
input_var = autograd.Variable(input, volatile=True)
labels = model(input_var)
top5 = labels.topk(5)[1]
top5_ids.append(top5.data.cpu().numpy())
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if batch_idx % args.print_freq == 0:
print('Predict: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})'.format(
batch_idx, len(loader), batch_time=batch_time))
top5_ids = np.concatenate(top5_ids, axis=0).squeeze()
with open(os.path.join(args.output_dir, './top5_ids.csv'), 'w') as out_file:
filenames = dataset.filenames()
for filename, label in zip(filenames, top5_ids):
filename = os.path.basename(filename)
out_file.write('{0},{1},{2},{3},{4},{5}\n'.format(
filename, label[0], label[1], label[2], label[3], label[4]))
'height': args.height,
'width': args.width,
'model_name': args.model_name,
'batch_size': args.batch_size,
'dropout_rate': args.dropout_rate,
'learning_rate': args.learning_rate,
'num_epochs': args.num_epochs,
'num_particles': args.num_particles,
'scaling_factor': args.steps_per_epoch,
'num_splits': args.num_splits,
'debug_mode': args.debug_mode,
'load_data_with_numpy': args.load_data_with_numpy
}
print('enter your command!')
code.interact(local=dict(globals(), **locals()))
# possible example run 1 - might use a lot of RAM if not exectuted with config['debug_mode'] == True!
config['load_data_with_numpy'] = True
model = model_factory.create_model(config)
train_images, test_images, train_labels, test_labels = dataloader.load_and_preprocess_binary_data(
config)
model_factory.train_model(model, test_images, test_labels, config,
train_images, train_labels)
# possible example run 2 - uses some very dirty fixes, that have to be improved!
model = model_factory.create_model(config)
test_images, test_labels = dataloader.load_and_preprocess_multiclass_validation_data(
config=config)
model_factory.train_model(model, test_images, test_labels, config)
def main():
args = parser.parse_args()
test_time_pool = False
if 'dpn' in args.model and args.img_size > 224 and not args.no_test_pool:
test_time_pool = True
# create model
num_classes = 1000
model = model_factory.create_model(args.model,
num_classes=num_classes,
pretrained=args.pretrained,
test_time_pool=test_time_pool)
print('Model %s created, param count: %d' %
(args.model, sum([m.numel() for m in model.parameters()])))
# optionally resume from a checkpoint
if args.restore_checkpoint and os.path.isfile(args.restore_checkpoint):
print("=> loading checkpoint '{}'".format(args.restore_checkpoint))
checkpoint = torch.load(args.restore_checkpoint)
if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:
model.load_state_dict(checkpoint['state_dict'])
else:
model.load_state_dict(checkpoint)
print("=> loaded checkpoint '{}'".format(args.restore_checkpoint))
elif not args.pretrained:
print("=> no checkpoint found at '{}'".format(args.restore_checkpoint))
exit(1)
if args.multi_gpu:
model = torch.nn.DataParallel(model).cuda()
else:
model = model.cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
cudnn.benchmark = True
transforms = model_factory.get_transforms_eval(args.model, args.img_size)
dataset = Dataset(args.data, transforms)
loader = data.DataLoader(dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
batch_time = AverageMeter()
losses = AverageMeter()
top1 = AverageMeter()
top5 = AverageMeter()
# switch to evaluate mode
model.eval()
end = time.time()
with torch.no_grad():
for i, (input, target) in enumerate(loader):
target = target.cuda()
input = input.cuda()
# compute output
output = model(input)
loss = criterion(output, target)
# measure accuracy and record loss
prec1, prec5 = accuracy(output.data, target, topk=(1, 5))
losses.update(loss.item(), input.size(0))
top1.update(prec1.item(), input.size(0))
top5.update(prec5.item(), input.size(0))
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if i % args.print_freq == 0:
print('Test: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t'
'Loss {loss.val:.4f} ({loss.avg:.4f})\t'
'Prec@1 {top1.val:.3f} ({top1.avg:.3f})\t'
'Prec@5 {top5.val:.3f} ({top5.avg:.3f})'.format(
i,
len(loader),
batch_time=batch_time,
loss=losses,
top1=top1,
top5=top5))
print(
' * Prec@1 {top1.avg:.3f} ({top1a:.3f}) Prec@5 {top5.avg:.3f} ({top5a:.3f})'
.format(top1=top1,
top1a=100 - top1.avg,
top5=top5,
top5a=100. - top5.avg))
def main():
args = parser.parse_args()
# create model
num_classes = 1000
model = model_factory.create_model(args.model,
num_classes=num_classes,
pretrained=args.pretrained,
test_time_pool=args.test_time_pool)
# resume from a checkpoint
if args.restore_checkpoint and os.path.isfile(args.restore_checkpoint):
print("=> loading checkpoint '{}'".format(args.restore_checkpoint))
checkpoint = torch.load(args.restore_checkpoint)
if isinstance(checkpoint, dict) and 'state_dict' in checkpoint:
model.load_state_dict(checkpoint['state_dict'])
else:
model.load_state_dict(checkpoint)
print("=> loaded checkpoint '{}'".format(args.restore_checkpoint))
elif not args.pretrained:
print("=> no checkpoint found at '{}'".format(args.restore_checkpoint))
exit(1)
if args.multi_gpu:
model = torch.nn.DataParallel(model).cuda()
else:
model = model.cuda()
transforms = model_factory.get_transforms_eval(args.model, args.img_size)
dataset = Dataset(args.data, transforms)
loader = data.DataLoader(dataset,
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
model.eval()
batch_time = AverageMeter()
end = time.time()
top5_ids = []
for batch_idx, (input, _) in enumerate(loader):
input = input.cuda()
input_var = autograd.Variable(input, volatile=True)
labels = model(input_var)
top5 = labels.topk(5)[1]
top5_ids.append(top5.data.cpu().numpy())
# measure elapsed time
batch_time.update(time.time() - end)
end = time.time()
if batch_idx % args.print_freq == 0:
print('Predict: [{0}/{1}]\t'
'Time {batch_time.val:.3f} ({batch_time.avg:.3f})'.format(
batch_idx, len(loader), batch_time=batch_time))
top5_ids = np.concatenate(top5_ids, axis=0).squeeze()
with open(os.path.join(args.output_dir, './top5_ids.csv'),
'w') as out_file:
filenames = dataset.filenames()
for filename, label in zip(filenames, top5_ids):
filename = os.path.basename(filename)
out_file.write('{0},{1},{2},{3},{4},{5}\n'.format(
filename, label[0], label[1], label[2], label[3], label[4]))
