def main(args):
if args.gpu is not None:
print('Using GPU %d' % args.gpu)
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
else:
print('CPU mode')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transform = transforms.Compose([
transforms.RandomResizedCrop(227),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
val_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(227),
#transforms.RandomResizedCrop(227),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
])
# DataLoader initialize
train_data = DataLoader(args.pascal_path,
'trainval',
transform=train_transform)
t_trainloader = torch.utils.data.DataLoader(dataset=train_data,
batch_size=args.batch,
shuffle=True,
num_workers=CORES,
pin_memory=True)
print('[DATA] Target Train loader done!')
val_data = DataLoader(args.pascal_path,
'test',
transform=val_transform,
random_crops=args.crops)
t_testloader = torch.utils.data.DataLoader(dataset=val_data,
batch_size=args.batch,
shuffle=False,
num_workers=CORES,
pin_memory=True)
print('[DATA] Target Test loader done!')
if not args.test:
s_trainset = torchvision.datasets.ImageFolder(
args.imgnet_path,
transform=transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.RandomResizedCrop(227),
transforms.ToTensor(), normalize
]))
s_trainloader = torch.utils.data.DataLoader(dataset=s_trainset,
batch_size=5 * args.batch,
shuffle=False,
num_workers=CORES,
pin_memory=True)
print('[DATA] Source Train loader done!')
N = len(train_data.names)
iter_per_epoch = N / args.batch
model = Network(num_classes=21)
g_model = Network(num_classes=21)
d_model = disnet()
if args.gpu is not None:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print('[MODEL] CUDA DEVICE : {}'.format(device))
model.to(device)
g_model.to(device)
d_model.to(device)
optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
lr=args.lr,
momentum=0.9,
weight_decay=0.0001)
g_optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
g_model.parameters()),
lr=args.lr,
momentum=0.9,
weight_decay=0.0001)
d_optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
d_model.parameters()),
lr=args.lr,
momentum=0.9,
weight_decay=0.0001)
if args.model is not None:
checkpoint = torch.load(args.model)
model.load(checkpoint['model'], True)
g_model.load(checkpoint['g_model'], True)
d_model.load_state_dict(checkpoint['d_model'])
optimizer.load_state_dict(checkpoint['optimizer'])
g_optimizer.load_state_dict(checkpoint['g_optimizer'])
d_optimizer.load_state_dict(checkpoint['d_optimizer'])
############## TRAINING ###############
print('Start training: lr %f, batch size %d' % (args.lr, args.batch))
print('Checkpoint: ' + args.checkpoint)
# Train the Model
steps = args.iter_start
best_mAP = 0.0
best_path = './{}/model-{}_pretrained-{}_lr-0pt001_lmd_s-{}_acc-{}.pth'.format(
args.checkpoint, 'alexnet', 'False', args.lmd_s, '{}')
if args.test:
args.epochs = 1
for epoch in range(int(iter_per_epoch * args.iter_start), args.epochs):
if not args.test:
adjust_learning_rate(optimizer,
epoch,
init_lr=args.lr,
step=100,
decay=0.1)
adjust_learning_rate(g_optimizer,
epoch,
init_lr=args.lr / 2,
step=100,
decay=0.1)
adjust_learning_rate(d_optimizer,
epoch,
init_lr=args.lr / 1.5,
step=100,
decay=0.1)
done = train(epoch, model, g_model, d_model, optimizer,
g_optimizer, d_optimizer, t_trainloader,
s_trainloader, args.lmd_s, device)
best_mAP = test(epoch, model, g_model, d_model, optimizer, g_optimizer,
d_optimizer, t_testloader, best_mAP, best_path, device)
def main():
save_dir = join(save_root, args.save_dir)
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
if args.gpu is not None:
print(('Using GPU %d' % args.gpu))
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
else:
print('CPU mode')
print('Process number: %d' % (os.getpid()))
## DataLoader initialize ILSVRC2012_train_processed
trainpath = join(args.data_path, args.domain)
train_data = DataLoader(trainpath,
split='train',
classes=args.classes,
ssl=True)
train_loader = torch.utils.data.DataLoader(dataset=train_data,
batch_size=args.batch,
shuffle=True,
num_workers=args.cores)
valpath = join(args.data_path, args.domain)
val_data = DataLoader(valpath, split='validation', classes=args.classes)
val_loader = torch.utils.data.DataLoader(dataset=val_data,
batch_size=args.batch,
shuffle=True,
num_workers=args.cores)
iter_per_epoch = train_data.N / args.batch
print('Images: train %d, validation %d' % (train_data.N, val_data.N))
# Network initialize
net = Network(args.classes)
if args.gpu is not None:
net.cuda()
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=5e-4)
logger = Logger(join(save_root, args.save_dir, 'train'))
logger_test = Logger(join(save_root, args.save_dir, 'test'))
############## TESTING ###############
if args.evaluate:
test(net, criterion, None, val_loader, 0)
return
############## TRAINING ###############
print(('Start training: lr %f, batch size %d, classes %d' %
(args.lr, args.batch, args.classes)))
print(('Checkpoint: ' + args.save_dir))
# Train the Model
batch_time, net_time = [], []
steps = args.iter_start
best_acc = -1
for epoch in range(args.epochs):
if epoch % 10 == 0 and epoch > 0:
net, acc = test(net, criterion, logger_test, val_loader, steps)
if (best_acc < acc):
net.save(join(save_dir, 'best_model.pth'))
lr = adjust_learning_rate(optimizer,
epoch,
init_lr=args.lr,
step=20,
decay=0.1)
end = time()
for i, (images, labels, original) in enumerate(train_loader):
batch_time.append(time() - end)
if len(batch_time) > 100:
del batch_time[0]
images = Variable(images)
labels = Variable(labels)
if args.gpu is not None:
images = images.cuda()
labels = labels.cuda()
# Forward + Backward + Optimize
optimizer.zero_grad()
t = time()
outputs = net(images)
net_time.append(time() - t)
if len(net_time) > 100:
del net_time[0]
prec1, prec5 = compute_accuracy(outputs.cpu().data,
labels.cpu().data,
topk=(1, 5))
# acc = prec1[0]
acc = prec1
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
loss = float(loss.cpu().data.numpy())
steps += 1
if steps % 1000 == 0:
filename = join(save_dir, ('%06d.pth.tar' % (steps)))
net.save(filename)
print('Saved: ' + args.save_dir)
end = time()
###########################################################################################################
# classifier finetune #
###########################################################################################################
finetune_model = Network(65)
pretrained_dict = {
k: v
for k, v in net.state_dict().items()
if k in finetune_model.state_dict()
}
finetune_model.state_dict().update(pretrained_dict)
def main():
if args.gpu is not None:
print(('Using GPU %d' % args.gpu))
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu)
else:
print('CPU mode')
print('Process number: %d' % (os.getpid()))
model = load_pretrained_weights(args)
model.train(True)
if args.gpu is not None:
model.cuda()
trainpath = join(args.data_path, args.domain)
train_data = DataLoader(trainpath, split='train', classes=args.classes, ssl=False)
train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=args.batch, shuffle=True,
num_workers=args.cores)
valpath = join(args.data_path, args.domain)
val_data = DataLoader(valpath, split='train', classes=args.classes, ssl=False)
val_loader = torch.utils.data.DataLoader(dataset=val_data, batch_size=args.batch, shuffle=True,
num_workers=args.cores)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4)
logger = Logger(join(save_root, args.save_dir, 'train'))
logger_test = Logger(join(save_root, args.save_dir, 'test'))
batch_time, net_time = [], []
steps = args.iter_start
for epoch in range(args.epochs):
if epoch % 10 == 0 and epoch > 0:
model = test(model, criterion, logger_test, val_loader, steps)
lr = adjust_learning_rate(optimizer, epoch, init_lr=args.lr, step=20, decay=0.1)
end = time()
for i, (images, labels) in enumerate(train_loader):
# print(i, images.shape, labels)
batch_time.append(time() - end)
if len(batch_time) > 100:
del batch_time[0]
images = Variable(images)
labels = Variable(labels)
if args.gpu is not None:
images = images.cuda()
labels = labels.cuda()
# Forward + Backward + Optimize
optimizer.zero_grad()
t = time()
outputs = model(images)
net_time.append(time() - t)
if len(net_time) > 100:
del net_time[0]
prec1 = compute_accuracy(outputs.cpu().data, labels.cpu().data, topk=(1,))
acc = prec1[0]
# acc = prec1
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
loss = float(loss.cpu().data.numpy())
if steps % 20 == 0:
print(
(
'[%2d/%2d] %5d) [batch load % 2.3fsec, net %1.2fsec], LR %.5f, Loss: % 1.3f, Accuracy % 2.2f%%' % (
epoch + 1, args.epochs, steps,
np.mean(batch_time), np.mean(net_time),
lr, loss, acc)))
steps += 1
if steps % 1000 == 0:
filename = 'jps_%03i_%06d.pth.tar' % (epoch, steps)
filename = join(save_root, args.save_dir, filename)
model.save(filename)
print('Saved: ' + args.save_dir)
end = time()
def train(args, model, train_data, val_data, save_dir, domain_num):
train_loader = torch.utils.data.DataLoader(dataset=train_data,
batch_size=args.batch,
shuffle=True,
num_workers=args.cores)
val_loader = torch.utils.data.DataLoader(dataset=val_data,
batch_size=args.batch,
shuffle=True,
num_workers=args.cores)
criterion = nn.CrossEntropyLoss()
# optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4)
optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
lr=args.lr,
momentum=0.9,
weight_decay=5e-4)
logger = Logger(join(save_dir, 'train'))
logger_test = Logger(join(save_dir, 'test'))
batch_time, net_time = [], []
steps = args.iter_start
best_acc = -1
for epoch in range(args.epochs):
if epoch % 10 == 0 and epoch > 0:
model, acc = test(args, model, logger_test, val_loader, steps,
domain_num, save_dir)
if (best_acc < acc):
best_acc = acc
filename = join(save_dir, 'best_model.pth')
model.save(filename)
lr = adjust_learning_rate(optimizer,
epoch,
init_lr=args.lr,
step=20,
decay=0.1)
end = time()
for i, (x, y) in enumerate(train_loader):
# print(i, images.shape, labels)
batch_time.append(time() - end)
if len(batch_time) > 100:
del batch_time[0]
x = Variable(x)
y = Variable(y)
if args.gpu is not None:
x = x.cuda()
y = y.cuda()
# Forward + Backward + Optimize
optimizer.zero_grad()
t = time()
outputs = model(
x,
domain_num *
torch.ones(x.shape[0], dtype=torch.long).cuda())
net_time.append(time() - t)
if len(net_time) > 100:
del net_time[0]
prec1 = compute_accuracy(outputs.cpu().data,
y.cpu().data,
topk=(1, ))
acc = prec1[0]
loss = criterion(outputs, y)
loss.backward()
optimizer.step()
steps += 1
if (best_acc < acc):
best_acc = acc
filename = join(save_dir, 'best_model.pth')
model.save(filename)
if steps % 1000 == 0:
filename = 'step_%06d.pth.tar' % (steps)
filename = join(save_dir, filename)
model.save(filename)
print('steps: %d' % (steps))
end = time()
steps = -1
model, acc = test(args, model, logger_test, val_loader, steps, domain_num,
save_dir)
print('final acc: %0.3f' % (acc))
return
def ssl_train(args, model, train_data, val_data, save_dir, domain_num):
logger_test = Logger(save_dir + '/test')
train_loader = torch.utils.data.DataLoader(dataset=train_data,
batch_size=args.batch,
shuffle=True,
num_workers=args.cores)
val_loader = torch.utils.data.DataLoader(dataset=val_data,
batch_size=args.batch,
shuffle=True,
num_workers=args.cores)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(filter(lambda p: p.requires_grad,
model.parameters()),
lr=args.lr,
momentum=0.9,
weight_decay=5e-4)
iter_per_epoch = train_data.N / args.batch
print('Images: train %d, validation %d' % (train_data.N, val_data.N))
print(('Start training: lr %f, batch size %d, classes %d' %
(args.lr, args.batch, args.classes[0])))
batch_time, net_time = [], []
steps = args.iter_start
best_acc = -1
for epoch in range(int(args.iter_start / iter_per_epoch), args.epochs):
if epoch % 10 == 0 and epoch > 0:
print('Evaluating network.......')
accuracy = []
model.eval()
for i, (x, y, _) in enumerate(val_loader):
x = Variable(x)
if args.gpu is not None:
x = x.cuda()
# Forward + Backward + Optimize
outputs = model(
x,
domain_num *
torch.ones(x.shape[0], dtype=torch.long).cuda())
outputs = outputs.cpu().data
prec1, prec5 = compute_accuracy(outputs, y, topk=(1, 5))
accuracy.append(prec1.item())
acc = np.mean(accuracy)
if (best_acc < acc):
best_acc = acc
filename = join(save_dir, 'best_model.pth')
model.save(filename)
if logger_test is not None:
logger_test.scalar_summary('accuracy', acc, steps)
print('TESTING: %d), Accuracy %.2f%%' % (steps, acc))
model.train()
lr = adjust_learning_rate(optimizer,
epoch,
init_lr=args.lr,
step=20,
decay=0.1)
end = time()
for i, (x, y, original) in enumerate(train_loader):
batch_time.append(time() - end)
if len(batch_time) > 100:
del batch_time[0]
images = Variable(x)
labels = Variable(y)
if args.gpu is not None:
x = x.cuda()
y = y.cuda()
# Forward + Backward + Optimize
optimizer.zero_grad()
t = time()
outputs = model(
x,
domain_num * torch.ones(x.shape[0], dtype=torch.long).cuda())
net_time.append(time() - t)
if len(net_time) > 100:
del net_time[0]
prec1, prec5 = compute_accuracy(outputs.cpu().data,
y.cpu().data,
topk=(1, 5))
# acc = prec1[0]
acc = prec1
loss = criterion(outputs, y)
loss.backward()
optimizer.step()
loss = float(loss.cpu().data.numpy())
steps += 1
if steps % 1000 == 0:
filename = 'step_%06d.pth.tar' % (steps)
filename = join(save_dir, filename)
model.save(filename)
print('model saved at: ', filename)
end = time()
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
trainpath = join('/data/jihun/OfficeHomeDataset_10072016/', 'RealWorld')
train_data = DataLoader(trainpath, split='train', classes=65, ssl=False)
train_loader = torch.utils.data.DataLoader(dataset=train_data, batch_size=40, shuffle=True,
num_workers=5)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9, weight_decay=5e-4)
batch_time, net_time = [], []
for epoch in range(10):
lr = adjust_learning_rate(optimizer, epoch, init_lr=0.001, step=20, decay=0.1)
for i, (images, labels) in enumerate(train_loader):
images = Variable(images)
labels = Variable(labels)
images = images.cuda()
labels = labels.cuda()
# Forward + Backward + Optimize
optimizer.zero_grad()
outputs = model(images, 0 * torch.ones(images.shape[0], dtype=torch.long).cuda())
prec1 = compute_accuracy(outputs.cpu().data, labels.cpu().data, topk=(1,))
acc = prec1[0]
# acc = prec1
loss = criterion(outputs, labels)