def main(opts): pprint(vars(opts)) device = torch.device(opts.device) print('using device: {}'.format(device)) encoder = Convnet().to(device) encoder.load_state_dict(torch.load(opts.weights)) encoder.eval() pipeline = protoPipe(encoder, opts.shot_k, opts.query_k) test_set = MNIST(mode='test') test_sampler = TaskSampler(test_set.label, 1000, opts.n_way, opts.shot_k + opts.query_k) test_loader = DataLoader(dataset=test_set, batch_sampler=test_sampler, num_workers=8, pin_memory=True) test_acc = [] for episode, batch in enumerate(test_loader, 0): task = batch[0].view(opts.n_way * (opts.shot_k + opts.query_k), 3, 84, 84) loss, acc = pipeline(task.to(device), opts.n_way) test_acc.append(acc) m, h = mean_confidence_interval(test_acc) print('TEST set acc: {:.4f}, h: {:.4f}'.format(m, h))
def main(opts): pprint(vars(opts)) device = torch.device(opts.device) print('using device: {}'.format(device)) encoder = Convnet().to(device) encoder.load_state_dict(torch.load(opts.weights)) encoder.eval() pipeline = protoPipe(encoder, opts.shot_k, opts.query_k) if opts.seed is not None: torch.manual_seed(opts.seed) torch.cuda.manual_seed_all(opts.seed) np.random.seed(opts.seed) print("\nrandom seed: {}".format(opts.seed)) if opts.dataset == 'mini': test_set = MiniImageNet(mode='test') elif opts.dataset == 'MNIST': test_set = MNIST(mode='test') elif opts.dataset == 'CIFAR': test_set = CIFAR(mode='test') elif opts.dataset == 'FashionMNIST': test_set = Fashion_MNIST(mode='test') test_sampler = TaskSampler(test_set.label, 1000, opts.n_way, opts.shot_k + opts.query_k) test_loader = DataLoader(dataset=test_set, batch_sampler=test_sampler, num_workers=8, pin_memory=True) test_acc = [] for episode, batch in enumerate(test_loader, 0): task = batch[0].view(opts.n_way * (opts.shot_k + opts.query_k), 3, 84, 84) loss, acc = pipeline(task.to(device), opts.n_way) test_acc.append(acc) m, h = mean_confidence_interval(test_acc) print('TEST set acc: {:.4f}, h: {:.4f}'.format(m, h))
parser.add_argument('--query', type=int, default=30) parser.add_argument('--folds', type=int, default=2) args = parser.parse_args() pprint(vars(args)) set_gpu(args.gpu) dataset = MiniImageNet('test') sampler = CategoriesSampler(dataset.label, args.batch, args.way, args.folds * args.shot + args.query) loader = DataLoader(dataset, batch_sampler=sampler, num_workers=8, pin_memory=True) model = Convnet().cuda() model.load_state_dict(torch.load(args.load)) model.eval() ave_acc = Averager() s_label = torch.arange(args.train_way).repeat(args.shot).view(args.shot * args.train_way) s_onehot = torch.zeros(s_label.size(0), 20) s_onehot = s_onehot.scatter_(1, s_label.unsqueeze(dim=1), 1).cuda() for i, batch in enumerate(loader, 1): data, _ = [_.cuda() for _ in batch] k = args.way * args.shot data_shot, meta_support, data_query = data[:k], data[k:2*k], data[2*k:] #p = inter_fold(model, args, data_shot) x = model(data_shot) x = x.reshape(args.shot, args.way, -1).mean(dim=0)
optimizer_global2.step() proto = None proto_final = None logits = None loss = None tl1 = tl1.item() tl2 = tl2.item() ta1 = ta1.item() ta2 = ta2.item() #log('epoch {}, train, loss={:.4f} acc={:.4f}'.format(epoch, tl, ta)) log('epoch {}, train, loss1={:.4f} loss2={:.4f} acc1={:.4f} acc2={:.4f}' .format(epoch, tl1, tl2, ta1, ta2)) model_cnn.eval() model_reg.eval() vl1 = Averager() vl2 = Averager() va1 = Averager() va2 = Averager() for i, batch in enumerate(val_loader, 1): data, lab = [_.cuda() for _ in batch] p = args.shot * args.test_way data_shot, data_query = data[:p], data[p:] data_shot = data_shot[:, 3:, :] data_query = data_query[:, 3:, :]
def main(args): device = torch.device(args.device) ensure_path(args.save_path) data = Data(args.dataset, args.n_batches, args.train_way, args.test_way, args.shot, args.query) train_loader = data.train_loader val_loader = data.valid_loader model = Convnet(x_dim=2).to(device) optimizer = torch.optim.Adam(model.parameters(), lr=0.001) lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5) def save_model(name): torch.save(model.state_dict(), osp.join(args.save_path, name + '.pth')) trlog = dict( args=vars(args), train_loss=[], val_loss=[], train_acc=[], val_acc=[], max_acc=0.0, ) timer = Timer() for epoch in range(1, args.max_epoch + 1): lr_scheduler.step() model.train() tl = Averager() ta = Averager() for i, batch in enumerate(train_loader, 1): data, _ = [_.to(device) for _ in batch] data = data.reshape(-1, 2, 105, 105) p = args.shot * args.train_way embedded = model(data) embedded_shot, embedded_query = embedded[:p], embedded[p:] proto = embedded_shot.reshape(args.shot, args.train_way, -1).mean(dim=0) label = torch.arange(args.train_way).repeat(args.query).to(device) logits = euclidean_metric(embedded_query, proto) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) print('epoch {}, train {}/{}, loss={:.4f} acc={:.4f}' .format(epoch, i, len(train_loader), loss.item(), acc)) tl.add(loss.item()) ta.add(acc) optimizer.zero_grad() loss.backward() optimizer.step() tl = tl.item() ta = ta.item() model.eval() vl = Averager() va = Averager() for i, batch in enumerate(val_loader, 1): data, _ = [_.cuda() for _ in batch] data = data.reshape(-1, 2, 105, 105) p = args.shot * args.test_way data_shot, data_query = data[:p], data[p:] proto = model(data_shot) proto = proto.reshape(args.shot, args.test_way, -1).mean(dim=0) label = torch.arange(args.test_way).repeat(args.query).to(device) logits = euclidean_metric(model(data_query), proto) loss = F.cross_entropy(logits, label) acc = count_acc(logits, label) vl.add(loss.item()) va.add(acc) vl = vl.item() va = va.item() print('epoch {}, val, loss={:.4f} acc={:.4f}'.format(epoch, vl, va)) if va > trlog['max_acc']: trlog['max_acc'] = va save_model('max-acc') trlog['train_loss'].append(tl) trlog['train_acc'].append(ta) trlog['val_loss'].append(vl) trlog['val_acc'].append(va) torch.save(trlog, osp.join(args.save_path, 'trlog')) save_model('epoch-last') if epoch % args.save_epoch == 0: save_model('epoch-{}'.format(epoch)) print('ETA:{}/{}'.format(timer.measure(), timer.measure(epoch / args.max_epoch)))