def load_attention_model(model_path, num_classes): model = VGG( num_classes=num_classes ) #AttnVGG(num_classes=num_classes, attention=True, normalize_attn=True) checkpoint = torch.load(model_path) model.load_state_dict(checkpoint['state_dict']) return model.to(device)
def find_quad_params(): f = open('../data/CUBS/image_crop_labels_random2.txt', 'w+') cnn = VGG(200, imsize).cuda() num_scales = 2 train_data = dataset.train_loader_cubs('../data/CUBS', 1, shuffle=False) test_data = dataset.test_loader_cubs('../data/CUBS', 1, shuffle=False) im_range = range(imsize//2) for data in [train_data, test_data]: for i, (img, label) in enumerate(data): img = torch.autograd.Variable(img.cuda()) assert(img.size() == (1, 3, imsize, imsize)) img_id = data.dataset.image_ids[i] h, w = img.size(2), img.size(3) hdiff = h - h//2 wdiff = w - w//2 split_centers = [(h//2, w//2), (h//4, w//4), (h//2 + hdiff//2, w//4), (h//4, w//2 + wdiff//2), (h//2, w//4), (h//2, w//2 + wdiff//2), (h//4, w//2), (h//2 + hdiff//2, w//2), (h//2 + hdiff//2, w//2 + wdiff//2)] centers = [] for j in range(num_scales): img, best_center = get_random_quad(img, cnn, im_range, im_range) centers.extend(best_center) centers.append(h//2) f.write("{} {} {} {} {} {} {}\n".format(img_id, *centers)) f.close()
def find_best_params(): f = open('../data/CUBS/image_crop_labels2.txt', 'w+') cnn = VGG(200).cuda() num_scales = 2 train_data = dataset.train_loader_cubs('../data/CUBS', 1, shuffle=False) test_data = dataset.test_loader_cubs('../data/CUBS', 1, shuffle=False) h = imsize w = imsize up = nn.Upsample(size=(h,w), mode='bilinear') for data in [train_data, test_data]: for i, (img, label) in enumerate(data): img = torch.autograd.Variable(img.cuda()) img_id = data.dataset.image_ids[i] for j in range(num_scales): img, best_center = get_best_split(img, cnn, up) centers.extend(best_center) centers.append(h//4) f.write("{} {} {} {} {} {} {}\n".format(img_id, *centers)) f.close()
#weights = torch.DoubleTensor(weights) #sampler = torch.utils.data.sampler.WeightedRandomSampler(weights, len(weights)) dataloaders = { x: torch.utils.data.DataLoader(image_datasets[x], batch_size=BATCH_SIZE, shuffle=True, num_workers=16) for x in ['train'] } num_classes = int(sys.argv[5]) # no of classes no_of_epochs = int(sys.argv[6]) # no of epochs to train #net = AttnVGG(num_classes=num_classes, attention=True, normalize_attn=True) net = VGG(num_classes=num_classes) net = net.to(device) model = net # nn.DataParallel(net, device_ids=device_ids).to(device) dataset_sizes = {x: len(image_datasets[x]) for x in ['train']} class_names = image_datasets['train'].classes # Observe that all parameters are being optimized optimizer_ft = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) # Decay LR by a factor of 0.1 every 7 epochs exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft, step_size=7, gamma=0.1) lr_lambda = lambda epoch: np.power(0.1, epoch // 10) scheduler = lr_scheduler.LambdaLR(optimizer_ft, lr_lambda=lr_lambda)
content_paths = ["avril_cropped.jpg", "chicago_cropped.jpg"] style_paths = ["impronte_d_artista_cropped.jpg", "ashville_cropped.jpg"] test_content_images = tf.concat( [load_img(f"images/content/{f}") for f in content_paths], axis=0) test_style_images = tf.concat( [load_img(f"images/style/{f}") for f in style_paths], axis=0) content_layer = "block4_conv1" # relu-4-1 style_layers = [ "block1_conv1", # relu1-1 "block2_conv1", # relu2-1 "block3_conv1", # relu3-1 "block4_conv1", # relu4-1 ] vgg = VGG(content_layer, style_layers) transformer = TransferNet(content_layer) vgg(test_style_images) def resize_and_crop(img, min_size): img = resize(img, min_size=min_size) img = tf.image.random_crop(img, size=(args.image_size, args.image_size, 3)) img = tf.cast(img, tf.float32) return img def process_content(features): img = features["image"] img = resize_and_crop(img, min_size=286) return img
def main(): # load data print('\nloading the dataset ...\n') num_aug = 5 im_size = 224 transform_train = transforms.Compose([ RatioCenterCrop(1.), transforms.Resize((256, 256)), transforms.RandomCrop(im_size), RandomRotate(), transforms.RandomVerticalFlip(), transforms.RandomHorizontalFlip(), transforms.ToTensor(), # transforms.Normalize((0.6901, 0.5442, 0.4867), (0.0810, 0.1118, 0.1266)) # without aug transforms.Normalize((0.7052, 0.5462, 0.5203), (0.0968, 0.1285, 0.1470)) # with aug ]) transform_test = transforms.Compose([ RatioCenterCrop(1.), transforms.Resize((256, 256)), transforms.CenterCrop(im_size), transforms.ToTensor(), # transforms.Normalize((0.6901, 0.5442, 0.4867), (0.0810, 0.1118, 0.1266)) # without aug transforms.Normalize((0.7052, 0.5462, 0.5203), (0.0968, 0.1285, 0.1470)) # with aug ]) trainset = ISIC(csv_file='train.csv', transform=transform_train) trainloader = torch.utils.data.DataLoader( trainset, batch_size=opt.batch_size, shuffle=True, num_workers=8, worker_init_fn=_worker_init_fn_(), drop_last=True) testset = ISIC(csv_file='test.csv', transform=transform_test) testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False, num_workers=8) print('\ndone\n') ''' Mean = torch.zeros(3) Std = torch.zeros(3) for data in trainloader: I, __ = data N, C, __, __ = I.size() Mean += I.view(N,C,-1).mean(2).sum(0) Std += I.view(N,C,-1).std(2).sum(0) Mean /= len(trainset) Std /= len(trainset) print('mean: '), print(Mean.numpy()) print('std: '), print(Std.numpy()) return ''' # load models print('\nloading the model ...\n') assert opt.model == 'VGGNet' or opt.model == 'ResNet', "invalid argument!" if opt.model == 'VGGNet': print('Using VGG-16') net = VGG(num_classes=2) if opt.model == 'ResNet': print('Uing ResNet-50') net = ResNet(num_classes=2) criterion = nn.CrossEntropyLoss() print('\ndone\n') # move to GPU print('\nmoving models to GPU ...\n') model = nn.DataParallel(net, device_ids=device_ids).to(device) criterion.to(device) print('\ndone\n') # optimizer optimizer = optim.SGD(model.parameters(), lr=opt.lr, momentum=0.9, weight_decay=5e-4) lr_lambda = lambda epoch: np.power(0.5, epoch // 10) scheduler = lr_scheduler.LambdaLR(optimizer, lr_lambda=lr_lambda) # training print('\nstart training ...\n') step = 0 EMA_accuracy = 0 writer = SummaryWriter(opt.outf) for epoch in range(opt.epochs): torch.cuda.empty_cache() # adjust learning rate scheduler.step() current_lr = optimizer.param_groups[0]['lr'] writer.add_scalar('train/learning_rate', current_lr, epoch) print("\nepoch %d learning rate %f\n" % (epoch, current_lr)) # run for one epoch for aug in range(num_aug): for i, data in enumerate(trainloader, 0): # warm up model.train() model.zero_grad() optimizer.zero_grad() inputs, labels = data inputs, labels = inputs.to(device), labels.to(device) # forward pred = model.forward(inputs) # backward loss = criterion(pred, labels) loss.backward() optimizer.step() # display results if i % 10 == 0: model.eval() pred = model.forward(inputs) predict = torch.argmax(pred, 1) total = labels.size(0) correct = torch.eq(predict, labels).sum().double().item() accuracy = correct / total EMA_accuracy = 0.98 * EMA_accuracy + 0.02 * accuracy writer.add_scalar('train/loss_c', loss.item(), step) writer.add_scalar('train/accuracy', accuracy, step) writer.add_scalar('train/EMA_accuracy', EMA_accuracy, step) print( "[epoch %d][aug %d/%d][%d/%d] loss %.4f accuracy %.2f%% EMA_accuracy %.2f%%" % (epoch, aug, num_aug - 1, i, len(trainloader) - 1, loss.item(), (100 * accuracy), (100 * EMA_accuracy))) step += 1 # the end of each epoch model.eval() # save checkpoints print('\none epoch done, saving checkpoints ...\n') checkpoint = { 'state_dict': model.module.state_dict(), 'opt_state_dict': optimizer.state_dict(), } torch.save(checkpoint, os.path.join(opt.outf, 'checkpoint.pth')) # log test results total = 0 correct = 0 with torch.no_grad(): with open('test_results.csv', 'wt', newline='') as csv_file: csv_writer = csv.writer(csv_file, delimiter=',') for i, data in enumerate(testloader, 0): images_test, labels_test = data images_test, labels_test = images_test.to( device), labels_test.to(device) pred_test = model.forward(images_test) predict = torch.argmax(pred_test, 1) total += labels_test.size(0) correct += torch.eq(predict, labels_test).sum().double().item() # record test predicted responses responses = F.softmax(pred_test, dim=1).squeeze().cpu().numpy() responses = [ responses[i] for i in range(responses.shape[0]) ] csv_writer.writerows(responses) # log scalars precision, recall, precision_mel, recall_mel = compute_mean_pecision_recall( 'test_results.csv', 'test.csv') mAP, AUC, ROC = compute_metrics('test_results.csv', 'test.csv') writer.add_scalar('test/accuracy', correct / total, epoch) writer.add_scalar('test/mean_precision', precision, epoch) writer.add_scalar('test/mean_recall', recall, epoch) writer.add_scalar('test/precision_mel', precision_mel, epoch) writer.add_scalar('test/recall_mel', recall_mel, epoch) writer.add_scalar('test/mAP', mAP, epoch) writer.add_scalar('test/AUC', AUC, epoch) writer.add_image('curve/ROC', ROC, epoch) print( "\n[epoch %d] test result: accuracy %.2f%% \nmean precision %.2f%% mean recall %.2f%% \ \nprecision for mel %.2f%% recall for mel %.2f%% \nmAP %.2f%% AUC %.4f\n" % (epoch, 100 * correct / total, 100 * precision, 100 * recall, 100 * precision_mel, 100 * recall_mel, 100 * mAP, AUC))
vutils.save_image(fixed_annos.float() / n_classes, join(sample_path, '{:03d}_anno.jpg'.format(0)), nrow=4, padding=0) # Models E = Encoder().to(device) E.apply(init_weights) # summary(E, (3, 256, 256), device=device) G = Generator(n_classes).to(device) G.apply(init_weights) # summary(G, [(256,), (10, 256, 256)], device=device) D = Discriminator(n_classes).to(device) D.apply(init_weights) # summary(D, (13, 256, 256), device=device) vgg = VGG().to(device) if args.multi_gpu: E = nn.DataParallel(E) G = nn.DataParallel(G) # G = convert_model(G) D = nn.DataParallel(D) VGG = nn.DataParallel(VGG) # Optimizers G_opt = optim.Adam(itertools.chain(G.parameters(), E.parameters()), lr=args.lr_G, betas=(args.beta1, args.beta2)) D_opt = optim.Adam(D.parameters(), lr=args.lr_D, betas=(args.beta1, args.beta2))
imgList.append(im) labelListOneHot.append(labelOneHot) labelList.append(int(label)) return np.array(imgList), np.array(labelListOneHot), np.array(labelList) #Defining hyperparameters batch_Size = 32 steps_Per_Epoch = 32 numEpochs = 2 #Instantating VGG19 model model = vgg.VGG19_dense( (360, 360, 1), 5 ) #VGG19_dense for revised VGG19, VGG19 for VGG19. Please pay attention to VGG16(), chnage the input shape and class number in VGG.py. #Creating an optimizers adaDelta = keras.optimizers.Adadelta(lr=1.0, rho=0.95) sgd = SGD(lr=0.01, decay=1e-6, momentum=0.95, nesterov=True) model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['accuracy']) #Image data generation for the training datagen = ImageDataGenerator( featurewise_center=False, samplewise_center=False, # set each sample mean to 0 featurewise_std_normalization=True, samplewise_std_normalization=False)