def main():
options = get_parser().parse_args()
if not os.path.exists(EXPERIMENT_PATH):
os.makedirs(EXPERIMENT_PATH)
print(options.is_validation)
print(options.classes_per_it_tr)
tr_dataloader = init_dataloader(options, 'train')
if options.is_validation:
val_dataloader = init_dataloader(options, 'test')
model = init_protonet(options)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
if options.is_validation:
train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=val_dataloader,
model=model,
optim=optim,
lr_scheduler=lr_scheduler)
else:
train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=None,
model=model,
optim=optim,
lr_scheduler=lr_scheduler)
def main():
'''
Initialize everything and train
'''
options = get_parser().parse_args()
if not os.path.exists(options.experiment_root):
os.makedirs(options.experiment_root)
if torch.cuda.is_available() and not options.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
init_seed(options)
# trainval_dataloader = init_dataloader(options, 'trainval')
test_dataloader = init_dataloader(options, 'test')
model = init_protonet(options)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
# model.load_state_dict(best_state)
print('Testing with best model..')
test(opt=options, test_dataloader=test_dataloader, model=model)
def eval(opt):
'''
Initialize everything and train
'''
options = get_parser().parse_args()
if torch.cuda.is_available() and not options.cuda:
print("WARNING: You have a CUDA device, so you should probably run with --cuda")
print("Evaluation mode")
init_seed(options)
test_dataloader = init_dataloader(options, 'test')
model = init_protonet(options)
model_path = os.path.join(opt.experiment_root, 'best_model.pth')
model.load_state_dict(torch.load(model_path))
distance_fn = "cosine" if options.distance_fn==0 else "euclidean"
test_loss_fn = PrototypicalLoss(options.num_support_val, distance_fn, options.regularizer)
test(opt=options,
test_dataloader=test_dataloader,
model=model,
loss_fn=test_loss_fn)
def main():
'''
Initialize everything and train
'''
options = get_parser().parse_args()
device = 'cuda:2' if torch.cuda.is_available() and options.cuda else 'cpu'
if not os.path.exists(options.experiment_root):
os.makedirs(options.experiment_root)
if torch.cuda.is_available() and not options.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
init_seed(options)
tr_dataloader, mytrain_dataloader = init_dataloader(options, 'train')
val_dataloader, _ = init_dataloader(options, 'val')
# trainval_dataloader = init_dataloader(options, 'trainval')
test_dataloader, mytest_dataloader = init_dataloader(options, 'val')
model = init_protonet(options, device=device)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
res = train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=val_dataloader,
test_dataloader=test_dataloader,
mytrain_dataloader=mytrain_dataloader,
mytest_dataloader=mytest_dataloader,
model=model,
optim=optim,
lr_scheduler=lr_scheduler,
device=device)
avg_train_loss, avg_train_acc, avg_val_loss, avg_val_acc, avg_test_acc = res
print('draw training loss and accuracy curve!!!')
plt.subplot(121)
plt.plot(range(options.epochs), avg_train_loss, 'g', label='train loss')
plt.plot(range(options.epochs), avg_val_loss, 'r', label='val loss')
plt.xlabel('epoch')
plt.ylabel('loss')
plt.legend(loc='best')
plt.subplot(122)
plt.plot(range(options.epochs), avg_train_acc, 'g', label='train acc')
plt.plot(range(options.epochs), avg_val_acc, 'r', label='val acc')
plt.plot(range(options.epochs), avg_test_acc, 'b', label='test acc')
plt.xlabel('epoch')
plt.ylabel('accuracy')
plt.legend(loc='best')
plt.savefig('result.jpg')
plt.show()
def main():
'''
Initialize everything and train
'''
options = get_parser().parse_args()
print(options)
if not os.path.exists(options.experiment_root):
os.makedirs(options.experiment_root)
if torch.cuda.is_available() and not options.cuda:
print("WARNING: You have a CUDA device, so you should probably run with --cuda")
init_seed(options)
tr_dataloader = init_dataloader(options, 'train')
val_dataloader = init_dataloader(options, 'val')
# trainval_dataloader = init_dataloader(options, 'trainval')
test_dataloader = init_dataloader(options, 'test')
model = init_protonet(options)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
distance_fn = "cosine" if options.distance_fn==0 else "euclidean"
train_loss_fn = PrototypicalLoss(options.num_support_tr, distance_fn)
train_loss_fn = PrototypicalLoss(options.num_support_vals, distance_fn)
res = train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=val_dataloader,
model=model,
optim=optim,
lr_scheduler=lr_scheduler)
best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res
print('Testing with last model..')
test(opt=options,
test_dataloader=test_dataloader,
model=model)
model.load_state_dict(best_state)
print('Testing with best model..')
test(opt=options,
test_dataloader=test_dataloader,
model=model)
def eval(opt):
'''
Initialize everything and train
'''
options = get_parser().parse_args()
if torch.cuda.is_available() and not options.cuda:
print("WARNING: You have a CUDA device, so you should probably run with --cuda")
init_seed(options)
test_dataloader = init_dataset(options)[-1]
model = init_protonet(options)
model_path = os.path.join(opt.experiment_root, 'best_model.pth')
model.load_state_dict(torch.load(model_path))
test(opt=options,
test_dataloader=test_dataloader,
model=model)
def main():
options = get_parser().parse_args()
opt = {}
for arg in vars(options):
opt[arg] = getattr(options, arg)
split_dir = os.path.join(options.dataset_root, "tabula_muris_split")
tissues = ["Marrow", "Skin", "Large_Intestine", "Tongue", "Lung", "Thymus", "Liver", "Aorta", "Trachea", "Pancreas"]
for tissue in tqdm(tissues):
full_dir = os.path.join(options.experiment_root, tissue)
utils.mkdir_p(full_dir)
opt["experiment_root"] = full_dir
opt["split_file"] = os.path.join(split_dir, tissue, "split.json")
command = "python train.py"
for arg in opt:
command += " --{} {}".format(arg, opt[arg])
print(command)
os.system(command)
def main():
'''
Initialize everything and run test
'''
options = get_parser().parse_args()
if torch.cuda.is_available() and not options.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
init_seed(options)
test_dataloader = init_dataloader(options, 'test')
model = init_protonet(options, x_dim=test_dataloader.dataset.get_dim())
model_path = os.path.join(options.experiment_root, 'best_model.pth')
model.load_state_dict(torch.load(model_path))
print('Testing with best model..')
test(opt=options, test_dataloader=test_dataloader, model=model)
def main():
'''
Initialize everything and train
'''
options = get_parser().parse_args()
if not os.path.exists(options.experiment_root):
os.makedirs(options.experiment_root)
if torch.cuda.is_available() and not options.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
init_seed(options)
tr_dataloader = init_dataloader(options, 'train')
val_dataloader = init_dataloader(options, 'val')
# trainval_dataloader = init_dataloader(options, 'trainval')
# test_dataloader = init_dataloader(options, 'test')
model = init_protonet(options)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
res = train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=val_dataloader,
model=model,
optim=optim,
lr_scheduler=lr_scheduler)
best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res
print(
'************************ Congrats! Training over ************************'
)
# test(opt=options,
# test_dataloader=test_dataloader,
# model=model)
# model.load_state_dict(best_state)
print('Now train for few shot classes')
def main():
'''
Initialize everything and train
'''
# 返回所有的参数选项
options = get_parser().parse_args()
# 创建输出路径
if not os.path.exists(options.experiment_root):
os.makedirs(options.experiment_root)
# 有cuda但命令行中没有指定
if torch.cuda.is_available() and not options.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
init_seed(options)
tr_dataloader = init_dataloader(options, 'train')
val_dataloader = init_dataloader(options, 'val')
# trainval_dataloader = init_dataloader(options, 'trainval')
test_dataloader = init_dataloader(options, 'test')
model = init_protonet(options)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
res = train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=val_dataloader,
model=model,
optim=optim,
lr_scheduler=lr_scheduler)
best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res
print('Testing with last model..')
test(opt=options, test_dataloader=test_dataloader, model=model)
model.load_state_dict(best_state)
print('Testing with best model..')
test(opt=options, test_dataloader=test_dataloader, model=model)
def main():
'''
Initialize everything and train
'''
options = get_parser().parse_args()
if not os.path.exists(options.experiment_root):
os.makedirs(options.experiment_root)
if options.distance_fn == "euk":
from prototypical_loss import prototypical_loss as loss_fn
elif options.distance_fn == "rbf":
print("using RBF distance")
from prototypical_loss import prototypical_loss_rbf as loss_fn
else:
raise NotImplementedError("Unknown distance function")
if torch.cuda.is_available() and not options.cuda:
print(
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
init_seed(options)
tr_dataloader = init_dataloader(options, 'train')
# trainval_dataloader = init_dataloader(options, 'trainval')
model = init_protonet(options)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
res = train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=tr_dataloader,
model=model,
loss_fn=loss_fn,
optim=optim,
lr_scheduler=lr_scheduler,
bg_weight=options.bg_weight)
def main():
'''
Initialize everything and train
'''
options = get_parser().parse_args()
if not os.path.exists(options.experiment_root):
os.makedirs(options.experiment_root)
if torch.cuda.is_available() and not options.cuda:
print("WARNING: You have a CUDA device, so you should probably run with --cuda")
init_seed(options)
dataset_root = options.dataset_root
train_split = 0.7
val_split = 0.1
test_split = 0.2
image_folders = [os.path.join(dataset_root, SKU, image) for SKU in os.listdir(dataset_root) \
if os.path.isdir(os.path.join(dataset_root, SKU)) for image in os.listdir(os.path.join(dataset_root, SKU))]
total_num = len(image_folders)
train_num = int(train_split*total_num)
val_num = int(val_split*total_num)
test_num = total_num - (train_num + val_num)
random.seed(0)
random.shuffle(image_folders)
metatrain = image_folders[:train_num]
print("No: of Images in train:", len(metatrain))
metaval = image_folders[train_num:train_num+val_num]
print("No: of images in validation: ", len(metaval))
metatest = image_folders[train_num+val_num:]
print("No: of images in test: ", len(metatest))
root_folder = '/home/caffe/data/'
train_folder = root_folder +'train'
val_folder = root_folder+'val'
test_folder = root_folder+'test'
split_dataset(train_folder, metatrain)
split_dataset(val_folder, metaval)
split_dataset(test_folder, metatest)
tr_dataloader = init_dataloader(options, 'train', root = train_folder)
torch.cuda.empty_cache()
val_dataloader = init_dataloader(options, 'val', root = val_folder)
torch.cuda.empty_cache()
# trainval_dataloader = init_dataloader(options, 'trainval')
test_dataloader = init_dataloader(options, 'test', root = test_folder)
torch.cuda.empty_cache()
filepath = '/home/caffe/orbix/Prototypical-Networks-for-Few-shot-Learning-PyTorch/output/best_model_rgb28.pth'
model = init_protonet(opt = options,pretrained_file = filepath, pretrained = True)
optim = init_optim(options, model)
lr_scheduler = init_lr_scheduler(options, optim)
res = train(opt=options,
tr_dataloader=tr_dataloader,
val_dataloader=val_dataloader,
model=model,
optim=optim,
lr_scheduler=lr_scheduler)
best_state, best_acc, train_loss, train_acc, val_loss, val_acc = res
print('Testing with last model..')
test(opt=options,
test_dataloader=test_dataloader,
model=model)
model.load_state_dict(best_state)
print('Testing with best model..')
test(opt=options,
test_dataloader=test_dataloader,
model=model)
_, preds = torch.max(outputs, 1)
if test_pred is None:
test_pred = outputs.data.cpu()
else:
test_pred = torch.cat((test_pred, outputs.data.cpu()), dim=0)
test_pred = torch.softmax(test_pred, dim=1, dtype=float)
submission_df[['healthy', 'multiple_diseases', 'rust', 'scab']] = test_pred
submission_df.to_csv(options.output_root + options.output_name + '.csv',
index=False)
if __name__ == "__main__":
options = get_parser().parse_args()
# model_idx = options.model
batch_size = options.batch_size
num_epoch = options.epochs
data_root = options.data_root
input_size = options.input_size
train_csv_path = data_root + "train.csv"
test_csv_path = data_root + "test.csv"
images_dir = data_root + "images/"
submission_df_path = data_root + "sample_submission.csv"
num_classes = 4
num_cv_folds = 5
device = get_device()
def config_parser():
import parser_util
return parser_util.get_parser()
