我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用mxnet.cpu()。
def __init__(self): self.replayMemory = deque() self.timestep = 0 if FLG_GPU: self.ctx = mx.gpu() else: self.ctx = mx.cpu() if args.mode == 'train': self.q_net = mx.mod.Module(symbol=self.createNet(1), data_names=['frame', 'act_mul'], label_names=['target', ], context=self.ctx) self.q_net.bind(data_shapes=[('frame', (BATCH, FRAME, HEIGHT, WIDTH)), ('act_mul', (BATCH, ACTIONS))], label_shapes=[('target', (BATCH,))], for_training=True) self.q_net.init_params(initializer=mx.init.Xavier(factor_type="in", magnitude=2.34)) self.q_net.init_optimizer(optimizer='adam', optimizer_params={'learning_rate': 0.0002, 'wd': 0.0, 'beta1': 0.5}) if args.pretrain: self.q_net.load_params(args.pretrain) print "load pretrained file......" self.tg_net = mx.mod.Module(symbol=self.createNet(), data_names=['frame',], label_names=[], context=self.ctx) self.tg_net.bind(data_shapes=[('frame', (1, FRAME, HEIGHT, WIDTH))], for_training=False) self.tg_net.init_params(initializer=mx.init.Xavier(factor_type='in', magnitude=2.34)) if args.pretrain: self.tg_net.load_params(args.pretrain) print "load pretrained file......"
def __init__(self, symbol, data_names, label_names, data_shapes, label_shapes, logger=logging, context=mx.cpu(), work_load_list=None, fixed_param_names=None): self.symbol = symbol self.data_names = data_names self.label_names = label_names self.data_shapes = data_shapes self.label_shapes = label_shapes self.context = context self.work_load_list = work_load_list self.fixed_param_names = fixed_param_names if logger is None: logger = logging.getLogger() logger.setLevel(logging.INFO) self.logger = logger self.module = Module(symbol=self.symbol, data_names=self.data_names, label_names=self.label_names, logger=self.logger, context=self.context, work_load_list=self.work_load_list, fixed_param_names=self.fixed_param_names)
def load_param(prefix, epoch, convert=False, ctx=None, process=False): """ wrapper for load checkpoint :param prefix: Prefix of model name. :param epoch: Epoch number of model we would like to load. :param convert: reference model should be converted to GPU NDArray first :param ctx: if convert then ctx must be designated. :param process: model should drop any test :return: (arg_params, aux_params) """ arg_params, aux_params = load_checkpoint(prefix, epoch) if convert: if ctx is None: ctx = mx.cpu() arg_params = convert_context(arg_params, ctx) aux_params = convert_context(aux_params, ctx) if process: tests = [k for k in arg_params.keys() if '_test' in k] for test in tests: arg_params[test.replace('_test', '')] = arg_params.pop(test) return arg_params, aux_params
def generate_main(args): """ generates text from trained model specified in args. main method for generate subcommand. """ # load model inference_model = Model.load(args.checkpoint_path, mx.cpu()) # create seed if not specified if args.seed is None: with open(args.text_path) as f: text = f.read() seed = generate_seed(text) logger.info("seed sequence generated from %s.", args.text_path) else: seed = args.seed return generate_text(inference_model, seed, args.length, args.top_n)
def image(): print 'api' url = request.args.get('image') print url sym, arg_params, aux_params = load_model(f_symbol_file.name, f_params_file.name) mod = mx.mod.Module(symbol=sym, context=mx.cpu()) mod.bind(for_training=False, data_shapes=[('data', (1,3,224,224))]) mod.set_params(arg_params, aux_params) labels = predict(url, mod, synsets) resp = Response(response=labels, status=200, \ mimetype="application/json") return(resp)
def build_parser(): parser = ArgumentParser() parser.add_argument('--checkpoint', type=str, dest='checkpoint', help='checkpoint params file which generated in training', metavar='CHECKPOINT', required=True) parser.add_argument('--in-path', type=str, dest='in_path', help='dir or file to transform', metavar='IN_PATH', required=True) parser.add_argument('--out-path', type=str, dest='out_path', help='destination dir of transformed file or files', metavar='OUT_PATH', required=True) parser.add_argument('--resize', type=int, nargs=2, dest='resize', help='resize the input image files, usage: --resize=300 400', ) parser.add_argument('--gpu', type=int, default=GPU, help='which gpu card to use, -1 means using cpu (default %(default)s)') return parser
def test_convolutional_embedding_encoder(config, out_data_shape, out_data_length, out_seq_len): conv_embed = sockeye.encoder.ConvolutionalEmbeddingEncoder(config) data_nd = mx.nd.random_normal(shape=(_BATCH_SIZE, _SEQ_LEN, _NUM_EMBED)) data = mx.sym.Variable("data", shape=data_nd.shape) data_length = mx.sym.Variable("data_length", shape=_DATA_LENGTH_ND.shape) (encoded_data, encoded_data_length, encoded_seq_len) = conv_embed.encode(data=data, data_length=data_length, seq_len=_SEQ_LEN) exe = encoded_data.simple_bind(mx.cpu(), data=data_nd.shape) exe.forward(data=data_nd) assert exe.outputs[0].shape == out_data_shape exe = encoded_data_length.simple_bind(mx.cpu(), data_length=_DATA_LENGTH_ND.shape) exe.forward(data_length=_DATA_LENGTH_ND) assert np.equal(exe.outputs[0].asnumpy(), np.asarray(out_data_length)).all() assert encoded_seq_len == out_seq_len
def _setup_context(args, exit_stack): if args.use_cpu: context = mx.cpu() else: num_gpus = get_num_gpus() check_condition(num_gpus >= 1, "No GPUs found, consider running on the CPU with --use-cpu " "(note: check depends on nvidia-smi and this could also mean that the nvidia-smi " "binary isn't on the path).") check_condition(len(args.device_ids) == 1, "cannot run on multiple devices for now") gpu_id = args.device_ids[0] if args.disable_device_locking: if gpu_id < 0: # without locking and a negative device id we just take the first device gpu_id = 0 else: gpu_ids = exit_stack.enter_context(acquire_gpus([gpu_id], lock_dir=args.lock_dir)) gpu_id = gpu_ids[0] context = mx.gpu(gpu_id) return context
def __call__(self, inputs): ret_outputs = [] if isinstance(inputs[-1], Number): self.is_train = inputs[-1] inputs = inputs[:-1] for x in self.output: bind_values = dfs_get_bind_values(x) data = {k.name: v for k, v in zip(self.inputs, inputs)} data = dict(data, **bind_values) args = x.symbol.list_arguments() data_shapes = {k.name: v.shape for k, v in zip(self.inputs, inputs) if k.name in args} executor = x.symbol.simple_bind(mx.cpu(), grad_req='null', **data_shapes) for v in executor.arg_dict: if v in data: executor.arg_dict[v][:] = data[v] outputs = executor.forward(is_train=self.is_train) ret_outputs.append(outputs[0].asnumpy()) return ret_outputs
def get_create_checkpoint_callback(iteration, model_prefix): def create_checkpoint(execution_params): if execution_params.nbatch % iteration == 0: original_executor = execution_params.locals['executor_manager'] save_dict = {('arg:%s' % k): v[0].as_in_context(mx.cpu()) for k, v in zip(original_executor.param_names, original_executor.param_arrays)} save_dict.update({('aux:%s' % k): v[0].as_in_context(mx.cpu()) for k, v in zip(original_executor.aux_names, original_executor.aux_arrays)}) symbol = execution_params.locals['symbol'] symbol.save('{}-symbol.json'.format(model_prefix)) model_name = "{}-{:0>4}-{:0>5}".format(model_prefix, execution_params.epoch, execution_params.nbatch) mx.nd.save( model_name, save_dict, ) logging.info('Saved checkpoint to \"{}\"'.format(model_name)) return create_checkpoint
def check_elementwise_sum_with_shape(shape, n): # forward inputs = [mx.symbol.Variable('arg%d' % i) for i in range(n)] out = mx.symbol.ElementWiseSum(*inputs, name='esum') arr = [mx.nd.empty(shape) for i in range(n)] arr_grad = [mx.nd.empty(shape) for i in range(n)] for i in range(n): arr[i][:] = np.random.uniform(-10, 10, shape) exec1 = out.bind(mx.Context('cpu'), args=arr, args_grad=arr_grad) out1 = exec1.outputs[0].asnumpy() exec1.forward() out1 = exec1.outputs[0].asnumpy() out = sum(a.asnumpy() for a in arr) assert reldiff(out, out1) < 1e-6 out_grad = mx.nd.empty(shape) out_grad[:] = np.random.uniform(-10, 10, shape) # backward exec1.backward([out_grad]) for a in arr_grad: assert same(a.asnumpy(), out_grad.asnumpy())
def check_regression(symbol, forward, backward): data = mx.symbol.Variable('data') label = mx.symbol.Variable('label') out = symbol(data, label) shape = (3, 1) arr_data = mx.random.uniform(-1, 1, shape) arr_label = mx.random.uniform(0, 1, shape[0]) arr_grad = mx.nd.empty(shape) exec1 = out.bind(mx.cpu(), args=[arr_data, arr_label], args_grad={"data" : arr_grad}) exec1.forward() out1 = exec1.outputs[0].asnumpy() npout = forward(arr_data.asnumpy()) assert reldiff(npout, out1) < 1e-6 exec1.backward() npout = backward(npout, arr_label.asnumpy().reshape(npout.shape)) assert reldiff(npout, arr_grad.asnumpy()) < 1e-6
def test_swapaxes(): data = mx.symbol.Variable('data') shape = (2, 3, 4) data_tmp = np.ones(shape) data_tmp[0] = 1 data_tmp[1] = 2 arr_data = mx.nd.array(data_tmp) swap0 = mx.symbol.SwapAxis(data=data, dim1=0, dim2=2) swap = mx.symbol.SwapAxis(data=swap0, dim1=1, dim2=2) exe_c = swap.bind(mx.cpu(), args=[arr_data]) exe_c.forward() out = exe_c.outputs[0].asnumpy() swap0_ = np.swapaxes(data_tmp, 0, 2) swap_ = np.swapaxes(swap0_, 1, 2) assert reldiff(out, swap_) < 1e-6
def test_binary_op_duplicate_input(): data = mx.symbol.Variable('data') shape = (3, 4) data_tmp = np.ones(shape) data_tmp[:] = 5 arr_data = mx.nd.array(data_tmp) arr_grad = mx.nd.empty(shape) arr_grad[:] = 3 out_grad = mx.nd.empty(shape) out_grad[:] = 1 square = data * data exe_square = square.bind(mx.cpu(), args=[arr_data], args_grad=[arr_grad]) exe_square.forward() assert reldiff(exe_square.outputs[0].asnumpy(), data_tmp * data_tmp) < 1e-6 exe_square.backward(out_grad) assert reldiff(arr_grad.asnumpy(), 2.0 * data_tmp) < 1e-6
def test_sign(): data = mx.symbol.Variable('data') shape = (3, 4) data_tmp = np.ones(shape) data_tmp[:]=5 arr_data = mx.nd.array(data_tmp) arr_grad = mx.nd.empty(shape) arr_grad[:]=3 test = mx.sym.sign(data) exe_test = test.bind(mx.cpu(), args=[arr_data], args_grad=[arr_grad]) exe_test.forward() out = exe_test.outputs[0].asnumpy() npout = np.sign(data_tmp) assert reldiff(out, npout) < 1e-6 out_grad = mx.nd.empty(shape) out_grad[:] = 2; npout_grad = out_grad.asnumpy() npout_grad = 0; exe_test.backward(out_grad) assert reldiff(arr_grad.asnumpy(), npout_grad) < 1e-6
def test_rsqrt_cos_sin(): data = mx.symbol.Variable('data') shape = (3, 4) data_tmp = np.ones(shape) data_tmp[:]=5 arr_data = mx.nd.array(data_tmp) arr_grad = mx.nd.empty(shape) arr_grad[:]=3 test = mx.sym.rsqrt(data) + mx.sym.cos(data) + mx.sym.sin(data) exe_test = test.bind(mx.cpu(), args=[arr_data], args_grad=[arr_grad]) exe_test.forward() out = exe_test.outputs[0].asnumpy() npout = 1/ np.sqrt(data_tmp) + np.cos(data_tmp) + np.sin(data_tmp) assert reldiff(out, npout) < 1e-6 out_grad = mx.nd.empty(shape) out_grad[:] = 2; npout_grad = out_grad.asnumpy() npout_grad = npout_grad * -(1.0 / (2.0 * data_tmp * np.sqrt(data_tmp))) + npout_grad * -1 * np.sin(data_tmp) + npout_grad * np.cos(data_tmp) exe_test.backward(out_grad) assert reldiff(arr_grad.asnumpy(), npout_grad) < 1e-6
def test_abs(): data = mx.symbol.Variable('data') shape = (3, 4) data_tmp = np.ones(shape) data_tmp[:]=5 arr_data = mx.nd.array(data_tmp) arr_grad = mx.nd.empty(shape) arr_grad[:]=3 test = mx.sym.abs(data) exe_test = test.bind(mx.cpu(), args=[arr_data], args_grad=[arr_grad]) exe_test.forward() out = exe_test.outputs[0].asnumpy() npout = abs(data_tmp) assert reldiff(out, npout) < 1e-6 out_grad = mx.nd.empty(shape) out_grad[:] = 2; npout_grad = out_grad.asnumpy() npout_grad = npout_grad * np.sign(data_tmp) exe_test.backward(out_grad) assert reldiff(arr_grad.asnumpy(), npout_grad) < 1e-6
def test_reshape(): x = mx.sym.Variable('x') y = mx.sym.FullyConnected(x, num_hidden=4) exe = y.simple_bind(mx.cpu(), x=(5,4)) exe.arg_arrays[0][:] = 1 exe.arg_arrays[1][:] = mx.nd.ones((4,4)) exe.arg_arrays[2][:] = 0 new_exe = exe.reshape(x=(3,4)) new_exe.forward(is_train=False) # test sub exec forward assert np.all(new_exe.outputs[0].asnumpy() == 4) # test shared memory assert np.all(exe.outputs[0].asnumpy()[:3] == 4) # test base exec forward exe.forward(is_train=False) assert np.all(exe.outputs[0].asnumpy() == 4)
def __init__(self, prefix, symbol, ctx=None, begin_epoch=0, num_epoch=None, arg_params=None, aux_params=None, optimizer='sgd', **kwargs): self.prefix = prefix self.symbol = symbol self.ctx = ctx if self.ctx is None: self.ctx = mx.cpu() self.begin_epoch = begin_epoch self.num_epoch = num_epoch self.arg_params = arg_params self.aux_params = aux_params self.grad_params = None self.executor = None self.optimizer = optimizer self.updater = None self.kwargs = kwargs.copy()
def extract_feature(sym, args, auxs, data_iter, N, xpu=mx.cpu()): input_buffs = [mx.nd.empty(shape, ctx=xpu) for k, shape in data_iter.provide_data] input_names = [k for k, shape in data_iter.provide_data] args = dict(args, **dict(zip(input_names, input_buffs))) exe = sym.bind(xpu, args=args, aux_states=auxs) outputs = [[] for i in exe.outputs] output_buffs = None data_iter.hard_reset() for batch in data_iter: for data, buff in zip(batch.data, input_buffs): data.copyto(buff) exe.forward(is_train=False) if output_buffs is None: output_buffs = [mx.nd.empty(i.shape, ctx=mx.cpu()) for i in exe.outputs] else: for out, buff in zip(outputs, output_buffs): out.append(buff.asnumpy()) for out, buff in zip(exe.outputs, output_buffs): out.copyto(buff) for out, buff in zip(outputs, output_buffs): out.append(buff.asnumpy()) outputs = [np.concatenate(i, axis=0)[:N] for i in outputs] return dict(zip(sym.list_outputs(), outputs))
def __init__(self, symbol, model_prefix, epoch, data_hw, mean_pixels, img_stride=32, th_nms=0.3333, ctx=None): ''' ''' self.ctx = mx.cpu() if not ctx else ctx if isinstance(data_hw, int): data_hw = (data_hw, data_hw) assert data_hw[0] % img_stride == 0 and data_hw[1] % img_stride == 0 self.data_hw = data_hw _, arg_params, aux_params = mx.model.load_checkpoint(model_prefix, epoch) self.mod = mx.mod.Module(symbol, label_names=None, context=ctx) self.mod.bind(data_shapes=[('data', (1, 3, data_hw[0], data_hw[1]))]) self.mod.set_params(arg_params, aux_params) self.mean_pixels = mean_pixels self.img_stride = img_stride self.th_nms = th_nms
def __init__(self, prefix='', symbol=None, ctx=None, data_shape=None, label_shape=None, num_epoch=None, opt_method='sgd', **kwargs): self.prefix = prefix self.symbol = symbol self.ctx = ctx if self.ctx is None: self.ctx = mx.cpu() self.data_shape = data_shape self.label_shape = label_shape self.batchsize = data_shape[0] self.num_epoch = num_epoch self.update_params = None self.arg_params = None self.aux_params = None self.grad_params = None self.executor = None self.opt_method = opt_method self.optimizer = None self.updater = None self.kwargs = kwargs.copy() self.initializer=mx.init.Xavier()
def __init__(self, prefix='', symbol=None, ctx=None, data_shape=None, label_shape=None, num_epoch=None, falsebigbatch=1, opt_method='sgd', **kwargs): self.prefix = prefix self.symbol = symbol self.ctx = ctx if self.ctx is None: self.ctx = mx.cpu() self.data_shape = data_shape self.label_shape = label_shape self.batchsize = data_shape[0] self.num_epoch = num_epoch self.update_params = None self.falsebigbatch = falsebigbatch print 'false big batch size:%d*%d=%d'%(falsebigbatch, self.batchsize, falsebigbatch * self.batchsize) self.arg_params = None self.aux_params = None self.grad_params = None self.executor = None self.opt_method = opt_method self.optimizer = None self.updater = None self.kwargs = kwargs.copy() self.initializer=mx.init.Xavier()
def __init__(self, prefix='', symbol=None, ctx=None, data_shape=None, label_shape=None, num_epoch=None, falsebigbatch=1, opt_method='sgd', **kwargs): self.prefix = prefix self.symbol = symbol self.ctx = ctx if self.ctx is None: self.ctx = mx.cpu() self.data_shape = data_shape self.label_shape = label_shape self.batchsize = data_shape[0] self.num_epoch = num_epoch self.update_params = None self.arg_params = None self.aux_params = None self.grad_params = None self.executor = None self.opt_method = opt_method self.optimizer = None self.falsebigbatch = falsebigbatch print 'false big batch size:%d*%d=%d'%(falsebigbatch, self.batchsize, falsebigbatch * self.batchsize) self.bigbatch_grads = None self.updater = None self.kwargs = kwargs.copy() self.initializer=mx.init.Xavier()
def __init__(self, name, symbol, data_names=('data',), data_shapes=(), label_names=('label'), label_shapes=(), inputs_need_grad=False, optimizer='sgd', optimizer_params={'learning_rate':0.1, 'momentum':0.9, 'wd':0.0005}, initializer=mx.init.Normal(), context=mx.cpu()): self.name = name self.symbol = symbol self.data_names = data_names self.label_names = label_names self.data_shapes = data_shapes self.label_shapes = label_shapes self.inputs_need_grad = inputs_need_grad self.optimizer = optimizer self.optimizer_params = optimizer_params self.initializer = initializer self.context = context
def __init__(self, symbol, ctx=None, begin_epoch=0, num_epoch=None, arg_params=None, aux_params=None, optimizer='sgd', **kwargs): # ?????? self.symbol = symbol if ctx is None: ctx = mx.cpu() self.ctx = ctx # ??epoch,??0????????? self.begin_epoch = begin_epoch # ???epoch? self.num_epoch = num_epoch self.arg_params = arg_params self.aux_params = aux_params # ??????,????????? self.optimizer = optimizer self.kwargs = kwargs.copy()
def train(): ctx = mx.gpu(args.gpu) if args.gpu >=0 else mx.cpu() train = mx.io.MNISTIter( image='data/train-images-idx3-ubyte', label='data/train-labels-idx1-ubyte', input_shape=(1, 28, 28), mean_r=128, scale=1./128, batch_size=args.batch_size, shuffle=True) val = mx.io.MNISTIter( image='data/t10k-images-idx3-ubyte', label='data/t10k-labels-idx1-ubyte', input_shape=(1, 28, 28), mean_r=128, scale=1./128, batch_size=args.batch_size) symbol = get_symbol() mod = mx.mod.Module( symbol=symbol, context=ctx, data_names=('data',), label_names=('softmax_label',)) num_examples = 60000 epoch_size = int(num_examples / args.batch_size) optim_params = { 'learning_rate': args.lr, 'momentum': 0.9, 'wd': 0.0005, 'lr_scheduler': mx.lr_scheduler.FactorScheduler(step=10*epoch_size, factor=0.1), } mod.fit(train_data=train, eval_data=val, eval_metric=mx.metric.Accuracy(), initializer=mx.init.Xavier(), optimizer='sgd', optimizer_params=optim_params, num_epoch=args.num_epoch, batch_end_callback=mx.callback.Speedometer(args.batch_size, 50), epoch_end_callback=mx.callback.do_checkpoint(args.model_prefix))
def profile(): ctx = mx.gpu(args.gpu) if args.gpu >=0 else mx.cpu() val = mx.io.MNISTIter( image='data/t10k-images-idx3-ubyte', label='data/t10k-labels-idx1-ubyte', input_shape=(1, 28, 28), mean_r=128, scale=1./128, batch_size=args.batch_size) symbol = get_symbol() mod = mx.mod.Module( symbol=symbol, context=ctx, data_names=('data',), label_names=('softmax_label',)) mod.bind(data_shapes=val.provide_data, label_shapes=val.provide_label, for_training=True) mod.init_params(initializer=mx.init.Xavier()) # run a while for nbatch, data_batch in enumerate(val): mod.forward_backward(data_batch) # profile mx.profiler.profiler_set_config(mode='symbolic', filename='profile.json') mx.profiler.profiler_set_state('run') val.reset() for nbatch, data_batch in enumerate(val): mod.forward_backward(data_batch) mx.profiler.profiler_set_state('stop')
def __init__(self, roidb, batch_size=2, shuffle=False, mode='train', ctx=None, work_load_list=None): """ This Iter will provide roi data to Fast R-CNN network :param roidb: must be preprocessed :param batch_size: must divide BATCH_SIZE(128) :param shuffle: bool :param mode: control returned info :param ctx: list of contexts :param work_load_list: list of work load :return: ROIIter """ super(ROIIter, self).__init__() self.roidb = roidb self.batch_size = batch_size self.shuffle = shuffle self.mode = mode self.ctx = ctx if self.ctx is None: self.ctx = [mx.cpu()] self.work_load_list = work_load_list self.cur = 0 self.size = len(roidb) self.index = np.arange(self.size) self.num_classes = self.roidb[0]['gt_overlaps'].shape[1] self.reset() self.batch = None self.data = None self.label = None self.get_batch() self.data_name = ['data', 'rois'] self.label_name = ['label', 'bbox_target', 'bbox_inside_weight', 'bbox_outside_weight']
def __init__(self, symbol, ctx=None, arg_params=None, aux_params=None): self.symbol = symbol self.ctx = ctx if self.ctx is None: self.ctx = mx.cpu() self.executor = None self.arg_params = arg_params self.aux_params = aux_params
def __init__(self, symbol, ctx=None, arg_params=None, aux_params=None): self.symbol = symbol self.ctx = ctx if self.ctx is None: self.ctx = mx.cpu() self.arg_params = arg_params self.aux_params = aux_params self.executor = None
def load_param_rcnn(prefix, epoch, convert=False, ctx=None): """ wrapper for load checkpoint :param prefix: Prefix of model name. :param epoch: Epoch number of model we would like to load. :param convert: reference model should be converted to GPU NDArray first :param ctx: if convert then ctx must be designated. :return: (arg_params, aux_params) """ arg_params, aux_params = load_checkpoint(prefix, epoch) num_classes = 1000 if "bbox_pred_bias" in arg_params.keys(): num_classes = len(arg_params['bbox_pred_bias'].asnumpy()) / 4 if config.TRAIN.BBOX_NORMALIZATION_PRECOMPUTED and "bbox_pred_bias" in arg_params.keys(): print "lode model with mean/std" means = np.tile(np.array(config.TRAIN.BBOX_MEANS_INV), (1, num_classes)) stds = np.tile(np.array(config.TRAIN.BBOX_STDS_INV), (1, num_classes)) arg_params['bbox_pred_weight'] = (arg_params['bbox_pred_weight'].T * mx.nd.array(stds)).T arg_params['bbox_pred_bias'] = (arg_params['bbox_pred_bias'] - mx.nd.array(np.squeeze(means))) * \ mx.nd.array(np.squeeze(stds)) if convert: if ctx is None: ctx = mx.cpu() arg_params = convert_context(arg_params, ctx) aux_params = convert_context(aux_params, ctx) return arg_params, aux_params, num_classes
def __init__(self, synset_path, network_prefix, params_url=None, symbol_url=None, synset_url=None, context=mx.cpu(), label_names=['prob_label'], input_shapes=[('data', (1,3,224,224))]): # Download the symbol set and network if URLs are provided if params_url is not None: print "fetching params from "+params_url fetched_file = urllib2.urlopen(params_url) with open(network_prefix+"-0000.params",'wb') as output: output.write(fetched_file.read()) if symbol_url is not None: print "fetching symbols from "+symbol_url fetched_file = urllib2.urlopen(symbol_url) with open(network_prefix+"-symbol.json",'wb') as output: output.write(fetched_file.read()) if synset_url is not None: print "fetching synset from "+synset_url fetched_file = urllib2.urlopen(synset_url) with open(synset_path,'wb') as output: output.write(fetched_file.read()) # Load the symbols for the networks with open(synset_path, 'r') as f: self.synsets = [l.rstrip() for l in f] # Load the network parameters from default epoch 0 sym, arg_params, aux_params = mx.model.load_checkpoint(network_prefix, 0) # Load the network into an MXNet module and bind the corresponding parameters self.mod = mx.mod.Module(symbol=sym, label_names=label_names, context=context) self.mod.bind(for_training=False, data_shapes= input_shapes) self.mod.set_params(arg_params, aux_params) self.camera = None
def __init__(self, symbol, model_prefix, epoch, data_shape, mean_pixels, \ batch_size=1, ctx=None): self.ctx = ctx if self.ctx is None: self.ctx = mx.cpu() load_symbol, args, auxs = mx.model.load_checkpoint(model_prefix, epoch) if symbol is None: symbol = load_symbol self.mod = mx.mod.Module(symbol, label_names=None, context=ctx) self.data_shape = data_shape self.mod.bind(data_shapes=[('data', (batch_size, 3, data_shape, data_shape))]) self.mod.set_params(args, auxs) self.data_shape = data_shape self.mean_pixels = mean_pixels
def header_code(self): return """import mxnet as mx import numpy as np import math # mxnet-cpu only support channel first, default convert the model and weight as channel first def RefactorModel(): """
def __init__(self,model_prefix='./model/cpt',ctx=mx.cpu()): ''' Initialize the estimator Parameters: ---------- model_prefix: string path for the pretrained mxnet models ctx: context the context where CNN running on ''' self.model = mx.model.FeedForward.load(model_prefix, 1, ctx=ctx)
def __init__(self, roidb, config, batch_size=2, shuffle=False, ctx=None, work_load_list=None, aspect_grouping=False): """ This Iter will provide roi data to Fast R-CNN network :param roidb: must be preprocessed :param batch_size: must divide BATCH_SIZE(128) :param shuffle: bool :param ctx: list of contexts :param work_load_list: list of work load :param aspect_grouping: group images with similar aspects :return: ROIIter """ super(ROIIter, self).__init__() # save parameters as properties self.roidb = roidb self.cfg = config self.batch_size = batch_size self.shuffle = shuffle self.ctx = ctx if self.ctx is None: self.ctx = [mx.cpu()] self.work_load_list = work_load_list self.aspect_grouping = aspect_grouping # infer properties from roidb self.size = len(roidb) self.index = np.arange(self.size) # decide data and label names (only for training) self.data_name = ['data', 'rois'] self.label_name = ['label', 'bbox_target', 'bbox_weight'] # status variable for synchronization between get_data and get_label self.cur = 0 self.batch = None self.data = None self.label = None # get first batch to fill in provide_data and provide_label self.reset() self.get_batch_individual()
def __init__(self, symbol, data_names, label_names, context=mx.cpu(), max_data_shapes=None, provide_data=None, provide_label=None, arg_params=None, aux_params=None): self._mod = MutableModule(symbol, data_names, label_names, context=context, max_data_shapes=max_data_shapes) self._mod.bind(provide_data, provide_label, for_training=False) self._mod.init_params(arg_params=arg_params, aux_params=aux_params)
def __init__(self, roidb, batch_size=2, shuffle=False, ctx=None, work_load_list=None, aspect_grouping=False): """ This Iter will provide roi data to Fast R-CNN network :param roidb: must be preprocessed :param batch_size: must divide BATCH_SIZE(128) :param shuffle: bool :param ctx: list of contexts :param work_load_list: list of work load :param aspect_grouping: group images with similar aspects :return: ROIIter """ super(ROIIter, self).__init__() # save parameters as properties self.roidb = roidb self.batch_size = batch_size self.shuffle = shuffle self.ctx = ctx if self.ctx is None: self.ctx = [mx.cpu()] self.work_load_list = work_load_list self.aspect_grouping = aspect_grouping # infer properties from roidb self.size = len(roidb) self.index = np.arange(self.size) # decide data and label names (only for training) self.data_name = ['data', 'rois'] self.label_name = ['label', 'bbox_target', 'bbox_weight'] # status variable for synchronization between get_data and get_label self.cur = 0 self.batch = None self.data = None self.label = None # get first batch to fill in provide_data and provide_label self.reset() self.get_batch()
def __init__(self, sym_gen,cfg,data_names, label_names, context=mx.cpu(), max_data_shapes=None, provide_data=None, provide_label=None, arg_params=None, aux_params=None): self._mod = MutableModule(sym_gen,cfg,data_names, label_names,is_train=False, context=context, max_data_shapes=max_data_shapes) self._mod.bind(provide_data, provide_label, for_training=False) self._mod.init_params(arg_params=arg_params, aux_params=aux_params)
def load_param(prefix, epoch, convert=False, ctx=None,cells=None, process=False): """ wrapper for load checkpoint :param prefix: Prefix of model name. :param epoch: Epoch number of model we would like to load. :param convert: reference model should be converted to GPU NDArray first :param ctx: if convert then ctx must be designated. :param process: model should drop any test :return: (arg_params, aux_params) """ arg_params, aux_params = load_checkpoint(prefix, epoch) if cells is not None: if isinstance(cells, mx.rnn.BaseRNNCell): cells = [cells] for cell in cells: arg_params = cell.pack_weights(arg_params) if convert: if ctx is None: ctx = mx.cpu() arg_params = convert_context(arg_params, ctx) aux_params = convert_context(aux_params, ctx) if process: tests = [k for k in arg_params.keys() if '_test' in k] for test in tests: arg_params[test.replace('_test', '')] = arg_params.pop(test) return arg_params, aux_params
def load(cls, checkpoint_path, ctx=mx.cpu(), **kwargs): """ loads model from checkpoint_path. """ with open("{}.json".format(checkpoint_path)) as f: model_args = json.load(f) model = cls(**model_args, **kwargs) model.load_params(checkpoint_path, ctx) logger.info("model loaded: %s.", checkpoint_path) return model
def test_print_value(): data = mx.sym.Variable("data") weights = mx.sym.Variable("weights") softmax_label = mx.sym.Variable("softmax_label") fc = mx.sym.FullyConnected(data=data, num_hidden=128, weight=weights, no_bias=True) out = mx.sym.SoftmaxOutput(data=fc, label=softmax_label, name="softmax") fc_print = mx.sym.Custom(op_type="PrintValue", data=fc, print_name="FullyConnected") out_print = mx.sym.SoftmaxOutput(data=fc_print, label=softmax_label, name="softmax") data_np = np.random.rand(1, 256) weights_np = np.random.rand(128, 256) label_np = np.random.rand(1, 128) executor_base = out.simple_bind(mx.cpu(), data=(1, 256), softmax_label=(1, 128), weights=(128, 256)) executor_base.arg_dict["data"][:] = data_np executor_base.arg_dict["weights"][:] = weights_np executor_base.arg_dict["softmax_label"][:] = label_np executor_print = out_print.simple_bind(mx.cpu(), data=(1, 256), softmax_label=(1, 128), weights=(128, 256)) executor_print.arg_dict["data"][:] = data_np executor_print.arg_dict["weights"][:] = weights_np executor_print.arg_dict["softmax_label"][:] = label_np output_base = executor_base.forward(is_train=True)[0] output_print = executor_print.forward(is_train=True)[0] assert np.isclose(output_base.asnumpy(), output_print.asnumpy()).all() executor_base.backward() executor_print.backward() assert np.isclose(executor_base.grad_arrays[1].asnumpy(), executor_print.grad_arrays[1].asnumpy()).all()
