def main(config): if config.mode == 'train': train_loader, dataset = get_loader(config.batch_size, num_thread=config.num_thread) # run = "nnet" # if not os.path.exists("%s/run-%s" % (config.save_fold, run)): # os.mkdir("%s/run-%s" % (config.save_fold, run)) # os.mkdir("%s/run-%s/logs" % (config.save_fold, run)) # os.mkdir("%s/run-%s/models" % (config.save_fold, run)) # config.save_fold = "%s/run-%s" % (config.save_fold, run) # train = Solver(train_loader, None, config) run = strftime('V_%m-%d_%H-%M-%S', gmtime()) if not os.path.exists("%s/%s" % (config.save_fold, run)): os.mkdir("%s/%s" % (config.save_fold, run)) os.mkdir("%s/%s/logs" % (config.save_fold, run)) os.mkdir("%s/%s/models" % (config.save_fold, run)) config.save_fold = "%s/%s" % (config.save_fold, run) temp_path = "%s/temp_see" % (config.save_fold) train = Solver(train_loader, None, config, temp_path=temp_path) train.train() elif config.mode == 'test': test_loader, dataset = get_loader(config.test_batch_size, mode='test', num_thread=config.num_thread) test = Solver(None, test_loader, config, dataset.save_folder()) test.test(test_mode=config.test_mode) else: raise IOError("illegal input!!!")
def main(config): if config.mode == 'train': train_loader = get_loader(config.train_path, config.label_path, config.img_size, config.batch_size, num_thread=config.num_thread) if config.val: val_loader = get_loader(config.val_path, config.val_label, config.img_size, config.batch_size, num_thread=config.num_thread) run = 0 while os.path.exists("%s/run-%d" % (config.save_fold, run)): run += 1 os.mkdir("%s/run-%d" % (config.save_fold, run)) os.mkdir("%s/run-%d/logs" % (config.save_fold, run)) # os.mkdir("%s/run-%d/images" % (config.save_fold, run)) os.mkdir("%s/run-%d/models" % (config.save_fold, run)) config.save_fold = "%s/run-%d" % (config.save_fold, run) if config.val: train = Solver(train_loader, val_loader, None, config) else: train = Solver(train_loader, None, None, config) train.train() elif config.mode == 'test': test_loader = get_loader(config.test_path, config.test_label, config.img_size, config.batch_size, mode='test', num_thread=config.num_thread) if not os.path.exists(config.test_fold): os.mkdir(config.test_fold) test = Solver(None, None, test_loader, config) test.test(100) else: raise IOError("illegal input!!!")
def main(): random_seeding() parser = argparse.ArgumentParser() parser.add_argument('-src_data', type=str, default='data/sent_dic.pkl') parser.add_argument('-trg_data', type=str, default='data/trg.txt') parser.add_argument('-test_src_data', type=str, default='data/test_sent_dic.pkl') parser.add_argument('-test_trg_data', type=str, default='data/test_trg.txt') parser.add_argument('-root_data', type=str, default='data/root.pkl') parser.add_argument('-test_root_data', type=str, default='data/test_root.pkl') parser.add_argument('-epochs', type=int, default=100) parser.add_argument('-d_model', type=int, default=300) parser.add_argument('-n_layers', type=int, default=4) parser.add_argument('-heads', type=int, default=4) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=64) parser.add_argument('-lr', type=int, default=0.001) parser.add_argument('-max_strlen', type=int, default=120) opt = parser.parse_args() # load vocab with open('./vocab/src_vocab.pkl', 'rb') as f: SRC = pickle.load(f) with open('./vocab/trg_vocab.pkl', 'rb') as f: TRG = pickle.load(f) # get model transformer, eventer = get_model(SRC, TRG, None, opt.d_model, opt.n_layers, opt.heads, opt.dropout) total_params = sum(p.numel() for p in transformer.parameters() if p.requires_grad) print("transformer trainable parameters: ", total_params) total_params = sum(p.numel() for p in eventer.parameters() if p.requires_grad) print("eventer trainable parameters: ", total_params) optimizer = torch.optim.Adam(itertools.chain(transformer.parameters(), eventer.parameters()), lr=opt.lr, betas=(0.9, 0.98), eps=1e-9) criterion = nn.CrossEntropyLoss(ignore_index=0) dataset = get_loader(opt.src_data, opt.trg_data, opt.root_data, SRC, TRG, opt.batchsize) test_dataset = get_loader(opt.test_src_data, opt.test_trg_data, opt.test_root_data, SRC, TRG, 1, False) train_model(transformer, eventer, dataset, test_dataset, opt.epochs, criterion, optimizer, SRC, TRG)
def main(): opt = opts.parse_opt() opt.src_data = '../data/visualstorytelling/train.pkl' opt.test_src_data = '../data/visualstorytelling/test.pkl' dataset = get_loader(opt.src_data, opt.batch_size, train=True) test_dataset = get_loader(opt.test_src_data, opt.batch_size, train=False, shuffle=False) # get model bart = BART(opt) train_model(opt, bart, dataset, test_dataset, 10)
def k_fold_cross_validation(net, optimizer, criterion, train_img_list, k, present_time): transform_train, transform_test = get_train_transform( ), get_test_transform() valid_img_num = math.ceil(len(train_img_list) / k) total_best_valid_acc, total_best_valid_loss = 0, 0 for val_idx in range( k): # Which part of training set should be validation set net.load_state_dict( torch.load(f"./weights/{present_time}/init_weight.pth")) train_imgs, valid_imgs = get_cross_valid_img_list( val_idx, valid_img_num, train_img_list) train_loader = get_loader(train_imgs, transform_train) valid_loader = get_loader(valid_imgs, transform_test) train_acc_list, train_loss_list, valid_acc_list, valid_loss_list = list( ), list(), list(), list() best_valid_loss, best_valid_epoch, non_improve_count = 10000, 0, 0 for epoch in range(120): print(f"\n({val_idx})Epoch: {epoch}") train_acc, train_loss = train(net, optimizer, criterion, epoch, train_loader) valid_acc, valid_loss = test(net, criterion, epoch, valid_loader) # 以下的 list 是為了畫圖用 train_acc_list.append(train_acc) train_loss_list.append(train_loss) valid_acc_list.append(valid_acc) valid_loss_list.append(valid_loss) if (valid_loss < best_valid_loss): best_valid_loss = valid_loss best_valid_epoch = epoch non_improve_count = 0 else: non_improve_count += 1 if (non_improve_count >= 10): break total_best_valid_acc += valid_acc_list[best_valid_epoch] total_best_valid_loss += valid_loss_list[best_valid_epoch] plot_figure(train_acc_list, valid_acc_list, train_loss_list, valid_loss_list, val_idx, present_time) print("\n----------") print( f"valid acc: {total_best_valid_acc / k:.2f}, valid loss: {total_best_valid_loss / k:.2f}" )
def main(args): dataset_configs = DatasetParams(args.dataset_config_file) dataset_params_1 = dataset_configs.get_params(args.dataset_1) dataset_params_2 = dataset_configs.get_params(args.dataset_2) for p in (dataset_params_1, dataset_params_2): for d in p: # Tell dataset to output id in integer or other simple format: d.config_dict['return_simple_image_id'] = True data_loader_1, _ = get_loader(dataset_params_1, vocab=None, transform=None, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, ext_feature_sets=None, skip_images=True, iter_over_images=True) data_loader_2, _ = get_loader(dataset_params_2, vocab=None, transform=None, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, ext_feature_sets=None, skip_images=True, iter_over_images=True) show_progress = sys.stderr.isatty() print("Reading image ids from dataset {}".format(args.dataset_1)) ids_1 = [ img_ids for _, _, _, img_ids, _ in tqdm(data_loader_1, disable=not show_progress) ] set_1 = set(chain(*ids_1)) print("Reading image ids from dataset {}".format(args.dataset_2)) ids_2 = [ img_ids for _, _, _, img_ids, _ in tqdm(data_loader_2, disable=not show_progress) ] set_2 = set(chain(*ids_2)) intersection = set_1.intersection(set_2) len_intersect = len(intersection) print("There are {} images shared between {} and {}".format( len_intersect, args.dataset_1, args.dataset_2))
def main(config): torch.manual_seed(config.seed) torch.cuda.manual_seed(config.seed) # if config.mode == 'train': train_loader = get_loader(config.train_img_path, config.train_label_path, config.img_size, config.batch_size, filename=config.train_file, num_thread=config.num_thread) test_dataset = ImageData(config.test_img_path, config.test_label_path, filename=config.test_file, test=True, require_name=True) run = 0 while os.path.exists("%s/run-%d" % (config.save_fold, run)): run += 1 os.mkdir("%s/run-%d" % (config.save_fold, run)) os.mkdir("%s/run-%d/logs" % (config.save_fold, run)) # os.mkdir("%s/run-%d/images" % (config.save_fold, run)) os.mkdir("%s/run-%d/models" % (config.save_fold, run)) config.save_fold = "%s/run-%d" % (config.save_fold, run) train = Solver(train_loader, test_dataset, config) if config.mode == 'train': train.train() elif config.mode == 'test': train.test(100) else: raise IOError("illegal input!!!")
def main(): parser = argparse.ArgumentParser() parser.add_argument('-beam_size', type=int, default=4) parser.add_argument('-max_len', type=int, default=80) parser.add_argument('-d_model', type=int, default=300) parser.add_argument('-n_layers', type=int, default=4) parser.add_argument('-src_lang', default='en') parser.add_argument('-trg_lang', default='en') parser.add_argument('-heads', type=int, default=4) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-load_epoch', type=int, default=10) opt = parser.parse_args() assert opt.beam_size > 0 assert opt.max_len > 10 # load vocab with open("vocab/vocab.pkl", 'rb') as f: vocab = pickle.load(f) # opt.load_epoch = None for load_epoch in [30]: transformer = get_model(251, load_epoch, opt.d_model, opt.n_layers, opt.heads, opt.dropout) test_dataset = get_loader("data/new_keyword_test.json", 1, train=False) # evaluate # eval(transformer, test_dataset) # generate # greedy_generate(model, SRC, TRG) print('epoch', load_epoch) generate(transformer, vocab, 4)
def main(): torch.manual_seed(1) np.random.seed(0) torch.cuda.manual_seed(1) torch.cuda.manual_seed_all(1) opt = edict() opt.nGPU = 1 opt.batchsize = 1 opt.cuda = True cudnn.benchmark = True print('========================LOAD DATA============================') data_name = 'widerfacetest' test_loader = get_loader(data_name, opt.batchsize) net_G_low2high = GEN_DEEP() net_G_low2high = net_G_low2high.cuda() a = torch.load('model.pkl') net_G_low2high.load_state_dict(a) net_G_low2high = net_G_low2high.eval() index = 0 test_file = 'test_res' if not os.path.exists(test_file): os.makedirs(test_file) for idx, data_dict in enumerate(test_loader): print(idx) index = index + 1 data_low = data_dict['img16'] data_high = data_dict['img64'] img_name = data_dict['imgpath'][0].split('/')[-1] data_input_low, batchsize_high = to_var(data_low) data_input_high, _ = to_var(data_high) data_high_output = net_G_low2high(data_input_low) path = os.path.join(test_file, img_name.split('.')[0] + '.jpg') vutils.save_image(data_high_output.data, path, normalize=True)
def train(): print('start training ...........') batch_size = 16 num_epochs = 50 learning_rate = 0.1 label_converter = LabelConverter(char_set=string.ascii_lowercase + string.digits) vocab_size = label_converter.get_vocab_size() device = torch.device("cuda:0" if (torch.cuda.is_available()) else "cpu") model = CRNN(vocab_size=vocab_size).to(device) # model.load_state_dict(torch.load('output/weight.pth', map_location=device)) train_loader, val_loader = get_loader('data/CAPTCHA Images/', batch_size=batch_size) optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9, nesterov=True) scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, 'min') # scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, 10, 2) train_losses, val_losses = [], [] for epoch in range(num_epochs): train_epoch_loss = fit(epoch, model, optimizer, label_converter, device, train_loader, phase='training') val_epoch_loss = fit(epoch, model, optimizer, label_converter, device, val_loader, phase='validation') print('-----------------------------------------') if epoch == 0 or val_epoch_loss <= np.min(val_losses): torch.save(model.state_dict(), 'output/weight.pth') train_losses.append(train_epoch_loss) val_losses.append(val_epoch_loss) write_figure('output', train_losses, val_losses) write_log('output', epoch, train_epoch_loss, val_epoch_loss) scheduler.step(val_epoch_loss)
def main(): torch.manual_seed(1) np.random.seed(0) torch.cuda.manual_seed(1) torch.cuda.manual_seed_all(1) opt = edict() opt.nGPU = 1 opt.batchsize = 1 opt.cuda = True cudnn.benchmark = True print("========================LOAD DATA============================") data_name = "widerfacetest" test_loader = get_loader(data_name, opt.batchsize) net_G_low2high = GEN_DEEP() net_G_low2high = net_G_low2high.cuda() a = torch.load("model.pkl") net_G_low2high.load_state_dict(a) net_G_low2high = net_G_low2high.eval() test_file = "test_res" if not os.path.exists(test_file): os.makedirs(test_file) for idx, data_dict in enumerate(test_loader): data_low = data_dict["img16"] data_high = data_dict["img64"] img_name = data_dict["imgpath"][0].split("/")[-1] data_input_low, batchsize_high = to_var(data_low) data_input_high, _ = to_var(data_high) data_high_output = net_G_low2high(data_input_low) path = os.path.join(test_file, img_name.split(".")[0] + ".png") vutils.save_image(data_high_output.data, path, normalize=True)
def train(root, device, model, epochs, bs, lr): print('start training ...........') train_loader, val_loader = get_loader(root=root, batch_size=bs, shuffle=True) optimizer = optim.Adam(model.parameters(), lr=lr) criterion = HDRLoss(device) train_losses, val_losses = [], [] for epoch in range(epochs): train_epoch_loss = fit(epoch, model, optimizer, criterion, device, train_loader, phase='training') val_epoch_loss = fit(epoch, model, optimizer, criterion, device, val_loader, phase='validation') print('-----------------------------------------') if epoch == 0 or val_epoch_loss <= np.min(val_losses): torch.save(model.state_dict(), 'output/weight.pth') train_losses.append(train_epoch_loss) val_losses.append(val_epoch_loss) write_figures('output', train_losses, val_losses) write_log('output', epoch, train_epoch_loss, val_epoch_loss)
def main(): # random_seeding() parser = argparse.ArgumentParser() parser.add_argument('-src_data', type=str, default='../data/concept_selection/train.pkl') parser.add_argument('-test_src_data', type=str, default='../data/concept_selection/test.pkl') parser.add_argument('-epochs', type=int, default=101) parser.add_argument('-d_model', type=int, default=300) parser.add_argument('-n_layers', type=int, default=4) parser.add_argument('-heads', type=int, default=4) parser.add_argument('-dropout', type=int, default=0.1) parser.add_argument('-batchsize', type=int, default=64) parser.add_argument('-lr', type=int, default=0.0004) parser.add_argument('-max_strlen', type=int, default=700) opt = parser.parse_args() with open('vocab/vocab.pkl','rb') as f: vocab = pickle.load(f) # get model transformer = get_model(len(vocab), None, opt.d_model, opt.n_layers, opt.heads, opt.dropout) total_params = sum(p.numel() for p in transformer.parameters() if p.requires_grad) print("transformer trainable parameters: ", total_params) optimizer = torch.optim.Adam(transformer.parameters(), lr=opt.lr) criterion = nn.MSELoss() dataset = get_loader(opt.src_data, vocab, opt.batchsize, train=True) train_model(transformer, dataset, opt.epochs, criterion, optimizer)
def train_attention_captioner(): print("Training The Attention Capitoner ... ") # Create model directory if not os.path.exists(path_trained_model): os.makedirs(path_trained_model) # Image preprocessing, first resize the input image then do normalization for the pretrained resnet transform = transforms.Compose([ transforms.Resize((input_resnet_size, input_resnet_size), interpolation=Image.ANTIALIAS), transforms.RandomCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) # Loading pickle dictionary with open(dict_path, 'rb') as file: dictionary = pickle.load(file) # Build data loader data_loader = get_loader(imgs_path, data_caps, dictionary, transform, BATCH_SIZE, shuffle=True, num_workers=2) # Building the Models encoder = EncoderCNN(word_embedding_size).to(device) attn_decoder = AttnDecoderRNN(word_embedding_size, len(dictionary[0])) # Loss and optimizer criterion = nn.CrossEntropyLoss() params = list(attn_decoder.parameters()) + list( encoder.linear.parameters()) + list(encoder.bn.parameters()) optimizer = torch.optim.Adam(params, lr=LEARN_RATE) word2idx = dictionary[0] # Initiazling the decoder hidden and output decoder_input = torch.tensor([[word2idx['START']]]).to(device) decoder_hidden = torch.zeros(word_embedding_size).to(device) total_steps = len(data_loader) for epcoh in range(NUM_EPOCHS): for i, (images, captions, lengths) in enumerate(data_loader): print(images.Size, captions.Size, lengths.Size) # Set mini-batch dataset images = images.to(device) captions = captions.to(device) targets = pack_padded_sequence(captions, lengths, batch_first=True)[0] features = encoder(images) decoder_output, decoder_hidden, attn_weights = attn_decoder( decoder_input, decoder_hidden, features)
def train(self): style_img = self.load_style() if self.gpu: self.style_net = self.style_net.gpu() self.loss_net = self.loss_net.gpu() style_img = style_img.gpu() adam = optim.Adam(self.style_net.parameters(), lr=self.lr) loader = get_loader(1, self.data_path, self.img_shape, self.transform) print('Data Load Success!!') print('Training Start!!') for count in range(self.epoch): for step, frames in enumerate(loader): for i in range(1, len(frames)): x_t = frames[i] x_t1 = frames[i - 1] h_xt = self.style_net(x_t) h_xt1 = self.style_net(x_t1) s_xt = self.loss_net(x_t, self.style_layer) s_xt1 = self.loss_net(x_t1, self.style_layer) s_hxt = self.loss_net(h_xt, self.style_layer) s_hxt1 = self.loss_net(h_xt1, self.style_layer) s = self.loss_net(style, self.style_layer) # ContentLoss, conv4_2 content_t = ContentLoss(self.gpu)(s_xt[3], s_hxt[3]) content_t1 = ContentLoss(self.gpu)(s_xt1[3], s_hxt1[3]) content_loss = content_t + content_t1 # StyleLoss style_t = None style_t1 = None tv_loss = None for layer in range(len(self.style_layer)): style_t += StyleLoss(self.gpu)(s, s_hxt[layer]) style_t1 += StyleLoss(self.gpu)(s, s_hxt1[layer]) # TVLoss tv_loss = TVLoss(s_hxt[layer]) style_loss = style_t + style_t1 # Optical flow flow, mask = opticalflow(h_xt.data.numpy(), h_xt1.data.numpy()) # Temporal Loss temporal_loss = TemporalLoss(self.gpu)(h_xt, flow, mask) # Spatial Loss spatial_loss = self.s_a * content_loss + self.s_b * style_loss + self.s_r * tv_loss Loss = spatial_loss + self.t_l * temporal_loss Loss.backward(retain_graph=True) adam.step()
def main(): # Training settings parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--batch-size', type=int, default=64, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.01, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--cuda', action='store_true', default=True, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') args = parser.parse_args() if torch.cuda.is_available(): if not args.cuda: print("you should use CUDA/GPU to train the model") torch.manual_seed(args.seed) device = torch.device("cuda" if args.cuda else "cpu") kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {} train_loader, test_loader = get_loader(args, kwargs) model = Net().to(device) optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) train(args, model, device, train_loader, test_loader, optimizer)
def main(args): backbone_names = args.backbones.split('+') dataset_names = args.datasets.split('+') for dataset in dataset_names: for backbone in backbone_names: print("Working on [DATASET: %s] with [BACKBONE: %s]" % (dataset, backbone)) # Configure testset path test_rgb_path = os.path.join(args.input_root, dataset, 'RGB') test_dep_path = os.path.join(args.input_root, dataset, 'depth') res_path = os.path.join(args.save_root, 'BiANet_' + backbone, dataset) os.makedirs(res_path, exist_ok=True) test_loader = get_loader(test_rgb_path, test_dep_path, 224, 1, num_thread=8, pin=True) # Load model and parameters exec('from models import BiANet_' + backbone) model = eval('BiANet_' + backbone).BiANet() pre_dict = torch.load( os.path.join(args.param_root, 'BiANet_' + backbone + '.pth')) device = torch.device("cuda") model.to(device) if backbone == 'vgg16': model = torch.nn.DataParallel(model, device_ids=[0]) model.load_state_dict(pre_dict) model.eval() # Test Go! tensor2pil = transforms.ToPILImage() with torch.no_grad(): for batch in test_loader: rgbs = batch[0].to(device) deps = batch[1].to(device) name = batch[2][0] imsize = batch[3] scaled_preds = model(rgbs, deps) res = scaled_preds[-1] res = nn.functional.interpolate(res, size=imsize, mode='bilinear', align_corners=True).cpu() res = res.squeeze(0) res = tensor2pil(res) res.save(os.path.join(res_path, name[:-3] + 'png')) print('Outputs were saved at:' + args.save_root)
def evaluate(self): model = load_ensemble_from_checkpoints( self.train_results["checkpoints"].checkpoints) results = evaluate(model, get_loader(get_dataset("val")), device=self.device) labels, preds = results["labels"], results["predictions"] print("AVG AUC", mt.roc_auc_score(labels, preds)) return labels, preds
def get_eval_loaders(): # We can extend this dict to evaluate on multiple datasets. eval_loaders = { 'TVL': get_loader( is_train=False, root=args.eval, mv_dir=args.eval_mv, args=args), } return eval_loaders
def _train(args): device = 'cuda' if torch.cuda.is_available() else 'cpu' # Data print('==> Preparing data..') trainloader, testloader = dataset.get_loader() # Model print('==> Building model..') teacher_net = VGG('VGG16') teacher_net = teacher_net.to(device) if device == 'cuda': teacher_net = torch.nn.DataParallel(teacher_net) cudnn.benchmark = True # Load checkpoint. print('==> Resuming from checkpoint..') assert os.path.isdir('checkpoint'), 'Error: no checkpoint directory found!' checkpoint = torch.load('./checkpoint/{}.pth'.format( args.teacher_model_name)) teacher_net.load_state_dict(checkpoint['net']) student_net = StudentNet() student_net = student_net.to(device) if device == 'cuda': student_net = torch.nn.DataParallel(student_net) cudnn.benchmark = True criterion = _make_criterion(alpha=args.alpha, T=args.T, mode=args.kd_mode) if args.optimizer == 'sgd': optimizer = optim.SGD(student_net.parameters(), lr=args.lr, momentum=0.9) elif args.optimizer == 'sgd-cifar10': optimizer = optim.SGD(student_net.parameters(), lr=0.1, momentum=0.9) elif args.optimizer == 'adam': optimizer = optim.Adam(student_net.parameters(), lr=args.lr) else: raise NotImplementedError() for epoch_idx in range(1, args.n_epoch + 1): print('\nEpoch: %d' % epoch_idx) __train_epoch(student_net, teacher_net, trainloader, device, criterion, optimizer) __test_epoch(student_net, testloader, device, criterion) if args.optimizer == 'sgd-cifar10': if epoch_idx == 150: optimizer = optim.SGD(student_net.parameters(), lr=0.01, momentum=0.9) elif epoch_idx == 250: optimizer = optim.SGD(student_net.parameters(), lr=0.001, momentum=0.9)
def main(config): if config.mode == 'train': train_loader = get_loader(config) if not os.path.exists("%s/demo-%s" % (config.save_folder, time.strftime("%d"))): os.mkdir("%s/demo-%s" % (config.save_folder, time.strftime("%d"))) config.save_folder = "%s/demo-%s" % (config.save_folder, time.strftime("%d")) train = Solver(train_loader, None, config) train.train() elif config.mode == 'test': test_loader = get_loader(config, mode='test') if not os.path.exists(config.test_folder): os.makedirs(config.test_folder) test = Solver(None, test_loader, config) test.test() else: raise IOError("illegal input!!!")
def main(config): if config.mode == 'train': train_loader, dataset = get_loader(config.batch_size, num_thread=config.num_thread) run = "nnet" if not os.path.exists("%s/run-%s" % (config.save_fold, run)): os.mkdir("%s/run-%s" % (config.save_fold, run)) os.mkdir("%s/run-%s/logs" % (config.save_fold, run)) os.mkdir("%s/run-%s/models" % (config.save_fold, run)) config.save_fold = "%s/run-%s" % (config.save_fold, run) train = Solver(train_loader, None, config) train.train() elif config.mode == 'test': test_loader, dataset = get_loader(config.test_batch_size, mode='test',num_thread=config.num_thread, test_mode=config.test_mode, sal_mode=config.sal_mode) test = Solver(None, test_loader, config, dataset.save_folder()) test.test(test_mode=config.test_mode) elif config.mode =='application': test_loader, dataset = get_loader(config.test_batch_size, mode='test', num_thread=config.num_thread, test_mode=config.test_mode, sal_mode=config.sal_mode) test = Solver(None, test_loader, config, dataset.save_folder()) test.application()
def main(opt): # model utils.ensure_dir(opt.checkpoint) model = get_model(opt) model = nn.DataParallel(model).cuda() utils.load_checkpoint(model, opt.model) # dataloader val_loader = get_loader(opt, train=False, shuffle=False)['loader'] _ = validate(val_loader, model, opt)
def __init__(self, finetune=False, max_train_samples=None, lr=0.00001, epochs=3, arch="resnet", layers=18, model=None, output_path="./models/model", uncertainty_strategy='best', side=None): print("Training using options", "arch", arch, "finetune", finetune, "layers", layers) self.output_path = output_path self.side = side if model is None: self.model = get_model(finetune=finetune, arch="resnet", layers=layers) else: self.model = model params = self.model.parameters( ) if finetune else self.model.fc.parameters() self.optimizer = optim.Adam(params, lr=lr) self.max_train_samples = max_train_samples self.criterion = nn.BCEWithLogitsLoss() self.dataloaders = { "train": get_loader( get_dataset("train", uncertainty_strategy=uncertainty_strategy, side=side)), "val": get_loader(get_dataset("val", side=side)) } self.device = torch.device( "cuda:0" if torch.cuda.is_available() else "cpu") self.model.to(self.device) self.epochs = epochs self.train_results = None
def run_loaders(args): for split in ['train', 'valid']: # Stanford loader print(f'Testing Stanford {split} loader') loader_SU = get_loader(stanford_frac=1, nih_frac=0, split=split, shuffle=True, args=args) test_loader(loader_SU) # Stanford loader STUDY print(f'Testing Stanford {split} loader') loader_SU_study = get_loader(stanford_frac=1, nih_frac=0, split=split, shuffle=True, args=args, study_level=True) test_loader(loader_SU_study) # NIH loader print(f'Testing NIH {split} loader') loader_NIH = get_loader(stanford_frac=0, nih_frac=1, split=split, shuffle=True, args=args) #test_loader(loader_NIH) # NIH & Stanford combined loaders print(f'Testing NIH & SU combo {split} loader') loader_combo = get_loader(stanford_frac=1, nih_frac=1, split=split, shuffle=True, args=args) test_loader(loader_combo)
def main(hyp): model = load_model(hyp) model.eval() train_loader, len_data = get_loader(hyp, mode='train') if has_threshold == False: threshold = compute_threshold(model, train_loader, len_data) else: #threshold = -6.2835 threshold = -0.6870 print('threshold: ', threshold) test_loader, len_data = get_loader(hyp, mode='test') scores = np.zeros(shape=(len_data, 2)) step = 0 with torch.no_grad(): for x, y in test_loader: enc, dec, z, gamma = model(x) m_prob, m_mean, m_cov = model.get_gmm_param(gamma, z) for i in range(z.shape[0]): zi = z[i].unsqueeze(1) sample_energy = model.sample_energy(m_prob, m_mean, m_cov, zi, gamma.shape[1], gamma.shape[0]) se = sample_energy.detach().item() scores[step] = [int(y[i]), int(se > threshold)] step += 1 accuracy = accuracy_score(scores[:, 0], scores[:, 1]) precision, recall, fscore, support = precision_recall_fscore_support( scores[:, 0], scores[:, 1], average='binary') print('Accuracy: %.4f Precision: %.4f Recall: %.4f F-score: %.4f' % (accuracy, precision, recall, fscore))
def test_net(net): for test_dir_img in test_lists: test_loader = get_loader(test_dir_img, img_size, 1, mode='test', num_thread=1) print(''' Starting testing: dataset: {} Testing size: {} '''.format( test_dir_img.split('/')[-1], len(test_loader.dataset))) for i, data_batch in enumerate(test_loader): print('{}/{}'.format(i, len(test_loader.dataset))) images, depths, image_w, image_h, image_path = data_batch images, depths = Variable(images.cuda()), Variable(depths.cuda()) outputs_image, outputs_depth = net(images, depths) _, _, _, _, _, imageBran_output = outputs_image _, _, _, _, _, depthBran_output = outputs_depth image_w, image_h = int(image_w[0]), int(image_h[0]) output_imageBran = F.sigmoid(imageBran_output) output_depthBran = F.sigmoid(depthBran_output) output_imageBran = output_imageBran.data.cpu().squeeze(0) output_depthBran = output_depthBran.data.cpu().squeeze(0) transform = trans.Compose( [transforms.ToPILImage(), trans.Scale((image_w, image_h))]) outputImageBranch = transform(output_imageBran) outputDepthBranch = transform(output_depthBran) dataset = image_path[0].split('RGBdDataset_processed')[1].split( '/')[1] filename = image_path[0].split('/')[-1].split('.')[0] # save image branch output save_test_path = save_test_path_root + dataset + '/' + test_model + '/' if not os.path.exists(save_test_path): os.makedirs(save_test_path) outputImageBranch.save( os.path.join(save_test_path, filename + '.png'))
def __init__(self, config): self.config = config self.device = torch.device( 'cuda' if torch.cuda.is_available() else 'cpu') self.train_data = Dataset(num_of_frame=config.num_of_frame, root=config.data_path, mode='train') self.train_loader = get_loader(dataset=self.train_data, batch_size=config.batch_size, shuffle=True, drop_last=True) self.val_data = Dataset(num_of_frame=config.num_of_frame, root=config.data_path, mode='val') self.val_loader = get_loader(dataset=self.val_data, batch_size=config.batch_size, shuffle=True, drop_last=True) # self.test_data self.lipnet = LipNet(config.vocab_size).to(self.device) self.ctc_loss = CTCLoss() self.optim = torch.optim.Adam(self.lipnet.parameters(), config.learning_rate)
def run(self): # try: data_loader = get_loader('custom') loader = data_loader(filepath=(self.left_path, self.right_path)) test_loader = data.DataLoader(loader, batch_size=1, shuffle=False, num_workers=1) model = AtrousNet(192).cuda() model = nn.DataParallel(model) model_name = 'net/KITTI2012-RAP.tar' checkpoint = torch.load(model_name) model.load_state_dict(checkpoint['state_dict']) model.eval() is_evalAl = True if (len(test_loader) > 1) else False for i, datafile in enumerate(test_loader): top_pad, left_pad, img_l, img_r, file_name = datafile top_pad = top_pad[0] left_pad = left_pad[0] img_l, img_r = Variable(img_l.squeeze(0), volatile=True).cuda(), \ Variable(img_r.squeeze(0), volatile=True).cuda() with torch.no_grad(): out = model(img_l, img_r) out = out[:, top_pad:, :-left_pad] pred_disp = out.data.cpu().numpy() _, h, w = pred_disp.shape pred_disp = np.reshape(pred_disp, (h, w)) pred_disp = (pred_disp * 255).astype('uint16') #(np.uint8) # v_max = pred_disp.max() # v_min = pred_disp.min() # pred_disp = cv2.convertScaleAbs(pred_disp, 255/(v_max-v_min)) # color_disp = cv2.applyColorMap(pred_disp, cv2.COLORMAP_JET) idx = i if is_evalAl else self.idx skimage.io.imsave(self.disp_path[i], pred_disp) self.signals.result.emit(i) # except: # pass#traceback.print_exc() # finally: self.signals.finished.emit()
def get_data_loader(args): check_dataset(args) dataset_configs = dl.DatasetParams(args.dataset_config_file) dataset_params = dataset_configs.get_params(args.dataset) # Get data loader data_loader, _ = dl.get_loader(dataset_params, None, None, 128, shuffle=False, num_workers=args.num_workers, skip_images=True, unique_ids=True) assert len(data_loader) != 0, 'ERROR: No captions found, please specify a dataset that has captions defined.' assert args.dataset != 'coco', 'HINT: instead of "coco" use "coco:train2014"' return data_loader