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)