opt.training_dataset = "unlabeled"
# random seeds
torch.manual_seed(opt.seed)
torch.cuda.manual_seed(opt.seed)
np.random.seed(opt.seed)
if opt.device.type != "cpu":
torch.backends.cudnn.benchmark = True
num_patches = opt.grid_dims * opt.grid_dims
# load model
models, optimizers = [None for i in range(num_patches)], [None for i in range(num_patches)]
for i in range(num_patches):
models[i], optimizers[i] = load_vision_model.load_model_and_optimizer(opt)
logs = logger.Logger(opt)
train_loader, _, supervised_loader, _, test_loader, _ = get_dataloader.get_dataloader(
opt
)
if opt.loss == 1:
train_loader = supervised_loader
try:
# Train the model
train(opt, models)
except KeyboardInterrupt:
opt = arg_parser.parse_args()
arg_parser.create_log_path(opt)
opt.training_dataset = "unlabeled"
# random seeds
torch.manual_seed(opt.seed)
torch.cuda.manual_seed(opt.seed)
np.random.seed(opt.seed)
if opt.device.type != "cpu":
torch.backends.cudnn.benchmark = True
# load model
models, optimizers = [None for i in range(4)], [None for i in range(4)]
for i in range(4):
models[i], optimizers[i] = load_vision_model.load_model_and_optimizer(
opt, patch_idx=i)
logs = logger.Logger(opt)
train_loader, _, supervised_loader, _, test_loader, _ = get_dataloader.get_dataloader(
opt)
if opt.loss == 1:
train_loader = supervised_loader
try:
# Train the model
train(opt, models)
except KeyboardInterrupt:
print("Training got interrupted, saving log-files now.")
if __name__ == "__main__":
opt = arg_parser.parse_args()
add_path_var = "linear_model"
arg_parser.create_log_path(opt, add_path_var=add_path_var)
opt.training_dataset = "train"
# random seeds
torch.manual_seed(opt.seed)
torch.cuda.manual_seed(opt.seed)
np.random.seed(opt.seed)
# load pretrained model
context_model, _ = load_vision_model.load_model_and_optimizer(
opt, reload_model=True, calc_loss=False)
context_model.module.switch_calc_loss(False)
## model_type=2 is supervised model which trains entire architecture; otherwise just extract features
if opt.model_type != 2:
context_model.eval()
_, _, train_loader, _, test_loader, _ = get_dataloader.get_dataloader(opt)
classification_model = load_vision_model.load_classification_model(opt)
if opt.model_type == 2:
params = list(context_model.parameters()) + list(
classification_model.parameters())
else:
params = classification_model.parameters()
if __name__ == "__main__":
opt = arg_parser.parse_args()
arg_parser.create_log_path(opt)
opt.training_dataset = "unlabeled"
# random seeds
torch.manual_seed(opt.seed)
torch.cuda.manual_seed(opt.seed)
np.random.seed(opt.seed)
if opt.device.type != "cpu":
torch.backends.cudnn.benchmark = True
# load model
model, optimizer = load_vision_model.load_model_and_optimizer(opt)
logs = logger.Logger(opt)
train_loader, _, supervised_loader, _, test_loader, _ = get_dataloader.get_dataloader(
opt)
if opt.loss == 1:
train_loader = supervised_loader
try:
# Train the model
train(opt, model)
except KeyboardInterrupt:
print("Training got interrupted, saving log-files now.")