def __init__(self, filename, gray_scale=False, transform=None, classes=None): flag = 0 if gray_scale else 1 # retrieve number of classes without decoding images td = RecordFileDataset(filename) s = set([ recordio.unpack(td.__getitem__(i))[0].label[0] for i in range(len(td)) ]) self._num_classes = len(s) if not classes: self._classes = [str(i) for i in range(self._num_classes)] else: if len(self._num_classes) != len(classes): warnings.warn( 'Provided class names do not match data, expected "num_class" is {} ' 'vs. provided: {}'.format(self._num_classes, len(classes))) self._classes = list(classes) + \ [str(i) for i in range(len(classes), self._num_classes)] self._dataset = ImageRecordDataset(filename, flag=flag) if transform: self._dataset = self._dataset.transform_first(transform)
def main(): # Create Datasets from rec files batch_size = 32 train_bin = os.path.join(data_dir, 'train/clouds-binary.rec') valid_bin = os.path.join(data_dir, 'valid/clouds-binary.rec') test_bin = os.path.join(data_dir, 'test/s2test-binary.rec') trainIterBin = ImageRecordDataset( filename=train_bin, transform=lambda X, y: transform(X, y, train_augs) ) validIterBin = ImageRecordDataset( filename=valid_bin, transform=lambda X, y: transform(X, y, train_augs) ) testIterBin = ImageRecordDataset( filename=test_bin, transform=lambda X, y: transform(X, y, test_augs) ) train_data = gluon.data.DataLoader(trainIterBin, batch_size, shuffle=True) val_data = gluon.data.DataLoader(validIterBin, batch_size) test_data = gluon.data.DataLoader(testIterBin, batch_size) data = {'train':train_data, 'val':val_data} # Create dir where we'll save the params of our model checkpoints = os.path.join(checkpoints_dir, 'resnet101') os.makedirs(checkpoints, exist_ok=True) # Load a pretrained network rn_pretrained = vision.resnet101_v2(pretrained=True) # Load the network to train, using the same prefix to avoid problems when saving and loading params, # as we will assign the features part of the pretrained network to this one rn101 = vision.resnet101_v2(classes=2, prefix=rn_pretrained.prefix) rn101.features = rn_pretrained.features rn101.output.initialize(mx.init.Xavier()) rn101_acc = train(rn101, data, ctx, epochs=2, learning_rate=0.003,checkpoint_dir=checkpoints) # Save np.save(checkpoints + '/accuracy-results.npy', rn101_acc) # Find best scoring model best = rn101_acc['val'].index(max(rn101_acc['val'])) + 1 best_params = os.path.join(checkpoints, '{}.params'.format(best)) # Test it on the test dataset rn101.load_params(best_params, ctx) test_acc = evaluate_accuracy(test_data, rn101) print('Best model on validation set saved in: {}'.format(best_params)) print('Accuracy on test set = {}'.format(test_acc))
def get_data_rec(rec_train, rec_val): rec_train = os.path.expanduser(rec_train) rec_val = os.path.expanduser(rec_val) # mean_rgb = [123.68, 116.779, 103.939] # std_rgb = [58.393, 57.12, 57.375] train_dataset = ImageRecordDataset(filename=rec_train, flag=1) val_dataset = ImageRecordDataset(filename=rec_val, flag=1) return train_dataset, val_dataset
def _make_datasets(data_desc): train, val = None, None if 'train' in data_desc: # download train set train_urls = data_desc['train'] train_path = _download(train_urls['rec'][0], train_urls['rec'][1]) _download(train_urls['idx'][0], train_urls['idx'][1]) _download(train_urls['lst'][0], train_urls['lst'][1]) train = ImageRecordDataset(train_path, flag=1) if 'val' in data_desc: # download validation set val_urls = data_desc['val'] val_path = _download(val_urls['rec'][0], val_urls['rec'][1]) _download(val_urls['idx'][0], val_urls['idx'][1]) _download(val_urls['lst'][0], val_urls['lst'][1]) val = ImageRecordDataset(val_path, flag=1) return train, val
class RecordDataset: """A dataset wrapping over a RecordIO file containing images. Each sample is an image and its corresponding label. Parameters ---------- filename : str Local path to the .rec file. gray_scale : False If True, always convert images to greyscale. If False, always convert images to colored (RGB). transform : function, default None A user defined callback that transforms each sample. classes : iterable of str, default is None User provided class names. If `None` is provide, will use a list of increasing natural number ['0', '1', ..., 'N'] by default. """ def __init__(self, filename, gray_scale=False, transform=None, classes=None): flag = 0 if gray_scale else 1 # retrieve number of classes without decoding images td = RecordFileDataset(filename) s = set([ recordio.unpack(td.__getitem__(i))[0].label[0] for i in range(len(td)) ]) self._num_classes = len(s) if not classes: self._classes = [str(i) for i in range(self._num_classes)] else: if len(self._num_classes) != len(classes): warnings.warn( 'Provided class names do not match data, expected "num_class" is {} ' 'vs. provided: {}'.format(self._num_classes, len(classes))) self._classes = list(classes) + \ [str(i) for i in range(len(classes), self._num_classes)] self._dataset = ImageRecordDataset(filename, flag=flag) if transform: self._dataset = self._dataset.transform_first(transform) @property def num_classes(self): return self._num_classes @property def classes(self): return self._classes def __len__(self): return len(self._dataset) def __getitem__(self, idx): return self._dataset[idx]
def display(): transform = transforms.ToTensor() dataset = ImageRecordDataset(args.input).transform_first(transform) loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=args.shuffle, last_batch='keep', num_workers=args.num_workers, pin_memory=False) for idx, (img, label) in enumerate(loader): show_images(img, ncols=min(8, args.batch_size)) # print(label) input('Press Enter...')
def create_loader(self): """ Create the data loader :return: """ if self.args.mode.upper() == 'TRAIN': tforms = [] tforms.append(transforms.Resize(self.args.resize)) if self.args.flip: tforms.append(transforms.RandomFlipLeftRight()) if self.args.random_crop: tforms.append( transforms.RandomResizedCrop(self.args.im_size, scale=(0.8, 1))) else: tforms.append(transforms.CenterCrop(self.args.im_size)) if self.args.random_jitter: tforms.append(transforms.RandomColorJitter(0.4, 0.4, 0.4, 0.4)) tforms.append(transforms.ToTensor()) tforms.append( transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))) tforms = transforms.Compose(tforms) tr_db = list(self.cfg['train'].values())[0] dataset = ImageRecordDataset(tr_db['rec'], transform=tforms) self.tr_loader = DataLoader(dataset, batch_size=self.args.bs, num_workers=8, pin_memory=True) else: tforms = transforms.Compose([ transforms.Resize(self.args.resize), transforms.CenterCrop(self.args.im_size), transforms.ToTensor(), transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)) ]) self.eval_tforms = tforms
def evaluate(): # Datasets test_transform = ToTensor() test_dataset = ImageRecordDataset(args.test_rec).transform_first(test_transform) test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False, last_batch='keep', num_workers=args.num_workers, pin_memory=True) logger.info('Evaluate model {}'.format(os.path.basename(args.model))) if args.model.endswith('.params'): # Create inference inference = resnet100(args.num_classes, emb_size=args.emb_size, s=args.margin_s, a=args.margin_a, m=args.margin_m, b=args.margin_b) inference.hybridize(static_alloc=True, static_shape=True) helper.load_params(inference, args.model, ctx=ctx) inference = inference.features elif args.model.endswith('-symbol.json'): # Load model symbol and params sym = mx.sym.load_json(open(args.model, 'r').read()) inference = gluon.nn.SymbolBlock(outputs=sym, inputs=mx.sym.var('data')) inference.load_parameters(args.model[:-11] + '0000.params', ctx=ctx) else: print('Incorrect model: {}'.format(args.model)) return # Test LFW if args.test_name.lower() == 'lfw': print('Evaluating LFW...') start_time = timeit.default_timer() mu, std, t, accuracies = eval_lfw(inference, args.test_rec, test_loader, ctx) elapsed_time = timeit.default_timer() - start_time scout = helper.print_scalars(OrderedDict([('mu', mu), ('std', std), ('t', t)]), 0, 0, elapsed_time) logger.info(scout) accuracies = accuracies.tolist() + [mu, std] logger.info(' '.join('{:.2f}'.format(x) for x in accuracies)) elif args.test_name.lower() == 'lfw-failure': print('Show LFW pairs...') indices, sim = top_failure_pairs_lfw(inference, args.test_rec, test_loader, ctx) images = mx.nd.stack(*[test_dataset[idx][0] for idx in indices]) sim_str = ['{:.2f}'.format(x) for x in sim] for idx in range(4): show_images(images[idx * 10:(idx + 1) * 10], titles=[''] * 5 + sim_str[idx * 5:(idx + 1) * 5], ncols=5) logger.info(' '.join(sim_str))
def display_multi(): transform = transforms.ToTensor() dataset = [] for rec in args.inputs: dataset.append(ImageRecordDataset(rec).transform_first(transform)) dataset = ArrayDataset(*dataset) loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=args.shuffle, last_batch='keep', num_workers=args.num_workers, pin_memory=False) for idx, batch_data in enumerate(loader): batch_img = [] for (img, _) in batch_data: batch_img.append(img) batch_img = mx.nd.concat(*batch_img, dim=0) show_images(batch_img, ncols=min(8, args.batch_size)) input('Press Enter...')
def transform(data, label, augs): data = data.astype('float32') for aug in augs: data = aug(data) data = nd.transpose(data, (2, 0, 1)) return data, nd.array([label]).asscalar().astype('float32') from mxnet.gluon.data.vision import ImageRecordDataset train_rec = root + '/data/household/train/household.rec' validation_rec = root + '/data/household/validation/household.rec' test_rec = root + '/data/household/test/household.rec' sample_rec = root + '/data/household/sample/household.rec' trainIterator = ImageRecordDataset( filename=train_rec, transform=lambda X, y: transform(X, y, train_augs)) validationIterator = ImageRecordDataset( filename=validation_rec, transform=lambda X, y: transform(X, y, test_augs)) testIterator = ImageRecordDataset( filename=test_rec, transform=lambda X, y: transform(X, y, test_augs)) sampleIterator = ImageRecordDataset( filename=sample_rec, transform=lambda X, y: transform(X, y, test_augs)) import time from mxnet.image import color_normalize from mxnet import autograd import mxnet as mx from mxnet import nd def evaluate_accuracy(data_iterator, net):
def train(): # Create inference inference = resnet100(args.num_classes, emb_size=args.emb_size, s=args.margin_s, a=args.margin_a, m=args.margin_m, b=args.margin_b) # Load inference params if args.init.lower() == 'xavier': init = mx.init.Xavier(rnd_type='gaussian', factor_type='out', magnitude=2) else: init = mx.initializer.Uniform() if args.model: helper.load_params(inference, args.model, ctx=ctx) cur_iter = 0 else: cur_iter = helper.load_params(inference, args.ckpt_dir, prefix=args.prefix, init=init, ctx=ctx) # Hybrid mode --> Symbol mode inference.hybridize(static_alloc=True, static_shape=True) # Datasets if args.color: train_transform = transforms.Compose([ transforms.RandomFlipLeftRight(), transforms.RandomColorJitter(0.1, 0.1, 0.1), ToTensor() ]) else: train_transform = transforms.Compose( [transforms.RandomFlipLeftRight(), ToTensor()]) train_dataset = ImageRecordDataset( args.train_rec).transform_first(train_transform) train_loader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, last_batch='discard', num_workers=args.num_workers, pin_memory=True) test_transform = ToTensor() test_dataset = ImageRecordDataset( args.test_rec).transform_first(test_transform) test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False, last_batch='keep', num_workers=args.num_workers, pin_memory=False) # Create learning rate scheduler iterations_per_epoch = int(len(train_dataset) / args.batch_size) lr_steps = [s * iterations_per_epoch for s in args.lr_steps] print('Learning rate drops after iterations: {}'.format(lr_steps)) lr_scheduler = mx.lr_scheduler.MultiFactorScheduler(step=lr_steps, factor=0.1) # Create trainer trainer = gluon.Trainer(inference.collect_params(), optimizer='sgd', optimizer_params={ 'learning_rate': args.lr, 'wd': args.wd, 'lr_scheduler': lr_scheduler, 'rescale_grad': 1. / len(ctx) }) # Load trainer from saved states helper.load_trainer(trainer, args.ckpt_dir, cur_iter, prefix=args.prefix) # Define loss functions softmax_cross_entropy = mx.gluon.loss.SoftmaxCrossEntropyLoss() # Define metric losses metric_ce_loss = mx.metric.Loss('CE-Loss') best_acc = 80 # only save the model if the accuracy is better than 80% # Start training print('Start to train {}...'.format(args.prefix)) start_epoch = cur_iter // iterations_per_epoch for cur_epoch in range(start_epoch + 1, args.max_epoch + 1): start_time = timeit.default_timer() for batch_idx, (image, label) in enumerate(train_loader): if label.ndim > 1: label = label[:, 0] # skip the landmarks # if batch_idx > 0: break cur_iter += 1 images = gluon.utils.split_and_load(image, ctx) labels = gluon.utils.split_and_load(label, ctx) with autograd.record(train_mode=True): losses = [] for x, y in zip(images, labels): fc = inference(x, y) loss_ce = softmax_cross_entropy(fc, y) losses.append(loss_ce) # update metrics metric_ce_loss.update(None, preds=loss_ce) for l in losses: l.backward() trainer.step(image.shape[0]) if (batch_idx % args.log_interval == 0) or (batch_idx == iterations_per_epoch - 1): elapsed_time = timeit.default_timer() - start_time scout = helper.print_scalars( OrderedDict([metric_ce_loss.get()]), cur_epoch, batch_idx, elapsed_time) logger.info(scout) start_time = timeit.default_timer() metric_ce_loss.reset() if (batch_idx % args.test_interval == 0) or (batch_idx == iterations_per_epoch - 1): # if batch_idx > 0: break start_time = timeit.default_timer() mu, std, t, _ = eval_lfw(inference.features, args.test_rec, test_loader, ctx) elapsed_time = timeit.default_timer() - start_time if mu > best_acc: best_acc = mu # Save trained model logger.info( 'Find better model at E: {}, B: {}, I: {}'.format( cur_epoch, batch_idx, cur_iter)) helper.save_params(inference, args.ckpt_dir, cur_iter, prefix=args.prefix + '-best') scout = helper.print_scalars( OrderedDict([('mu', mu), ('std', std), ('t', t)]), cur_epoch, batch_idx, elapsed_time) logger.info(scout) # Save trained model helper.save_params(inference, args.ckpt_dir, cur_iter, prefix=args.prefix) helper.save_trainer(trainer, args.ckpt_dir, cur_iter, prefix=args.prefix)
# arguments data_dir = sys.argv[1] model_name = sys.argv[2] batch_size = int(sys.argv[3]) epochs = int(sys.argv[4]) lr = float(sys.argv[5]) # pathing train_rec = os.path.join(data_dir, 'train/img.rec') validation_rec = os.path.join(data_dir, 'validation/img.rec') model_out_path = os.path.join(data_dir, '../models/{}.params'.format(model_name)) # load data train_iterator = ImageRecordDataset( filename=train_rec, transform=lambda X, y: transform(X, y, train_augs) ) validation_iterator = ImageRecordDataset( filename=validation_rec, transform=lambda X, y: transform(X, y, test_augs) ) # instantiate source model pretrained_net = mobilenet1_0(pretrained=True, prefix='model_') # instantiate target model net = mobilenet1_0(classes=2, prefix='model_') # transfer non output layers from source model to target model net.features = pretrained_net.features # initializing parameters for output layers of target model net.output.initialize(init.Xavier())
return data[:, 1:].reshape(-1, 3, 32, 32).transpose(0, 2, 3, 1), \ data[:, 0].astype(np.int32) def _get_data(self): if self._train: data_files = self._train_data else: data_files = self._test_data data, label = zip(*(self._read_batch(os.path.join(self._root, name)) for name, _ in data_files)) data = np.concatenate(data) label = np.concatenate(label) self._data = data self._label = label if __name__ == '__main__': cifar_ori = CIFAR10(train=False) cifar_rec = ImageRecordDataset("./cifar10_test.rec") for a, b in zip(cifar_ori, cifar_rec): im1 = a[0] im2 = b[0].asnumpy()[..., ::-1] diff = im1 - im2 assert np.sum(diff) == 0 assert a[1] == b[1]