def test_ssd300_infer(): context.set_context(mode=context.GRAPH_MODE, device_target="CPU") model = Model(ssd300_infer()) model.compile() loc, score = model.predict(ts.ones((1, 3, 300, 300))) print(loc.asnumpy(), score.asnumpy())
def test_mobilenetv2_infer(): context.set_context(mode=context.GRAPH_MODE, device_target="CPU") model = Model(mobilenetv2_infer()) model.compile() z = model.predict(ts.ones((1, 3, 224, 224))) print(z.asnumpy())
def test_densenetBC_100(): context.set_context(mode=context.GRAPH_MODE, device_target="CPU") model = Model(densenetBC_100()) model.compile() z = model.predict(ts.ones((1, 3, 32, 32))) print(z.asnumpy())
def test_sequential(): context.set_context(mode=context.GRAPH_MODE, device_target="CPU") net = layers.SequentialLayer([ layers.Conv2d(1, 6, 5, pad_mode='valid', weight_init="ones"), layers.ReLU(), layers.MaxPool2d(kernel_size=2, stride=2) ]) model = Model(net) model.compile() z = model.predict(ts.ones((1, 1, 32, 32))) print(z.asnumpy())
cifar_ds = Cifar10Dataset(data_path, num_parallel_workers=num_parallel_workers, shuffle=True) cifar_ds = cifar10_transform.apply_ds( cifar_ds, repeat_size=repeat_size, batch_size=batch_size, num_parallel_workers=num_parallel_workers, is_training=is_training) return cifar_ds if __name__ == '__main__': args_opt = parse_args() context.set_context(mode=context.GRAPH_MODE, device_target=args_opt.device_target) # download cifar10 dataset if not args_opt.dataset_path: args_opt.dataset_path = download_dataset('cifar10') # build the network if args_opt.do_eval and args_opt.load_pretrained == 'hub': from tinyms import hub net = hub.load(args_opt.hub_uid, class_num=args_opt.num_classes) else: net = vgg16(class_num=args_opt.num_classes) net.update_parameters_name(prefix='huawei') model = Model(net) # define the loss function net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean") # define the optimizer
def run_pretrain(): """pre-train bert_clue""" parser = argparse_init() args_opt = parser.parse_args() context.set_context(mode=context.GRAPH_MODE, device_target=args_opt.device_target, device_id=args_opt.device_id) context.set_context(reserve_class_name_in_scope=False) is_auto_enable_graph_kernel = _auto_enable_graph_kernel(args_opt.device_target, args_opt.enable_graph_kernel) _set_graph_kernel_context(args_opt.device_target, args_opt.enable_graph_kernel, is_auto_enable_graph_kernel) ckpt_save_dir = args_opt.save_checkpoint_path device_num = 1 _check_compute_type(args_opt, is_auto_enable_graph_kernel) if args_opt.accumulation_steps > 1: logger.info("accumulation steps: {}".format(args_opt.accumulation_steps)) logger.info("global batch size: {}".format(cfg.batch_size * args_opt.accumulation_steps)) if args_opt.enable_data_sink == "true": args_opt.data_sink_steps *= args_opt.accumulation_steps logger.info("data sink steps: {}".format(args_opt.data_sink_steps)) if args_opt.enable_save_ckpt == "true": args_opt.save_checkpoint_steps *= args_opt.accumulation_steps logger.info("save checkpoint steps: {}".format(args_opt.save_checkpoint_steps)) ds = create_bert_dataset( batch_size=cfg.batch_size, shuffle=args_opt.do_shuffle, data_dir=args_opt.data_dir, schema_dir=args_opt.schema_dir, num_parallel_workers=args_opt.num_parallel_workers ) net_with_loss = BertNetworkWithLoss(bert_net_cfg, True) new_repeat_count = args_opt.epoch_size * ds.get_dataset_size() // args_opt.data_sink_steps if args_opt.train_steps > 0: train_steps = args_opt.train_steps * args_opt.accumulation_steps new_repeat_count = min(new_repeat_count, train_steps // args_opt.data_sink_steps) else: args_opt.train_steps = args_opt.epoch_size * ds.get_dataset_size() // args_opt.accumulation_steps logger.info("train steps: {}".format(args_opt.train_steps)) # get the optimizer followed args_opt.optimizer optimizer = get_optimizer(args_opt, net_with_loss, cfg, bert_net_cfg) # define the callbacks callback = [TimeMonitor(args_opt.data_sink_steps), BertLossCallBack(ds.get_dataset_size())] if args_opt.enable_save_ckpt == "true": config_ck = CheckpointConfig(save_checkpoint_steps=args_opt.save_checkpoint_steps, keep_checkpoint_max=args_opt.save_checkpoint_num) ckpoint_cb = ModelCheckpoint(prefix='checkpoint_bert', directory=None if ckpt_save_dir == "" else ckpt_save_dir, config=config_ck) callback.append(ckpoint_cb) if args_opt.enable_lossscale == "true": update_cell = DynamicLossScaleUpdateCell(loss_scale_value=cfg.loss_scale_value, scale_factor=cfg.scale_factor, scale_window=cfg.scale_window) accumulation_steps = args_opt.accumulation_steps enable_global_norm = cfg.enable_global_norm if accumulation_steps <= 1: if cfg.optimizer == 'AdamWeightDecay' and args_opt.device_target == 'GPU': net_with_grads = BertTrainOneStepWithLossScaleCellForAdam(net_with_loss, optimizer=optimizer, scale_update_cell=update_cell) else: net_with_grads = BertTrainOneStepWithLossScaleCell(net_with_loss, optimizer=optimizer, scale_update_cell=update_cell) else: allreduce_post = args_opt.distribute == "false" or args_opt.allreduce_post_accumulation == "true" net_with_accumulation = (BertTrainAccumulationAllReducePostWithLossScaleLayer if allreduce_post else BertTrainAccumulationAllReduceEachWithLossScaleLayer) net_with_grads = net_with_accumulation(net_with_loss, optimizer=optimizer, scale_update_cell=update_cell, accumulation_steps=accumulation_steps, enable_global_norm=enable_global_norm) else: net_with_grads = BertTrainOneStepCell(net_with_loss, optimizer=optimizer) model = Model(net_with_grads) if args_opt.load_checkpoint_path: model.load_checkpoint(args_opt.load_checkpoint_path) model.train(new_repeat_count, ds, callbacks=callback, dataset_sink_mode=(args_opt.enable_data_sink == "true"), sink_size=args_opt.data_sink_steps)
def _set_graph_kernel_context(device_target, enable_graph_kernel, is_auto_enable_graph_kernel): if enable_graph_kernel == "true" or is_auto_enable_graph_kernel: if device_target == 'GPU': context.set_context(enable_graph_kernel=True) else: logger.warning('Graph kernel only supports GPU back-end now, run with graph kernel off.')
def run_classifier(): """run classifier task""" parser = argparse.ArgumentParser(description="run classifier") parser.add_argument("--device_target", type=str, default="Ascend", choices=["Ascend", "GPU"], help="Device type, default is Ascend") parser.add_argument( "--assessment_method", type=str, default="Accuracy", choices=["Mcc", "Spearman_correlation", "Accuracy", "F1"], help= "assessment_method including [Mcc, Spearman_correlation, Accuracy, F1],\ default is Accuracy") parser.add_argument("--do_train", action="store_true", help="Enable train, default is false") parser.add_argument("--do_eval", action="store_true", help="Enable eval, default is false") parser.add_argument("--device_id", type=int, default=0, help="Device id, default is 0.") parser.add_argument("--epoch_num", type=int, default="1", help="Epoch number, default is 1.") parser.add_argument("--num_class", type=int, default="2", help="The number of class, default is 2.") parser.add_argument("--train_data_shuffle", type=bool, default=True, help="Enable train data shuffle, default is true") parser.add_argument("--eval_data_shuffle", type=bool, default=False, help="Enable eval data shuffle, default is false") parser.add_argument("--save_finetune_checkpoint_path", type=str, default="", help="Save checkpoint path") parser.add_argument("--load_pretrain_checkpoint_path", type=str, default="", help="Load checkpoint file path") parser.add_argument("--load_finetune_checkpoint_path", type=str, default="", help="Load checkpoint file path") parser.add_argument("--train_data_file_path", type=str, default="", help="Data path, it is better to use absolute path") parser.add_argument("--eval_data_file_path", type=str, default="", help="Data path, it is better to use absolute path") parser.add_argument("--schema_file_path", type=str, default="", help="Schema path, it is better to use absolute path") args_opt = parser.parse_args() epoch_num = args_opt.epoch_num assessment_method = args_opt.assessment_method.lower() load_pretrain_checkpoint_path = args_opt.load_pretrain_checkpoint_path save_finetune_checkpoint_path = args_opt.save_finetune_checkpoint_path load_finetune_checkpoint_path = args_opt.load_finetune_checkpoint_path if args_opt.do_train and args_opt.do_eval: raise ValueError( "At least one of 'do_train' or 'do_eval' must be true") if args_opt.do_train and args_opt.train_data_file_path == "": raise ValueError( "'train_data_file_path' must be set when do finetune task") if args_opt.do_eval and args_opt.eval_data_file_path == "": raise ValueError( "'eval_data_file_path' must be set when do evaluation task") if args_opt.device_target == "Ascend": context.set_context(mode=context.GRAPH_MODE, device_target="Ascend", device_id=args_opt.device_id) elif args_opt.device_target == "GPU": context.set_context(mode=context.GRAPH_MODE, device_target="GPU", device_id=args_opt.device_id) context.set_context(enable_graph_kernel=True) if bert_net_cfg.compute_type != ts.float32: logger.warning('GPU only support fp32 temporarily, run with fp32.') bert_net_cfg.compute_type = ts.float32 else: raise Exception("Target error, GPU or Ascend is supported.") netwithloss = BertCLS(bert_net_cfg, True, num_labels=args_opt.num_class, dropout_prob=0.1, assessment_method=assessment_method) if args_opt.do_train: ds = create_classification_dataset( batch_size=optimizer_cfg.batch_size, repeat_count=1, assessment_method=assessment_method, data_file_path=args_opt.train_data_file_path, schema_file_path=args_opt.schema_file_path, do_shuffle=args_opt.train_data_shuffle) do_train(ds, netwithloss, load_pretrain_checkpoint_path, save_finetune_checkpoint_path, epoch_num) if args_opt.do_eval: if save_finetune_checkpoint_path == "": load_finetune_checkpoint_dir = _cur_dir else: load_finetune_checkpoint_dir = make_directory( save_finetune_checkpoint_path) load_finetune_checkpoint_path = LoadNewestCkpt( load_finetune_checkpoint_dir, ds.get_dataset_size(), epoch_num, "classifier") if args_opt.do_eval: ds = create_classification_dataset( batch_size=optimizer_cfg.batch_size, repeat_count=1, assessment_method=assessment_method, data_file_path=args_opt.eval_data_file_path, schema_file_path=args_opt.schema_file_path, do_shuffle=args_opt.eval_data_shuffle) do_eval(ds, BertCLS, args_opt.num_class, assessment_method, load_finetune_checkpoint_path)