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)