def test(backend): args = {'a': mx.nd.ones((3, 2)), 'b': mx.nd.ones((3, 2))} ############################################### # Test with subgraph not consuming params ############################################### #execute in MXNet print('-------------------------------') print('Testing regular Gluon execution') inputs = [a, b] sym_block = nn.SymbolBlock(sym, inputs) sym_block.initialize() out = sym_block(mx.nd.ones((3, 2)), mx.nd.ones((3, 2))) print(out) # Gluon Hybridize partitioning with shapes/types without inference print('-------------------------------') print( 'Testing %s Gluon Hybridize partitioning with shapes/types without inference' % backend) inputs = [a, b] sym_block2 = nn.SymbolBlock(sym, inputs) sym_block2.initialize() sym_block2.optimize_for(mx.nd.ones((3, 2)), mx.nd.ones((3, 2)), backend=backend) sym_block2.export('partitioned') # Test with additional input to subgraph op print('-------------------------------') print('Testing %s Gluon Hybridize partitioning with extra input' % backend) sym_block2.optimize_for(mx.nd.ones((3, 2)), mx.nd.ones((3, 2)), backend="addInputPass") out3 = sym_block2(mx.nd.ones((3, 2)), mx.nd.ones((3, 2))) print(out3) ############################################### # Test with subgraph directly consuming params ############################################### args = {'a': mx.nd.ones((3, 2))} #execute in MXNet print('-------------------------------') print('Testing regular MXNet execution') inputs = [a] sym2_block = nn.SymbolBlock(sym2, inputs) sym2_block.initialize() out5 = sym2_block(mx.nd.ones((3, 2))) print(out5) # Gluon optimize_for partitioning with shapes/types print('-------------------------------') print('Testing %s Gluon optimize_for partitioning with shapes/types' % backend) inputs = [a] sym2_block = nn.SymbolBlock(sym2, inputs) sym2_block.initialize() sym2_block.optimize_for(mx.nd.ones((3, 2)), backend=backend) out8 = sym2_block(mx.nd.ones((3, 2))) print(out8)
def test_model(pass_name): args = {'a': mx.nd.ones((3, 2)), 'b': mx.nd.ones((3, 2))} # execute in MXNet print('-------------------------------') print('Testing regular MXNet execution') exe = sym.bind(ctx=mx.cpu(), args=args) out = exe.forward() print(out) # Symbol optimize_for # with propogating shapes/types print('-------------------------------') print('Testing pass "%s" with shapes/types' % pass_name) aux = {} mysym2 = sym.optimize_for(pass_name, args, aux) print(mysym2.tojson()) exe2 = mysym2.bind(ctx=mx.cpu(), args=args) out2 = exe2.forward() print(out2) # without propogating shapes/types print('-------------------------------') print('Testing pass "%s" without shapes/types' % pass_name) mysym3 = sym.optimize_for(pass_name, myOpt='yello') exe3 = mysym3.bind(ctx=mx.cpu(), args=args) out3 = exe3.forward() print(out3) # Gluon Hybridize print('-------------------------------') print('Testing pass "%s" Gluon Hybridize with shapes/types' % pass_name) inputs = [a, b] sym_block = nn.SymbolBlock(sym, inputs) sym_block.initialize() sym_block.hybridize(backend=pass_name) out4 = sym_block(mx.nd.ones((3, 2)), mx.nd.ones((3, 2))) print(out4) # Gluon optimize_for print('-------------------------------') print( 'Testing pass "%s" Gluon Hybridize with shapes/types without inference' % pass_name) inputs = [a, b] sym_block2 = nn.SymbolBlock(sym, inputs) sym_block2.initialize() sym_block2.optimize_for(mx.nd.ones((3, 2)), mx.nd.ones((3, 2)), backend=pass_name) sym_block2.export('modified')
def check_subgraph_exe9(sym, subgraph_backend, op_names): """Call hybridize() to partition the graph, and then compare results of the partitioned sym and the original sym. Here do an inference before hybridizing with the subgraph_backend which means we'll pass shapes/types""" # create Gluon block for given symbol inputs = [mx.sym.var(i, dtype=mx_real_t) for i in sym[1]] sym_block = nn.SymbolBlock(sym[0], inputs) sym_block.initialize(ctx=mx.current_context()) x = [ mx.nd.random.uniform(shape=s, ctx=mx.current_context()) for s in sym[2] ] # hybridize and export to get baseline sym_block.hybridize() outputs1 = sym_block(*x) sym_block.export('check_subgraph_exe9') # load model and partition sym_block = nn.SymbolBlock.imports('check_subgraph_exe9-symbol.json', sym[1], 'check_subgraph_exe9-0000.params', ctx=mx.current_context()) check_call( _LIB.MXSetSubgraphPropertyOpNamesV2(c_str(subgraph_backend), mx_uint(len(op_names)), c_str_array(op_names))) sym_block.hybridize(backend=subgraph_backend) outputs2 = sym_block(*x) check_call(_LIB.MXRemoveSubgraphPropertyOpNamesV2(c_str(subgraph_backend))) # compare outputs assert len(outputs1) == len(outputs2) for i in range(len(outputs1)): assert_almost_equal((outputs1[i] - outputs2[i]).abs().sum().asnumpy(), np.zeros(shape=(1, )))
def test_model(pass_name): args={'a':mx.nd.ones((3,2)), 'b':mx.nd.ones((3,2))} # execute in MXNet print('-------------------------------') print('Testing regular MXNet execution') inputs = [a,b] sym_block = nn.SymbolBlock(sym, inputs) sym_block.initialize() out = sym_block(mx.nd.ones((3,2)),mx.nd.ones((3,2))) print(out) # Gluon optimize_for print('-------------------------------') print('Testing pass "%s" Gluon Hybridize with shapes/types without inference' % pass_name) inputs = [a,b] sym_block2 = nn.SymbolBlock(sym, inputs) sym_block2.initialize() sym_block2.optimize_for(mx.nd.ones((3,2)), mx.nd.ones((3,2)), backend=pass_name) sym_block2.export('modified')
def test_yxnet_mnist(): mnist_sym = make_mnist_graph() inputs_ext = { 'data': { 'shape': (1, 1, 28, 28), 'precision': 8, } } in_shape = (1, 1, 28, 28) arg_shapes, _, aux_shapes = mnist_sym.infer_shape(data=in_shape) args, auxs = mnist_sym.list_arguments(), mnist_sym.list_auxiliary_states() infer_shapes = {args[i]: arg_shapes[i] for i in range(len(args))} infer_shapes.update({auxs[i]: aux_shapes[i] for i in range(len(auxs))}) root = "/home/serving/warehouse" _, bd = load_parameters( mnist_sym, infer_shapes, root + "/ca3d0286d5758697cdef653c1375960a868ac08a/data/params") mnist_sym, bd = spass.mx_set_precs(mnist_sym, bd, inputs_ext) dump_sym, dump_par = '/tmp/mnist_yxnet.symbol', '/tmp/mnist_yxnet.params' with open(dump_sym, 'w') as fout: fout.write(mnist_sym.tojson()) nd.save(dump_par, bd) inputs = [mx.sym.var('data')] data = np.load(root + '/ba9fedfc87ccb6064fcd437fd2287f5edef1bd84/data') data = nd.array([data.astype(np.int8)]) if False: graph = nn.SymbolBlock(mnist_sym, inputs) utils.load_parameters(graph, bd) res = graph.forward(data).astype('int32') else: prefix = "/tmp/yxnet/mnist" dump_sym, dump_params = prefix + ".json", prefix + ".params" print(sutils.sym_collect_attr(mnist_sym)) spass.mxnet_to_nnvm(mnist_sym, bd, {'data': { 'shape': (1, 1, 28, 28) }}, dump_sym, dump_params) exit() print(res.asnumpy().flatten()[:100])
def test_subgraph(): # possible places to find library file if (os.name=='posix'): lib = 'libsubgraph_lib.so' if os.path.exists(lib): # plain make build, when run in the CI fname = lib elif os.path.exists(os.path.join(base_path, 'build/'+lib)): # plain cmake build when run in the CI fname = os.path.join(base_path, 'build/'+lib) else: raise MXNetError("library %s not found " % lib) elif (os.name=='nt'): lib = 'libsubgraph_lib.dll' if os.path.exists('windows_package\\lib\\'+lib): # plain make build, when run in the CI fname = 'windows_package\\lib\\'+lib else: # plain cmake build when run in the CI raise MXNetError("library %s not found " % lib) fname = os.path.abspath(fname) mx.library.load(fname) # test simple graph with add, exp and log operators, library supports exp/log a = mx.sym.var('a') b = mx.sym.var('b') c = a + b d = mx.sym.exp(c) sym = mx.sym.log(d) args = {'a':mx.nd.ones((3,2),ctx=mx.cpu()), 'b':mx.nd.ones((3,2),ctx=mx.cpu())} # baseline - regular execution in MXNet exe = sym._bind(ctx=mx.cpu(), args=args) out = exe.forward() # without propogating shapes/types, passing a custom option to subgraph prop "myOpt" # should not create subgraph since subgraph prop requires type info mysym1 = sym.optimize_for("myProp", myOpt='yello') exe1 = mysym1._bind(ctx=mx.cpu(), args=args) out1 = exe1.forward() # check that result matches one executed by MXNet assert_almost_equal(out[0].asnumpy(), out1[0].asnumpy(), rtol=1e-3, atol=1e-3) # with propogating shapes/types, rejecting subgraph # this tests creating the subgraph and having the subgraph prop reject it mysym2 = sym.optimize_for("myProp", args, reject=True) exe2 = mysym2._bind(ctx=mx.cpu(), args=args) out2 = exe2.forward() # check that result matches one executed by MXNet assert_almost_equal(out[0].asnumpy(), out2[0].asnumpy(), rtol=1e-3, atol=1e-3) # with propogating shapes/types mysym3 = sym.optimize_for("myProp",args) exe3 = mysym3._bind(ctx=mx.cpu(), args=args) out3 = exe3.forward() # check that result matches one executed by MXNet assert_almost_equal(out[0].asnumpy(), out3[0].asnumpy(), rtol=1e-3, atol=1e-3) # Gluon Hybridize partitioning with shapes/types sym_block = nn.SymbolBlock(sym, [a,b]) sym_block.initialize() sym_block.optimize_for(mx.nd.ones((3,2)),mx.nd.ones((3,2)),backend='myProp') out4 = sym_block(mx.nd.ones((3,2)),mx.nd.ones((3,2))) # check that result matches one executed by MXNet assert_almost_equal(out[0].asnumpy(), out4[0].asnumpy(), rtol=1e-3, atol=1e-3) # Gluon Hybridize partitioning with sym.var sym_block2 = nn.SymbolBlock(sym, [a,b]) sym_block2.initialize() a_var = mx.sym.var('a',shape=(3,2)) b_var = mx.sym.var('b',shape=(3,2)) sym_block2.optimize_for(a_var, b_var, backend='myProp') # Gluon Hybridize partitioning with shapes/types sym_block3 = nn.SymbolBlock(sym, [a,b]) sym_block3.initialize() a_data = mx.nd.ones((3,2)) b_data = mx.nd.ones((3,2)) sym_block3.optimize_for(a_data, b_data, backend='myProp') sym_filename, params_filename = sym_block3.export('optimized') assert sym_filename == 'optimized-symbol.json' assert params_filename is None sym_block4 = nn.SymbolBlock.imports(sym_filename, ['a','b'], params_filename) out5 = sym_block4(a_data, b_data) # check that result matches one executed by MXNet assert_almost_equal(out[0].asnumpy(), out5[0].asnumpy(), rtol=1e-3, atol=1e-3)
print('-------------------------------') print('Testing partitioning without shapes/types') mysym3 = sym.optimize_for("myProp", myOpt='yello') exe3 = mysym3.bind(ctx=mx.cpu(), args={ 'a': mx.nd.ones((3, 2)), 'b': mx.nd.ones((3, 2)) }) out3 = exe3.forward() print(out3) # Gluon Hybridize partitioning with shapes/types print('-------------------------------') print('Testing Gluon Hybridize partitioning with shapes/types') inputs = [a, b] sym_block = nn.SymbolBlock(sym, inputs) sym_block.initialize() sym_block.hybridize(backend='myProp') out4 = sym_block(mx.nd.ones((3, 2)), mx.nd.ones((3, 2))) print(out4) # Gluon Hybridize partitioning with shapes/types without inference print('-------------------------------') print( 'Testing Gluon Hybridize partitioning with shapes/types without inference') inputs = [a, b] sym_block2 = nn.SymbolBlock(sym, inputs) sym_block2.initialize() sym_block2.optimize_for(mx.nd.ones((3, 2)), mx.nd.ones((3, 2)), backend='myProp')
def get_net(_ctx, json, params): inputs = mx.sym.var('data', dtype='float32') net = gnn.SymbolBlock(mx.sym.load(json)['fc_pyr_fwd_output'], inputs) net.load_parameters(params, ctx=_ctx) net.hybridize() return net
def test(backend): ############################################### # Test with subgraph not consuming params ############################################### #execute in MXNet print('-------------------------------') print('Testing regular MXNet execution') exe = sym.bind(ctx=mx.cpu(), args={ 'a': mx.nd.ones((3, 2)), 'b': mx.nd.ones((3, 2)) }) out = exe.forward() print(out) # with propogating shapes/types print('-------------------------------') print('Testing %s partitioning with shapes/types' % backend) arg_array = [ mx.nd.ones((3, 2), dtype='float32'), mx.nd.ones((3, 2), dtype='float32') ] mysym2 = sym.optimize_for(backend, arg_array) print(mysym2.tojson()) exe2 = mysym2.bind(ctx=mx.cpu(), args={ 'a': mx.nd.ones((3, 2)), 'b': mx.nd.ones((3, 2)) }) out2 = exe2.forward() print(out2) # with propogating shapes/types, rejecting subgraph print('-------------------------------') print('Testing %s partitioning with shapes/types - rejecting subgraph' % backend) arg_array = [ mx.nd.ones((3, 2), dtype='float32'), mx.nd.ones((3, 2), dtype='float32') ] mysym2 = sym.optimize_for(backend, arg_array, reject=True) exe2 = mysym2.bind(ctx=mx.cpu(), args={ 'a': mx.nd.ones((3, 2)), 'b': mx.nd.ones((3, 2)) }) out2 = exe2.forward() print(out2) # without propogating shapes/types print('-------------------------------') print('Testing %s partitioning without shapes/types' % backend) mysym3 = sym.optimize_for(backend, myOpt='yello') exe3 = mysym3.bind(ctx=mx.cpu(), args={ 'a': mx.nd.ones((3, 2)), 'b': mx.nd.ones((3, 2)) }) out3 = exe3.forward() print(out3) # Gluon Hybridize partitioning with shapes/types print('-------------------------------') print('Testing %s Gluon Hybridize partitioning with shapes/types' % backend) inputs = [a, b] sym_block = nn.SymbolBlock(sym, inputs) sym_block.initialize() sym_block.hybridize(backend=backend) out4 = sym_block(mx.nd.ones((3, 2)), mx.nd.ones((3, 2))) print(out4) # Gluon Hybridize partitioning with shapes/types without inference print('-------------------------------') print( 'Testing %s Gluon Hybridize partitioning with shapes/types without inference' % backend) inputs = [a, b] sym_block2 = nn.SymbolBlock(sym, inputs) sym_block2.initialize() sym_block2.optimize_for(mx.nd.ones((3, 2)), mx.nd.ones((3, 2)), backend=backend) sym_block2.export('partitioned') ############################################### # Test with subgraph directly consuming params ############################################### #execute in MXNet print('-------------------------------') print('Testing regular MXNet execution') exe5 = sym2.bind(ctx=mx.cpu(), args={'a': mx.nd.ones((3, 2))}) out5 = exe5.forward() print(out5) # with propogating shapes/types print('-------------------------------') print('Testing %s partitioning with shapes/types' % backend) arg_array = [mx.nd.ones((3, 2), dtype='float32')] mysym6 = sym2.optimize_for(backend, arg_array, reqArgs=True) print(mysym6.tojson()) exe6 = mysym6.bind(ctx=mx.cpu(), args={'a': mx.nd.ones((3, 2))}) out6 = exe6.forward() print(out6) # without propogating shapes/types print('-------------------------------') print('Testing %s partitioning without shapes/types' % backend) mysym7 = sym2.optimize_for(backend, reqArgs=True) exe7 = mysym7.bind(ctx=mx.cpu(), args={'a': mx.nd.ones((3, 2))}) out7 = exe7.forward() print(out7) # Gluon Hybridize partitioning with shapes/types print('-------------------------------') print('Testing %s Gluon Hybridize partitioning with shapes/types' % backend) inputs = [a] sym2_block = nn.SymbolBlock(sym2, inputs) sym2_block.initialize() sym2_block.hybridize(backend=backend) out8 = sym2_block(mx.nd.ones((3, 2))) print(out8)