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)
