def get_model(self): image = paddle.static.data( name='image', shape=[None, 1, 28, 28], dtype='float32') label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label) avg_cost = paddle.mean(x=cost) startup_prog = paddle.static.default_startup_program() train_prog = paddle.static.default_main_program() return startup_prog, train_prog
def get_model(self): image = fluid.layers.data( name='image', shape=[1, 28, 28], dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = fluid.layers.cross_entropy(input=out, label=label) avg_cost = fluid.layers.mean(x=cost) startup_prog = fluid.default_startup_program() train_prog = fluid.default_main_program() return startup_prog, train_prog
def test_analysis_helper(self): image = paddle.static.data( name='image', shape=[None, 1, 28, 28], dtype='float32') label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label) avg_cost = paddle.mean(x=cost) acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1) acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5) optimizer = paddle.optimizer.Momentum( momentum=0.9, learning_rate=0.01, weight_decay=paddle.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = paddle.static.default_main_program() places = paddle.static.cuda_places() if paddle.is_compiled_with_cuda( ) else paddle.static.cpu_places() exe = paddle.static.Executor(places[0]) def transform(x): return np.reshape(x, [1, 28, 28]) train_dataset = paddle.vision.datasets.MNIST( mode='train', backend='cv2', transform=transform) train_loader = paddle.io.DataLoader( train_dataset, places=places, feed_list=[image, label], drop_last=True, return_list=False, batch_size=64) exe.run(paddle.static.default_startup_program()) vars = ['conv2d_0.tmp_0', 'fc_0.tmp_0', 'fc_0.tmp_1', 'fc_0.tmp_2'] var_collector1 = VarCollector(main_prog, vars, use_ema=True) values = var_collector1.abs_max_run( train_loader, exe, step=None, loss_name=avg_cost.name) vars = [v.name for v in main_prog.list_vars() if v.persistable] var_collector2 = VarCollector(main_prog, vars, use_ema=False) values = var_collector2.run(train_loader, exe, step=None, loss_name=avg_cost.name) var_collector2.pdf(values)
def test_analysis_helper(self): image = fluid.layers.data(name='image', shape=[1, 28, 28], dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = fluid.layers.cross_entropy(input=out, label=label) avg_cost = fluid.layers.mean(x=cost) acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1) acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5) optimizer = fluid.optimizer.Momentum( momentum=0.9, learning_rate=0.01, regularization=fluid.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = fluid.default_main_program() places = fluid.cuda_places() if fluid.is_compiled_with_cuda( ) else fluid.cpu_places() exe = fluid.Executor(places[0]) train_reader = paddle.fluid.io.batch(paddle.dataset.mnist.train(), batch_size=64) train_loader = fluid.io.DataLoader.from_generator( feed_list=[image, label], capacity=512, use_double_buffer=True, iterable=True) train_loader.set_sample_list_generator(train_reader, places) exe.run(fluid.default_startup_program()) vars = ['conv2d_0.tmp_0', 'fc_0.tmp_0', 'fc_0.tmp_1', 'fc_0.tmp_2'] var_collector1 = VarCollector(main_prog, vars, use_ema=True) values = var_collector1.abs_max_run(train_loader, exe, step=None, loss_name=avg_cost.name) vars = [v.name for v in main_prog.list_vars() if v.persistable] var_collector2 = VarCollector(main_prog, vars, use_ema=False) values = var_collector2.run(train_loader, exe, step=None, loss_name=avg_cost.name) var_collector2.pdf(values)
def load_model(model_name): if model_name == 'deepyeast': from models import DeepYeast model = DeepYeast() elif model_name == 'resnet': from models import ResNet50 model = ResNet50() elif model_name == 'mobilenet': from models import MobileNet model = MobileNet() elif model_name == 'densenet': from models import DenseNet40_BC model = DenseNet40_BC() return model
def cfg2fitness(cfg): if args.local_rank == 0: print(str(cfg)) if str(cfg) in cfg2fit_dict.keys(): return cfg2fit_dict[str(cfg)] elif cfg == run_manager.net.module.config['cfg_base']: return 0. else: run_manager.run_config.n_epochs = run_manager.run_config.search_epoch if args.model == 'resnet18': run_manager.reset_model( ResNet_ImageNet(num_classes=1000, cfg=cfg, depth=18), net_origin.cpu()) elif args.model == 'resnet34': run_manager.reset_model( ResNet_ImageNet(num_classes=1000, cfg=cfg, depth=34), net_origin.cpu()) elif args.model == 'resnet50': run_manager.reset_model( ResNet_ImageNet(num_classes=1000, cfg=cfg, depth=50), net_origin.cpu()) elif args.model == 'mobilenet': run_manager.reset_model(MobileNet(num_classes=1000, cfg=cfg), net_origin.cpu()) elif args.model == 'mobilenetv2': run_manager.reset_model(MobileNetV2(num_classes=1000, cfg=cfg), net_origin.cpu()) elif args.model == 'vgg': run_manager.reset_model( VGG_CIFAR(cfg=cfg, cutout=False, num_classes=10), net_origin.cpu()) elif args.model == 'resnet56': run_manager.reset_model( ResNet_CIFAR(cfg=cfg, depth=56, num_classes=10, cutout=False), net_origin.cpu()) elif args.model == 'resnet110': run_manager.reset_model( ResNet_CIFAR(cfg=cfg, depth=110, num_classes=10, cutout=False), net_origin.cpu()) run_manager.start_epoch = 0 run_manager.train() _, acc1, _ = run_manager.validate(is_test=False, return_top5=True) cfg2fit_dict[str(cfg)] = acc1.item() return acc1.item()
def _get_model_archtecture(self): """ 通过配置文件得到网络的结构 :return: """ if self.config['type'] == 'DenseNet': from models import DenseNet model_object = DenseNet.DenseNet(self.config['model_config']) if self.config['type'] == 'ResNet': from models import ResNet model_object = ResNet.ResNet(self.config['model_config']) if self.config['type'] == 'MobilenetV2': from models import MobileNet model_object = MobileNet.mobilenetV2(self.config['model_config']) self.model = model_object.constuct_model()
def build_model(device, model_name, num_classes=10): """构建模型:vgg、vggnonorm、resnet、preactresnet、googlenet、densenet、 resnext、mobilenet、mobilenetv2、dpn、shufflenetg2、senet、shufflenetv2 :param device: 'cuda' if you have a GPU, 'cpu' otherwise :param model_name: One of the models available in the folder 'models' :param num_classes: 10 or 100 depending on the chosen dataset :return: The model architecture """ print('==> Building model..') model_name = model_name.lower() if model_name == 'vgg': net = VGG('VGG19', num_classes=num_classes) elif model_name == 'vggnonorm': net = VGG('VGG19', num_classes=num_classes, batch_norm=False) elif model_name == 'resnet': net = ResNet18(num_classes=num_classes) elif model_name == 'preactresnet': net = PreActResNet18() elif model_name == 'googlenet': net = GoogLeNet() elif model_name == 'densenet': net = DenseNet121() elif model_name == 'resnext': net = ResNeXt29_2x64d() elif model_name == 'mobilenet': net = MobileNet() elif model_name == 'mobilenetv2': net = MobileNetV2() elif model_name == 'dpn': net = DPN92() elif model_name == 'shufflenetg2': net = ShuffleNetG2() elif model_name == 'senet': net = SENet18() elif model_name == 'shufflenetv2': net = ShuffleNetV2(1) else: raise ValueError('Error: the specified model is incorrect ({})'.format(model_name)) net = net.to(device) if device == 'cuda': net = torch.nn.DataParallel(net) cudnn.benchmark = True return net
def train_net(args): torch.manual_seed(7) np.random.seed(7) checkpoint = args.checkpoint start_epoch = 0 best_acc = 0 writer = SummaryWriter() epochs_since_improvement = 0 # Initialize / load checkpoint if checkpoint is None: if args.network == 'r18': model = resnet18(args) elif args.network == 'r34': model = resnet34(args) elif args.network == 'r50': model = resnet50(args) elif args.network == 'r101': model = resnet101(args) elif args.network == 'r152': model = resnet152(args) elif args.network == 'mobile': model = MobileNet(1.0) else: model = resnet_face18(args.use_se) model = nn.DataParallel(model) metric_fc = ArcMarginModel(args) metric_fc = nn.DataParallel(metric_fc) if args.optimizer == 'sgd': # optimizer = torch.optim.SGD([{'params': model.parameters()}, {'params': metric_fc.parameters()}], # lr=args.lr, momentum=args.mom, weight_decay=args.weight_decay) optimizer = InsightFaceOptimizer( torch.optim.SGD([{ 'params': model.parameters() }, { 'params': metric_fc.parameters() }], lr=args.lr, momentum=args.mom, weight_decay=args.weight_decay)) else: optimizer = torch.optim.Adam([{ 'params': model.parameters() }, { 'params': metric_fc.parameters() }], lr=args.lr, weight_decay=args.weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] model = checkpoint['model'] metric_fc = checkpoint['metric_fc'] optimizer = checkpoint['optimizer'] logger = get_logger() # Move to GPU, if available model = model.to(device) metric_fc = metric_fc.to(device) # Loss function if args.focal_loss: criterion = FocalLoss(gamma=args.gamma).to(device) else: criterion = nn.CrossEntropyLoss().to(device) # Custom dataloaders train_dataset = ArcFaceDataset('train') train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=8) # Epochs for epoch in range(start_epoch, args.end_epoch): # One epoch's training train_loss, train_top1_accs = train(train_loader=train_loader, model=model, metric_fc=metric_fc, criterion=criterion, optimizer=optimizer, epoch=epoch, logger=logger) print('\nCurrent effective learning rate: {}\n'.format(optimizer.lr)) print('Step num: {}\n'.format(optimizer.step_num)) writer.add_scalar('model/train_loss', train_loss, epoch) writer.add_scalar('model/train_accuracy', train_top1_accs, epoch) writer.add_scalar('model/learning_rate', optimizer.lr, epoch) # One epoch's validation megaface_acc = megaface_test(model) writer.add_scalar('model/megaface_accuracy', megaface_acc, epoch) # Check if there was an improvement is_best = megaface_acc > best_acc best_acc = max(megaface_acc, best_acc) if not is_best: epochs_since_improvement += 1 print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement, )) else: epochs_since_improvement = 0 # Save checkpoint save_checkpoint(epoch, epochs_since_improvement, model, metric_fc, optimizer, best_acc, is_best)
def test_accuracy(self): image = paddle.static.data( name='image', shape=[None, 1, 28, 28], dtype='float32') label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label) avg_cost = paddle.mean(x=cost) acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1) acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5) optimizer = paddle.optimizer.Momentum( momentum=0.9, learning_rate=0.01, weight_decay=paddle.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = paddle.static.default_main_program() val_prog = main_prog.clone(for_test=True) place = paddle.CUDAPlace(0) if paddle.fluid.is_compiled_with_cuda( ) else paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(paddle.static.default_startup_program()) train_loader = paddle.io.DataLoader.from_generator( feed_list=[image, label], capacity=512, use_double_buffer=True, iterable=True) valid_loader = paddle.io.DataLoader.from_generator( feed_list=[image, label], capacity=512, use_double_buffer=True, iterable=True) train_reader = paddle.batch(paddle.dataset.mnist.train(), batch_size=64) eval_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=64) train_loader.set_sample_list_generator(train_reader, place) valid_loader.set_sample_list_generator(eval_reader, place) def train(program): iter = 0 for data in train_loader(): cost, top1, top5 = exe.run( program, feed=data, fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) def test(program, outputs=[avg_cost, acc_top1, acc_top5]): iter = 0 result = [[], [], []] for data in valid_loader(): cost, top1, top5 = exe.run(program, feed=data, fetch_list=outputs) iter += 1 if iter % 100 == 0: print('eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean(result[2]))) return np.mean(result[1]), np.mean(result[2]) train(main_prog) top1_1, top5_1 = test(val_prog) paddle.static.save_inference_model( dirname='./test_quant_post_dynamic', feeded_var_names=[image.name, label.name], target_vars=[avg_cost, acc_top1, acc_top5], main_program=val_prog, executor=exe, model_filename='model', params_filename='params') quant_post_dynamic( model_dir='./test_quant_post_dynamic', save_model_dir='./test_quant_post_inference', model_filename='model', params_filename='params', generate_test_model=True) quant_post_prog, feed_target_names, fetch_targets = paddle.static.load_inference_model( dirname='./test_quant_post_inference/test_model', executor=exe) top1_2, top5_2 = test(quant_post_prog, fetch_targets) print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1)) print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
ResNet_ImageNet(depth=18, num_classes=1000)) elif args.model == 'resnet34': assert args.dataset == 'imagenet', 'resnet34 only supports imagenet dataset' net = ResNet_ImageNet(num_classes=1000, cfg=None, depth=34) weight_path = 'Exp_base/resnet34_base/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel( ResNet_ImageNet(depth=34, num_classes=1000)) elif args.model == 'resnet50': assert args.dataset == 'imagenet', 'resnet50 only supports imagenet dataset' net = ResNet_ImageNet(num_classes=1000, cfg=None, depth=50) weight_path = 'Exp_base/resnet50_base/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel( ResNet_ImageNet(depth=50, num_classes=1000)) elif args.model == 'mobilenet': assert args.dataset == 'imagenet', 'mobilenet only supports imagenet dataset' net = MobileNet(num_classes=1000, cfg=None) weight_path = 'Exp_base/mobilenet_base/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel(MobileNet(num_classes=1000)) elif args.model == 'mobilenetv2': assert args.dataset == 'imagenet', 'mobilenetv2 only supports imagenet dataset' net = MobileNetV2(num_classes=1000, cfg=None) weight_path = 'Exp_base/mobilenetv2_base/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel(MobileNetV2(num_classes=1000)) elif args.model == 'vgg': assert args.dataset == 'cifar10', 'vgg only supports cifar10 dataset' net = VGG_CIFAR(cfg=None, cutout=False) weight_path = 'Exp_base/vgg_base/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel(VGG_CIFAR(cutout=False)) elif args.model == "resnet56": assert args.dataset == 'cifar10', 'resnet56 only supports cifar10 dataset' net = ResNet_CIFAR(cfg=None, depth=56, num_classes=10, cutout=False)
num_workers=opt.n_workers, shuffle=True) test_data_loader = DataLoader(test_dataset, batch_size=opt.batch_size, num_workers=opt.n_workers, shuffle=False) backbone_network = opt.backbone_network n_layers = opt.n_layers if backbone_network == 'MobileNet': from models import MobileNet model = MobileNet(width_multiplier=opt.width_multiplier, attention=opt.attention_module, group_size=opt.group_size) if backbone_network == 'ResNet': from models import ResidualNetwork model = ResidualNetwork(n_layers=n_layers, dataset=opt.dataset, attention=opt.attention_module, group_size=opt.group_size) elif backbone_network == 'ResNext': from models import ResNext model = ResNext(n_layers=n_layers, n_groups=opt.n_groups,
def test_accuracy(self): image = fluid.layers.data(name='image', shape=[1, 28, 28], dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = fluid.layers.cross_entropy(input=out, label=label) avg_cost = fluid.layers.mean(x=cost) acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1) acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5) optimizer = fluid.optimizer.Momentum( momentum=0.9, learning_rate=0.01, regularization=fluid.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = fluid.default_main_program() val_prog = main_prog.clone(for_test=True) place = fluid.CUDAPlace( 0) if fluid.is_compiled_with_cuda() else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) feeder = fluid.DataFeeder([image, label], place, program=main_prog) train_reader = paddle.fluid.io.batch(paddle.dataset.mnist.train(), batch_size=64) eval_reader = paddle.fluid.io.batch(paddle.dataset.mnist.test(), batch_size=64) def train(program): iter = 0 for data in train_reader(): cost, top1, top5 = exe.run( program, feed=feeder.feed(data), fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) def test(program, outputs=[avg_cost, acc_top1, acc_top5]): iter = 0 result = [[], [], []] for data in train_reader(): cost, top1, top5 = exe.run(program, feed=feeder.feed(data), fetch_list=outputs) iter += 1 if iter % 100 == 0: print( 'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean(result[2]))) return np.mean(result[1]), np.mean(result[2]) train(main_prog) top1_1, top5_1 = test(val_prog) fluid.io.save_inference_model( dirname='./test_quant_post', feeded_var_names=[image.name, label.name], target_vars=[avg_cost, acc_top1, acc_top5], main_program=val_prog, executor=exe, model_filename='model', params_filename='params') quant_post_static(exe, './test_quant_post', './test_quant_post_inference', sample_generator=paddle.dataset.mnist.test(), model_filename='model', params_filename='params', batch_nums=10) quant_post_prog, feed_target_names, fetch_targets = fluid.io.load_inference_model( dirname='./test_quant_post_inference', executor=exe, model_filename='__model__', params_filename='__params__') top1_2, top5_2 = test(quant_post_prog, fetch_targets) print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1)) print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
transforms.ToTensor(), transforms.Normalize(mean=[0.5],std=[0.5]), ]) # Argv test_fpath = sys.argv[1] model_fpath = sys.argv[2] output_fpath = sys.argv[3] print('# [Info] Argv') print(' - Test : {}'.format(test_fpath)) print(' - Model : {}'.format(model_fpath)) print(' = Output : {}'.format(output_fpath)) # Make data loader test_dataset = MyDataset(filename=test_fpath, is_train=False, transform=test_transform) test_loader = DataLoader(dataset=test_dataset, batch_size=BATCH_SIZE, shuffle=False) # Load model model = MobileNet() model.load_state_dict(torch.load(model_fpath, map_location=device)) model.to(device) # Model prediction model.eval() prediction = [] for i, data in enumerate(test_loader): data_device = data.to(device) output = model(data_device) labels = torch.max(output, 1)[1] for label in labels: prediction.append(label) # Output prediction print('# [Info] Output prediction: {}'.format(output_fpath)) with open(output_fpath, 'w') as f: f.write('id,label\n')
net_origin = nn.DataParallel(ResNet_ImageNet(depth=34, num_classes=run_config.data_provider.n_classes)) elif args.model=="resnet50": assert args.dataset=='imagenet', 'resnet50 only supports imagenet dataset' net = ResNet_ImageNet(depth=50, num_classes=run_config.data_provider.n_classes, cfg=eval(args.cfg)) if args.base_path!=None: weight_path = args.base_path+'/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel(ResNet_ImageNet(depth=50, num_classes=run_config.data_provider.n_classes)) elif args.model=="mobilenetv2": assert args.dataset=='imagenet', 'mobilenetv2 only supports imagenet dataset' net = MobileNetV2(num_classes=run_config.data_provider.n_classes, cfg=eval(args.cfg)) if args.base_path!=None: weight_path = args.base_path+'/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel(MobileNetV2(num_classes=run_config.data_provider.n_classes)) elif args.model=="mobilenet": assert args.dataset=='imagenet', 'mobilenet only supports imagenet dataset' net = MobileNet(num_classes=run_config.data_provider.n_classes, cfg=eval(args.cfg)) if args.base_path!=None: weight_path = args.base_path+'/checkpoint/model_best.pth.tar' net_origin = nn.DataParallel(MobileNet(num_classes=run_config.data_provider.n_classes)) # build run manager run_manager = RunManager(args.path, net, run_config) if args.local_rank == 0: run_manager.save_config(print_info=True) # load checkpoints if args.base_path!=None: weight_path = args.base_path+'/checkpoint/model_best.pth.tar' if args.resume: run_manager.load_model() if args.train and run_manager.best_acc == 0:
def main(): parser = argparse.ArgumentParser() parser.add_argument("--mode", type=str, default="train") parser.add_argument("--model", type=str, default="mobilenet_v2") parser.add_argument("--dataset", type=str, default="cifar10") parser.add_argument("--dataroot", type=str, default="/tmp/data") parser.add_argument("--batch_size", type=int, default=128) parser.add_argument("--n_epochs", type=int, default=100) parser.add_argument("--lr", type=float, default=1e-3) parser.add_argument("--n_gpus", type=int, default=1) parser.add_argument("--checkpoint", type=str, default="/tmp/chkpt.pth.tar") parser.add_argument("--save_every", type=int, default=10) parser.add_argument("--pretrained", type=str, default=None) args = parser.parse_args() print(args) if torch.cuda.is_available(): print("cuda is available, use cuda") device = torch.device("cuda") else: print("cuda is not available, use cpu") device = torch.device("cpu") print("download dataset: {}".format(args.dataset)) train_loader, test_loader, n_classes = get_loaders( dataset=args.dataset, root=args.dataroot, batch_size=args.batch_size) print("build model: {}".format(args.model)) if args.model == "mobilenet": from models import MobileNet model = MobileNet(n_classes=n_classes) elif args.model == "mobilenet_v2": from models import MobileNet_v2 model = MobileNet_v2(n_classes=n_classes) elif args.model == "shufflenet": from models import ShuffleNet model = ShuffleNet(n_classes=n_classes) elif args.model == "shufflenet_v2": from models import ShuffleNet_v2 model = ShuffleNet_v2(n_classes=n_classes) elif args.model == "squeezenet": from models import SqueezeNet model = SqueezeNet(n_classes=n_classes) else: raise NotImplementedError model = model.to(device) if args.pretrained: model.load_state_dict(torch.load(args.checkpoint)) if args.n_gpus > 1: gpus = [] for i in range(args.n_gpus): gpus.append(i) model = nn.DataParallel(model, device_ids=gpus) optimizer = optim.Adam(model.parameters(), lr=args.lr) criterion = nn.CrossEntropyLoss() if args.mode == "train": for epoch in range(args.n_epochs): train(epoch, model, optimizer, criterion, train_loader, device) if (epoch + 1) % args.save_every == 0: print("saving model...") torch.save(the_model.state_dict(), args.checkpoint) elif args.mode == "test": test(model, criterion, test_loader, device) else: raise NotImplementedError
]) # Create dataset train_dataset = MyDataset(filename=train_fpath, transform=train_transform) val_dataset = MyDataset(filename=train_fpath, transform=val_transform) # Split train and val data_len = len(train_dataset) indices = list(range(data_len)) val_len = int(VAL_RATIO * data_len) val_idx = np.random.choice(indices, size=val_len, replace=False) train_idx = list(set(indices) - set(val_idx)) train_sampler = SubsetRandomSampler(train_idx) val_sampler = SubsetRandomSampler(val_idx) train_loader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, sampler=train_sampler) val_loader = DataLoader(dataset=val_dataset, batch_size=BATCH_SIZE, sampler=val_sampler) # Train print('# [Info] Start training...') mobile = MobileNet() trainer = Trainer(model=mobile, train_loader=train_loader, val_loader=val_loader, weight_fpath=weight_fpath) trainer.train(epochs=EPOCHS) print('Done!')
def train_net(args): torch.manual_seed(7) np.random.seed(7) checkpoint = args.checkpoint start_epoch = 0 best_acc = 0 writer = SummaryWriter() epochs_since_improvement = 0 # Initialize / load checkpoint if checkpoint is None: if args.network == 'r18': model = resnet18(args) elif args.network == 'r34': model = resnet34(args) elif args.network == 'r50': model = resnet50(args) elif args.network == 'r101': model = resnet101(args) elif args.network == 'r152': model = resnet152(args) elif args.network == 'mobile': model = MobileNet(1.0) elif args.network == 'mr18': print("mr18") model = myResnet18() else: model = resnet_face18(args.use_se) model = nn.DataParallel(model) metric_fc = ArcMarginModel(args) metric_fc = nn.DataParallel(metric_fc) if args.optimizer == 'sgd': optimizer = torch.optim.SGD([{ 'params': model.parameters() }, { 'params': metric_fc.parameters() }], lr=args.lr, momentum=args.mom, weight_decay=args.weight_decay) else: optimizer = torch.optim.Adam([{ 'params': model.parameters() }, { 'params': metric_fc.parameters() }], lr=args.lr, weight_decay=args.weight_decay) else: checkpoint = torch.load(checkpoint) start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] model = checkpoint['model'] metric_fc = checkpoint['metric_fc'] optimizer = checkpoint['optimizer'] logger = get_logger() # Move to GPU, if available model = model.to(device) metric_fc = metric_fc.to(device) # Loss function if args.focal_loss: criterion = FocalLoss(gamma=args.gamma).to(device) else: criterion = nn.CrossEntropyLoss().to(device) # Custom dataloaders train_dataset = ArcFaceDataset('train') train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True) scheduler = StepLR(optimizer, step_size=args.lr_step, gamma=0.1) # Epochs for epoch in range(start_epoch, args.end_epoch): scheduler.step() if args.full_log: lfw_acc, threshold = lfw_test(model) writer.add_scalar('LFW_Accuracy', lfw_acc, epoch) full_log(epoch) start = datetime.now() # One epoch's training train_loss, train_top5_accs = train(train_loader=train_loader, model=model, metric_fc=metric_fc, criterion=criterion, optimizer=optimizer, epoch=epoch, logger=logger, writer=writer) writer.add_scalar('Train_Loss', train_loss, epoch) writer.add_scalar('Train_Top5_Accuracy', train_top5_accs, epoch) end = datetime.now() delta = end - start print('{} seconds'.format(delta.seconds)) # One epoch's validation lfw_acc, threshold = lfw_test(model) writer.add_scalar('LFW Accuracy', lfw_acc, epoch) # Check if there was an improvement is_best = lfw_acc > best_acc best_acc = max(lfw_acc, best_acc) if not is_best: epochs_since_improvement += 1 print("\nEpochs since last improvement: %d\n" % (epochs_since_improvement, )) else: epochs_since_improvement = 0 # Save checkpoint save_checkpoint(epoch, epochs_since_improvement, model, metric_fc, optimizer, best_acc, is_best)
def test_accuracy(self): image = paddle.static.data(name='image', shape=[None, 1, 28, 28], dtype='float32') label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label) avg_cost = paddle.mean(x=cost) acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1) acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5) optimizer = paddle.optimizer.Momentum( momentum=0.9, learning_rate=0.01, weight_decay=paddle.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = paddle.static.default_main_program() val_prog = main_prog.clone(for_test=True) place = paddle.CUDAPlace(0) if paddle.fluid.is_compiled_with_cuda( ) else paddle.static.CPUPlace() exe = paddle.static.Executor(place) exe.run(paddle.static.default_startup_program()) train_loader = paddle.io.DataLoader.from_generator( feed_list=[image, label], capacity=512, use_double_buffer=True, iterable=True) valid_loader = paddle.io.DataLoader.from_generator( feed_list=[image, label], capacity=512, use_double_buffer=True, iterable=True) train_reader = paddle.batch(paddle.dataset.mnist.train(), batch_size=64) eval_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=64) train_loader.set_sample_list_generator(train_reader, place) valid_loader.set_sample_list_generator(eval_reader, place) def train(program): iter = 0 for data in train_loader(): cost, top1, top5 = exe.run( program, feed=data, fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) def test(program): iter = 0 result = [[], [], []] for data in valid_loader(): cost, top1, top5 = exe.run( program, feed=data, fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean(result[2]))) return np.mean(result[1]), np.mean(result[2]) train(main_prog) top1_1, top5_1 = test(main_prog) config = { 'weight_quantize_type': 'channel_wise_abs_max', 'activation_quantize_type': 'moving_average_abs_max', 'quantize_op_types': ['depthwise_conv2d', 'mul', 'conv2d'], } quant_train_prog = quant_aware(main_prog, place, config, for_test=False) quant_eval_prog = quant_aware(val_prog, place, config, for_test=True) train(quant_train_prog) quant_eval_prog, int8_prog = convert(quant_eval_prog, place, config, save_int8=True) top1_2, top5_2 = test(quant_eval_prog) # values before quantization and after quantization should be close print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1)) print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
def main(): parser = argparse.ArgumentParser( description='Deep Learning SNN simulation') parser.add_argument('--config-file', default='config_1.ini') args = parser.parse_args() print(args) config = configparser.ConfigParser() config.read(args.config_file) pprint.pprint( {section: dict(config[section]) for section in config.sections()}) print defaults = config['DEFAULT'] device = defaults['device'] app_name = defaults['app_name'] print('[INFO] Simulating spiking {}'.format(app_name)) if not os.path.isdir(app_name): os.mkdir(app_name) out_dir = app_name org_model = config['original model'] " Load the original model " net = None if 'mobilenet_cifar10' in org_model['arch']: net = MobileNet() if org_model['arch'] == 'vgg_cifar10': net = VGG_16_cifar10 num_classes = org_model.getint('num_classes') model_path = org_model['model_path'] file_name = org_model['file_name'] state = None state, net = load_model(net, model_path, file_name) net = net.to(device) " Load the dataset " testloader, img_size = None, None data_config = config['dataset'] data_dir = data_config['data_dir'] if data_config['dataset'] == 'cifar10': _, testloader = load_cifar10(data_dir, org_model['arch']) img_size = [-1, 3, 32, 32] " Tasks to do " tasks = config['functions'] if tasks.getboolean('validate'): print(net) validate(net, testloader, device) new_net = None if tasks.getboolean('remove_bn'): if has_bn(net): new_net = MobileNet_nobn() new_net = merge_bn(net, new_net) new_net = new_net.to(device) print(new_net) print('Validating model after folding back BN layers...') validate(new_net, testloader, device) save_model(new_net, state, out_dir, 'nobn_' + file_name) else: print('model has no BN layers') if tasks.getboolean('use_nobn'): if 'mobilenet_cifar10' in org_model['arch']: net = MobileNet_nobn() state, net = load_model(net, out_dir, 'nobn_' + file_name) net = net.to(device) " quantize model " quant_config = config['quantization'] W = quant_config.getint('W') F = quant_config.getint('F') if tasks.getboolean('quantize'): net = quantize_model(net, W, F) net = net.to(device) print('Validating model after quantization...') state['acc'] = validate(net, testloader, device) save_model(net, state, out_dir, 'quant{}.{}_'.format(W, F) + file_name) " use quantized model " if tasks.getboolean('use_quant'): state, net = load_model(net, out_dir, 'quant{}.{}_'.format(W, F) + file_name) net = net.to(device) if tasks.getboolean('validate_nobn'): if not has_bn(net): print('Validating no_bn model...') validate(net, testloader) else: print('model has BN layers!! Exiting..') exit() " compute thresholds " spike_config = config['spiking'] percentile = spike_config.getfloat('percentile') if spike_config.getboolean('compute_thresholds'): compute_thresholds(net, testloader, out_dir, percentile, device) " convert ann to snn " spike_net, thresholds, max_acts, clamp_slope = None, None, None, None if spike_config.getboolean('convert_to_spike'): thresholds = np.loadtxt(os.path.join(out_dir, 'thresholds.txt')) max_acts = np.loadtxt(os.path.join(out_dir, 'max_acts.txt')) clamp_slope = spike_config.getfloat('clamp_slope') spike_net = createSpikingModel(net, org_model['arch'], num_classes, spike_config, thresholds, max_acts, device) print(spike_net) sanity_check(net, spike_net, max_acts) " simulate snn " if spike_config.getboolean('simulate_spiking'): thresholds = np.loadtxt(os.path.join(out_dir, 'thresholds.txt')) max_acts = np.loadtxt(os.path.join(out_dir, 'max_acts.txt')) simulate_spike_model(net, org_model['arch'], testloader, config, thresholds, max_acts, num_classes, img_size, device) " plot correlations " if spike_config.getboolean('plot_correlations'): corr = np.load(os.path.join(out_dir, 'layerwise_corr.npy')) plot_config = config['plotting'] #print('corr matrix shape: {}'.format(corr.shape)) plot_correlations(corr, out_dir, plot_config)
def main(): global args, best_err1, best_err5 args = parser.parse_args() traindir = os.path.join(args.data_path, 'train') valdir = os.path.join(args.data_path, 'val') normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) train_dataset = datasets.ImageFolder(traindir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), normalize]) ) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers, pin_memory=True, sampler=None) val_dataset = datasets.ImageFolder(valdir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), normalize]) ) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers, pin_memory=True) if args.net_type == 'mobilenet': t_net = ResNet.resnet50(pretrained=True) s_net = Mov.MobileNet() elif args.net_type == 'resnet': t_net = ResNet.resnet152(pretrained=True) s_net = ResNet.resnet50(pretrained=False) else: print('undefined network type !!!') raise d_net = distiller.Distiller(t_net, s_net) print ('Teacher Net: ') print(t_net) print ('Student Net: ') print(s_net) print('the number of teacher model parameters: {}'.format(sum([p.data.nelement() for p in t_net.parameters()]))) print('the number of student model parameters: {}'.format(sum([p.data.nelement() for p in s_net.parameters()]))) t_net = torch.nn.DataParallel(t_net).cuda() s_net = torch.nn.DataParallel(s_net).cuda() d_net = torch.nn.DataParallel(d_net).cuda() # define loss function (criterion) and optimizer criterion_CE = nn.CrossEntropyLoss().cuda() optimizer = torch.optim.SGD(list(s_net.parameters()) + list(d_net.module.Connectors.parameters()), args.lr, momentum=args.momentum, weight_decay=args.weight_decay, nesterov=True) cudnn.benchmark = True print('Teacher network performance') validate(val_loader, t_net, criterion_CE, 0) for epoch in range(1, args.epochs+1): adjust_learning_rate(optimizer, epoch) # train for one epoch train_with_distill(train_loader, d_net, optimizer, criterion_CE, epoch) # evaluate on validation set err1, err5 = validate(val_loader, s_net, criterion_CE, epoch) # remember best prec@1 and save checkpoint is_best = err1 <= best_err1 best_err1 = min(err1, best_err1) if is_best: best_err5 = err5 print ('Current best accuracy (top-1 and 5 error):', best_err1, best_err5) save_checkpoint({ 'epoch': epoch, 'arch': args.net_type, 'state_dict': s_net.state_dict(), 'best_err1': best_err1, 'best_err5': best_err5, 'optimizer' : optimizer.state_dict(), }, is_best) gc.collect() print ('Best accuracy (top-1 and 5 error):', best_err1, best_err5)
assert args.dataset == 'imagenet', 'resnet34 only supports imagenet dataset' net = ResNet_ImageNet(depth=34, num_classes=run_config.data_provider.n_classes, cfg=eval(args.cfg)) elif args.model == "resnet50": assert args.dataset == 'imagenet', 'resnet50 only supports imagenet dataset' net = ResNet_ImageNet(depth=50, num_classes=run_config.data_provider.n_classes, cfg=eval(args.cfg)) elif args.model == "mobilenetv2": assert args.dataset == 'imagenet', 'mobilenetv2 only supports imagenet dataset' net = MobileNetV2(num_classes=run_config.data_provider.n_classes, cfg=eval(args.cfg)) elif args.model == "mobilenet": assert args.dataset == 'imagenet', 'mobilenet only supports imagenet dataset' net = MobileNet(num_classes=run_config.data_provider.n_classes, cfg=eval(args.cfg)) # build run manager run_manager = RunManager(args.path, net, run_config) # load checkpoints best_model_path = '%s/checkpoint/model_best.pth.tar' % args.path assert os.path.isfile(best_model_path), 'wrong path' if torch.cuda.is_available(): checkpoint = torch.load(best_model_path) else: checkpoint = torch.load(best_model_path, map_location='cpu') if 'state_dict' in checkpoint: checkpoint = checkpoint['state_dict'] run_manager.net.load_state_dict(checkpoint)
def main(): global best_err1, best_err5 if config.train_params.use_seed: utils.set_seed(config.train_params.seed) imagenet = imagenet_data.ImageNet12(trainFolder=os.path.join(config.data.data_path, 'train'), testFolder=os.path.join(config.data.data_path, 'val'), num_workers=config.data.num_workers, type_of_data_augmentation=config.data.type_of_data_aug, data_config=config.data) train_loader, val_loader = imagenet.getTrainTestLoader(config.data.batch_size) if config.net_type == 'mobilenet': t_net = ResNet.resnet50(pretrained=True) s_net = Mov.MobileNet() elif config.net_type == 'resnet': t_net = ResNet.resnet34(pretrained=True) s_net = ResNet.resnet18(pretrained=False) else: print('undefined network type !!!') raise RuntimeError('%s does not support' % config.net_type) import knowledge_distiller d_net = knowledge_distiller.WSLDistiller(t_net, s_net) print('Teacher Net: ') print(t_net) print('Student Net: ') print(s_net) print('the number of teacher model parameters: {}'.format(sum([p.data.nelement() for p in t_net.parameters()]))) print('the number of student model parameters: {}'.format(sum([p.data.nelement() for p in s_net.parameters()]))) t_net = torch.nn.DataParallel(t_net) s_net = torch.nn.DataParallel(s_net) d_net = torch.nn.DataParallel(d_net) if config.optim.if_resume: checkpoint = torch.load(config.optim.resume_path) d_net.module.load_state_dict(checkpoint['train_state_dict']) best_err1 = checkpoint['best_err1'] best_err5 = checkpoint['best_err5'] start_epoch = checkpoint['epoch'] + 1 else: start_epoch = 0 t_net = t_net.cuda() s_net = s_net.cuda() d_net = d_net.cuda() ### choose optimizer parameters optimizer = torch.optim.SGD(list(s_net.parameters()), config.optim.init_lr, momentum=config.optim.momentum, weight_decay=config.optim.weight_decay, nesterov=True) cudnn.benchmark = True cudnn.enabled = True print('Teacher network performance') validate(val_loader, t_net, 0) for epoch in range(start_epoch, config.train_params.epochs + 1): adjust_learning_rate(optimizer, epoch) # train for one epoch train_with_distill(train_loader, d_net, optimizer, epoch) # evaluate on validation set err1, err5 = validate(val_loader, s_net, epoch) # remember best prec@1 and save checkpoint is_best = err1 <= best_err1 best_err1 = min(err1, best_err1) if is_best: best_err5 = err5 print('Current best accuracy (top-1 and 5 error):', best_err1, best_err5) save_checkpoint({ 'epoch': epoch, 'state_dict': s_net.module.state_dict(), 'train_state_dict': d_net.module.state_dict(), 'best_err1': best_err1, 'best_err5': best_err5, 'optimizer': optimizer.state_dict(), }, is_best) gc.collect() print('Best accuracy (top-1 and 5 error):', best_err1, best_err5)
def test_accuracy(self): image = paddle.static.data(name='image', shape=[None, 1, 28, 28], dtype='float32') label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label) avg_cost = paddle.mean(x=cost) acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1) acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5) optimizer = paddle.optimizer.Momentum( momentum=0.9, learning_rate=0.01, weight_decay=paddle.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = paddle.static.default_main_program() val_prog = main_prog.clone(for_test=True) place = paddle.CUDAPlace( 0) if paddle.is_compiled_with_cuda() else paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(paddle.static.default_startup_program()) def transform(x): return np.reshape(x, [1, 28, 28]) train_dataset = paddle.vision.datasets.MNIST(mode='train', backend='cv2', transform=transform) test_dataset = paddle.vision.datasets.MNIST(mode='test', backend='cv2', transform=transform) train_loader = paddle.io.DataLoader(train_dataset, places=place, feed_list=[image, label], drop_last=True, batch_size=64, return_list=False) valid_loader = paddle.io.DataLoader(test_dataset, places=place, feed_list=[image, label], batch_size=64, return_list=False) def sample_generator_creator(): def __reader__(): for data in test_dataset: image, label = data yield image, label return __reader__ def train(program): iter = 0 for data in train_loader(): cost, top1, top5 = exe.run( program, feed=data, fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) def test(program, outputs=[avg_cost, acc_top1, acc_top5]): iter = 0 result = [[], [], []] for data in valid_loader(): cost, top1, top5 = exe.run(program, feed=data, fetch_list=outputs) iter += 1 if iter % 100 == 0: print( 'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean(result[2]))) return np.mean(result[1]), np.mean(result[2]) train(main_prog) top1_1, top5_1 = test(val_prog) paddle.fluid.io.save_inference_model( dirname='./test_quant_post', feeded_var_names=[image.name, label.name], target_vars=[avg_cost, acc_top1, acc_top5], main_program=val_prog, executor=exe, model_filename='model', params_filename='params') quant_post_static(exe, './test_quant_post', './test_quant_post_inference', sample_generator=sample_generator_creator(), model_filename='model', params_filename='params', batch_nums=10) quant_post_prog, feed_target_names, fetch_targets = paddle.fluid.io.load_inference_model( dirname='./test_quant_post_inference', executor=exe, model_filename='__model__', params_filename='__params__') top1_2, top5_2 = test(quant_post_prog, fetch_targets) print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1)) print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
from flask import Flask, render_template, request from models import MobileNet import os from math import floor app = Flask(__name__) app.config['UPLOAD_FOLDER'] = 'uploads' model = MobileNet() @app.route('/') def index(): return render_template('index.html') @app.route('/about') def about(): return render_template('about.html') @app.route('/infer', methods = ['POST']) def success(): if request.method == 'POST': f = request.files['file'] saveLocation = f.filename f.save(saveLocation) inference, confidence = model.infer(saveLocation) # make a percentage with 2 decimal points confidence = floor(confidence * 10000) / 100 # delete file after making an inference os.remove(saveLocation) # respond with the inference
def test_accuracy(self): image = fluid.layers.data(name='image', shape=[1, 28, 28], dtype='float32') image.stop_gradient = False label = fluid.layers.data(name='label', shape=[1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = fluid.layers.cross_entropy(input=out, label=label) avg_cost = fluid.layers.mean(x=cost) acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1) acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5) optimizer = fluid.optimizer.Momentum( momentum=0.9, learning_rate=0.01, regularization=fluid.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = fluid.default_main_program() val_prog = main_prog.clone(for_test=True) place = fluid.CUDAPlace( 0) if fluid.is_compiled_with_cuda() else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) feeder = fluid.DataFeeder([image, label], place, program=main_prog) train_reader = paddle.fluid.io.batch(paddle.dataset.mnist.train(), batch_size=64) eval_reader = paddle.fluid.io.batch(paddle.dataset.mnist.test(), batch_size=64) def train(program): iter = 0 for data in train_reader(): cost, top1, top5 = exe.run( program, feed=feeder.feed(data), fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) def test(program): iter = 0 result = [[], [], []] for data in eval_reader(): cost, top1, top5 = exe.run( program, feed=feeder.feed(data), fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean(result[2]))) return np.mean(result[1]), np.mean(result[2]) train(main_prog) top1_1, top5_1 = test(main_prog) config = { 'weight_quantize_type': 'channel_wise_abs_max', 'activation_quantize_type': 'moving_average_abs_max', 'quantize_op_types': ['depthwise_conv2d', 'mul', 'conv2d'], } quant_train_prog_pact = quant_aware(main_prog, place, config, for_test=False, act_preprocess_func=pact, optimizer_func=get_optimizer, executor=exe) quant_eval_prog = quant_aware(val_prog, place, config, for_test=True) train(quant_train_prog_pact) quant_eval_prog, int8_prog = convert(quant_eval_prog, place, config, save_int8=True) top1_2, top5_2 = test(quant_eval_prog) # values before quantization and after quantization should be close print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1)) print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
def test_accuracy(self): image = paddle.static.data( name='image', shape=[None, 1, 28, 28], dtype='float32') image.stop_gradient = False label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label) avg_cost = paddle.mean(x=cost) acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1) acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5) optimizer = paddle.optimizer.Momentum( momentum=0.9, learning_rate=0.01, weight_decay=paddle.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = paddle.static.default_main_program() val_prog = main_prog.clone(for_test=True) place = paddle.CUDAPlace(0) if paddle.is_compiled_with_cuda( ) else paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(paddle.static.default_startup_program()) def transform(x): return np.reshape(x, [1, 28, 28]) train_dataset = paddle.vision.datasets.MNIST( mode='train', backend='cv2', transform=transform) test_dataset = paddle.vision.datasets.MNIST( mode='test', backend='cv2', transform=transform) train_loader = paddle.io.DataLoader( train_dataset, places=place, feed_list=[image, label], drop_last=True, return_list=False, batch_size=64) valid_loader = paddle.io.DataLoader( test_dataset, places=place, feed_list=[image, label], batch_size=64, return_list=False) def train(program): iter = 0 for data in train_loader(): cost, top1, top5 = exe.run( program, feed=data, fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) def test(program): iter = 0 result = [[], [], []] for data in valid_loader(): cost, top1, top5 = exe.run( program, feed=data, fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print('eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean(result[2]))) return np.mean(result[1]), np.mean(result[2]) train(main_prog) top1_1, top5_1 = test(main_prog) config = { 'weight_quantize_type': 'channel_wise_abs_max', 'activation_quantize_type': 'moving_average_abs_max', 'quantize_op_types': ['depthwise_conv2d', 'mul', 'conv2d'], } quant_train_prog_pact = quant_aware( main_prog, place, config, for_test=False, act_preprocess_func=pact, optimizer_func=get_optimizer, executor=exe) quant_eval_prog = quant_aware(val_prog, place, config, for_test=True) train(quant_train_prog_pact) quant_eval_prog, int8_prog = convert( quant_eval_prog, place, config, save_int8=True) top1_2, top5_2 = test(quant_eval_prog) # values before quantization and after quantization should be close print("before quantization: top1: {}, top5: {}".format(top1_1, top5_1)) print("after quantization: top1: {}, top5: {}".format(top1_2, top5_2))
def train_net(args): torch.manual_seed(7) #torch的随机种子,在torch.randn使用 np.random.seed(7) checkpoint = args.checkpoint start_epoch = 0 best_acc = 0 writer = SummaryWriter() #tensorboard epochs_since_improvement = 0 # Initialize / load checkpoint if checkpoint is None: if args.network == 'r18': model = resnet18(args) elif args.network == 'r34': model = resnet34(args) elif args.network == 'r50': model = resnet50(args) elif args.network == 'r101': model = resnet101(args) elif args.network == 'r152': model = resnet152(args) elif args.network == 'mobile': model = MobileNet(1.0) else: model = resnet_face18(args.use_se) model = nn.DataParallel(model) metric_fc = ArcMarginModel(args) metric_fc = nn.DataParallel(metric_fc) if args.optimizer == 'sgd': # optimizer = torch.optim.SGD([{'params': model.parameters()}, {'params': metric_fc.parameters()}], # lr=args.lr, momentum=args.mom, weight_decay=args.weight_decay) optimizer = InsightFaceOptimizer( torch.optim.SGD([{ 'params': model.parameters() }, { 'params': metric_fc.parameters() }], lr=args.lr, momentum=args.mom, weight_decay=args.weight_decay)) else: optimizer = torch.optim.Adam([{ 'params': model.parameters() }, { 'params': metric_fc.parameters() }], lr=args.lr, weight_decay=args.weight_decay) else: checkpoint = torch.load(checkpoint) #这里还需要自己加载进去 start_epoch = checkpoint['epoch'] + 1 epochs_since_improvement = checkpoint['epochs_since_improvement'] model = checkpoint['model'] metric_fc = checkpoint['metric_fc'] optimizer = checkpoint['optimizer'] logger = get_logger() # Move to GPU, if available model = model.to(device) metric_fc = metric_fc.to(device) # Loss function if args.focal_loss: criterion = FocalLoss(gamma=args.gamma).to(device) else: criterion = nn.CrossEntropyLoss().to(device) # Custom dataloaders train_dataset = Dataset(root=args.train_path, phase='train', input_shape=(3, 112, 112)) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=8) # Epochs for epoch in range(start_epoch, args.end_epoch): # One epoch's training # 这里写一个训练函数十分简练,值得学习 train_loss, train_top1_accs = train(train_loader=train_loader, model=model, metric_fc=metric_fc, criterion=criterion, optimizer=optimizer, epoch=epoch, logger=logger) print('\nCurrent effective learning rate: {}\n'.format(optimizer.lr)) print('Step num: {}\n'.format(optimizer.step_num)) writer.add_scalar('model/train_loss', train_loss, epoch) writer.add_scalar('model/train_accuracy', train_top1_accs, epoch) writer.add_scalar('model/learning_rate', optimizer.lr, epoch) # Save checkpoint if epoch % 10 == 0: save_checkpoint(epoch, epochs_since_improvement, model, metric_fc, optimizer, best_acc)
def test_accuracy(self): float_infer_model_path_prefix = "./mv1_float_inference" image = paddle.static.data(name='image', shape=[None, 1, 28, 28], dtype='float32') label = paddle.static.data(name='label', shape=[None, 1], dtype='int64') model = MobileNet() out = model.net(input=image, class_dim=10) cost = paddle.nn.functional.loss.cross_entropy(input=out, label=label) avg_cost = paddle.mean(x=cost) acc_top1 = paddle.metric.accuracy(input=out, label=label, k=1) acc_top5 = paddle.metric.accuracy(input=out, label=label, k=5) optimizer = paddle.optimizer.Momentum( momentum=0.9, learning_rate=0.01, weight_decay=paddle.regularizer.L2Decay(4e-5)) optimizer.minimize(avg_cost) main_prog = paddle.static.default_main_program() val_prog = main_prog.clone(for_test=True) #place = paddle.CPUPlace() place = paddle.CUDAPlace( 0) if paddle.is_compiled_with_cuda() else paddle.CPUPlace() exe = paddle.static.Executor(place) exe.run(paddle.static.default_startup_program()) def transform(x): return np.reshape(x, [1, 28, 28]) train_dataset = paddle.vision.datasets.MNIST(mode='train', backend='cv2', transform=transform) test_dataset = paddle.vision.datasets.MNIST(mode='test', backend='cv2', transform=transform) train_loader = paddle.io.DataLoader(train_dataset, places=place, feed_list=[image, label], drop_last=True, batch_size=64, return_list=False) valid_loader = paddle.io.DataLoader(test_dataset, places=place, feed_list=[image, label], batch_size=64, return_list=False) def sample_generator_creator(): def __reader__(): for data in test_dataset: image, label = data yield image, label return __reader__ def train(program): iter = 0 for data in train_loader(): cost, top1, top5 = exe.run( program, feed=data, fetch_list=[avg_cost, acc_top1, acc_top5]) iter += 1 if iter % 100 == 0: print( 'train iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) def test(program, outputs=[avg_cost, acc_top1, acc_top5]): iter = 0 result = [[], [], []] for data in valid_loader(): cost, top1, top5 = exe.run(program, feed=data, fetch_list=outputs) iter += 1 if iter % 100 == 0: print( 'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print(' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean(result[2]))) return np.mean(result[1]), np.mean(result[2]) train(main_prog) top1_1, top5_1 = test(val_prog) paddle.static.save_inference_model( path_prefix=float_infer_model_path_prefix, feed_vars=[image, label], fetch_vars=[avg_cost, acc_top1, acc_top5], executor=exe, program=val_prog) quant_config = { 'weight_quantize_type': 'channel_wise_abs_max', 'activation_quantize_type': 'moving_average_abs_max', 'not_quant_pattern': ['skip_quant'], 'quantize_op_types': ['conv2d', 'depthwise_conv2d', 'mul'] } train_config = { "num_epoch": 1, # training epoch num "max_iter": 20, "save_iter_step": 10, "learning_rate": 0.0001, "weight_decay": 0.0001, "use_pact": False, "quant_model_ckpt_path": "./quantaware_with_infermodel_checkpoints/", "teacher_model_path_prefix": float_infer_model_path_prefix, "model_path_prefix": float_infer_model_path_prefix, "distill_node_pair": [ "teacher_fc_0.tmp_0", "fc_0.tmp_0", "teacher_batch_norm_24.tmp_4", "batch_norm_24.tmp_4", "teacher_batch_norm_22.tmp_4", "batch_norm_22.tmp_4", "teacher_batch_norm_18.tmp_4", "batch_norm_18.tmp_4", "teacher_batch_norm_13.tmp_4", "batch_norm_13.tmp_4", "teacher_batch_norm_5.tmp_4", "batch_norm_5.tmp_4" ] } def test_callback(compiled_test_program, feed_names, fetch_list, checkpoint_name): outputs = fetch_list iter = 0 result = [[], [], []] for data in valid_loader(): cost, top1, top5 = exe.run(compiled_test_program, feed=data, fetch_list=fetch_list) iter += 1 if iter % 100 == 0: print( 'eval iter={}, avg loss {}, acc_top1 {}, acc_top5 {}'. format(iter, cost, top1, top5)) result[0].append(cost) result[1].append(top1) result[2].append(top5) print("quant model checkpoint: " + checkpoint_name + ' avg loss {}, acc_top1 {}, acc_top5 {}'.format( np.mean(result[0]), np.mean(result[1]), np.mean( result[2]))) return np.mean(result[1]), np.mean(result[2]) def test_quant_aware_with_infermodel(exe, place): quant_aware_with_infermodel(exe, place, scope=None, train_reader=train_loader, quant_config=quant_config, train_config=train_config, test_callback=test_callback) def test_export_quant_infermodel(exe, place, checkpoint_path, quant_infermodel_save_path): export_quant_infermodel( exe, place, scope=None, quant_config=quant_config, train_config=train_config, checkpoint_path=checkpoint_path, export_inference_model_path_prefix=quant_infermodel_save_path) #place = paddle.CPUPlace() place = paddle.CUDAPlace( 0) if paddle.is_compiled_with_cuda() else paddle.CPUPlace() exe = paddle.static.Executor(place) test_quant_aware_with_infermodel(exe, place) checkpoint_path = "./quantaware_with_infermodel_checkpoints/epoch_0_iter_10" quant_infermodel_save_path = "./quantaware_with_infermodel_export" test_export_quant_infermodel(exe, place, checkpoint_path, quant_infermodel_save_path) train_config["use_pact"] = True test_quant_aware_with_infermodel(exe, place) train_config["use_pact"] = False checkpoint_path = "./quantaware_with_infermodel_checkpoints/epoch_0_iter_10" quant_infermodel_save_path = "./quantaware_with_infermodel_export" test_export_quant_infermodel(exe, place, checkpoint_path, quant_infermodel_save_path)
def __init__(self, architecture, # Only MobileNet for now input_size, # a tuple (height, width) labels, # class for classification max_box_per_image, anchors, debug, trainable=True): self.input_size = input_size self.debug = debug self.labels = list(labels) self.nb_class = len(self.labels) self.nb_box = 5 self.class_wt = np.ones(self.nb_class, dtype='float32') self.anchors = anchors self.n_cls = len(self.labels) self.max_box_per_image = max_box_per_image self.preprocess_input = preprocess_input ########################## # Make the model ########################## # make the feature extractor layers input_image = Input(shape=(self.input_size[1], self.input_size[0], 3)) self.true_boxes = Input(shape=(1, 1, 1, self.max_box_per_image, 4)) # self.feature_extractor = MobileNetFeature(self.input_size) if architecture == 'MobileNet': self.feature_extractor = MobileNet(input_shape=(self.input_size[1], self.input_size[0], 3), include_top=False, input_tensor=input_image, weights=None, trainable=trainable) last_layer = 'conv_pw_13_relu' elif architecture == 'Tiny Yolo': self.feature_extractor = DarkNet(416, input_tensor=input_image) last_layer = 'leaky_1' elif architecture == 'InceptionResNet': self.feature_extractor = InceptionResNetV2(include_top=False, input_shape=(self.input_size[1], self.input_size[0], 3), input_tensor=input_image, weights=None, trainable=trainable) last_layer = 'conv_7b_ac' else: raise ValueError('Architecture must be either MobileNet or InceptionResNet') if architecture == 'InceptionResNet': self.grid_h, self.grid_w = 11, 11 else: self.grid_h, self.grid_w = int(self.input_size[1] / 32), int(self.input_size[0] / 32) features = self.feature_extractor.get_layer(last_layer).output # make the object detection layer box_out = Conv2D(self.nb_box * (4 + 1 + self.nb_class), (1, 1), strides=(1, 1), padding='same', name='conv_output', kernel_initializer='lecun_normal')(features) box_out = Reshape((self.grid_h, self.grid_w, self.nb_box, 4 + 1 + self.nb_class))(box_out) box_out = Lambda(lambda args: args[0])([box_out, self.true_boxes]) class_out = GlobalAveragePooling2D()(features) class_out = Reshape((1, 1, 1024))(class_out) class_out = Conv2D(10, (1, 1), padding='same', name='conv_preds')(class_out) class_out = Activation('softmax')(class_out) class_out = Reshape((10,), name='classifier')(class_out) self.model = Model([input_image, self.true_boxes], [box_out, class_out]) # initialize the weights of the detection layer layer = self.model.layers[-6] weights = layer.get_weights() new_kernel = np.random.normal(size=weights[0].shape) / (self.grid_h * self.grid_w) new_bias = np.random.normal(size=weights[1].shape) / (self.grid_h * self.grid_w) layer.set_weights([new_kernel, new_bias]) # print a summary of the whole model self.model.summary()