print('classes', num_classes) try: os.makedirs(opt.outf) except OSError: pass classifier = PointNetCls(k = num_classes,views=opt.n_views) if opt.model != '': classifier.load_state_dict(torch.load(opt.model)) optimizer = optim.SGD(classifier.parameters(), lr=opt.lr, momentum=opt.momentum) classifier.cuda() num_batch = len(dataset)/opt.batchSize for epoch in range(opt.nepoch): for i, data in enumerate(dataloader, 0): points, target = data points, target = Variable(points), Variable(target[:,0]) points = points.transpose(2,1) # sys.exit(0) points, target = points.cuda(), target.cuda() optimizer.zero_grad() classifier = classifier.train() pred = classifier(points) loss = F.nll_loss(pred, target)
num_classes = len(dataset.obj_list) print('classes', num_classes) try: os.makedirs(opt.outf) except OSError: pass classifier = PointNetCls(k=num_classes, num_points=opt.num_points) if opt.model != '': classifier.load_state_dict(torch.load(opt.model)) classifier = classifier.cuda() optimizer = optim.SGD(classifier.parameters(), lr=0.01, momentum=0.9) # if torch.cuda.is_available(): # classifier.cuda() num_batch = len(dataset) / opt.batchSize for epoch in range(opt.nepoch): for i, data in enumerate(dataloader, 0): points, target = data points, target = Variable(points), Variable(target[:, 0]) points = points.transpose(2, 1) # if torch.cuda.is_available(): # points, target = points.cuda(), target.cuda() points = points.cuda() target = target.cuda() optimizer.zero_grad()
def weights_init(m): classname = m.__class__.__name__ if classname.find('Conv') != -1: m.weight.data.normal_(0.0, 0.02) elif classname.find('BatchNorm') != -1: m.weight.data.normal_(1.0, 0.02) m.bias.data.fill_(0) classifier.apply(weights_init) gen.apply(weights_init) classifier.cuda() gen.cuda() optimizerD = optim.Adagrad(classifier.parameters(), lr = 0.001) optimizerG = optim.Adagrad(gen.parameters(), lr = 0.001) num_batch = len(dataset)/opt.batchSize for epoch in range(opt.nepoch): for i, data in enumerate(dataloader, 0): optimizerD.zero_grad() points, _ = data points = Variable(points) bs = points.size()[0] target = Variable(torch.from_numpy(np.ones(bs,).astype(np.int64))).cuda() points = points.transpose(2,1) points = points.cuda() #print(points.size())
def main(): # Download dataset for point cloud classification modelnet_dir = 'modelnet40_ply_hdf5_2048' BASE_DIR = os.path.dirname(os.path.abspath(__file__)) sys.path.append(BASE_DIR) DATA_DIR = os.path.join(BASE_DIR, 'data') if not os.path.exists(DATA_DIR): os.mkdir(DATA_DIR) if not os.path.exists(os.path.join(DATA_DIR, modelnet_dir)): www = 'https://shapenet.cs.stanford.edu/media/' + modelnet_dir + '.zip' zipfile = os.path.basename(www) os.system('wget %s; unzip %s' % (www, zipfile)) os.system('mv %s %s' % (zipfile[:-4], DATA_DIR)) os.system('rm %s' % (zipfile)) datapath = './data/' + modelnet_dir + '/' args = parse_args() if args.robust_type == 'Q': type_string = 'quadratic' outlier_string = 'outliers_' + str(args.outlier_fraction) elif args.robust_type == 'PH': type_string = 'pseudohuber' outlier_string = 'outliers_' + str(args.outlier_fraction) elif args.robust_type == 'H': type_string = 'huber' outlier_string = 'outliers_' + str(args.outlier_fraction) elif args.robust_type == 'W': type_string = 'welsch' outlier_string = 'outliers_' + str(args.outlier_fraction) elif args.robust_type == 'TQ': type_string = 'truncatedquadratic' outlier_string = 'outliers_' + str(args.outlier_fraction) else: type_string = 'max' outlier_string = 'outliers_' + str(args.outlier_fraction) if args.rotation is not None: ROTATION = (int(args.rotation[0:2]), int(args.rotation[3:5])) else: ROTATION = None '''CREATE DIRS''' experiment_dir = Path('./tests/') if not experiment_dir.exists(): experiment_dir.mkdir() type_dir = Path(str(experiment_dir) + '/' + type_string + '/') if not type_dir.exists(): type_dir.mkdir() outlier_dir = Path(str(type_dir) + '/' + outlier_string + '/') if not outlier_dir.exists(): outlier_dir.mkdir() checkpoints_dir = outlier_dir '''LOG''' logger = logging.getLogger("PointNet") logger.setLevel(logging.INFO) formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler = logging.FileHandler( str(checkpoints_dir) + '/' + 'train_%s_' % args.model_name + str(datetime.datetime.now().strftime('%Y-%m-%d-%H-%M')) + '.txt') file_handler.setLevel(logging.INFO) file_handler.setFormatter(formatter) logger.addHandler(file_handler) logger.info( '---------------------------------------------------TRAINING---------------------------------------------------' ) logger.info('PARAMETER ...') logger.info(args) '''DATA LOADING''' logger.info('Load dataset ...') train_data, train_label, test_data, test_label = load_data( datapath, classification=True) logger.info("The number of training data is: %d", train_data.shape[0]) logger.info("The number of test data is: %d", test_data.shape[0]) ## Replace a fraction of the points with outliers drawn uniformly from the unit sphere if args.outlier_fraction > 0.0: # Training set num_outliers = int(args.outlier_fraction * train_data.shape[1]) print('Number of training set outliers per point cloud: {}'.format( num_outliers)) for i in range( train_data.shape[0]): # For each point cloud in the batch random_indices = np.random.choice(train_data.shape[1], num_outliers, replace=False) for j in range(num_outliers): # For each point in outlier subset random_point = 2.0 * np.random.rand(3) - 1.0 # Ensure outliers are within unit sphere: while np.linalg.norm(random_point) > 1.0: random_point = 2.0 * np.random.rand(3) - 1.0 train_data[i, random_indices[ j], :] = random_point # Make an outlier, uniform distribution in [-1,1]^3 # Testing set num_outliers = int(args.outlier_fraction * test_data.shape[1]) print('Number of test set outliers per point cloud: {}'.format( num_outliers)) for i in range( test_data.shape[0]): # For each point cloud in the batch random_indices = np.random.choice(test_data.shape[1], num_outliers, replace=False) for j in range(num_outliers): # For each point in outlier subset random_point = 2.0 * np.random.rand(3) - 1.0 # Ensure outliers are within unit sphere: while np.linalg.norm(random_point) > 1.0: random_point = 2.0 * np.random.rand(3) - 1.0 test_data[i, random_indices[ j], :] = random_point # Make an outlier, uniform distribution in [-1,1]^3 trainDataset = ModelNetDataLoader(train_data, train_label, rotation=ROTATION) if ROTATION is not None: print('The range of training rotation is', ROTATION) testDataset = ModelNetDataLoader(test_data, test_label, rotation=ROTATION) trainDataLoader = torch.utils.data.DataLoader(trainDataset, batch_size=args.batchsize, shuffle=True) testDataLoader = torch.utils.data.DataLoader(testDataset, batch_size=args.batchsize, shuffle=False) '''MODEL LOADING''' num_class = 40 classifier = PointNetCls(num_class, args.input_transform, args.feature_transform, args.robust_type, args.alpha).cuda() if args.pretrain is not None: print('Use pretrain model...') logger.info('Use pretrain model') checkpoint = torch.load(args.pretrain) start_epoch = checkpoint['epoch'] classifier.load_state_dict(checkpoint['model_state_dict']) else: print('No existing model, starting training from scratch...') start_epoch = 0 if args.evaluate: acc, map, _ = test(classifier, testDataLoader, do_map=True) logger.info('Test Accuracy: %f', acc) logger.info('mAP: %f', map) logger.info('%f,%f' % (acc, map)) print('Test Accuracy:\n%f' % acc) print('mAP:\n%f' % map) # print('%f,%f'%(acc, map)) return if args.optimizer == 'SGD': optimizer = torch.optim.SGD(classifier.parameters(), lr=0.01, momentum=0.9) elif args.optimizer == 'Adam': optimizer = torch.optim.Adam(classifier.parameters(), lr=args.learning_rate, betas=(0.9, 0.999), eps=1e-08, weight_decay=args.decay_rate) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5) global_epoch = 0 global_step = 0 best_tst_accuracy = 0.0 blue = lambda x: '\033[94m' + x + '\033[0m' '''TRAINING''' logger.info('Start training...') for epoch in range(start_epoch, args.epoch): print('Epoch %d (%d/%s):' % (global_epoch + 1, epoch + 1, args.epoch)) logger.info('Epoch %d (%d/%s):', global_epoch + 1, epoch + 1, args.epoch) scheduler.step() for batch_id, data in tqdm(enumerate(trainDataLoader, 0), total=len(trainDataLoader), smoothing=0.9): points, target = data target = target[:, 0] points = points.transpose(2, 1) points, target = points.cuda(), target.cuda() optimizer.zero_grad() classifier = classifier.train() pred, trans_feat = classifier(points) loss = F.nll_loss(pred, target.long()) if args.feature_transform and args.model_name == 'pointnet': loss += feature_transform_regularizer(trans_feat) * 0.001 loss.backward() optimizer.step() global_step += 1 train_acc = test(classifier.eval(), trainDataLoader) if args.train_metric else None acc, map, _ = test(classifier, testDataLoader, do_map=True) print('\r Loss: %f' % loss.data) logger.info('Loss: %f', loss.data) if args.train_metric: print('Train Accuracy: %f' % train_acc) logger.info('Train Accuracy: %f', (train_acc)) logger.info('Test Accuracy: %f', acc) logger.info('Test mAP: %f', map) print('\r Test %s: %f' % (blue('Accuracy'), acc)) print('\r Test %s: %f' % (blue('mAP'), map)) if args.train_metric: logger.info('%f,%f,%f' % (train_acc, acc, map)) print('\r%f,%f,%f' % (train_acc, acc, map)) else: logger.info('%f,%f' % (acc, map)) print('\r%f,%f' % (acc, map)) if (acc >= best_tst_accuracy): best_tst_accuracy = acc # Save every 10 if (epoch + 1) % 10 == 0: logger.info('Save model...') save_checkpoint(global_epoch + 1, train_acc if args.train_metric else 0.0, acc, map, classifier, optimizer, str(checkpoints_dir), args.model_name) print('Saving model....') global_epoch += 1 print('Best Accuracy: %f' % best_tst_accuracy) logger.info('Save final model...') save_checkpoint(global_epoch, train_acc if args.train_metric else 0.0, acc, map, classifier, optimizer, str(checkpoints_dir), args.model_name) print('Saving final model....') logger.info('End of training...')
def train(config): print('Random seed: %d' % int(config.seed)) torch.manual_seed(config.seed) torch.backends.cudnn.benchmark = True dset = config.dataset if dset == 'modelnet10' or dset == 'modelnet40': dataset = ClsDataset(root=config.root, npoints=config.npoints, train=True) test_dataset = ClsDataset(root=config.root, npoints=config.npoints, train=False) else: raise NotImplementedError('Dataset not supported.') print('Selected %s' % dset) dataloader = torch.utils.data.DataLoader(dataset, batch_size=config.batchsize, shuffle=True, num_workers=config.workers) test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=config.batchsize, shuffle=True, num_workers=config.workers) num_classes = dataset.num_classes print('number of classes: %d' % num_classes) print('train set size: %d | test set size: %d' % (len(dataset), len(test_dataset))) try: os.makedirs(config.outf) except: pass blue = lambda x: '\033[94m' + x + '\033[0m' yellow = lambda x: '\033[93m' + x + '\033[0m' red = lambda x: '\033[91m' + x + '\033[0m' classifier = PointNetCls(k=num_classes) if config.model != '': classifier.load_state_dict(torch.load(config.model)) optimizer = optim.SGD(classifier.parameters(), lr=config.lr, momentum=config.momentum) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') classifier.to(device) if config.mgpu: classifier = torch.nn.DataParallel(classifier, device_ids=config.gpuids) num_batch = len(dataset) / config.batchsize lera.log_hyperparams({ 'title': dset, 'batchsize': config.batchsize, 'epochs': config.nepochs, 'npoints': config.npoints, 'optimizer': 'SGD', 'lr': config.lr, }) for epoch in range(config.nepochs): train_acc_epoch, test_acc_epoch = [], [] for i, data in enumerate(dataloader): points, labels = data points = points.transpose(2, 1) labels = labels[:, 0] points, labels = points.to(device), labels.to(device) optimizer.zero_grad() classifier = classifier.train() pred, _ = classifier(points) pred = pred.view(-1, num_classes) # print(pred.size(), labels.size()) loss = F.nll_loss(pred, labels) loss.backward() optimizer.step() pred_choice = pred.data.max(1)[1] correct = pred_choice.eq(labels.data).cpu().sum() train_acc = correct.item() / float(config.batchsize) print('epoch %d: %d/%d | train loss: %f | train acc: %f' % (epoch+1, i+1, num_batch+1, loss.item(), train_acc)) train_acc_epoch.append(train_acc) lera.log({ 'train loss': loss.item(), 'train acc': train_acc }) if (i+1) % 10 == 0: j, data = next(enumerate(test_dataloader, 0)) points, labels = data points = points.transpose(2, 1) labels = labels[:, 0] points, labels = points.to(device), labels.to(device) classifier = classifier.eval() with torch.no_grad(): pred, _ = classifier(points) pred = pred.view(-1, num_classes) loss = F.nll_loss(pred, labels) pred_choice = pred.data.max(1)[1] correct = pred_choice.eq(labels.data).cpu().sum() test_acc = correct.item() / float(config.batchsize) print(blue('epoch %d: %d/%d | test loss: %f | test acc: %f') % (epoch+1, i+1, num_batch+1, loss.item(), test_acc)) test_acc_epoch.append(test_acc) lera.log({ 'test loss': loss.item(), 'test acc': test_acc }) print(yellow('epoch %d | mean train acc: %f') % (epoch+1, np.mean(train_acc_epoch))) print(red('epoch %d | mean test acc: %f') % (epoch+1, np.mean(test_acc_epoch))) lera.log({ 'train acc epoch': np.mean(train_acc_epoch), 'test acc epoch': np.mean(test_acc_epoch)}) torch.save(classifier.state_dict(), '%s/%s_model_%d.pth' % (config.outf, config.dataset, epoch))
print('classes', num_classes) try: os.makedirs(opt.outf) except OSError: pass classifier = PointNetCls(k = num_classes, num_points = opt.num_points) if opt.model != '': classifier.load_state_dict(torch.load(opt.model)) optimizer = optim.SGD(classifier.parameters(), lr=0.01, momentum=0.9) classifier.cuda() num_batch = len(dataset)/opt.batchSize for epoch in range(opt.nepoch): for i, data in enumerate(dataloader, 0): points, target = data points, target = Variable(points), Variable(target[:,0]) points = points.transpose(2,1) points, target = points.cuda(), target.cuda() optimizer.zero_grad() classifier = classifier.train() pred, _ = classifier(points) loss = F.nll_loss(pred, target) loss.backward()
shuffle=True, num_workers=int(opt.workers)) print('train: {} val: {}'.format(len(dataset), len(val_dataset))) num_classes = len(dataset.classes) print('classes', num_classes) classifier = PointNetCls(k=num_classes).to(device) start_epoch = -1 if opt.model != '': classifier.load_state_dict(torch.load(opt.model)) # TODO update start_epoch from pre-trained optimizer = optim.SGD(params=filter(lambda p: p.requires_grad, classifier.parameters()), lr=0.01, momentum=0.9) lambda_lr = lambda epoch: 1 / (1 + (opt.lr_decay_rate * epoch)) lr_scheduler = LambdaLR(optimizer, lr_lambda=lambda_lr, last_epoch=start_epoch) num_batch = len(dataset) / opt.batchSize num_val_batch = len(val_dataset) / opt.batchSize n_log = 100 epochs = [] train_acc = [] train_loss = [] test_acc = [] test_loss = []
num_classes = len(dataset.classes) print('classes', num_classes) try: os.makedirs(opt.outf) except OSError: pass classifier = PointNetCls(n=opt.base_features, k=num_classes) if opt.model != '': classifier.load_state_dict(torch.load(opt.model)) device = torch.cuda.current_device() #optimizer = optim.SGD(classifier.parameters(), lr=opt.lr, momentum=0.9) optimizer = optim.Adam(classifier.parameters(), lr=opt.lr) classifier.to(device) classifier.eval() num_batch = len(dataset) / opt.batchSize def prepare(data): points, target = data return points.transpose(2, 1).to(device), target[:, 0].to(device) for epoch in range(opt.nepoch): correct = 0
train_data, test_data = data.random_split(dataset, [train_size, test_size]) train_loader = data.DataLoader( dataset=train_data, batch_size=BATCH_SIZE, shuffle=True, ) test_loader = data.DataLoader( dataset=test_data, batch_size=BATCH_SIZE, ) # define something about training... mynet = PointNetCls() optimizer = torch.optim.Adam(mynet.parameters(), lr=LR) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=30, gamma=0.8) loss_func = torch.nn.MSELoss() # train myepoch = tqdm(range(1, 500)) for epoch in myepoch: loss_list = [] valid_loss_list = [] for step, (features, targets) in enumerate(train_loader): mynet.cuda() mynet.train() features = features.transpose(2, 1) features, targets = features.cuda(), targets.cuda() predicted_targets, feature_transform_matrix = mynet(features)
if opt.model != '': classifier.load_state_dict(torch.load(opt.model)) def adjust_learning_rate(optimizer, epoch): """Sets the learning rate to the initial LR decayed by 10 every 30 epochs""" # lr = opt.lr * (0.8 ** (epoch // 20)) lr = opt.lr * (0.8**(epoch // 50)) for param_group in optimizer.param_groups: param_group['lr'] = lr print 'learning rate = ', param_group['lr'] # optimizer = optim.SGD(classifier.parameters(), lr=0.001, momentum=0.9) optimizer = optim.Adam(classifier.parameters(), lr=0.001, weight_decay=1e-4) classifier.cuda() num_batch = len(dataset) / opt.batchSize best_train_acc = 0 best_test_acc = 0 all_losses = [] if opt.focal_loss: gamma = 2 alpha = 0.25 criterion_focal_loss = FocalLoss(gamma) f = open('/home/tarek/Dropbox/desktop_results/results_morepoints.txt', 'w')