def test(config_yaml: str, data: np.array, test_fn: Callable = None): np.random.seed(23423) def get_data_iter(batch_size, shuffle): dataset = gluon.data.ArrayDataset(data.astype(np.float32), range(len(data))) return gluon.data.DataLoader(dataset, batch_size=batch_size, shuffle=True) config = yaml.load(config_yaml) data_iter = get_data_iter(config['gradient']['batch_size'], shuffle=True) my_model = fit.fit(config, data_iter) data_iter = get_data_iter(config['gradient']['batch_size'], shuffle=False) n_samples_stats = 10 for data_batch in data_iter: _, _, sample = my_model(data_batch) tmp_sample = nd.zeros_like(sample) for _ in range(n_samples_stats): _, _, sample = my_model(data_batch) tmp_sample += sample tmp_sample /= n_samples_stats if tmp_sample.ndim == 3: tmp_sample = nd.mean(tmp_sample, 0, keepdims=True) tmp_sample = tmp_sample.asnumpy() if len(data) == 1: tmp_sample = tmp_sample.reshape((1, -1)) test_fn(tmp_sample) else: test_fn(tmp_sample, data_batch[0].asnumpy())
description="train cifar10", formatter_class=argparse.ArgumentDefaultsHelpFormatter) fit.add_fit_args(parser) data.add_data_args(parser) data.add_data_aug_args(parser) # use a large aug level data.set_data_aug_level(parser, 3) parser.set_defaults( # network network='resnet', num_layers=50, # data num_classes=1000, num_examples=1281167, image_shape='3,224,224', min_random_scale=1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs=80, lr_step_epochs='30,60', ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, data.get_list_iter)
data.add_data_args(parser) data.add_data_aug_args(parser) data.set_data_aug_level(parser, 2) parser.set_defaults( # network network = 'alexnet', # data data_dir = os.environ['HOME'] + '/data/mxnet/cifar10_32/', data_train = 'train.rec', data_val = None, #data_dir + 'test.rec', num_classes = 10, num_examples = 50000, image_shape = '3,32,32', pad_size = 0, # train batch_size = 128, num_epochs = 4, lr = .01, lr_step_epochs = '200,250', ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) init = mx.initializer.Normal(sigma=0.01) # train fit.fit(args, sym, data.get_rec_iter, init)
# additional parameters for large batch sgd # macrobatch_size = 96, # warmup_strategy = 'linear' ) args = parser.parse_args() if not os.path.exists(os.path.dirname(args.model_dir)): os.makedirs(os.path.dirname(args.model_dir)) # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # not mobilenet-v2 # sym = net.get_symbol(args.num_classes, args.multiplier) # mobilenet-v2 specific # model structure visualization if args.visibility == 1: mx.viz.plot_network(sym, shape={ "data": (1, 3, 224, 224) }, node_attrs={ "shape": 'rect', "fixedsize": 'false' }).render(args.network) exit() # train fit.fit(args, sym, data.get_rec_iter)
args.data_train = example_fname args.train_val_split = 0.5 # args.num_examples = dd.nb_wgt_samples([example_fname], args.weight_names)[0] if args.load_epoch: print('-' * 50) # n_train, n_val, n_test = dd.nb_wgt_samples([args.data_train, args.data_val, args.data_test], args.weight_names) n_train_val, n_test = dd.nb_samples([args.data_train, args.data_test]) n_train = int(n_train_val * args.train_val_split) n_val = int(n_train_val * (1 - args.train_val_split)) print( ' --- Training sample size = %d, Validation sample size = %d, Test sample size = %d ---' % (n_train, n_val, n_test)) if args.num_examples < 0: args.num_examples = n_train if args.predict: fit.predict(args, dd.load_data) else: # load network sym = import_module('symbols.' + args.network) save_dir = os.path.dirname(args.model_prefix) if not os.path.exists(save_dir): os.makedirs(save_dir) shutil.copy('symbols/%s.py' % args.network, save_dir) # train fit.fit(args, sym, dd.load_data)
formatter_class=argparse.ArgumentDefaultsHelpFormatter) fit.add_fit_args(parser) data.add_data_args(parser) data.add_data_aug_args(parser) # uncomment to set standard augmentation for resnet training # data.set_resnet_aug(parser) parser.set_defaults( # network network = 'resnet', num_layers = 50, # data num_classes = 1000, num_examples = 1281167, image_shape = '3,224,224', min_random_scale = 1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs = 80, lr_step_epochs = '30,60', dtype = 'float32' ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, data.get_rec_iter)
action='store_true', help='use_aux_head') parser.add_argument('--use-python-iter', type=int, default=0, help='whether or not use python version iter') parser.add_argument('--use-gpu-augmenter', type=int, default=0, help='whether or not augment the image in gpus') parser.add_argument('--color-aug', type=int, default=0, help='whether or not augment the color') parser.add_argument('--lighting-aug', type=int, default=0, help='whether or not augment the lighting') fit.add_fit_args(parser) args = parser.parse_args() logging.info(args) def get_symbol(is_training=True): return symbol(model_type='renasnet-ImageNet', classes=args.num_classes, use_aux_head=args.use_aux, is_training=is_training) fit.fit(args, get_symbol, get_iterator)
default=False, dest="is_nnp") fit.add_fit_args(parser) data.add_data_args(parser) data.add_data_aug_args(parser) # uncomment to set standard augmentations for imagenet training # set_imagenet_aug(parser) parser.set_defaults( # network network='resnet', num_layers=50, # data num_classes=1000, num_examples=1281167, image_shape='3,224,224', min_random_scale=1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs=80, lr_step_epochs='30,60', dtype='float32') args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, data.get_rec_iter, args.is_nnp)
logger.setLevel(logging.INFO) if log_file: fh = logging.FileHandler(log_file) logger.addHandler(fh) # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) devs = mx.cpu() if args.gpus is None or args.gpus is '' else [ mx.gpu(int(i)) for i in args.gpus.split(',')] #load pretrained args_params=None auxs_params=None # train if args_params and auxs_params: fit.fit( args, sym, data.get_rec_iter, arg_params=args_params, aux_params=auxs_params) else: fit.fit( args, sym, data.get_rec_iter)
data.add_data_args(parser) data.add_data_aug_args(parser) # use a large aug level data.set_data_aug_level(parser, 3) parser.set_defaults( # network network='resnet', # num_layers = 50, num_layers=18, # data num_classes=1000, #num_examples = 1281167, #gbxu num_example=51200, # reduce the num example image_shape='3,224,224', min_random_scale=1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs=80, lr_step_epochs='30,60', dtype='float32') args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, resized_iter) # reduce the examples # fit.fit(args, sym, data.get_rec_iter)
# set up logger log_file = args.log_file logger = logging.getLogger() logger.setLevel(logging.INFO) if log_file: fh = logging.FileHandler(log_file) logger.addHandler(fh) # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) devs = mx.cpu() if args.gpus is None or args.gpus is '' else [ mx.gpu(int(i)) for i in args.gpus.split(',') ] #load pretrained args_params = None auxs_params = None # train if args_params and auxs_params: fit.fit(args, sym, data.prepair_data_hotspot, arg_params=args_params, aux_params=auxs_params) else: fit.fit(args, sym, data.prepair_data_hotspot)
val = mx.io.NDArrayIter( to4d(val_img), val_lbl, args.batch_size) return (train, val) if __name__ == '__main__': # parse args parser = argparse.ArgumentParser(description="train mnist", formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--num-classes', type=int, default=10, help='the number of classes') parser.add_argument('--num-examples', type=int, default=60000, help='the number of training examples') parser.add_argument('--data-dir', type=str, default=os.environ['HOME'] + '/data/mxnet/mnist/') fit.add_fit_args(parser) parser.set_defaults( # network network = 'mlp', # train gpus = None, batch_size = 64, disp_batches = 100, num_epochs = 20, lr = .05, lr_step_epochs = '10', ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, get_mnist_iter, mx.init.Xavier(factor_type="in", magnitude=3))
num_epochs=20, lr=.05, lr_step_epochs='10') args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # tensorboard logs train_log = 'logs/mnist/train' eval_log = 'logs/mnist/eval' batch_end_callbacks = [] eval_end_callbacks = [] try: import tensorboard batch_end_callbacks.append( mx.contrib.tensorboard.LogMetricsCallback(train_log)) eval_end_callbacks.append( mx.contrib.tensorboard.LogMetricsCallback(eval_log)) except: print( "warning: can't generate event files of tensorboard. You can install tensorboard using 'pip install tensorboard'." ) # train fit.fit(args, sym, get_mnist_iter,\ batch_end_callback = batch_end_callbacks,\ eval_end_callback = eval_end_callbacks)
validation_subsets = [int(k) for k in args.val_subsets.split(',')] train_iter = get_iterator(args.train_data_root, train_subsets, batch_size=args.batch_size, shuffle=True) val_iter = get_iterator(args.val_data_root, validation_subsets, batch_size=args.batch_size) args.num_examples = train_iter.total_size() # load network from importlib import import_module net = import_module('3Dsymbols.' + args.network) sym = net.get_symbol(**vars(args)) #load pretrained args_params = None auxs_params = None # train if args_params and auxs_params: fit.fit(args, sym, train_iter, val_iter, arg_params=args_params, aux_params=auxs_params) else: fit.fit(args, sym, train_iter, val_iter)
weight_distribution: point_mass data_distribution: poisson data_size: null """.format(path)) if cfg['clear_dir']: for f in os.listdir(cfg['dir']): os.remove(os.path.join(cfg['dir'], f)) with open(os.path.join(cfg['dir'], 'config.yml'), 'w') as f: yaml.dump(cfg, f, default_flow_style=False) util.log_to_file(os.path.join(cfg['dir'], 'train.log')) fname = os.path.join(os.environ['DAT'], 'science/documents_train.dat') fname_vocab = os.path.join(os.environ['DAT'], 'science/VOCAB-TFIDF-1000.dat') corpus = gensim.corpora.bleicorpus.BleiCorpus(fname, fname_vocab) cfg['layer_0']['data_size'] = len(corpus.id2word) docs = [doc for doc in corpus if len(doc) > 0] dataset = gluon.data.ArrayDataset(data=docs, label=range(len(docs))) train_data = data.DocumentDataLoader( dataset=dataset, id2word=corpus.id2word, batch_size=cfg['gradient']['batch_size'], last_batch='discard', shuffle=True) fit.fit(cfg, train_data)
parser.add_argument( '--add_stn', action="store_true", default=False, help='Add Spatial Transformer Network Layer (lenet only)') parser.add_argument('--image_shape', default='1, 28, 28', help='shape of training images') fit.add_fit_args(parser) parser.set_defaults( # network network='mlp', # train gpus=None, batch_size=64, disp_batches=100, num_epochs=20, lr=.05, lr_step_epochs='10') args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, get_mnist_iter, args.is_nnp)
import os import argparse import logging logging.basicConfig(level=logging.DEBUG) from common import find_mxnet from common import data, fit import mxnet as mx import os, urllib if __name__ == "__main__": parser = argparse.ArgumentParser( description="simple conv3 net", formatter_class=argparse.ArgumentDefaultsHelpFormatter) train = fit.add_fit_args(parser) data.add_data_args(parser) aug = data.add_data_aug_args(parser) data.set_data_aug_level(parser, 1) parser.set_defaults(image_shape='3,48,48', num_epochs=200, lr=.001, wd=0) args = parser.parse_args() # define simpleconv3 net = mx.sym.load('models/simple-conv3-symbol.json') print "net", net # train fit.fit(args=args, network=net, data_loader=data.get_rec_iter)
net = irnext_deeplab_dcn(**vars(args)) sym = net.get_cls_symbol() # Init Parameters ctx = mx.cpu() _, deeplab_args, deeplab_auxs = mx.model.load_checkpoint( args.model_ft_prefix, args.load_ft_epoch) data_shape_dict = { 'data': (args.batch_size, 3, 224, 224), 'softmax_label': (args.batch_size, ) } if args.model_ft_prefix[0:3] == 'CLS': deeplab_args, deeplab_auxs = runs_CAIScene.scene_init_from_cls.init_from_irnext_cls(ctx, \ sym, deeplab_args, deeplab_auxs, data_shape_dict, block567=args.block567) else: args.lr_step_epochs = '50,100' # train #args.arg_params = deeplab_args #args.aux_params = deeplab_auxs fit.fit(args, sym, data.get_rec_iter, arg_params=deeplab_args, aux_params=deeplab_auxs)
if __name__ == '__main__': # parse args parser = argparse.ArgumentParser(description="train mnist", formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--num-classes', type=int, default=10, help='the number of classes') parser.add_argument('--num-examples', type=int, default=60000, help='the number of training examples') fit.add_fit_args(parser) parser.set_defaults( # network network = 'mlp', # train gpus = None, batch_size = 64, disp_batches = 100, num_epochs = 20, lr = .05, lr_step_epochs = '10', ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, get_mnist_iter)
def start_new_training(): # binding signals SUPPORTED_SIGNALS = ( signal.SIGINT, signal.SIGTERM, ) for signum in SUPPORTED_SIGNALS: try: signal.signal(signum, signal_handler) logger.info("Bind signal '%s' success to %s", signum, signal_handler) except Exception as identifier: logger.warning("Bind signal '%s' failed, err: %s", signum, identifier) try: # parse args parser = argparse.ArgumentParser( description="train imagenet-1k", formatter_class=argparse.ArgumentDefaultsHelpFormatter) fit.add_fit_args(parser) data.add_data_args(parser) data.add_data_aug_args(parser) # use a large aug level data.set_data_aug_level(parser, 3) parser.set_defaults( # network network='resnet', num_layers=50, # data num_classes=10, num_examples=60000, image_shape='3,28,28', min_random_scale=1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs=80, lr_step_epochs='30,60', dtype='float32', batch_size=32) args = parser.parse_args() # AVA-SDK new an Instance train_ins = train.TrainInstance() # add CALLBACK batch_end_cb = train_ins.get_monitor_callback( "mxnet", batch_size=args.batch_size, batch_freq=10) args.batch_end_callback = batch_end_cb # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, data.get_rec_iter) logger.info("training finish") err_msg = "" if train_ins == None: return train_ins.done(err_msg=err_msg) except Exception as err: err_msg = "training failed, err: %s" % (err) logger.info(err_msg) traceback.print_exc(file=sys.stderr) if train_ins == None: return train_ins.done(err_msg=err_msg)
# Create dummy data shapes and bind them to the model data_shapes = [ mx.io.DataDesc('data', (args.batch_size, 224, 224, 4), 'float16') ] label_shapes = [ mx.io.DataDesc('softmax_label', (args.batch_size, ), 'float32') ] model.bind(data_shapes=data_shapes, label_shapes=label_shapes) # Horovod: fetch and broadcast parameters model.init_params(initializer, arg_params=arg_params, aux_params=aux_params) (arg_params, aux_params) = model.get_params() if arg_params is not None: hvd.broadcast_parameters(arg_params, root_rank=0) if aux_params is not None: hvd.broadcast_parameters(aux_params, root_rank=0) model.set_params(arg_params=arg_params, aux_params=aux_params) mx.ndarray.waitall() mx_resnet_print(key=mlperf_constants.INIT_STOP, sync=True) # Start training mx_resnet_print(key=mlperf_constants.RUN_START, sync=True) fit.fit(args, kv, model, initializer, lambda_fnc_dali_get_rec_iter, devs, arg_params, aux_params)
data.add_data_aug_args(parser) # use a large aug level data.set_data_aug_level(parser, 3) parser.set_defaults( # network network = 'resnet', # num_layers = 50, num_layers = 18, # data num_classes = 1000, #num_examples = 1281167, #gbxu num_example = 51200, # reduce the num example image_shape = '3,224,224', min_random_scale = 1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs = 80, lr_step_epochs = '30,60', dtype = 'float32' ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, resized_iter) # reduce the examples # fit.fit(args, sym, data.get_rec_iter)
if len(active_layers) > 15: for layer in active_layers[:15]: print(layer) print('...(snip)...') else: for layer in active_layers: print(layer) for k in new_args: is_active = False for a in active_layers: if k == a: is_active = True train_params.append(k) if not is_active: fixed_params.append(k) print('--------------------------------------') print("Train the last fc layers and the following layers: %s" % ', '.join(train_params)) else: print("Train all the layers") # train fit.fit(args = args, network = new_sym, data_loader = data.get_rec_iter, arg_params = new_args, aux_params = aux_params, fixed_params_names = fixed_params)
min_random_scale=1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs=90, lr_step_epochs='30,60,80', dtype='float32') args = parser.parse_args() # load network from importlib import import_module if args.network == "resnet-v1b" and args.num_layers == 50: net = get_model('resnet50_v1b', ctx=[mx.gpu(int(i)) for i in args.gpus.split(',')], pretrained=False, classes=args.num_classes, last_gamma=args.bn_gamma_init0) d = mx.sym.var('data') if args.dtype == 'float16': d = mx.sym.Cast(data=d, dtype=np.float16) net.cast(args.dtype) out = net(d) if args.dtype == 'float16': out = mx.sym.Cast(data=out, dtype=np.float32) sym = mx.sym.SoftmaxOutput(out, name='softmax') else: net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, dali.get_rec_iter)
if prefix is None: (prefix, epoch) = (args.pretrained_model, args.load_epoch) sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch) if args.dtype != 'float32': # load symbol of trained network, so we can cast it to support other dtype # fine tuning a network in a datatype which was not used for training originally, # requires access to the code used to generate the symbol used to train that model. # we then need to modify the symbol to add a layer at the beginning # to cast data to that dtype. We also need to cast output of layers before softmax # to float32 so that softmax can still be in float32. # if the network chosen from symols/ folder doesn't have cast for the new datatype, # it will still train in fp32 if args.network not in ['inception-v3',\ 'inception-v4', 'resnet-v1', 'resnet', 'resnext', 'vgg']: raise ValueError('Given network does not have support for dtypes other than float32.\ Please add a cast layer at the beginning to train in that mode.') from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) # remove the last fullc layer and add a new softmax layer (new_sym, new_args) = get_fine_tune_model(sym, arg_params, args.num_classes, args.layer_before_fullc, args.dtype) # train fit.fit(args = args, network = new_sym, data_loader = data.get_rec_iter, arg_params = new_args, aux_params = aux_params)
# data num_classes = 1000, num_examples = 1281167, image_shape = '3,224,224', min_random_scale = 1, # if input image has min size k, suggest to use # 256.0/x, e.g. 0.533 for 480 # train num_epochs = 60, lr_step_epochs = '20,30,40,50', lr = 0.01, batch_size = 32, optimizer = 'sgd', disp_batches = 10, top_k = 5, data_train = '/data/imagenet1k/imagenet1k-train', data_val = '/data/imagenet1k/imagenet1k-val' ) args = parser.parse_args() #load pretrained model if args.pretrained_model: sym, args_params, aux_params = mx.model.load_checkpoint(args.pretrained_model, 126)#inception-bn # train fit.fit(args = args, network = sym, data_loader = data.get_rec_iter, arg_params = args_params, aux_params = aux_params, )
parser.set_defaults(image_shape='3,224,224', num_epochs=30, lr=.01, lr_step_epochs='20', wd=0, mom=0) args = parser.parse_args() # load pretrained model dir_path = os.path.dirname(os.path.realpath(__file__)) (prefix, epoch) = modelzoo.download_model( args.pretrained_model, os.path.join(dir_path, 'model')) if prefix is None: (prefix, epoch) = (args.pretrained_model, args.load_epoch) if epoch is None: epoch =0 sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch) # remove the last fullc layer (new_sym, new_args) = get_fine_tune_model( sym, arg_params, args.num_classes, args.layer_before_fullc) print(args) if 'lst' in args.data_train: loader = data.get_list_iter if 'rec' in args.data_train: loader = data.get_rec_iter # train fit.fit(args = args, network = new_sym, data_loader = loader, arg_params = new_args, aux_params = aux_params)
batch_size: 10 layer_1: latent_distribution: poisson # weight_distribution: point_mass size: 10 layer_0: weight_distribution: point_mass data_distribution: bernoulli data_size: 784 """.format(path)) if config['clear_dir']: for f in os.listdir(config['dir']): os.remove(os.path.join(config['dir'], f)) # hdf5 file from: # https://github.com/altosaar/proximity_vi/blob/master/get_binary_mnist.py data_path = os.path.join(os.environ['DAT'], 'binarized_mnist.hdf5') f = h5py.File(data_path, 'r') raw_data = f['train'][:][0:10] f.close() train_data = mx.io.NDArrayIter( data={'data': nd.array(raw_data)}, label={'label': range(len(raw_data)) * np.ones((len(raw_data), ))}, batch_size=config['gradient']['batch_size'], shuffle=True) fit.fit(config, train_data)
formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--num-classes', type=int, default=10, help='the number of classes') parser.add_argument('--num-examples', type=int, default=60000, help='the number of training examples') fit.add_fit_args(parser) parser.set_defaults( # network network='mlp', # train gpus=None, batch_size=64, disp_batches=10, num_epochs=20, lr=.05, lr_step_epochs='10', ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.' + args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, get_mnist_iter)
devs = mx.cpu() if args.gpus is None or args.gpus is '' else [ mx.gpu(int(i)) for i in args.gpus.split(',')] # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) if args.visualize: mx.visualization.print_summary(sym, shape={'data': (1, 3, 224, 224)}) # digraph = mx.visualization.plot_network(sym, save_format='jpg') # digraph.render() else: #load pretrained args_params=None auxs_params=None # train if args_params and auxs_params: fit.fit( args, sym, data.get_rec_iter, arg_params=args_params, aux_params=auxs_params) else: fit.fit( args, sym, data.get_rec_iter)
(prefix, epoch) = modelzoo.download_model( args.pretrained_model, os.path.join(dir_path, 'model')) if args.load_epoch is not None: (prefix, epoch) = (args.model_prefix, args.load_epoch) logging.info(prefix) logging.info(epoch) sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch) # remove the last fullc layer (new_sym, new_args) = get_fine_tune_model( sym, arg_params, args.num_classes, args.layer_before_fullc) print(args.batch_size,args.image_shape[0],args.image_shape[1],args.image_shape[2]) image_shape = [args.batch_size] for part in str.split(args.image_shape,','): image_shape.append(int(part)) arg_shape,out_shape,aux_shape = new_sym.infer_shape(data=(image_shape[0],image_shape[1],image_shape[2],image_shape[3])) print("out-shape") print(out_shape) print("arg_shape") print(arg_shape) # train fit.fit(args = args, network = new_sym, data_loader = data.get_rec_iter_mutil, arg_params = new_args, aux_params = aux_params)
data.add_data_aug_args(parser) data.set_data_aug_level(parser, 2) parser.set_defaults( # network network = 'resnet_mixup', num_layers = 50, # data data_train = train_fname, data_val = val_fname, num_classes = 10, num_examples = 50000, image_shape = '3,28,28', pad_size = 4, # train batch_size = 128, num_epochs = 300, lr = 0.7, lr_step_epochs = '10,100,200', is_train = True ) args = parser.parse_args() # load network from importlib import import_module net = import_module('symbols.'+args.network) sym = net.get_symbol(**vars(args)) # train fit.fit(args, sym, data.get_rec_iter,is_train = True)