def get_dataset_and_model(dataset_name, model_name, pretrained_model, input_size): if dataset_name == 'cityscapes': dataset = CityscapesSemanticSegmentationDataset( split='val', label_resolution='fine') label_names = cityscapes_semantic_segmentation_label_names elif dataset_name == 'ade20k': dataset = ADE20KSemanticSegmentationDataset(split='val') label_names = ade20k_semantic_segmentation_label_names elif dataset_name == 'camvid': dataset = CamVidDataset(split='test') label_names = camvid_label_names n_class = len(label_names) if pretrained_model: pretrained_model = pretrained_model else: pretrained_model = dataset_name if model_name == 'pspnet_resnet101': model = PSPNetResNet101(n_class=n_class, pretrained_model=pretrained_model, input_size=input_size) elif model_name == 'pspnet_resnet50': model = PSPNetResNet50(n_class=n_class, pretrained_model=pretrained_model, input_size=input_size) elif model_name == 'segnet': model = SegNetBasic(n_class=n_class, pretrained_model=pretrained_model) return dataset, label_names, model
def calc_bn_statistics(model, gpu): model.to_gpu(gpu) d = CamVidDataset(split='train') it = chainer.iterators.SerialIterator(d, 24, repeat=False, shuffle=False) bn_params = {} num_iterations = 0 for batch in it: imgs, labels = concat_examples(batch, device=gpu) model(imgs) for name, link in model.namedlinks(): if name.endswith('_bn'): if name not in bn_params: bn_params[name] = [ cuda.to_cpu(link.avg_mean), cuda.to_cpu(link.avg_var) ] else: bn_params[name][0] += cuda.to_cpu(link.avg_mean) bn_params[name][1] += cuda.to_cpu(link.avg_var) num_iterations += 1 for name, params in bn_params.items(): bn_params[name][0] /= num_iterations bn_params[name][1] /= num_iterations for name, link in model.namedlinks(): if name.endswith('_bn'): link.avg_mean = bn_params[name][0] link.avg_var = bn_params[name][1] model.to_cpu() return model
def recalculate_bn_statistics(model, batchsize, dtype='float32'): print( '==> Recalculating BN statistics (batchsize={}) ...'.format(batchsize)) train = CamVidDataset(split='train') it = chainer.iterators.SerialIterator(train, batchsize, repeat=False, shuffle=False) bn_avg_mean = defaultdict(np.float32) bn_avg_var = defaultdict(np.float32) if dtype == 'mixed16': dtype = 'float16' n_iter = 0 for batch in it: imgs, _ = concat_examples(batch) model(F.cast(model.xp.array(imgs), dtype)) for name, link in model.namedlinks(): if name.endswith('_bn'): bn_avg_mean[name] += link.avg_mean bn_avg_var[name] += link.avg_var n_iter += 1 for name, link in model.namedlinks(): if name.endswith('_bn'): link.avg_mean = bn_avg_mean[name] / n_iter link.avg_var = bn_avg_var[name] / n_iter return model
def calc_bn_statistics(model, batchsize): train = CamVidDataset(split="train") it = chainer.iterators.SerialIterator(train, batchsize, repeat=False, shuffle=False) bn_avg_mean = defaultdict(np.float32) bn_avg_var = defaultdict(np.float32) n_iter = 0 for batch in it: imgs, _ = concat_examples(batch) model(model.xp.array(imgs)) for name, link in model.namedlinks(): if name.endwith("_bn"): bn_avg_mean[name] += link.avg_mean bn_avg_var[name] += link.avg_var n_iter += 1 for name, link in model.namedlinks(): if name.endwith("_bn"): link.avg_mean = bn_avg_mean[name] / n_iter link.avg_var = bn_avg_var[name] / n_iter return model
def CamVid_loader(dataset_dir=root_dir): # Dataset train = CamVidDataset(dataset_dir, split='train') test = CamVidDataset(dataset_dir, split='val') train = concat_examples(train) test = concat_examples(test) train_images = train[:][0] train_labels = train[:][1] test_images = test[:][0] test_labels = test[:][1] train_images /= 255.0 test_images /= 255.0 return train_images, test_images, train_labels, test_labels
def main(): args = arg() data = CamVidDataset(split=args.type) img = data[args.index][0] img /= 255.0 #img = np.clip(img, -1.0, 1.0) import matplotlib.pyplot as plt img1 = img.transpose(1, 2, 0) plt.imshow(img1) plt.show()
def setup(dataset, model, pretrained_model, batchsize, input_size): dataset_name = dataset if dataset_name == 'cityscapes': dataset = CityscapesSemanticSegmentationDataset( split='val', label_resolution='fine') label_names = cityscapes_semantic_segmentation_label_names elif dataset_name == 'ade20k': dataset = ADE20KSemanticSegmentationDataset(split='val') label_names = ade20k_semantic_segmentation_label_names elif dataset_name == 'camvid': dataset = CamVidDataset(split='test') label_names = camvid_label_names elif dataset_name == 'voc': dataset = VOCSemanticSegmentationDataset(split='val') label_names = voc_semantic_segmentation_label_names def eval_(out_values, rest_values): pred_labels, = out_values gt_labels, = rest_values result = eval_semantic_segmentation(pred_labels, gt_labels) for iu, label_name in zip(result['iou'], label_names): print('{:>23} : {:.4f}'.format(label_name, iu)) print('=' * 34) print('{:>23} : {:.4f}'.format('mean IoU', result['miou'])) print('{:>23} : {:.4f}'.format('Class average accuracy', result['mean_class_accuracy'])) print('{:>23} : {:.4f}'.format('Global average accuracy', result['pixel_accuracy'])) cls, pretrained_models, default_batchsize = models[model] if pretrained_model is None: pretrained_model = pretrained_models.get(dataset_name, dataset_name) if input_size is None: input_size = None else: input_size = (input_size, input_size) kwargs = { 'n_class': len(label_names), 'pretrained_model': pretrained_model, } if model in ['pspnet_resnet50', 'pspnet_resnet101']: kwargs.update({'input_size': input_size}) elif model == 'deeplab_v3plus_xception65': kwargs.update({'min_input_size': input_size}) model = cls(**kwargs) if batchsize is None: batchsize = default_batchsize return dataset, eval_, model, batchsize
def main(): n_class = 11 dataset = CamVidDataset(split="train") n_cls_pixels = np.zeros((n_class, )) n_img_pizels = np.zeros((n_class, )) for img, label in dataset: for cls_i in np.unique(label): if cls_i == -1: continue n_cls_pixels[cls_i] += np.sum(label == cls_i) n_img_pizels[cls_i] += label.size freq = n_cls_pixels / n_img_pizels median_freq = np.median(freq) np.save("class_weight", median_freq / freq)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model', type=str, default='camvid') parser.add_argument('--batchsize', type=int, default=24) args = parser.parse_args() model = SegNetBasic(n_class=len(camvid_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: model.to_gpu(args.gpu) model = calc_bn_statistics(model, args.batchsize) chainer.config.train = False test = CamVidDataset(split='test') it = chainer.iterators.SerialIterator(test, batch_size=args.batchsize, repeat=False, shuffle=False) imgs, pred_values, gt_values = apply_prediction_to_iterator( model.predict, it) # Delete an iterator of images to save memory usage. del imgs pred_labels, = pred_values gt_labels, = gt_values confusion = calc_semantic_segmentation_confusion(pred_labels, gt_labels) ious = calc_semantic_segmentation_iou(confusion) pixel_accuracy = np.diag(confusion).sum() / confusion.sum() mean_pixel_accuracy = np.mean( np.diag(confusion) / np.sum(confusion, axis=1)) for iou, label_name in zip(ious, camvid_label_names): print('{:>23} : {:.4f}'.format(label_name, iou)) print('=' * 34) print('{:>23} : {:.4f}'.format('mean IoU', np.nanmean(ious))) print('{:>23} : {:.4f}'.format('Class average accuracy', mean_pixel_accuracy)) print('{:>23} : {:.4f}'.format('Global average accuracy', pixel_accuracy))
def main(): parser = argparse.ArgumentParser() parser.add_argument("--gpu", type=int, default=-1) parser.add_argument("--pretrained_model", type=str, default="camvid") parser.add_argument("-batchsize", type=int, default=24) args = parser.parse_args() model = SegNetBasic(n_class=len(camvid_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() model = calc_bn_statistics(model, args.batchsize) test = CamVidDataset(split="test") it = chainer.iterators.SerialIterator(test, batch_size=args.batchsize, repeat=False, shuffle=False) imgs, pred_values, gt_values = apply_prediction_to_iterator( model.predict, it) # Delete an iterator of iamges to save memory usage. del imgs pred_labels, = pred_values gt_labels, = gt_values result = eval_semantic_segmentation(pred_labels, gt_labels) for iu, label_name in zip(result["iou"], camvid_label_names): print("{:>23} : {:.4f}".format(label_name, iu)) print("=" * 34) print("{:>23} : {:.4f}".format("mean IoU", result["miou"])) print("{:>23} : {:.4f}".format("Class average accuracy", result["mean_calss_accuracy"])) print("{:>23} : {:.4f}".format("Global average accuracy", result["pixe;_accuracy"]))
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--pretrained_model', type=str, default='camvid') parser.add_argument('--batchsize', type=int, default=24) args = parser.parse_args() model = SegNetBasic(n_class=len(camvid_label_names), pretrained_model=args.pretrained_model) if args.gpu >= 0: chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() model = calc_bn_statistics(model, args.batchsize) chainer.config.train = False test = CamVidDataset(split='test') it = chainer.iterators.SerialIterator(test, batch_size=args.batchsize, repeat=False, shuffle=False) imgs, pred_values, gt_values = apply_prediction_to_iterator( model.predict, it) # Delete an iterator of images to save memory usage. del imgs pred_labels, = pred_values gt_labels, = gt_values result = eval_semantic_segmentation(pred_labels, gt_labels) for iu, label_name in zip(result['iou'], camvid_label_names): print('{:>23} : {:.4f}'.format(label_name, iu)) print('=' * 34) print('{:>23} : {:.4f}'.format('mean IoU', result['miou'])) print('{:>23} : {:.4f}'.format('Class average accuracy', result['mean_class_accuracy'])) print('{:>23} : {:.4f}'.format('Global average accuracy', result['pixel_accuracy']))
def main(): args = arg() model = CamVidAutoEncoder(F.mean_squared_error) chainer.serializers.load_npz(args.model, model) train = CamVidDataset(split='test') img = train[0][0] img /= 255.0 ch, w, h = img.shape example_input = img.reshape(1, ch, w, h) x = chainer.Variable(example_input) y = model.predict(x) import matplotlib.pyplot as plt img1 = img.transpose(1, 2, 0) plt.subplot(1,2,1) plt.imshow(img1) y = y.data.reshape(ch, w, h) y = y.transpose(1, 2, 0).clip(0, 1.0) plt.subplot(1,2,2) plt.imshow(y) plt.show()
def CamVid_loader(dataset_dir=root_dir): # Dataset train = CamVidDataset(dataset_dir, split='train') train = TransformDataset(train, transform) test = CamVidDataset(dataset_dir, split='val')
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--batchsize', type=int, default=12) parser.add_argument('--class_weight', type=str, default='class_weight.npy') parser.add_argument('--out', type=str, default='result') args = parser.parse_args() # Triggers log_trigger = (50, 'iteration') validation_trigger = (2000, 'iteration') end_trigger = (16000, 'iteration') # Dataset train = CamVidDataset(split='train') train = TransformDataset(train, transform) val = CamVidDataset(split='val') # Iterator train_iter = iterators.MultiprocessIterator(train, args.batchsize) val_iter = iterators.MultiprocessIterator(val, args.batchsize, shuffle=False, repeat=False) # Model class_weight = np.load(args.class_weight) model = SegNetBasic(n_class=len(camvid_label_names)) model = PixelwiseSoftmaxClassifier(model, class_weight=class_weight) if args.gpu >= 0: # Make a specified GPU current chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Copy the model to the GPU # Optimizer optimizer = optimizers.MomentumSGD(lr=0.1, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005)) # Updater updater = training.updaters.StandardUpdater(train_iter, optimizer, device=args.gpu) # Trainer trainer = training.Trainer(updater, end_trigger, out=args.out) trainer.extend(extensions.LogReport(trigger=log_trigger)) trainer.extend(extensions.observe_lr(), trigger=log_trigger) trainer.extend(extensions.dump_graph('main/loss')) if extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss'], x_key='iteration', file_name='loss.png')) trainer.extend( extensions.PlotReport(['validation/main/miou'], x_key='iteration', file_name='miou.png')) trainer.extend(extensions.snapshot_object( model.predictor, filename='model_iteration-{.updater.iteration}'), trigger=end_trigger) trainer.extend(extensions.PrintReport([ 'epoch', 'iteration', 'elapsed_time', 'lr', 'main/loss', 'validation/main/miou', 'validation/main/mean_class_accuracy', 'validation/main/pixel_accuracy' ]), trigger=log_trigger) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.extend(SemanticSegmentationEvaluator(val_iter, model.predictor, camvid_label_names), trigger=validation_trigger) trainer.run()
def main(): parser = argparse.ArgumentParser() parser.add_argument("--gpu", type=int, default=-1) parser.add_argument("--batchsize", type=int, default=12) parser.add_argument("--class_weight", type=str, default="class_weight.npy") parser.add_argument("--out", type=str, default="result") args = parser.parse_args() # Triggers log_trigger = (50, "iteration") validation_trigger = (2000, "iteration") end_trigger = (16000, "iteration") # Dataset train = CamVidDataset(split="train") train = TransformDataset(dataset=train, transform=transform) val = CamVidDataset(split="val") # Iterator train_iter = iterators.MultiprocessIterator(train, args.batchsize) val_iter = iterators.MultiprocessIterator(val, args.batchsize, repeat=False, shuffle=False) # Model class_weight = np.load(args.class_weight) model = SegNetBasic(n_class=11) model = PixelwiseSoftmaxClassifier( model, class_weight=class_weight ) if args.gpu >= 0: # Make a specified GPU current chainer.cuda.get_device_from_id(args.gpu).use() # Copy the model to the GPU model.to_gpu() # Optimizer optimizer = optimizers.MomentumSGD(lr=0.1, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer.WeightDecay(rate=0.0005)) # Updater updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu) # Trainer trainer = training.Trainer(updater=updater, stop_trigger=end_trigger, out=args.out) trainer.extend(extensions.LogReport(trigger=log_trigger)) trainer.extend(extensions.observe_lr(), trigger=log_trigger) trainer.extend(extensions.dump_graph("main/loss")) if extensions.PlotReport.available(): trainer.extend(extensions.PlotReport( ["main/loss"], x_key="iteration", file_name="loss.png" )) trainer.extend(extensions.PlotReport( ["validation/loss"], x_key="iteration", file_name="miou.png" )) trainer.extend(extensions.snapshot_object( model.predictor, filename="model_iteration-{.updater.iteration}"), trigger=end_trigger) trainer.extend(extensions.PrintReport( ["epoch", "iteration", "elapsed_time", "lr", "main/loss", "validation/main/miou", "validation/main/mean_class_accuracy", "validation/main/pixel_accuracy" ] ), trigger=log_trigger) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.extend(SemanticSegmentationEvaluator( val_iter, model.predictor, camvid_label_names), trigger=validation_trigger) trainer.run()
def main(): # This follows evaluation code used in SegNet. # https://github.com/alexgkendall/SegNet-Tutorial/blob/master/ # # Scripts/compute_test_results.m parser = argparse.ArgumentParser() parser.add_argument('gpu', type=int, default=-1) parser.add_argument('snapshot', type=str) parser.add_argument('--batchsize', type=int, default=24) args = parser.parse_args() n_class = 11 ignore_labels = [-1] model = SegNetBasic(n_class=n_class) serializers.load_npz(args.snapshot, model) model = calc_bn_statistics(model, args.gpu) model.train = False if args.gpu >= 0: model.to_gpu(args.gpu) test = CamVidDataset(split='test') it = chainer.iterators.SerialIterator(test, batch_size=args.batchsize, repeat=False, shuffle=False) n_positive = [0 for _ in range(n_class)] n_true = [0 for _ in range(n_class)] n_true_positive = [0 for _ in range(n_class)] for batch in it: img, gt_label = concat_examples(batch, args.gpu) img = chainer.Variable(img, volatile=True) pred_label = F.argmax(F.softmax(model(img)), axis=1) pred_label = cuda.to_cpu(pred_label.data) gt_label = cuda.to_cpu(gt_label) for cls_i in range(n_class): if cls_i in ignore_labels: continue n_positive[cls_i] += np.sum(pred_label == cls_i) n_true[cls_i] += np.sum(gt_label == cls_i) n_true_positive[cls_i] += np.sum( (pred_label == cls_i) * (gt_label == cls_i)) ious = [] mean_accs = [] pixel_accs = [] for cls_i in range(n_class): if cls_i in ignore_labels: continue deno = n_positive[cls_i] + n_true[cls_i] - n_true_positive[cls_i] iou = n_true_positive[cls_i] / deno ious.append(iou) print('{:>23} : {:.4f}'.format(camvid_label_names[cls_i], iou)) mean_accs.append(n_true_positive[cls_i] / n_true[cls_i]) pixel_accs.append([n_true_positive[cls_i], n_true[cls_i]]) print('=' * 34) print('{:>23} : {:.4f}'.format('mean IoU', np.mean(ious))) print('{:>23} : {:.4f}'.format('Class average accuracy', np.mean(mean_accs))) pixel_accs = np.asarray(pixel_accs) pixel_accs = pixel_accs[:, 0].sum() / pixel_accs[:, 1].sum() print('{:>23} : {:.4f}'.format('Global average accuracy', pixel_accs))
def setUp(self): self.dataset = CamVidDataset(split=self.split)
def main(): parser = argparse.ArgumentParser() parser.add_argument('--gpu', type=int, default=-1) parser.add_argument('--batchsize', type=int, default=12) parser.add_argument('--class-weight', type=str, default='class_weight.npy') parser.add_argument('--val-iter', type=int, default=2000) parser.add_argument('--out', type=str, default='result') parser.add_argument('--iter', type=int, default=16000) parser.add_argument('--dtype', type=str, default='float32') parser.add_argument('--init-scale', type=float, default=1.0) parser.add_argument('--n-uf', type=float, default=1e-5) parser.add_argument('--dynamic-interval', type=int, default=None) parser.add_argument('--loss-scale-method', type=str, default='approx_range') parser.add_argument('--verbose', action='store_true', default=False) args = parser.parse_args() # Data type print('==> Using data type: {}'.format(args.dtype)) chainer.global_config.dtype = dtypes[args.dtype] # Triggers log_trigger = (50, 'iteration') validation_trigger = (args.val_iter, 'iteration') end_trigger = (args.iter, 'iteration') # Dataset train = CamVidDataset(split='train') train = TransformDataset(train, transform) val = CamVidDataset(split='val') # Iterator train_iter = iterators.MultiprocessIterator(train, args.batchsize) val_iter = iterators.MultiprocessIterator(val, args.batchsize, shuffle=False, repeat=False) # Model class_weight = np.load(args.class_weight) model = SegNetBasic(n_class=len(camvid_label_names), dtype=dtypes[args.dtype]) # adaptive loss scaling if args.dtype != 'float32': recorder = AdaLossRecorder(sample_per_n_iter=100) model = AdaLossScaled(model, init_scale=args.init_scale, transforms=[ AdaLossTransformLinear(), AdaLossTransformConvolution2D(), AdaLossTransformBatchNormalization(), ], cfg={ 'loss_scale_method': args.loss_scale_method, 'scale_upper_bound': 65504, 'accum_upper_bound': 65504, 'update_per_n_iteration': 100, 'recorder': recorder, 'n_uf_threshold': args.n_uf, }, verbose=args.verbose) model = PixelwiseSoftmaxClassifier(model, class_weight=class_weight) if args.gpu >= 0: # Make a specified GPU current chainer.cuda.get_device_from_id(args.gpu).use() model.to_gpu() # Copy the model to the GPU # Optimizer optimizer = optimizers.MomentumSGD(lr=0.1, momentum=0.9) optimizer.setup(model) optimizer.add_hook(chainer.optimizer_hooks.WeightDecay(rate=0.0005)) if args.dtype == 'mixed16': optimizer.use_fp32_update() # Updater updater = training.updaters.StandardUpdater(train_iter, optimizer, device=args.gpu) if args.dtype == 'mixed16': if args.dynamic_interval is not None: print('==> Using dynamic loss scaling (interval={}) ...'.format( args.dynamic_interval)) optimizer.loss_scaling(interval=args.dynamic_interval, scale=None) optimizer._loss_scale_max = 32770.0 else: if args.loss_scale_method == 'approx_range': print('==> Using adaptive loss scaling ...') else: print('==> Using default fixed loss scaling (scale={}) ...'. format(args.init_scale)) optimizer.loss_scaling(interval=float('inf'), scale=None) optimizer._loss_scale_max = 1.0 # to prevent actual loss scaling # Trainer trainer = training.Trainer(updater, end_trigger, out=args.out) # warmup_attr_ratio = 0.1 if args.dtype != 'float32' else None # # NOTE: this is confusing but it means n_iter # warmup_n_epoch = 1000 if args.dtype != 'float32' else None # lr_shift = chainerlp.extensions.ExponentialShift( # 'lr', # 0.1, # init=0.1 * warmup_attr_ratio, # warmup_attr_ratio=warmup_attr_ratio, # warmup_n_epoch=warmup_n_epoch) # trainer.extend(lr_shift, trigger=(1, 'iteration')) trainer.extend(extensions.LogReport(trigger=log_trigger)) trainer.extend(extensions.observe_lr(), trigger=log_trigger) if args.dtype != 'float32': trainer.extend(extensions.observe_value( 'loss_scale', lambda trainer: trainer.updater.get_optimizer('main')._loss_scale), trigger=log_trigger) trainer.extend(extensions.dump_graph('main/loss')) # snapshot the trainer after each trainer.extend(extensions.snapshot(), trigger=validation_trigger) # snapshot the model itself trainer.extend(extensions.snapshot_object( get_snapshot_model(model), 'model_iter_{.updater.iteration}'), trigger=validation_trigger) if extensions.PlotReport.available(): trainer.extend( extensions.PlotReport(['main/loss'], x_key='iteration', file_name='loss.png')) trainer.extend( extensions.PlotReport(['validation/main/miou'], x_key='iteration', file_name='miou.png')) metrics = [ 'epoch', 'iteration', 'elapsed_time', 'lr', 'main/loss', 'validation/main/miou', 'validation/main/mean_class_accuracy', 'validation/main/pixel_accuracy' ] if args.dtype != 'float32': metrics.append('loss_scale') trainer.extend(extensions.PrintReport(metrics), trigger=log_trigger) trainer.extend(extensions.ProgressBar(update_interval=10)) trainer.extend(SemanticSegmentationEvaluator(val_iter, model.predictor, camvid_label_names), trigger=validation_trigger) # snapshot the best validation result trainer.extend(extensions.snapshot_object(get_snapshot_model(model), 'model_best'), trigger=chainer.training.triggers.MaxValueTrigger( 'validation/main/miou', trigger=validation_trigger)) hooks = [] if args.dtype != 'float32': hook = AdaLossMonitor(sample_per_n_iter=100, verbose=args.verbose, includes=['Grad', 'Deconvolution']) recorder.trainer = trainer hook.trainer = trainer hooks.append(hook) with ExitStack() as stack: for hook in hooks: stack.enter_context(hook) trainer.run() chainer.serializers.save_npz( os.path.join(args.out, 'snapshot_model.npz'), recalculate_bn_statistics(model.predictor, args.batchsize, dtype=args.dtype)) if args.dtype != 'float32': recorder.export().to_csv(os.path.join(args.out, 'loss_scale.csv'))
from __future__ import division import numpy as np from chainercv.datasets import CamVidDataset n_class = 11 dataset = CamVidDataset(split='train') n_cls_pixels = np.zeros((n_class, )) n_img_pixels = np.zeros((n_class, )) for img, label in dataset: for cls_i in np.unique(label): if cls_i == -1: continue n_cls_pixels[cls_i] += np.sum(label == cls_i) n_img_pixels[cls_i] += label.size freq = n_cls_pixels / n_img_pixels median_freq = np.median(freq) np.save('class_weight', median_freq / freq)