transform=train_transform) dataset_val = VGG10Dataset('data', 'vgg10vallist.txt', train=False) loss_fn = nn.CrossEntropyLoss() train_loader = DataLoader(dataset_tr, batch_size=batch_size, shuffle=True, **kwargs) val_loader = DataLoader(dataset_val, batch_size=batch_size, shuffle=False, **kwargs) embedding_net = EmbeddingNet() model = ClassificationNet(embedding_net, nclasses) if cuda: model = nn.DataParallel(model).cuda() optimizer = optim.SGD(model.parameters(), lr=lr, nesterov=True, momentum=0.9, weight_decay=1e-4) scheduler = lr_scheduler.CosineAnnealingLR(optimizer, 20, eta_min=1e-5, last_epoch=-1) fit(train_loader, val_loader,
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {} train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, **kwargs) # Set up the network and training parameters from networks import EmbeddingNet, ClassificationNet from metrics import AccumulatedAccuracyMetric embedding_net = EmbeddingNet() model = ClassificationNet(embedding_net, n_classes=n_classes) if cuda: model.cuda() loss_fn = torch.nn.NLLLoss() lr = 1e-2 optimizer = optim.Adam(model.parameters(), lr=lr) scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1) n_epochs = 20 log_interval = 50 fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler,
train_transform = transforms.Compose([ transforms.RandomHorizontalFlip(), transforms.ColorJitter(hue=0.1), transforms.RandomGrayscale(p=0.1) ]) # we dont add ToTensor as it is done using from_numpy in the dataset class dataset_tr = VGG10Dataset('data', 'vgg10trainlist.txt', transform=train_transform) dataset_val = VGG10Dataset('data', 'vgg10vallist.txt', train=False) loss_fn = DopplegangerLoss() embedding_net = EmbeddingNet() model = ClassificationNet(embedding_net, nclasses) if cuda: model = nn.DataParallel(model).cuda() loss_fn = loss_fn.cuda() optimizer = optim.SGD([{ 'params': model.parameters() }, { 'params': loss_fn.parameters() }], lr=lr, nesterov=True, momentum=0.9, weight_decay=1e-4) scheduler = lr_scheduler.CosineAnnealingLR(optimizer, 20,
accuracy = [] thd = [] folds = KFold(n=6000, n_folds=10) thresholds = np.arange(-1.0, 1.0, 0.005) #predicts = np.array(map(lambda line: line.strip('\n').split(), predicts)) predicts = np.array(predicts) for idx, (train, test) in enumerate(folds): best_thresh = find_best_threshold(thresholds, predicts[train]) accuracy.append(eval_acc(best_thresh, predicts[test])) thd.append(best_thresh) print('LFWACC={:.4f} std={:.4f} thd={:.4f}'.format(np.mean(accuracy), np.std(accuracy), np.mean(thd))) return np.mean(accuracy), predicts if __name__ == '__main__': #breakpoint() mining_tech = 'RandomSampling_l2_parametrized' model_eval = nn.DataParallel(ClassificationNet(EmbeddingNet(), 854)).to('cuda') _, result = eval(model_eval, model_path=os.path.join('checkpoints', mining_tech, 'best_model.pth')) np.savetxt(os.path.join('results', mining_tech, 'result.txt'), result, '%s')
# Set up data loaders batch_size = 64 kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {} train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, **kwargs) # Set up the network and training parameters from networks import EmbeddingNet, ClassificationNet from metrics import AccumulatedAccuracyMetric n_items = 7981 embed_dim = 2 embedding_net = EmbeddingNet(embed_dim) model = ClassificationNet(embedding_net, n_classes=n_items) if cuda: model.cuda() loss_fn = torch.nn.NLLLoss() lr = 1e-2 optimizer = optim.Adam(model.parameters(), lr=lr) scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1) # n_epochs = 20 n_epochs = 20 log_interval = 1 if not resume_from_pth: record_history = fit(train_loader, test_loader, model, loss_fn, optimizer, scheduler, n_epochs, cuda, log_interval, metrics=[AccumulatedAccuracyMetric()]) plot_history(experiment_folder, record_history) torch.save(model.state_dict(), trained_weight_file)
kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {} train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, **kwargs) # Set up the network and training parameters from networks import EmbeddingNet, ClassificationNet, EmbeddingResnet from metrics import AccumulatedAccuracyMetric embedding_net = EmbeddingResnet() model = ClassificationNet(embedding_net, n_classes=n_classes) if cuda: model.cuda() loss_fn = nn.NLLLoss() lr = 1e-2 #optimizer = optim.Adam(model.parameters(), lr=lr) optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=0.0005) scheduler = lr_scheduler.StepLR(optimizer, 8, gamma=0.1, last_epoch=-1) n_epochs = 25 log_interval = 50 fit(train_loader, test_loader,
shuffle=True, num_workers=4) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=True, num_workers=4) no_of_training_batches = len(train_loader) / batch_size no_of_test_batches = len(test_loader) / batch_size device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') n_classes = 10 epochs = 20 embeddingNet = EmbeddingNet() classificationNet = ClassificationNet(embeddingNet, n_classes) optimizer = optim.Adam(classificationNet.parameters(), lr=0.001, betas=(0.9, 0.999), weight_decay=0.0005) def visualize_tensor(x): x = x.squeeze(0) x = x.squeeze(0) x = x.numpy() plt.imshow(x, cmap='gray') plt.show()
def main(): """main function""" writer = SummaryWriter(log_dir='runs/' + args.log_dir) # tensorboard # hyper parameters setting lr = args.lr k = args.K amount = args.amount n_epochs = args.n_epochs log_interval = 100 batch_size = args.batch_size pretrained = args.pretrained method = args.method n_K = args.n_K margin = args.margin shuffle_interval = args.shuffle_interval opt = args.optimizer step_size = args.step_size global_loss = args.global_loss triplet_loss_p = args.triplet_loss_p network = args.network embedding_len = args.embedding_len batch_n_classes = args.batch_n_classes batch_n_num = args.batch_n_num use_sampler = args.use_sampler rm_zero = args.rm_zero center_sigma = args.center_sigma gamma = args.gamma weight_decay = args.weight_decay data_augmentation = args.data_augmentation save_model_path = args.save_model_path log_dir = args.log_dir freeze_parameter = args.freeze_parameter use_cross_entropy = args.use_cross_entropy # load data dataset = SpecificDataset(args.dataset, data_augmentation) n_classes = dataset.n_classes classes = dataset.classes channels = dataset.channels width, height = dataset.width, dataset.height gap = dataset.gap train_dataset = SampledDataset(dataset.train_dataset, channels, amount) print('Train data has {}'.format(len(train_dataset))) test_dataset = dataset.test_dataset print('Validation data has {}'.format(len(test_dataset))) test_dataset_fc = dataset.test_dataset_fc if dataset.test_dataset_fc is not None else None kwargs = {'num_workers': 8, 'pin_memory': False} # tarin_shuffle = True if shuffle_interval == 0 else False tarin_shuffle = (shuffle_interval == 0) batch_sampler = BatchSampler(train_dataset, n_classes=batch_n_classes, n_num=batch_n_num) sampler_train_loader = torch.utils.data.DataLoader(train_dataset, batch_sampler=batch_sampler, **kwargs) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=tarin_shuffle, **kwargs) test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False, **kwargs) test_fc_loader = torch.utils.data.DataLoader(test_dataset_fc, batch_size=batch_size, shuffle=False, **kwargs) if test_dataset_fc is not None else None embedding_net = EmbeddingNet(network=network, pretrained=pretrained, embedding_len=embedding_len, gap=gap, freeze_parameter=freeze_parameter) if method == 'classification': # model = resnet.resnet32().cuda() model = ClassificationNet(embedding_net, n_classes=n_classes, embedding_len=embedding_len).cuda() elif method in ['kTriplet', 'batchHardTriplet', 'batchAllTriplet', 'batchSemiHardTriplet']: model = embedding_net.cuda() else: print('method must provide') sys.exit(-1) optimizer = get_optimizer(opt, model, lr, weight_decay) if opt == 'SGD': #if args.dataset == 'SD198': #scheduler = lr_scheduler.MultiStepLR(optimizer, milestones=[200, 500, 950], gamma=0.5, last_epoch=-1) #else: scheduler = lr_scheduler.StepLR(optimizer, step_size, gamma=0.5, last_epoch=-1) else: scheduler = None # add model graph into tensorboard #dummy_input = torch.zeros(size=(batch_size, channels, height, width)).cuda() #writer.add_graph(model, dummy_input) #del dummy_input if method == 'classification': loss_fn = nn.CrossEntropyLoss().cuda() fit_classification(train_loader, test_loader, test_fc_loader, model, loss_fn, optimizer, scheduler, n_epochs, writer=writer, n_classes=n_classes, data_augmentation=data_augmentation) elif method in ['kTriplet', 'batchHardTriplet', 'batchAllTriplet', 'batchSemiHardTriplet']: loss_fn = nn.TripletMarginLoss(margin=margin, p=triplet_loss_p, reduction='none').cuda() fit(train_loader, sampler_train_loader, test_loader, test_fc_loader, model, loss_fn, optimizer, scheduler, n_epochs, k, n_K, log_interval, shuffle_interval, global_loss=global_loss, writer=writer, n_classes=n_classes, gamma=gamma, center_sigma=center_sigma, use_sampler=use_sampler, rm_zero=rm_zero, method=method, data_augmentation=data_augmentation, freeze_parameter=freeze_parameter, use_cross_entropy=use_cross_entropy) # save model save_model_path = os.path.join(save_model_path, log_dir) torch.save(model.state_dict(), save_model_path) print('save model in {}'.format(save_model_path)) # plot tensor in tensorboard train_embeddings_tl, train_labels_tl = extract_embeddings(train_loader, model, embedding_len) plot_embeddings(train_embeddings_tl, train_labels_tl, classes, writer, tag='train_embeddings') val_embeddings_tl, val_labels_tl = extract_embeddings(test_loader, model, embedding_len) plot_embeddings(val_embeddings_tl, val_labels_tl, classes, writer, tag='val_embeddings')
mnist_classes = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b', '#e377c2', '#7f7f7f', '#bcbd22', '#17becf'] batch_size = 4096 train_loader = DataLoader(train_dataset, batch_size = batch_size, shuffle = True, num_workers = 4) test_loader = DataLoader(test_dataset, batch_size = batch_size, shuffle = True, num_workers = 4) no_of_training_batches = len(train_loader)/batch_size no_of_test_batches = len(test_loader)/batch_size device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu') n_classes = 10 embeddingNet = EmbeddingNet() classificationNet = ClassificationNet(embeddingNet, n_classes) model = classificationNet model.to(device) checkpoint = torch.load(checkpoints_path) model_parameters = checkpoint['state_dict'] model.load_state_dict(model_parameters) model.eval() def plot_embeddings(embeddings, targets): for i in range(10): inds = np.where(targets == i)[0] x = embeddings[inds, 0] y = embeddings[inds, 1] plt.scatter(x, y, alpha = 0.5, color = colors[i])