id int32 0 252k | repo stringlengths 7 55 | path stringlengths 4 127 | func_name stringlengths 1 88 | original_string stringlengths 75 19.8k | language stringclasses 1 value | code stringlengths 75 19.8k | code_tokens list | docstring stringlengths 3 17.3k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 87 242 |
|---|---|---|---|---|---|---|---|---|---|---|---|
23,800 | apache/incubator-mxnet | example/image-classification/train_mnist.py | get_mnist_iter | def get_mnist_iter(args, kv):
"""
create data iterator with NDArrayIter
"""
(train_lbl, train_img) = read_data(
'train-labels-idx1-ubyte.gz', 'train-images-idx3-ubyte.gz')
(val_lbl, val_img) = read_data(
't10k-labels-idx1-ubyte.gz', 't10k-images-idx3-ubyte.gz')
train = mx.io.NDArrayIter(
to4d(train_img), train_lbl, args.batch_size, shuffle=True)
val = mx.io.NDArrayIter(
to4d(val_img), val_lbl, args.batch_size)
return (train, val) | python | def get_mnist_iter(args, kv):
"""
create data iterator with NDArrayIter
"""
(train_lbl, train_img) = read_data(
'train-labels-idx1-ubyte.gz', 'train-images-idx3-ubyte.gz')
(val_lbl, val_img) = read_data(
't10k-labels-idx1-ubyte.gz', 't10k-images-idx3-ubyte.gz')
train = mx.io.NDArrayIter(
to4d(train_img), train_lbl, args.batch_size, shuffle=True)
val = mx.io.NDArrayIter(
to4d(val_img), val_lbl, args.batch_size)
return (train, val) | [
"def",
"get_mnist_iter",
"(",
"args",
",",
"kv",
")",
":",
"(",
"train_lbl",
",",
"train_img",
")",
"=",
"read_data",
"(",
"'train-labels-idx1-ubyte.gz'",
",",
"'train-images-idx3-ubyte.gz'",
")",
"(",
"val_lbl",
",",
"val_img",
")",
"=",
"read_data",
"(",
"'t10k-labels-idx1-ubyte.gz'",
",",
"'t10k-images-idx3-ubyte.gz'",
")",
"train",
"=",
"mx",
".",
"io",
".",
"NDArrayIter",
"(",
"to4d",
"(",
"train_img",
")",
",",
"train_lbl",
",",
"args",
".",
"batch_size",
",",
"shuffle",
"=",
"True",
")",
"val",
"=",
"mx",
".",
"io",
".",
"NDArrayIter",
"(",
"to4d",
"(",
"val_img",
")",
",",
"val_lbl",
",",
"args",
".",
"batch_size",
")",
"return",
"(",
"train",
",",
"val",
")"
] | create data iterator with NDArrayIter | [
"create",
"data",
"iterator",
"with",
"NDArrayIter"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/image-classification/train_mnist.py#L51-L63 |
23,801 | apache/incubator-mxnet | example/fcn-xs/image_segmentaion.py | main | def main():
"""Module main execution"""
# Initialization variables - update to change your model and execution context
model_prefix = "FCN8s_VGG16"
epoch = 19
# By default, MXNet will run on the CPU. Change to ctx = mx.gpu() to run on GPU.
ctx = mx.cpu()
fcnxs, fcnxs_args, fcnxs_auxs = mx.model.load_checkpoint(model_prefix, epoch)
fcnxs_args["data"] = mx.nd.array(get_data(args.input), ctx)
data_shape = fcnxs_args["data"].shape
label_shape = (1, data_shape[2]*data_shape[3])
fcnxs_args["softmax_label"] = mx.nd.empty(label_shape, ctx)
exector = fcnxs.bind(ctx, fcnxs_args, args_grad=None, grad_req="null", aux_states=fcnxs_args)
exector.forward(is_train=False)
output = exector.outputs[0]
out_img = np.uint8(np.squeeze(output.asnumpy().argmax(axis=1)))
out_img = Image.fromarray(out_img)
out_img.putpalette(get_palette())
out_img.save(args.output) | python | def main():
"""Module main execution"""
# Initialization variables - update to change your model and execution context
model_prefix = "FCN8s_VGG16"
epoch = 19
# By default, MXNet will run on the CPU. Change to ctx = mx.gpu() to run on GPU.
ctx = mx.cpu()
fcnxs, fcnxs_args, fcnxs_auxs = mx.model.load_checkpoint(model_prefix, epoch)
fcnxs_args["data"] = mx.nd.array(get_data(args.input), ctx)
data_shape = fcnxs_args["data"].shape
label_shape = (1, data_shape[2]*data_shape[3])
fcnxs_args["softmax_label"] = mx.nd.empty(label_shape, ctx)
exector = fcnxs.bind(ctx, fcnxs_args, args_grad=None, grad_req="null", aux_states=fcnxs_args)
exector.forward(is_train=False)
output = exector.outputs[0]
out_img = np.uint8(np.squeeze(output.asnumpy().argmax(axis=1)))
out_img = Image.fromarray(out_img)
out_img.putpalette(get_palette())
out_img.save(args.output) | [
"def",
"main",
"(",
")",
":",
"# Initialization variables - update to change your model and execution context",
"model_prefix",
"=",
"\"FCN8s_VGG16\"",
"epoch",
"=",
"19",
"# By default, MXNet will run on the CPU. Change to ctx = mx.gpu() to run on GPU.",
"ctx",
"=",
"mx",
".",
"cpu",
"(",
")",
"fcnxs",
",",
"fcnxs_args",
",",
"fcnxs_auxs",
"=",
"mx",
".",
"model",
".",
"load_checkpoint",
"(",
"model_prefix",
",",
"epoch",
")",
"fcnxs_args",
"[",
"\"data\"",
"]",
"=",
"mx",
".",
"nd",
".",
"array",
"(",
"get_data",
"(",
"args",
".",
"input",
")",
",",
"ctx",
")",
"data_shape",
"=",
"fcnxs_args",
"[",
"\"data\"",
"]",
".",
"shape",
"label_shape",
"=",
"(",
"1",
",",
"data_shape",
"[",
"2",
"]",
"*",
"data_shape",
"[",
"3",
"]",
")",
"fcnxs_args",
"[",
"\"softmax_label\"",
"]",
"=",
"mx",
".",
"nd",
".",
"empty",
"(",
"label_shape",
",",
"ctx",
")",
"exector",
"=",
"fcnxs",
".",
"bind",
"(",
"ctx",
",",
"fcnxs_args",
",",
"args_grad",
"=",
"None",
",",
"grad_req",
"=",
"\"null\"",
",",
"aux_states",
"=",
"fcnxs_args",
")",
"exector",
".",
"forward",
"(",
"is_train",
"=",
"False",
")",
"output",
"=",
"exector",
".",
"outputs",
"[",
"0",
"]",
"out_img",
"=",
"np",
".",
"uint8",
"(",
"np",
".",
"squeeze",
"(",
"output",
".",
"asnumpy",
"(",
")",
".",
"argmax",
"(",
"axis",
"=",
"1",
")",
")",
")",
"out_img",
"=",
"Image",
".",
"fromarray",
"(",
"out_img",
")",
"out_img",
".",
"putpalette",
"(",
"get_palette",
"(",
")",
")",
"out_img",
".",
"save",
"(",
"args",
".",
"output",
")"
] | Module main execution | [
"Module",
"main",
"execution"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/fcn-xs/image_segmentaion.py#L90-L110 |
23,802 | apache/incubator-mxnet | example/ssd/dataset/concat_db.py | ConcatDB._check_classes | def _check_classes(self):
"""
check input imdbs, make sure they have same classes
"""
try:
self.classes = self.imdbs[0].classes
self.num_classes = len(self.classes)
except AttributeError:
# fine, if no classes is provided
pass
if self.num_classes > 0:
for db in self.imdbs:
assert self.classes == db.classes, "Multiple imdb must have same classes" | python | def _check_classes(self):
"""
check input imdbs, make sure they have same classes
"""
try:
self.classes = self.imdbs[0].classes
self.num_classes = len(self.classes)
except AttributeError:
# fine, if no classes is provided
pass
if self.num_classes > 0:
for db in self.imdbs:
assert self.classes == db.classes, "Multiple imdb must have same classes" | [
"def",
"_check_classes",
"(",
"self",
")",
":",
"try",
":",
"self",
".",
"classes",
"=",
"self",
".",
"imdbs",
"[",
"0",
"]",
".",
"classes",
"self",
".",
"num_classes",
"=",
"len",
"(",
"self",
".",
"classes",
")",
"except",
"AttributeError",
":",
"# fine, if no classes is provided",
"pass",
"if",
"self",
".",
"num_classes",
">",
"0",
":",
"for",
"db",
"in",
"self",
".",
"imdbs",
":",
"assert",
"self",
".",
"classes",
"==",
"db",
".",
"classes",
",",
"\"Multiple imdb must have same classes\""
] | check input imdbs, make sure they have same classes | [
"check",
"input",
"imdbs",
"make",
"sure",
"they",
"have",
"same",
"classes"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/concat_db.py#L40-L53 |
23,803 | apache/incubator-mxnet | example/ssd/dataset/concat_db.py | ConcatDB._load_image_set_index | def _load_image_set_index(self, shuffle):
"""
get total number of images, init indices
Parameters
----------
shuffle : bool
whether to shuffle the initial indices
"""
self.num_images = 0
for db in self.imdbs:
self.num_images += db.num_images
indices = list(range(self.num_images))
if shuffle:
random.shuffle(indices)
return indices | python | def _load_image_set_index(self, shuffle):
"""
get total number of images, init indices
Parameters
----------
shuffle : bool
whether to shuffle the initial indices
"""
self.num_images = 0
for db in self.imdbs:
self.num_images += db.num_images
indices = list(range(self.num_images))
if shuffle:
random.shuffle(indices)
return indices | [
"def",
"_load_image_set_index",
"(",
"self",
",",
"shuffle",
")",
":",
"self",
".",
"num_images",
"=",
"0",
"for",
"db",
"in",
"self",
".",
"imdbs",
":",
"self",
".",
"num_images",
"+=",
"db",
".",
"num_images",
"indices",
"=",
"list",
"(",
"range",
"(",
"self",
".",
"num_images",
")",
")",
"if",
"shuffle",
":",
"random",
".",
"shuffle",
"(",
"indices",
")",
"return",
"indices"
] | get total number of images, init indices
Parameters
----------
shuffle : bool
whether to shuffle the initial indices | [
"get",
"total",
"number",
"of",
"images",
"init",
"indices"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/concat_db.py#L55-L70 |
23,804 | apache/incubator-mxnet | example/ssd/dataset/concat_db.py | ConcatDB._locate_index | def _locate_index(self, index):
"""
given index, find out sub-db and sub-index
Parameters
----------
index : int
index of a specific image
Returns
----------
a tuple (sub-db, sub-index)
"""
assert index >= 0 and index < self.num_images, "index out of range"
pos = self.image_set_index[index]
for k, v in enumerate(self.imdbs):
if pos >= v.num_images:
pos -= v.num_images
else:
return (k, pos) | python | def _locate_index(self, index):
"""
given index, find out sub-db and sub-index
Parameters
----------
index : int
index of a specific image
Returns
----------
a tuple (sub-db, sub-index)
"""
assert index >= 0 and index < self.num_images, "index out of range"
pos = self.image_set_index[index]
for k, v in enumerate(self.imdbs):
if pos >= v.num_images:
pos -= v.num_images
else:
return (k, pos) | [
"def",
"_locate_index",
"(",
"self",
",",
"index",
")",
":",
"assert",
"index",
">=",
"0",
"and",
"index",
"<",
"self",
".",
"num_images",
",",
"\"index out of range\"",
"pos",
"=",
"self",
".",
"image_set_index",
"[",
"index",
"]",
"for",
"k",
",",
"v",
"in",
"enumerate",
"(",
"self",
".",
"imdbs",
")",
":",
"if",
"pos",
">=",
"v",
".",
"num_images",
":",
"pos",
"-=",
"v",
".",
"num_images",
"else",
":",
"return",
"(",
"k",
",",
"pos",
")"
] | given index, find out sub-db and sub-index
Parameters
----------
index : int
index of a specific image
Returns
----------
a tuple (sub-db, sub-index) | [
"given",
"index",
"find",
"out",
"sub",
"-",
"db",
"and",
"sub",
"-",
"index"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/concat_db.py#L72-L91 |
23,805 | apache/incubator-mxnet | python/mxnet/callback.py | module_checkpoint | def module_checkpoint(mod, prefix, period=1, save_optimizer_states=False):
"""Callback to checkpoint Module to prefix every epoch.
Parameters
----------
mod : subclass of BaseModule
The module to checkpoint.
prefix : str
The file prefix for this checkpoint.
period : int
How many epochs to wait before checkpointing. Defaults to 1.
save_optimizer_states : bool
Indicates whether or not to save optimizer states for continued training.
Returns
-------
callback : function
The callback function that can be passed as iter_end_callback to fit.
"""
period = int(max(1, period))
# pylint: disable=unused-argument
def _callback(iter_no, sym=None, arg=None, aux=None):
"""The checkpoint function."""
if (iter_no + 1) % period == 0:
mod.save_checkpoint(prefix, iter_no + 1, save_optimizer_states)
return _callback | python | def module_checkpoint(mod, prefix, period=1, save_optimizer_states=False):
"""Callback to checkpoint Module to prefix every epoch.
Parameters
----------
mod : subclass of BaseModule
The module to checkpoint.
prefix : str
The file prefix for this checkpoint.
period : int
How many epochs to wait before checkpointing. Defaults to 1.
save_optimizer_states : bool
Indicates whether or not to save optimizer states for continued training.
Returns
-------
callback : function
The callback function that can be passed as iter_end_callback to fit.
"""
period = int(max(1, period))
# pylint: disable=unused-argument
def _callback(iter_no, sym=None, arg=None, aux=None):
"""The checkpoint function."""
if (iter_no + 1) % period == 0:
mod.save_checkpoint(prefix, iter_no + 1, save_optimizer_states)
return _callback | [
"def",
"module_checkpoint",
"(",
"mod",
",",
"prefix",
",",
"period",
"=",
"1",
",",
"save_optimizer_states",
"=",
"False",
")",
":",
"period",
"=",
"int",
"(",
"max",
"(",
"1",
",",
"period",
")",
")",
"# pylint: disable=unused-argument",
"def",
"_callback",
"(",
"iter_no",
",",
"sym",
"=",
"None",
",",
"arg",
"=",
"None",
",",
"aux",
"=",
"None",
")",
":",
"\"\"\"The checkpoint function.\"\"\"",
"if",
"(",
"iter_no",
"+",
"1",
")",
"%",
"period",
"==",
"0",
":",
"mod",
".",
"save_checkpoint",
"(",
"prefix",
",",
"iter_no",
"+",
"1",
",",
"save_optimizer_states",
")",
"return",
"_callback"
] | Callback to checkpoint Module to prefix every epoch.
Parameters
----------
mod : subclass of BaseModule
The module to checkpoint.
prefix : str
The file prefix for this checkpoint.
period : int
How many epochs to wait before checkpointing. Defaults to 1.
save_optimizer_states : bool
Indicates whether or not to save optimizer states for continued training.
Returns
-------
callback : function
The callback function that can be passed as iter_end_callback to fit. | [
"Callback",
"to",
"checkpoint",
"Module",
"to",
"prefix",
"every",
"epoch",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/callback.py#L27-L52 |
23,806 | apache/incubator-mxnet | python/mxnet/callback.py | log_train_metric | def log_train_metric(period, auto_reset=False):
"""Callback to log the training evaluation result every period.
Parameters
----------
period : int
The number of batch to log the training evaluation metric.
auto_reset : bool
Reset the metric after each log.
Returns
-------
callback : function
The callback function that can be passed as iter_epoch_callback to fit.
"""
def _callback(param):
"""The checkpoint function."""
if param.nbatch % period == 0 and param.eval_metric is not None:
name_value = param.eval_metric.get_name_value()
for name, value in name_value:
logging.info('Iter[%d] Batch[%d] Train-%s=%f',
param.epoch, param.nbatch, name, value)
if auto_reset:
param.eval_metric.reset_local()
return _callback | python | def log_train_metric(period, auto_reset=False):
"""Callback to log the training evaluation result every period.
Parameters
----------
period : int
The number of batch to log the training evaluation metric.
auto_reset : bool
Reset the metric after each log.
Returns
-------
callback : function
The callback function that can be passed as iter_epoch_callback to fit.
"""
def _callback(param):
"""The checkpoint function."""
if param.nbatch % period == 0 and param.eval_metric is not None:
name_value = param.eval_metric.get_name_value()
for name, value in name_value:
logging.info('Iter[%d] Batch[%d] Train-%s=%f',
param.epoch, param.nbatch, name, value)
if auto_reset:
param.eval_metric.reset_local()
return _callback | [
"def",
"log_train_metric",
"(",
"period",
",",
"auto_reset",
"=",
"False",
")",
":",
"def",
"_callback",
"(",
"param",
")",
":",
"\"\"\"The checkpoint function.\"\"\"",
"if",
"param",
".",
"nbatch",
"%",
"period",
"==",
"0",
"and",
"param",
".",
"eval_metric",
"is",
"not",
"None",
":",
"name_value",
"=",
"param",
".",
"eval_metric",
".",
"get_name_value",
"(",
")",
"for",
"name",
",",
"value",
"in",
"name_value",
":",
"logging",
".",
"info",
"(",
"'Iter[%d] Batch[%d] Train-%s=%f'",
",",
"param",
".",
"epoch",
",",
"param",
".",
"nbatch",
",",
"name",
",",
"value",
")",
"if",
"auto_reset",
":",
"param",
".",
"eval_metric",
".",
"reset_local",
"(",
")",
"return",
"_callback"
] | Callback to log the training evaluation result every period.
Parameters
----------
period : int
The number of batch to log the training evaluation metric.
auto_reset : bool
Reset the metric after each log.
Returns
-------
callback : function
The callback function that can be passed as iter_epoch_callback to fit. | [
"Callback",
"to",
"log",
"the",
"training",
"evaluation",
"result",
"every",
"period",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/callback.py#L93-L117 |
23,807 | apache/incubator-mxnet | python/mxnet/monitor.py | Monitor.install | def install(self, exe):
"""install callback to executor.
Supports installing to multiple exes.
Parameters
----------
exe : mx.executor.Executor
The Executor (returned by symbol.bind) to install to.
"""
exe.set_monitor_callback(self.stat_helper, self.monitor_all)
self.exes.append(exe) | python | def install(self, exe):
"""install callback to executor.
Supports installing to multiple exes.
Parameters
----------
exe : mx.executor.Executor
The Executor (returned by symbol.bind) to install to.
"""
exe.set_monitor_callback(self.stat_helper, self.monitor_all)
self.exes.append(exe) | [
"def",
"install",
"(",
"self",
",",
"exe",
")",
":",
"exe",
".",
"set_monitor_callback",
"(",
"self",
".",
"stat_helper",
",",
"self",
".",
"monitor_all",
")",
"self",
".",
"exes",
".",
"append",
"(",
"exe",
")"
] | install callback to executor.
Supports installing to multiple exes.
Parameters
----------
exe : mx.executor.Executor
The Executor (returned by symbol.bind) to install to. | [
"install",
"callback",
"to",
"executor",
".",
"Supports",
"installing",
"to",
"multiple",
"exes",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/monitor.py#L76-L86 |
23,808 | apache/incubator-mxnet | python/mxnet/monitor.py | Monitor.tic | def tic(self):
"""Start collecting stats for current batch.
Call before calling forward."""
if self.step % self.interval == 0:
for exe in self.exes:
for array in exe.arg_arrays:
array.wait_to_read()
for array in exe.aux_arrays:
array.wait_to_read()
self.queue = []
self.activated = True
self.step += 1 | python | def tic(self):
"""Start collecting stats for current batch.
Call before calling forward."""
if self.step % self.interval == 0:
for exe in self.exes:
for array in exe.arg_arrays:
array.wait_to_read()
for array in exe.aux_arrays:
array.wait_to_read()
self.queue = []
self.activated = True
self.step += 1 | [
"def",
"tic",
"(",
"self",
")",
":",
"if",
"self",
".",
"step",
"%",
"self",
".",
"interval",
"==",
"0",
":",
"for",
"exe",
"in",
"self",
".",
"exes",
":",
"for",
"array",
"in",
"exe",
".",
"arg_arrays",
":",
"array",
".",
"wait_to_read",
"(",
")",
"for",
"array",
"in",
"exe",
".",
"aux_arrays",
":",
"array",
".",
"wait_to_read",
"(",
")",
"self",
".",
"queue",
"=",
"[",
"]",
"self",
".",
"activated",
"=",
"True",
"self",
".",
"step",
"+=",
"1"
] | Start collecting stats for current batch.
Call before calling forward. | [
"Start",
"collecting",
"stats",
"for",
"current",
"batch",
".",
"Call",
"before",
"calling",
"forward",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/monitor.py#L88-L99 |
23,809 | apache/incubator-mxnet | python/mxnet/monitor.py | Monitor.toc | def toc(self):
"""End collecting for current batch and return results.
Call after computation of current batch.
Returns
-------
res : list of """
if not self.activated:
return []
for exe in self.exes:
for array in exe.arg_arrays:
array.wait_to_read()
for array in exe.aux_arrays:
array.wait_to_read()
for exe in self.exes:
for name, array in zip(exe._symbol.list_arguments(), exe.arg_arrays):
if self.re_prog.match(name):
self.queue.append((self.step, name, self.stat_func(array)))
for name, array in zip(exe._symbol.list_auxiliary_states(), exe.aux_arrays):
if self.re_prog.match(name):
self.queue.append((self.step, name, self.stat_func(array)))
self.activated = False
res = []
if self.sort:
self.queue.sort(key=lambda x: x[1])
for n, k, v_list in self.queue:
if isinstance(v_list, NDArray):
v_list = [v_list]
assert isinstance(v_list, list)
s = ''
for v in v_list:
assert isinstance(v, NDArray)
if v.shape == (1,):
s += str(v.asscalar()) + '\t'
else:
s += str(v.asnumpy()) + '\t'
res.append((n, k, s))
self.queue = []
return res | python | def toc(self):
"""End collecting for current batch and return results.
Call after computation of current batch.
Returns
-------
res : list of """
if not self.activated:
return []
for exe in self.exes:
for array in exe.arg_arrays:
array.wait_to_read()
for array in exe.aux_arrays:
array.wait_to_read()
for exe in self.exes:
for name, array in zip(exe._symbol.list_arguments(), exe.arg_arrays):
if self.re_prog.match(name):
self.queue.append((self.step, name, self.stat_func(array)))
for name, array in zip(exe._symbol.list_auxiliary_states(), exe.aux_arrays):
if self.re_prog.match(name):
self.queue.append((self.step, name, self.stat_func(array)))
self.activated = False
res = []
if self.sort:
self.queue.sort(key=lambda x: x[1])
for n, k, v_list in self.queue:
if isinstance(v_list, NDArray):
v_list = [v_list]
assert isinstance(v_list, list)
s = ''
for v in v_list:
assert isinstance(v, NDArray)
if v.shape == (1,):
s += str(v.asscalar()) + '\t'
else:
s += str(v.asnumpy()) + '\t'
res.append((n, k, s))
self.queue = []
return res | [
"def",
"toc",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"activated",
":",
"return",
"[",
"]",
"for",
"exe",
"in",
"self",
".",
"exes",
":",
"for",
"array",
"in",
"exe",
".",
"arg_arrays",
":",
"array",
".",
"wait_to_read",
"(",
")",
"for",
"array",
"in",
"exe",
".",
"aux_arrays",
":",
"array",
".",
"wait_to_read",
"(",
")",
"for",
"exe",
"in",
"self",
".",
"exes",
":",
"for",
"name",
",",
"array",
"in",
"zip",
"(",
"exe",
".",
"_symbol",
".",
"list_arguments",
"(",
")",
",",
"exe",
".",
"arg_arrays",
")",
":",
"if",
"self",
".",
"re_prog",
".",
"match",
"(",
"name",
")",
":",
"self",
".",
"queue",
".",
"append",
"(",
"(",
"self",
".",
"step",
",",
"name",
",",
"self",
".",
"stat_func",
"(",
"array",
")",
")",
")",
"for",
"name",
",",
"array",
"in",
"zip",
"(",
"exe",
".",
"_symbol",
".",
"list_auxiliary_states",
"(",
")",
",",
"exe",
".",
"aux_arrays",
")",
":",
"if",
"self",
".",
"re_prog",
".",
"match",
"(",
"name",
")",
":",
"self",
".",
"queue",
".",
"append",
"(",
"(",
"self",
".",
"step",
",",
"name",
",",
"self",
".",
"stat_func",
"(",
"array",
")",
")",
")",
"self",
".",
"activated",
"=",
"False",
"res",
"=",
"[",
"]",
"if",
"self",
".",
"sort",
":",
"self",
".",
"queue",
".",
"sort",
"(",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"1",
"]",
")",
"for",
"n",
",",
"k",
",",
"v_list",
"in",
"self",
".",
"queue",
":",
"if",
"isinstance",
"(",
"v_list",
",",
"NDArray",
")",
":",
"v_list",
"=",
"[",
"v_list",
"]",
"assert",
"isinstance",
"(",
"v_list",
",",
"list",
")",
"s",
"=",
"''",
"for",
"v",
"in",
"v_list",
":",
"assert",
"isinstance",
"(",
"v",
",",
"NDArray",
")",
"if",
"v",
".",
"shape",
"==",
"(",
"1",
",",
")",
":",
"s",
"+=",
"str",
"(",
"v",
".",
"asscalar",
"(",
")",
")",
"+",
"'\\t'",
"else",
":",
"s",
"+=",
"str",
"(",
"v",
".",
"asnumpy",
"(",
")",
")",
"+",
"'\\t'",
"res",
".",
"append",
"(",
"(",
"n",
",",
"k",
",",
"s",
")",
")",
"self",
".",
"queue",
"=",
"[",
"]",
"return",
"res"
] | End collecting for current batch and return results.
Call after computation of current batch.
Returns
-------
res : list of | [
"End",
"collecting",
"for",
"current",
"batch",
"and",
"return",
"results",
".",
"Call",
"after",
"computation",
"of",
"current",
"batch",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/monitor.py#L102-L140 |
23,810 | apache/incubator-mxnet | python/mxnet/monitor.py | Monitor.toc_print | def toc_print(self):
"""End collecting and print results."""
res = self.toc()
for n, k, v in res:
logging.info('Batch: {:7d} {:30s} {:s}'.format(n, k, v)) | python | def toc_print(self):
"""End collecting and print results."""
res = self.toc()
for n, k, v in res:
logging.info('Batch: {:7d} {:30s} {:s}'.format(n, k, v)) | [
"def",
"toc_print",
"(",
"self",
")",
":",
"res",
"=",
"self",
".",
"toc",
"(",
")",
"for",
"n",
",",
"k",
",",
"v",
"in",
"res",
":",
"logging",
".",
"info",
"(",
"'Batch: {:7d} {:30s} {:s}'",
".",
"format",
"(",
"n",
",",
"k",
",",
"v",
")",
")"
] | End collecting and print results. | [
"End",
"collecting",
"and",
"print",
"results",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/monitor.py#L142-L146 |
23,811 | apache/incubator-mxnet | example/rnn/old/bucket_io.py | BucketSentenceIter.make_data_iter_plan | def make_data_iter_plan(self):
"make a random data iteration plan"
# truncate each bucket into multiple of batch-size
bucket_n_batches = []
for i in range(len(self.data)):
bucket_n_batches.append(np.floor((self.data[i]) / self.batch_size))
self.data[i] = self.data[i][:int(bucket_n_batches[i]*self.batch_size)]
bucket_plan = np.hstack([np.zeros(n, int)+i for i, n in enumerate(bucket_n_batches)])
np.random.shuffle(bucket_plan)
bucket_idx_all = [np.random.permutation(len(x)) for x in self.data]
self.bucket_plan = bucket_plan
self.bucket_idx_all = bucket_idx_all
self.bucket_curr_idx = [0 for x in self.data]
self.data_buffer = []
self.label_buffer = []
for i_bucket in range(len(self.data)):
if not self.model_parallel:
data = np.zeros((self.batch_size, self.buckets[i_bucket]))
label = np.zeros((self.batch_size, self.buckets[i_bucket]))
self.data_buffer.append(data)
self.label_buffer.append(label)
else:
data = np.zeros((self.buckets[i_bucket], self.batch_size))
self.data_buffer.append(data)
if self.model_parallel:
# Transpose data if model parallel
for i in range(len(self.data)):
bucket_data = self.data[i]
self.data[i] = np.transpose(bucket_data) | python | def make_data_iter_plan(self):
"make a random data iteration plan"
# truncate each bucket into multiple of batch-size
bucket_n_batches = []
for i in range(len(self.data)):
bucket_n_batches.append(np.floor((self.data[i]) / self.batch_size))
self.data[i] = self.data[i][:int(bucket_n_batches[i]*self.batch_size)]
bucket_plan = np.hstack([np.zeros(n, int)+i for i, n in enumerate(bucket_n_batches)])
np.random.shuffle(bucket_plan)
bucket_idx_all = [np.random.permutation(len(x)) for x in self.data]
self.bucket_plan = bucket_plan
self.bucket_idx_all = bucket_idx_all
self.bucket_curr_idx = [0 for x in self.data]
self.data_buffer = []
self.label_buffer = []
for i_bucket in range(len(self.data)):
if not self.model_parallel:
data = np.zeros((self.batch_size, self.buckets[i_bucket]))
label = np.zeros((self.batch_size, self.buckets[i_bucket]))
self.data_buffer.append(data)
self.label_buffer.append(label)
else:
data = np.zeros((self.buckets[i_bucket], self.batch_size))
self.data_buffer.append(data)
if self.model_parallel:
# Transpose data if model parallel
for i in range(len(self.data)):
bucket_data = self.data[i]
self.data[i] = np.transpose(bucket_data) | [
"def",
"make_data_iter_plan",
"(",
"self",
")",
":",
"# truncate each bucket into multiple of batch-size",
"bucket_n_batches",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"data",
")",
")",
":",
"bucket_n_batches",
".",
"append",
"(",
"np",
".",
"floor",
"(",
"(",
"self",
".",
"data",
"[",
"i",
"]",
")",
"/",
"self",
".",
"batch_size",
")",
")",
"self",
".",
"data",
"[",
"i",
"]",
"=",
"self",
".",
"data",
"[",
"i",
"]",
"[",
":",
"int",
"(",
"bucket_n_batches",
"[",
"i",
"]",
"*",
"self",
".",
"batch_size",
")",
"]",
"bucket_plan",
"=",
"np",
".",
"hstack",
"(",
"[",
"np",
".",
"zeros",
"(",
"n",
",",
"int",
")",
"+",
"i",
"for",
"i",
",",
"n",
"in",
"enumerate",
"(",
"bucket_n_batches",
")",
"]",
")",
"np",
".",
"random",
".",
"shuffle",
"(",
"bucket_plan",
")",
"bucket_idx_all",
"=",
"[",
"np",
".",
"random",
".",
"permutation",
"(",
"len",
"(",
"x",
")",
")",
"for",
"x",
"in",
"self",
".",
"data",
"]",
"self",
".",
"bucket_plan",
"=",
"bucket_plan",
"self",
".",
"bucket_idx_all",
"=",
"bucket_idx_all",
"self",
".",
"bucket_curr_idx",
"=",
"[",
"0",
"for",
"x",
"in",
"self",
".",
"data",
"]",
"self",
".",
"data_buffer",
"=",
"[",
"]",
"self",
".",
"label_buffer",
"=",
"[",
"]",
"for",
"i_bucket",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"data",
")",
")",
":",
"if",
"not",
"self",
".",
"model_parallel",
":",
"data",
"=",
"np",
".",
"zeros",
"(",
"(",
"self",
".",
"batch_size",
",",
"self",
".",
"buckets",
"[",
"i_bucket",
"]",
")",
")",
"label",
"=",
"np",
".",
"zeros",
"(",
"(",
"self",
".",
"batch_size",
",",
"self",
".",
"buckets",
"[",
"i_bucket",
"]",
")",
")",
"self",
".",
"data_buffer",
".",
"append",
"(",
"data",
")",
"self",
".",
"label_buffer",
".",
"append",
"(",
"label",
")",
"else",
":",
"data",
"=",
"np",
".",
"zeros",
"(",
"(",
"self",
".",
"buckets",
"[",
"i_bucket",
"]",
",",
"self",
".",
"batch_size",
")",
")",
"self",
".",
"data_buffer",
".",
"append",
"(",
"data",
")",
"if",
"self",
".",
"model_parallel",
":",
"# Transpose data if model parallel",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"data",
")",
")",
":",
"bucket_data",
"=",
"self",
".",
"data",
"[",
"i",
"]",
"self",
".",
"data",
"[",
"i",
"]",
"=",
"np",
".",
"transpose",
"(",
"bucket_data",
")"
] | make a random data iteration plan | [
"make",
"a",
"random",
"data",
"iteration",
"plan"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/old/bucket_io.py#L200-L233 |
23,812 | apache/incubator-mxnet | amalgamation/amalgamation.py | expand | def expand(x, pending, stage):
"""
Expand the pending files in the current stage.
Parameters
----------
x: str
The file to expand.
pending : str
The list of pending files to expand.
stage: str
The current stage for file expansion, used for matching the prefix of files.
"""
if x in history and x not in ['mshadow/mshadow/expr_scalar-inl.h']: # MULTIPLE includes
return
if x in pending:
#print('loop found: {} in {}'.format(x, pending))
return
whtspace = ' ' * expand.treeDepth
expand.fileCount += 1
comment = u"//=====[{:3d}] STAGE:{:>4} {}EXPANDING: {} =====\n\n".format(expand.fileCount, stage, whtspace, x)
out.write(comment.encode('ascii'))
print(comment)
with open(x, 'rb') as x_h:
for line in x_h.readlines():
uline = line.decode('utf-8')
if '#define DMLC_LOG_STACK_TRACE 1' in uline.strip():
# Do not enable stacktrace logging
continue
if uline.find('#include') < 0:
out.write(line)
continue
if uline.strip().find('#include') > 0:
print(uline)
continue
m = re1.search(uline)
if not m:
m = re2.search(uline)
if m:
path = m.groups()[0]
else:
m = re3.search(uline)
if m:
path = 'execinfo.h'
else:
print(uline + ' not found')
continue
h = path.strip('./') if "../3rdparty/" not in path else path
if h.endswith('complex.h') and x.endswith('openblas_config.h'):
source = ''
elif h.startswith('ps/'):
source = '../3rdparty/ps-lite/include/' + h
else:
source = find_source(h, x, stage)
if not source:
if (h not in blacklist and
h not in sysheaders and
'mkl' not in h and
'nnpack' not in h and
'tensorrt' not in h and
not h.endswith('.cuh')): sysheaders.append(h)
else:
expand.treeDepth += 1
expand(source, pending + [x], stage)
expand.treeDepth -= 1
out.write(u"//===== EXPANDED : {} =====\n\n".format(x).encode('ascii'))
history.add(x) | python | def expand(x, pending, stage):
"""
Expand the pending files in the current stage.
Parameters
----------
x: str
The file to expand.
pending : str
The list of pending files to expand.
stage: str
The current stage for file expansion, used for matching the prefix of files.
"""
if x in history and x not in ['mshadow/mshadow/expr_scalar-inl.h']: # MULTIPLE includes
return
if x in pending:
#print('loop found: {} in {}'.format(x, pending))
return
whtspace = ' ' * expand.treeDepth
expand.fileCount += 1
comment = u"//=====[{:3d}] STAGE:{:>4} {}EXPANDING: {} =====\n\n".format(expand.fileCount, stage, whtspace, x)
out.write(comment.encode('ascii'))
print(comment)
with open(x, 'rb') as x_h:
for line in x_h.readlines():
uline = line.decode('utf-8')
if '#define DMLC_LOG_STACK_TRACE 1' in uline.strip():
# Do not enable stacktrace logging
continue
if uline.find('#include') < 0:
out.write(line)
continue
if uline.strip().find('#include') > 0:
print(uline)
continue
m = re1.search(uline)
if not m:
m = re2.search(uline)
if m:
path = m.groups()[0]
else:
m = re3.search(uline)
if m:
path = 'execinfo.h'
else:
print(uline + ' not found')
continue
h = path.strip('./') if "../3rdparty/" not in path else path
if h.endswith('complex.h') and x.endswith('openblas_config.h'):
source = ''
elif h.startswith('ps/'):
source = '../3rdparty/ps-lite/include/' + h
else:
source = find_source(h, x, stage)
if not source:
if (h not in blacklist and
h not in sysheaders and
'mkl' not in h and
'nnpack' not in h and
'tensorrt' not in h and
not h.endswith('.cuh')): sysheaders.append(h)
else:
expand.treeDepth += 1
expand(source, pending + [x], stage)
expand.treeDepth -= 1
out.write(u"//===== EXPANDED : {} =====\n\n".format(x).encode('ascii'))
history.add(x) | [
"def",
"expand",
"(",
"x",
",",
"pending",
",",
"stage",
")",
":",
"if",
"x",
"in",
"history",
"and",
"x",
"not",
"in",
"[",
"'mshadow/mshadow/expr_scalar-inl.h'",
"]",
":",
"# MULTIPLE includes",
"return",
"if",
"x",
"in",
"pending",
":",
"#print('loop found: {} in {}'.format(x, pending))",
"return",
"whtspace",
"=",
"' '",
"*",
"expand",
".",
"treeDepth",
"expand",
".",
"fileCount",
"+=",
"1",
"comment",
"=",
"u\"//=====[{:3d}] STAGE:{:>4} {}EXPANDING: {} =====\\n\\n\"",
".",
"format",
"(",
"expand",
".",
"fileCount",
",",
"stage",
",",
"whtspace",
",",
"x",
")",
"out",
".",
"write",
"(",
"comment",
".",
"encode",
"(",
"'ascii'",
")",
")",
"print",
"(",
"comment",
")",
"with",
"open",
"(",
"x",
",",
"'rb'",
")",
"as",
"x_h",
":",
"for",
"line",
"in",
"x_h",
".",
"readlines",
"(",
")",
":",
"uline",
"=",
"line",
".",
"decode",
"(",
"'utf-8'",
")",
"if",
"'#define DMLC_LOG_STACK_TRACE 1'",
"in",
"uline",
".",
"strip",
"(",
")",
":",
"# Do not enable stacktrace logging",
"continue",
"if",
"uline",
".",
"find",
"(",
"'#include'",
")",
"<",
"0",
":",
"out",
".",
"write",
"(",
"line",
")",
"continue",
"if",
"uline",
".",
"strip",
"(",
")",
".",
"find",
"(",
"'#include'",
")",
">",
"0",
":",
"print",
"(",
"uline",
")",
"continue",
"m",
"=",
"re1",
".",
"search",
"(",
"uline",
")",
"if",
"not",
"m",
":",
"m",
"=",
"re2",
".",
"search",
"(",
"uline",
")",
"if",
"m",
":",
"path",
"=",
"m",
".",
"groups",
"(",
")",
"[",
"0",
"]",
"else",
":",
"m",
"=",
"re3",
".",
"search",
"(",
"uline",
")",
"if",
"m",
":",
"path",
"=",
"'execinfo.h'",
"else",
":",
"print",
"(",
"uline",
"+",
"' not found'",
")",
"continue",
"h",
"=",
"path",
".",
"strip",
"(",
"'./'",
")",
"if",
"\"../3rdparty/\"",
"not",
"in",
"path",
"else",
"path",
"if",
"h",
".",
"endswith",
"(",
"'complex.h'",
")",
"and",
"x",
".",
"endswith",
"(",
"'openblas_config.h'",
")",
":",
"source",
"=",
"''",
"elif",
"h",
".",
"startswith",
"(",
"'ps/'",
")",
":",
"source",
"=",
"'../3rdparty/ps-lite/include/'",
"+",
"h",
"else",
":",
"source",
"=",
"find_source",
"(",
"h",
",",
"x",
",",
"stage",
")",
"if",
"not",
"source",
":",
"if",
"(",
"h",
"not",
"in",
"blacklist",
"and",
"h",
"not",
"in",
"sysheaders",
"and",
"'mkl'",
"not",
"in",
"h",
"and",
"'nnpack'",
"not",
"in",
"h",
"and",
"'tensorrt'",
"not",
"in",
"h",
"and",
"not",
"h",
".",
"endswith",
"(",
"'.cuh'",
")",
")",
":",
"sysheaders",
".",
"append",
"(",
"h",
")",
"else",
":",
"expand",
".",
"treeDepth",
"+=",
"1",
"expand",
"(",
"source",
",",
"pending",
"+",
"[",
"x",
"]",
",",
"stage",
")",
"expand",
".",
"treeDepth",
"-=",
"1",
"out",
".",
"write",
"(",
"u\"//===== EXPANDED : {} =====\\n\\n\"",
".",
"format",
"(",
"x",
")",
".",
"encode",
"(",
"'ascii'",
")",
")",
"history",
".",
"add",
"(",
"x",
")"
] | Expand the pending files in the current stage.
Parameters
----------
x: str
The file to expand.
pending : str
The list of pending files to expand.
stage: str
The current stage for file expansion, used for matching the prefix of files. | [
"Expand",
"the",
"pending",
"files",
"in",
"the",
"current",
"stage",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/amalgamation.py#L112-L182 |
23,813 | apache/incubator-mxnet | example/gluon/data.py | get_imagenet_iterator | def get_imagenet_iterator(root, batch_size, num_workers, data_shape=224, dtype='float32'):
"""Dataset loader with preprocessing."""
train_dir = os.path.join(root, 'train')
train_transform, val_transform = get_imagenet_transforms(data_shape, dtype)
logging.info("Loading image folder %s, this may take a bit long...", train_dir)
train_dataset = ImageFolderDataset(train_dir, transform=train_transform)
train_data = DataLoader(train_dataset, batch_size, shuffle=True,
last_batch='discard', num_workers=num_workers)
val_dir = os.path.join(root, 'val')
if not os.path.isdir(os.path.expanduser(os.path.join(root, 'val', 'n01440764'))):
user_warning = 'Make sure validation images are stored in one subdir per category, a helper script is available at https://git.io/vNQv1'
raise ValueError(user_warning)
logging.info("Loading image folder %s, this may take a bit long...", val_dir)
val_dataset = ImageFolderDataset(val_dir, transform=val_transform)
val_data = DataLoader(val_dataset, batch_size, last_batch='keep', num_workers=num_workers)
return DataLoaderIter(train_data, dtype), DataLoaderIter(val_data, dtype) | python | def get_imagenet_iterator(root, batch_size, num_workers, data_shape=224, dtype='float32'):
"""Dataset loader with preprocessing."""
train_dir = os.path.join(root, 'train')
train_transform, val_transform = get_imagenet_transforms(data_shape, dtype)
logging.info("Loading image folder %s, this may take a bit long...", train_dir)
train_dataset = ImageFolderDataset(train_dir, transform=train_transform)
train_data = DataLoader(train_dataset, batch_size, shuffle=True,
last_batch='discard', num_workers=num_workers)
val_dir = os.path.join(root, 'val')
if not os.path.isdir(os.path.expanduser(os.path.join(root, 'val', 'n01440764'))):
user_warning = 'Make sure validation images are stored in one subdir per category, a helper script is available at https://git.io/vNQv1'
raise ValueError(user_warning)
logging.info("Loading image folder %s, this may take a bit long...", val_dir)
val_dataset = ImageFolderDataset(val_dir, transform=val_transform)
val_data = DataLoader(val_dataset, batch_size, last_batch='keep', num_workers=num_workers)
return DataLoaderIter(train_data, dtype), DataLoaderIter(val_data, dtype) | [
"def",
"get_imagenet_iterator",
"(",
"root",
",",
"batch_size",
",",
"num_workers",
",",
"data_shape",
"=",
"224",
",",
"dtype",
"=",
"'float32'",
")",
":",
"train_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"root",
",",
"'train'",
")",
"train_transform",
",",
"val_transform",
"=",
"get_imagenet_transforms",
"(",
"data_shape",
",",
"dtype",
")",
"logging",
".",
"info",
"(",
"\"Loading image folder %s, this may take a bit long...\"",
",",
"train_dir",
")",
"train_dataset",
"=",
"ImageFolderDataset",
"(",
"train_dir",
",",
"transform",
"=",
"train_transform",
")",
"train_data",
"=",
"DataLoader",
"(",
"train_dataset",
",",
"batch_size",
",",
"shuffle",
"=",
"True",
",",
"last_batch",
"=",
"'discard'",
",",
"num_workers",
"=",
"num_workers",
")",
"val_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"root",
",",
"'val'",
")",
"if",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"os",
".",
"path",
".",
"join",
"(",
"root",
",",
"'val'",
",",
"'n01440764'",
")",
")",
")",
":",
"user_warning",
"=",
"'Make sure validation images are stored in one subdir per category, a helper script is available at https://git.io/vNQv1'",
"raise",
"ValueError",
"(",
"user_warning",
")",
"logging",
".",
"info",
"(",
"\"Loading image folder %s, this may take a bit long...\"",
",",
"val_dir",
")",
"val_dataset",
"=",
"ImageFolderDataset",
"(",
"val_dir",
",",
"transform",
"=",
"val_transform",
")",
"val_data",
"=",
"DataLoader",
"(",
"val_dataset",
",",
"batch_size",
",",
"last_batch",
"=",
"'keep'",
",",
"num_workers",
"=",
"num_workers",
")",
"return",
"DataLoaderIter",
"(",
"train_data",
",",
"dtype",
")",
",",
"DataLoaderIter",
"(",
"val_data",
",",
"dtype",
")"
] | Dataset loader with preprocessing. | [
"Dataset",
"loader",
"with",
"preprocessing",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/data.py#L76-L91 |
23,814 | apache/incubator-mxnet | python/mxnet/contrib/text/embedding.py | _TokenEmbedding._load_embedding | def _load_embedding(self, pretrained_file_path, elem_delim, init_unknown_vec, encoding='utf8'):
"""Load embedding vectors from the pre-trained token embedding file.
For every unknown token, if its representation `self.unknown_token` is encountered in the
pre-trained token embedding file, index 0 of `self.idx_to_vec` maps to the pre-trained token
embedding vector loaded from the file; otherwise, index 0 of `self.idx_to_vec` maps to the
text embedding vector initialized by `init_unknown_vec`.
If a token is encountered multiple times in the pre-trained text embedding file, only the
first-encountered token embedding vector will be loaded and the rest will be skipped.
"""
pretrained_file_path = os.path.expanduser(pretrained_file_path)
if not os.path.isfile(pretrained_file_path):
raise ValueError('`pretrained_file_path` must be a valid path to '
'the pre-trained token embedding file.')
logging.info('Loading pre-trained token embedding vectors from %s', pretrained_file_path)
vec_len = None
all_elems = []
tokens = set()
loaded_unknown_vec = None
line_num = 0
with io.open(pretrained_file_path, 'r', encoding=encoding) as f:
for line in f:
line_num += 1
elems = line.rstrip().split(elem_delim)
assert len(elems) > 1, 'At line %d of the pre-trained text embedding file: the ' \
'data format of the pre-trained token embedding file %s ' \
'is unexpected.' % (line_num, pretrained_file_path)
token, elems = elems[0], [float(i) for i in elems[1:]]
if token == self.unknown_token and loaded_unknown_vec is None:
loaded_unknown_vec = elems
tokens.add(self.unknown_token)
elif token in tokens:
warnings.warn('At line %d of the pre-trained token embedding file: the '
'embedding vector for token %s has been loaded and a duplicate '
'embedding for the same token is seen and skipped.' %
(line_num, token))
elif len(elems) == 1:
warnings.warn('At line %d of the pre-trained text embedding file: token %s '
'with 1-dimensional vector %s is likely a header and is '
'skipped.' % (line_num, token, elems))
else:
if vec_len is None:
vec_len = len(elems)
# Reserve a vector slot for the unknown token at the very beggining because
# the unknown index is 0.
all_elems.extend([0] * vec_len)
else:
assert len(elems) == vec_len, \
'At line %d of the pre-trained token embedding file: the dimension ' \
'of token %s is %d but the dimension of previous tokens is %d. ' \
'Dimensions of all the tokens must be the same.' \
% (line_num, token, len(elems), vec_len)
all_elems.extend(elems)
self._idx_to_token.append(token)
self._token_to_idx[token] = len(self._idx_to_token) - 1
tokens.add(token)
self._vec_len = vec_len
self._idx_to_vec = nd.array(all_elems).reshape((-1, self.vec_len))
if loaded_unknown_vec is None:
self._idx_to_vec[C.UNKNOWN_IDX] = init_unknown_vec(shape=self.vec_len)
else:
self._idx_to_vec[C.UNKNOWN_IDX] = nd.array(loaded_unknown_vec) | python | def _load_embedding(self, pretrained_file_path, elem_delim, init_unknown_vec, encoding='utf8'):
"""Load embedding vectors from the pre-trained token embedding file.
For every unknown token, if its representation `self.unknown_token` is encountered in the
pre-trained token embedding file, index 0 of `self.idx_to_vec` maps to the pre-trained token
embedding vector loaded from the file; otherwise, index 0 of `self.idx_to_vec` maps to the
text embedding vector initialized by `init_unknown_vec`.
If a token is encountered multiple times in the pre-trained text embedding file, only the
first-encountered token embedding vector will be loaded and the rest will be skipped.
"""
pretrained_file_path = os.path.expanduser(pretrained_file_path)
if not os.path.isfile(pretrained_file_path):
raise ValueError('`pretrained_file_path` must be a valid path to '
'the pre-trained token embedding file.')
logging.info('Loading pre-trained token embedding vectors from %s', pretrained_file_path)
vec_len = None
all_elems = []
tokens = set()
loaded_unknown_vec = None
line_num = 0
with io.open(pretrained_file_path, 'r', encoding=encoding) as f:
for line in f:
line_num += 1
elems = line.rstrip().split(elem_delim)
assert len(elems) > 1, 'At line %d of the pre-trained text embedding file: the ' \
'data format of the pre-trained token embedding file %s ' \
'is unexpected.' % (line_num, pretrained_file_path)
token, elems = elems[0], [float(i) for i in elems[1:]]
if token == self.unknown_token and loaded_unknown_vec is None:
loaded_unknown_vec = elems
tokens.add(self.unknown_token)
elif token in tokens:
warnings.warn('At line %d of the pre-trained token embedding file: the '
'embedding vector for token %s has been loaded and a duplicate '
'embedding for the same token is seen and skipped.' %
(line_num, token))
elif len(elems) == 1:
warnings.warn('At line %d of the pre-trained text embedding file: token %s '
'with 1-dimensional vector %s is likely a header and is '
'skipped.' % (line_num, token, elems))
else:
if vec_len is None:
vec_len = len(elems)
# Reserve a vector slot for the unknown token at the very beggining because
# the unknown index is 0.
all_elems.extend([0] * vec_len)
else:
assert len(elems) == vec_len, \
'At line %d of the pre-trained token embedding file: the dimension ' \
'of token %s is %d but the dimension of previous tokens is %d. ' \
'Dimensions of all the tokens must be the same.' \
% (line_num, token, len(elems), vec_len)
all_elems.extend(elems)
self._idx_to_token.append(token)
self._token_to_idx[token] = len(self._idx_to_token) - 1
tokens.add(token)
self._vec_len = vec_len
self._idx_to_vec = nd.array(all_elems).reshape((-1, self.vec_len))
if loaded_unknown_vec is None:
self._idx_to_vec[C.UNKNOWN_IDX] = init_unknown_vec(shape=self.vec_len)
else:
self._idx_to_vec[C.UNKNOWN_IDX] = nd.array(loaded_unknown_vec) | [
"def",
"_load_embedding",
"(",
"self",
",",
"pretrained_file_path",
",",
"elem_delim",
",",
"init_unknown_vec",
",",
"encoding",
"=",
"'utf8'",
")",
":",
"pretrained_file_path",
"=",
"os",
".",
"path",
".",
"expanduser",
"(",
"pretrained_file_path",
")",
"if",
"not",
"os",
".",
"path",
".",
"isfile",
"(",
"pretrained_file_path",
")",
":",
"raise",
"ValueError",
"(",
"'`pretrained_file_path` must be a valid path to '",
"'the pre-trained token embedding file.'",
")",
"logging",
".",
"info",
"(",
"'Loading pre-trained token embedding vectors from %s'",
",",
"pretrained_file_path",
")",
"vec_len",
"=",
"None",
"all_elems",
"=",
"[",
"]",
"tokens",
"=",
"set",
"(",
")",
"loaded_unknown_vec",
"=",
"None",
"line_num",
"=",
"0",
"with",
"io",
".",
"open",
"(",
"pretrained_file_path",
",",
"'r'",
",",
"encoding",
"=",
"encoding",
")",
"as",
"f",
":",
"for",
"line",
"in",
"f",
":",
"line_num",
"+=",
"1",
"elems",
"=",
"line",
".",
"rstrip",
"(",
")",
".",
"split",
"(",
"elem_delim",
")",
"assert",
"len",
"(",
"elems",
")",
">",
"1",
",",
"'At line %d of the pre-trained text embedding file: the '",
"'data format of the pre-trained token embedding file %s '",
"'is unexpected.'",
"%",
"(",
"line_num",
",",
"pretrained_file_path",
")",
"token",
",",
"elems",
"=",
"elems",
"[",
"0",
"]",
",",
"[",
"float",
"(",
"i",
")",
"for",
"i",
"in",
"elems",
"[",
"1",
":",
"]",
"]",
"if",
"token",
"==",
"self",
".",
"unknown_token",
"and",
"loaded_unknown_vec",
"is",
"None",
":",
"loaded_unknown_vec",
"=",
"elems",
"tokens",
".",
"add",
"(",
"self",
".",
"unknown_token",
")",
"elif",
"token",
"in",
"tokens",
":",
"warnings",
".",
"warn",
"(",
"'At line %d of the pre-trained token embedding file: the '",
"'embedding vector for token %s has been loaded and a duplicate '",
"'embedding for the same token is seen and skipped.'",
"%",
"(",
"line_num",
",",
"token",
")",
")",
"elif",
"len",
"(",
"elems",
")",
"==",
"1",
":",
"warnings",
".",
"warn",
"(",
"'At line %d of the pre-trained text embedding file: token %s '",
"'with 1-dimensional vector %s is likely a header and is '",
"'skipped.'",
"%",
"(",
"line_num",
",",
"token",
",",
"elems",
")",
")",
"else",
":",
"if",
"vec_len",
"is",
"None",
":",
"vec_len",
"=",
"len",
"(",
"elems",
")",
"# Reserve a vector slot for the unknown token at the very beggining because",
"# the unknown index is 0.",
"all_elems",
".",
"extend",
"(",
"[",
"0",
"]",
"*",
"vec_len",
")",
"else",
":",
"assert",
"len",
"(",
"elems",
")",
"==",
"vec_len",
",",
"'At line %d of the pre-trained token embedding file: the dimension '",
"'of token %s is %d but the dimension of previous tokens is %d. '",
"'Dimensions of all the tokens must be the same.'",
"%",
"(",
"line_num",
",",
"token",
",",
"len",
"(",
"elems",
")",
",",
"vec_len",
")",
"all_elems",
".",
"extend",
"(",
"elems",
")",
"self",
".",
"_idx_to_token",
".",
"append",
"(",
"token",
")",
"self",
".",
"_token_to_idx",
"[",
"token",
"]",
"=",
"len",
"(",
"self",
".",
"_idx_to_token",
")",
"-",
"1",
"tokens",
".",
"add",
"(",
"token",
")",
"self",
".",
"_vec_len",
"=",
"vec_len",
"self",
".",
"_idx_to_vec",
"=",
"nd",
".",
"array",
"(",
"all_elems",
")",
".",
"reshape",
"(",
"(",
"-",
"1",
",",
"self",
".",
"vec_len",
")",
")",
"if",
"loaded_unknown_vec",
"is",
"None",
":",
"self",
".",
"_idx_to_vec",
"[",
"C",
".",
"UNKNOWN_IDX",
"]",
"=",
"init_unknown_vec",
"(",
"shape",
"=",
"self",
".",
"vec_len",
")",
"else",
":",
"self",
".",
"_idx_to_vec",
"[",
"C",
".",
"UNKNOWN_IDX",
"]",
"=",
"nd",
".",
"array",
"(",
"loaded_unknown_vec",
")"
] | Load embedding vectors from the pre-trained token embedding file.
For every unknown token, if its representation `self.unknown_token` is encountered in the
pre-trained token embedding file, index 0 of `self.idx_to_vec` maps to the pre-trained token
embedding vector loaded from the file; otherwise, index 0 of `self.idx_to_vec` maps to the
text embedding vector initialized by `init_unknown_vec`.
If a token is encountered multiple times in the pre-trained text embedding file, only the
first-encountered token embedding vector will be loaded and the rest will be skipped. | [
"Load",
"embedding",
"vectors",
"from",
"the",
"pre",
"-",
"trained",
"token",
"embedding",
"file",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/embedding.py#L232-L303 |
23,815 | apache/incubator-mxnet | python/mxnet/contrib/text/embedding.py | _TokenEmbedding._set_idx_to_vec_by_embeddings | def _set_idx_to_vec_by_embeddings(self, token_embeddings, vocab_len, vocab_idx_to_token):
"""Sets the mapping between token indices and token embedding vectors.
Parameters
----------
token_embeddings : instance or list `mxnet.contrib.text.embedding._TokenEmbedding`
One or multiple pre-trained token embeddings to load. If it is a list of multiple
embeddings, these embedding vectors will be concatenated for each token.
vocab_len : int
Length of vocabulary whose tokens are indexed in the token embedding.
vocab_idx_to_token: list of str
A list of indexed tokens in the vocabulary. These tokens are indexed in the token
embedding.
"""
new_vec_len = sum(embed.vec_len for embed in token_embeddings)
new_idx_to_vec = nd.zeros(shape=(vocab_len, new_vec_len))
col_start = 0
# Concatenate all the embedding vectors in token_embeddings.
for embed in token_embeddings:
col_end = col_start + embed.vec_len
# Cancatenate vectors of the unknown token.
new_idx_to_vec[0, col_start:col_end] = embed.idx_to_vec[0]
new_idx_to_vec[1:, col_start:col_end] = embed.get_vecs_by_tokens(vocab_idx_to_token[1:])
col_start = col_end
self._vec_len = new_vec_len
self._idx_to_vec = new_idx_to_vec | python | def _set_idx_to_vec_by_embeddings(self, token_embeddings, vocab_len, vocab_idx_to_token):
"""Sets the mapping between token indices and token embedding vectors.
Parameters
----------
token_embeddings : instance or list `mxnet.contrib.text.embedding._TokenEmbedding`
One or multiple pre-trained token embeddings to load. If it is a list of multiple
embeddings, these embedding vectors will be concatenated for each token.
vocab_len : int
Length of vocabulary whose tokens are indexed in the token embedding.
vocab_idx_to_token: list of str
A list of indexed tokens in the vocabulary. These tokens are indexed in the token
embedding.
"""
new_vec_len = sum(embed.vec_len for embed in token_embeddings)
new_idx_to_vec = nd.zeros(shape=(vocab_len, new_vec_len))
col_start = 0
# Concatenate all the embedding vectors in token_embeddings.
for embed in token_embeddings:
col_end = col_start + embed.vec_len
# Cancatenate vectors of the unknown token.
new_idx_to_vec[0, col_start:col_end] = embed.idx_to_vec[0]
new_idx_to_vec[1:, col_start:col_end] = embed.get_vecs_by_tokens(vocab_idx_to_token[1:])
col_start = col_end
self._vec_len = new_vec_len
self._idx_to_vec = new_idx_to_vec | [
"def",
"_set_idx_to_vec_by_embeddings",
"(",
"self",
",",
"token_embeddings",
",",
"vocab_len",
",",
"vocab_idx_to_token",
")",
":",
"new_vec_len",
"=",
"sum",
"(",
"embed",
".",
"vec_len",
"for",
"embed",
"in",
"token_embeddings",
")",
"new_idx_to_vec",
"=",
"nd",
".",
"zeros",
"(",
"shape",
"=",
"(",
"vocab_len",
",",
"new_vec_len",
")",
")",
"col_start",
"=",
"0",
"# Concatenate all the embedding vectors in token_embeddings.",
"for",
"embed",
"in",
"token_embeddings",
":",
"col_end",
"=",
"col_start",
"+",
"embed",
".",
"vec_len",
"# Cancatenate vectors of the unknown token.",
"new_idx_to_vec",
"[",
"0",
",",
"col_start",
":",
"col_end",
"]",
"=",
"embed",
".",
"idx_to_vec",
"[",
"0",
"]",
"new_idx_to_vec",
"[",
"1",
":",
",",
"col_start",
":",
"col_end",
"]",
"=",
"embed",
".",
"get_vecs_by_tokens",
"(",
"vocab_idx_to_token",
"[",
"1",
":",
"]",
")",
"col_start",
"=",
"col_end",
"self",
".",
"_vec_len",
"=",
"new_vec_len",
"self",
".",
"_idx_to_vec",
"=",
"new_idx_to_vec"
] | Sets the mapping between token indices and token embedding vectors.
Parameters
----------
token_embeddings : instance or list `mxnet.contrib.text.embedding._TokenEmbedding`
One or multiple pre-trained token embeddings to load. If it is a list of multiple
embeddings, these embedding vectors will be concatenated for each token.
vocab_len : int
Length of vocabulary whose tokens are indexed in the token embedding.
vocab_idx_to_token: list of str
A list of indexed tokens in the vocabulary. These tokens are indexed in the token
embedding. | [
"Sets",
"the",
"mapping",
"between",
"token",
"indices",
"and",
"token",
"embedding",
"vectors",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/embedding.py#L314-L343 |
23,816 | apache/incubator-mxnet | python/mxnet/contrib/text/embedding.py | _TokenEmbedding.get_vecs_by_tokens | def get_vecs_by_tokens(self, tokens, lower_case_backup=False):
"""Look up embedding vectors of tokens.
Parameters
----------
tokens : str or list of strs
A token or a list of tokens.
lower_case_backup : bool, default False
If False, each token in the original case will be looked up; if True, each token in the
original case will be looked up first, if not found in the keys of the property
`token_to_idx`, the token in the lower case will be looked up.
Returns
-------
mxnet.ndarray.NDArray:
The embedding vector(s) of the token(s). According to numpy conventions, if `tokens` is
a string, returns a 1-D NDArray of shape `self.vec_len`; if `tokens` is a list of
strings, returns a 2-D NDArray of shape=(len(tokens), self.vec_len).
"""
to_reduce = False
if not isinstance(tokens, list):
tokens = [tokens]
to_reduce = True
if not lower_case_backup:
indices = [self.token_to_idx.get(token, C.UNKNOWN_IDX) for token in tokens]
else:
indices = [self.token_to_idx[token] if token in self.token_to_idx
else self.token_to_idx.get(token.lower(), C.UNKNOWN_IDX)
for token in tokens]
vecs = nd.Embedding(nd.array(indices), self.idx_to_vec, self.idx_to_vec.shape[0],
self.idx_to_vec.shape[1])
return vecs[0] if to_reduce else vecs | python | def get_vecs_by_tokens(self, tokens, lower_case_backup=False):
"""Look up embedding vectors of tokens.
Parameters
----------
tokens : str or list of strs
A token or a list of tokens.
lower_case_backup : bool, default False
If False, each token in the original case will be looked up; if True, each token in the
original case will be looked up first, if not found in the keys of the property
`token_to_idx`, the token in the lower case will be looked up.
Returns
-------
mxnet.ndarray.NDArray:
The embedding vector(s) of the token(s). According to numpy conventions, if `tokens` is
a string, returns a 1-D NDArray of shape `self.vec_len`; if `tokens` is a list of
strings, returns a 2-D NDArray of shape=(len(tokens), self.vec_len).
"""
to_reduce = False
if not isinstance(tokens, list):
tokens = [tokens]
to_reduce = True
if not lower_case_backup:
indices = [self.token_to_idx.get(token, C.UNKNOWN_IDX) for token in tokens]
else:
indices = [self.token_to_idx[token] if token in self.token_to_idx
else self.token_to_idx.get(token.lower(), C.UNKNOWN_IDX)
for token in tokens]
vecs = nd.Embedding(nd.array(indices), self.idx_to_vec, self.idx_to_vec.shape[0],
self.idx_to_vec.shape[1])
return vecs[0] if to_reduce else vecs | [
"def",
"get_vecs_by_tokens",
"(",
"self",
",",
"tokens",
",",
"lower_case_backup",
"=",
"False",
")",
":",
"to_reduce",
"=",
"False",
"if",
"not",
"isinstance",
"(",
"tokens",
",",
"list",
")",
":",
"tokens",
"=",
"[",
"tokens",
"]",
"to_reduce",
"=",
"True",
"if",
"not",
"lower_case_backup",
":",
"indices",
"=",
"[",
"self",
".",
"token_to_idx",
".",
"get",
"(",
"token",
",",
"C",
".",
"UNKNOWN_IDX",
")",
"for",
"token",
"in",
"tokens",
"]",
"else",
":",
"indices",
"=",
"[",
"self",
".",
"token_to_idx",
"[",
"token",
"]",
"if",
"token",
"in",
"self",
".",
"token_to_idx",
"else",
"self",
".",
"token_to_idx",
".",
"get",
"(",
"token",
".",
"lower",
"(",
")",
",",
"C",
".",
"UNKNOWN_IDX",
")",
"for",
"token",
"in",
"tokens",
"]",
"vecs",
"=",
"nd",
".",
"Embedding",
"(",
"nd",
".",
"array",
"(",
"indices",
")",
",",
"self",
".",
"idx_to_vec",
",",
"self",
".",
"idx_to_vec",
".",
"shape",
"[",
"0",
"]",
",",
"self",
".",
"idx_to_vec",
".",
"shape",
"[",
"1",
"]",
")",
"return",
"vecs",
"[",
"0",
"]",
"if",
"to_reduce",
"else",
"vecs"
] | Look up embedding vectors of tokens.
Parameters
----------
tokens : str or list of strs
A token or a list of tokens.
lower_case_backup : bool, default False
If False, each token in the original case will be looked up; if True, each token in the
original case will be looked up first, if not found in the keys of the property
`token_to_idx`, the token in the lower case will be looked up.
Returns
-------
mxnet.ndarray.NDArray:
The embedding vector(s) of the token(s). According to numpy conventions, if `tokens` is
a string, returns a 1-D NDArray of shape `self.vec_len`; if `tokens` is a list of
strings, returns a 2-D NDArray of shape=(len(tokens), self.vec_len). | [
"Look",
"up",
"embedding",
"vectors",
"of",
"tokens",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/embedding.py#L366-L403 |
23,817 | apache/incubator-mxnet | python/mxnet/contrib/text/embedding.py | _TokenEmbedding.update_token_vectors | def update_token_vectors(self, tokens, new_vectors):
"""Updates embedding vectors for tokens.
Parameters
----------
tokens : str or a list of strs
A token or a list of tokens whose embedding vector are to be updated.
new_vectors : mxnet.ndarray.NDArray
An NDArray to be assigned to the embedding vectors of `tokens`. Its length must be equal
to the number of `tokens` and its width must be equal to the dimension of embeddings of
the glossary. If `tokens` is a singleton, it must be 1-D or 2-D. If `tokens` is a list
of multiple strings, it must be 2-D.
"""
assert self.idx_to_vec is not None, 'The property `idx_to_vec` has not been properly set.'
if not isinstance(tokens, list) or len(tokens) == 1:
assert isinstance(new_vectors, nd.NDArray) and len(new_vectors.shape) in [1, 2], \
'`new_vectors` must be a 1-D or 2-D NDArray if `tokens` is a singleton.'
if not isinstance(tokens, list):
tokens = [tokens]
if len(new_vectors.shape) == 1:
new_vectors = new_vectors.expand_dims(0)
else:
assert isinstance(new_vectors, nd.NDArray) and len(new_vectors.shape) == 2, \
'`new_vectors` must be a 2-D NDArray if `tokens` is a list of multiple strings.'
assert new_vectors.shape == (len(tokens), self.vec_len), \
'The length of new_vectors must be equal to the number of tokens and the width of' \
'new_vectors must be equal to the dimension of embeddings of the glossary.'
indices = []
for token in tokens:
if token in self.token_to_idx:
indices.append(self.token_to_idx[token])
else:
raise ValueError('Token %s is unknown. To update the embedding vector for an '
'unknown token, please specify it explicitly as the '
'`unknown_token` %s in `tokens`. This is to avoid unintended '
'updates.' % (token, self.idx_to_token[C.UNKNOWN_IDX]))
self._idx_to_vec[nd.array(indices)] = new_vectors | python | def update_token_vectors(self, tokens, new_vectors):
"""Updates embedding vectors for tokens.
Parameters
----------
tokens : str or a list of strs
A token or a list of tokens whose embedding vector are to be updated.
new_vectors : mxnet.ndarray.NDArray
An NDArray to be assigned to the embedding vectors of `tokens`. Its length must be equal
to the number of `tokens` and its width must be equal to the dimension of embeddings of
the glossary. If `tokens` is a singleton, it must be 1-D or 2-D. If `tokens` is a list
of multiple strings, it must be 2-D.
"""
assert self.idx_to_vec is not None, 'The property `idx_to_vec` has not been properly set.'
if not isinstance(tokens, list) or len(tokens) == 1:
assert isinstance(new_vectors, nd.NDArray) and len(new_vectors.shape) in [1, 2], \
'`new_vectors` must be a 1-D or 2-D NDArray if `tokens` is a singleton.'
if not isinstance(tokens, list):
tokens = [tokens]
if len(new_vectors.shape) == 1:
new_vectors = new_vectors.expand_dims(0)
else:
assert isinstance(new_vectors, nd.NDArray) and len(new_vectors.shape) == 2, \
'`new_vectors` must be a 2-D NDArray if `tokens` is a list of multiple strings.'
assert new_vectors.shape == (len(tokens), self.vec_len), \
'The length of new_vectors must be equal to the number of tokens and the width of' \
'new_vectors must be equal to the dimension of embeddings of the glossary.'
indices = []
for token in tokens:
if token in self.token_to_idx:
indices.append(self.token_to_idx[token])
else:
raise ValueError('Token %s is unknown. To update the embedding vector for an '
'unknown token, please specify it explicitly as the '
'`unknown_token` %s in `tokens`. This is to avoid unintended '
'updates.' % (token, self.idx_to_token[C.UNKNOWN_IDX]))
self._idx_to_vec[nd.array(indices)] = new_vectors | [
"def",
"update_token_vectors",
"(",
"self",
",",
"tokens",
",",
"new_vectors",
")",
":",
"assert",
"self",
".",
"idx_to_vec",
"is",
"not",
"None",
",",
"'The property `idx_to_vec` has not been properly set.'",
"if",
"not",
"isinstance",
"(",
"tokens",
",",
"list",
")",
"or",
"len",
"(",
"tokens",
")",
"==",
"1",
":",
"assert",
"isinstance",
"(",
"new_vectors",
",",
"nd",
".",
"NDArray",
")",
"and",
"len",
"(",
"new_vectors",
".",
"shape",
")",
"in",
"[",
"1",
",",
"2",
"]",
",",
"'`new_vectors` must be a 1-D or 2-D NDArray if `tokens` is a singleton.'",
"if",
"not",
"isinstance",
"(",
"tokens",
",",
"list",
")",
":",
"tokens",
"=",
"[",
"tokens",
"]",
"if",
"len",
"(",
"new_vectors",
".",
"shape",
")",
"==",
"1",
":",
"new_vectors",
"=",
"new_vectors",
".",
"expand_dims",
"(",
"0",
")",
"else",
":",
"assert",
"isinstance",
"(",
"new_vectors",
",",
"nd",
".",
"NDArray",
")",
"and",
"len",
"(",
"new_vectors",
".",
"shape",
")",
"==",
"2",
",",
"'`new_vectors` must be a 2-D NDArray if `tokens` is a list of multiple strings.'",
"assert",
"new_vectors",
".",
"shape",
"==",
"(",
"len",
"(",
"tokens",
")",
",",
"self",
".",
"vec_len",
")",
",",
"'The length of new_vectors must be equal to the number of tokens and the width of'",
"'new_vectors must be equal to the dimension of embeddings of the glossary.'",
"indices",
"=",
"[",
"]",
"for",
"token",
"in",
"tokens",
":",
"if",
"token",
"in",
"self",
".",
"token_to_idx",
":",
"indices",
".",
"append",
"(",
"self",
".",
"token_to_idx",
"[",
"token",
"]",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Token %s is unknown. To update the embedding vector for an '",
"'unknown token, please specify it explicitly as the '",
"'`unknown_token` %s in `tokens`. This is to avoid unintended '",
"'updates.'",
"%",
"(",
"token",
",",
"self",
".",
"idx_to_token",
"[",
"C",
".",
"UNKNOWN_IDX",
"]",
")",
")",
"self",
".",
"_idx_to_vec",
"[",
"nd",
".",
"array",
"(",
"indices",
")",
"]",
"=",
"new_vectors"
] | Updates embedding vectors for tokens.
Parameters
----------
tokens : str or a list of strs
A token or a list of tokens whose embedding vector are to be updated.
new_vectors : mxnet.ndarray.NDArray
An NDArray to be assigned to the embedding vectors of `tokens`. Its length must be equal
to the number of `tokens` and its width must be equal to the dimension of embeddings of
the glossary. If `tokens` is a singleton, it must be 1-D or 2-D. If `tokens` is a list
of multiple strings, it must be 2-D. | [
"Updates",
"embedding",
"vectors",
"for",
"tokens",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/embedding.py#L405-L447 |
23,818 | apache/incubator-mxnet | python/mxnet/contrib/text/embedding.py | _TokenEmbedding._check_pretrained_file_names | def _check_pretrained_file_names(cls, pretrained_file_name):
"""Checks if a pre-trained token embedding file name is valid.
Parameters
----------
pretrained_file_name : str
The pre-trained token embedding file.
"""
embedding_name = cls.__name__.lower()
if pretrained_file_name not in cls.pretrained_file_name_sha1:
raise KeyError('Cannot find pretrained file %s for token embedding %s. Valid '
'pretrained files for embedding %s: %s' %
(pretrained_file_name, embedding_name, embedding_name,
', '.join(cls.pretrained_file_name_sha1.keys()))) | python | def _check_pretrained_file_names(cls, pretrained_file_name):
"""Checks if a pre-trained token embedding file name is valid.
Parameters
----------
pretrained_file_name : str
The pre-trained token embedding file.
"""
embedding_name = cls.__name__.lower()
if pretrained_file_name not in cls.pretrained_file_name_sha1:
raise KeyError('Cannot find pretrained file %s for token embedding %s. Valid '
'pretrained files for embedding %s: %s' %
(pretrained_file_name, embedding_name, embedding_name,
', '.join(cls.pretrained_file_name_sha1.keys()))) | [
"def",
"_check_pretrained_file_names",
"(",
"cls",
",",
"pretrained_file_name",
")",
":",
"embedding_name",
"=",
"cls",
".",
"__name__",
".",
"lower",
"(",
")",
"if",
"pretrained_file_name",
"not",
"in",
"cls",
".",
"pretrained_file_name_sha1",
":",
"raise",
"KeyError",
"(",
"'Cannot find pretrained file %s for token embedding %s. Valid '",
"'pretrained files for embedding %s: %s'",
"%",
"(",
"pretrained_file_name",
",",
"embedding_name",
",",
"embedding_name",
",",
"', '",
".",
"join",
"(",
"cls",
".",
"pretrained_file_name_sha1",
".",
"keys",
"(",
")",
")",
")",
")"
] | Checks if a pre-trained token embedding file name is valid.
Parameters
----------
pretrained_file_name : str
The pre-trained token embedding file. | [
"Checks",
"if",
"a",
"pre",
"-",
"trained",
"token",
"embedding",
"file",
"name",
"is",
"valid",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/embedding.py#L450-L465 |
23,819 | apache/incubator-mxnet | example/bayesian-methods/algos.py | step_HMC | def step_HMC(exe, exe_params, exe_grads, label_key, noise_precision, prior_precision, L=10, eps=1E-6):
"""Generate the implementation of step HMC"""
init_params = {k: v.copyto(v.context) for k, v in exe_params.items()}
end_params = {k: v.copyto(v.context) for k, v in exe_params.items()}
init_momentums = {k: mx.random.normal(0, 1, v.shape) for k, v in init_params.items()}
end_momentums = {k: v.copyto(v.context) for k, v in init_momentums.items()}
init_potential = calc_potential(exe, init_params, label_key, noise_precision, prior_precision)
# 0. Calculate Initial Energy and Kinetic
init_kinetic = sum([nd.sum(nd.square(momentum)) / 2.0
for momentum in init_momentums.values()]).asscalar()
# 1. Make a half step for momentum at the beginning
exe.copy_params_from(end_params)
exe.forward(is_train=True)
exe.backward()
for k, v in exe_grads.items():
v.wait_to_read()
for k, momentum in end_momentums.items():
momentum[:] = momentum - (eps / 2) * exe_grads[k]
# 2. Alternate full steps for position and momentum
for i in range(L):
# 2.1 Full step for position
for k, param in exe_params.items():
param[:] = param + eps * end_momentums[k]
# 2.2 Full step for the momentum, except at the end of trajectory we perform a half step
exe.forward(is_train=True)
exe.backward()
for v in exe_grads.values():
v.wait_to_read()
if i != L - 1:
for k, momentum in end_momentums.items():
momentum[:] = momentum - eps * exe_grads[k]
else:
for k, momentum in end_momentums.items():
# We should reverse the sign of the momentum at the end
momentum[:] = -(momentum - eps / 2.0 * exe_grads[k])
copy_param(exe, end_params)
# 3. Calculate acceptance ratio and accept/reject the move
end_potential = calc_potential(exe, end_params, label_key, noise_precision, prior_precision)
end_kinetic = sum([nd.sum(nd.square(momentum)) / 2.0
for momentum in end_momentums.values()]).asscalar()
# print init_potential, init_kinetic, end_potential, end_kinetic
r = numpy.random.rand(1)
if r < numpy.exp(-(end_potential + end_kinetic) + (init_potential + init_kinetic)):
exe.copy_params_from(end_params)
return end_params, 1
else:
exe.copy_params_from(init_params)
return init_params, 0 | python | def step_HMC(exe, exe_params, exe_grads, label_key, noise_precision, prior_precision, L=10, eps=1E-6):
"""Generate the implementation of step HMC"""
init_params = {k: v.copyto(v.context) for k, v in exe_params.items()}
end_params = {k: v.copyto(v.context) for k, v in exe_params.items()}
init_momentums = {k: mx.random.normal(0, 1, v.shape) for k, v in init_params.items()}
end_momentums = {k: v.copyto(v.context) for k, v in init_momentums.items()}
init_potential = calc_potential(exe, init_params, label_key, noise_precision, prior_precision)
# 0. Calculate Initial Energy and Kinetic
init_kinetic = sum([nd.sum(nd.square(momentum)) / 2.0
for momentum in init_momentums.values()]).asscalar()
# 1. Make a half step for momentum at the beginning
exe.copy_params_from(end_params)
exe.forward(is_train=True)
exe.backward()
for k, v in exe_grads.items():
v.wait_to_read()
for k, momentum in end_momentums.items():
momentum[:] = momentum - (eps / 2) * exe_grads[k]
# 2. Alternate full steps for position and momentum
for i in range(L):
# 2.1 Full step for position
for k, param in exe_params.items():
param[:] = param + eps * end_momentums[k]
# 2.2 Full step for the momentum, except at the end of trajectory we perform a half step
exe.forward(is_train=True)
exe.backward()
for v in exe_grads.values():
v.wait_to_read()
if i != L - 1:
for k, momentum in end_momentums.items():
momentum[:] = momentum - eps * exe_grads[k]
else:
for k, momentum in end_momentums.items():
# We should reverse the sign of the momentum at the end
momentum[:] = -(momentum - eps / 2.0 * exe_grads[k])
copy_param(exe, end_params)
# 3. Calculate acceptance ratio and accept/reject the move
end_potential = calc_potential(exe, end_params, label_key, noise_precision, prior_precision)
end_kinetic = sum([nd.sum(nd.square(momentum)) / 2.0
for momentum in end_momentums.values()]).asscalar()
# print init_potential, init_kinetic, end_potential, end_kinetic
r = numpy.random.rand(1)
if r < numpy.exp(-(end_potential + end_kinetic) + (init_potential + init_kinetic)):
exe.copy_params_from(end_params)
return end_params, 1
else:
exe.copy_params_from(init_params)
return init_params, 0 | [
"def",
"step_HMC",
"(",
"exe",
",",
"exe_params",
",",
"exe_grads",
",",
"label_key",
",",
"noise_precision",
",",
"prior_precision",
",",
"L",
"=",
"10",
",",
"eps",
"=",
"1E-6",
")",
":",
"init_params",
"=",
"{",
"k",
":",
"v",
".",
"copyto",
"(",
"v",
".",
"context",
")",
"for",
"k",
",",
"v",
"in",
"exe_params",
".",
"items",
"(",
")",
"}",
"end_params",
"=",
"{",
"k",
":",
"v",
".",
"copyto",
"(",
"v",
".",
"context",
")",
"for",
"k",
",",
"v",
"in",
"exe_params",
".",
"items",
"(",
")",
"}",
"init_momentums",
"=",
"{",
"k",
":",
"mx",
".",
"random",
".",
"normal",
"(",
"0",
",",
"1",
",",
"v",
".",
"shape",
")",
"for",
"k",
",",
"v",
"in",
"init_params",
".",
"items",
"(",
")",
"}",
"end_momentums",
"=",
"{",
"k",
":",
"v",
".",
"copyto",
"(",
"v",
".",
"context",
")",
"for",
"k",
",",
"v",
"in",
"init_momentums",
".",
"items",
"(",
")",
"}",
"init_potential",
"=",
"calc_potential",
"(",
"exe",
",",
"init_params",
",",
"label_key",
",",
"noise_precision",
",",
"prior_precision",
")",
"# 0. Calculate Initial Energy and Kinetic",
"init_kinetic",
"=",
"sum",
"(",
"[",
"nd",
".",
"sum",
"(",
"nd",
".",
"square",
"(",
"momentum",
")",
")",
"/",
"2.0",
"for",
"momentum",
"in",
"init_momentums",
".",
"values",
"(",
")",
"]",
")",
".",
"asscalar",
"(",
")",
"# 1. Make a half step for momentum at the beginning",
"exe",
".",
"copy_params_from",
"(",
"end_params",
")",
"exe",
".",
"forward",
"(",
"is_train",
"=",
"True",
")",
"exe",
".",
"backward",
"(",
")",
"for",
"k",
",",
"v",
"in",
"exe_grads",
".",
"items",
"(",
")",
":",
"v",
".",
"wait_to_read",
"(",
")",
"for",
"k",
",",
"momentum",
"in",
"end_momentums",
".",
"items",
"(",
")",
":",
"momentum",
"[",
":",
"]",
"=",
"momentum",
"-",
"(",
"eps",
"/",
"2",
")",
"*",
"exe_grads",
"[",
"k",
"]",
"# 2. Alternate full steps for position and momentum",
"for",
"i",
"in",
"range",
"(",
"L",
")",
":",
"# 2.1 Full step for position",
"for",
"k",
",",
"param",
"in",
"exe_params",
".",
"items",
"(",
")",
":",
"param",
"[",
":",
"]",
"=",
"param",
"+",
"eps",
"*",
"end_momentums",
"[",
"k",
"]",
"# 2.2 Full step for the momentum, except at the end of trajectory we perform a half step",
"exe",
".",
"forward",
"(",
"is_train",
"=",
"True",
")",
"exe",
".",
"backward",
"(",
")",
"for",
"v",
"in",
"exe_grads",
".",
"values",
"(",
")",
":",
"v",
".",
"wait_to_read",
"(",
")",
"if",
"i",
"!=",
"L",
"-",
"1",
":",
"for",
"k",
",",
"momentum",
"in",
"end_momentums",
".",
"items",
"(",
")",
":",
"momentum",
"[",
":",
"]",
"=",
"momentum",
"-",
"eps",
"*",
"exe_grads",
"[",
"k",
"]",
"else",
":",
"for",
"k",
",",
"momentum",
"in",
"end_momentums",
".",
"items",
"(",
")",
":",
"# We should reverse the sign of the momentum at the end",
"momentum",
"[",
":",
"]",
"=",
"-",
"(",
"momentum",
"-",
"eps",
"/",
"2.0",
"*",
"exe_grads",
"[",
"k",
"]",
")",
"copy_param",
"(",
"exe",
",",
"end_params",
")",
"# 3. Calculate acceptance ratio and accept/reject the move",
"end_potential",
"=",
"calc_potential",
"(",
"exe",
",",
"end_params",
",",
"label_key",
",",
"noise_precision",
",",
"prior_precision",
")",
"end_kinetic",
"=",
"sum",
"(",
"[",
"nd",
".",
"sum",
"(",
"nd",
".",
"square",
"(",
"momentum",
")",
")",
"/",
"2.0",
"for",
"momentum",
"in",
"end_momentums",
".",
"values",
"(",
")",
"]",
")",
".",
"asscalar",
"(",
")",
"# print init_potential, init_kinetic, end_potential, end_kinetic",
"r",
"=",
"numpy",
".",
"random",
".",
"rand",
"(",
"1",
")",
"if",
"r",
"<",
"numpy",
".",
"exp",
"(",
"-",
"(",
"end_potential",
"+",
"end_kinetic",
")",
"+",
"(",
"init_potential",
"+",
"init_kinetic",
")",
")",
":",
"exe",
".",
"copy_params_from",
"(",
"end_params",
")",
"return",
"end_params",
",",
"1",
"else",
":",
"exe",
".",
"copy_params_from",
"(",
"init_params",
")",
"return",
"init_params",
",",
"0"
] | Generate the implementation of step HMC | [
"Generate",
"the",
"implementation",
"of",
"step",
"HMC"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/bayesian-methods/algos.py#L52-L100 |
23,820 | apache/incubator-mxnet | example/bayesian-methods/algos.py | HMC | def HMC(sym, data_inputs, X, Y, X_test, Y_test, sample_num,
initializer=None, noise_precision=1 / 9.0, prior_precision=0.1,
learning_rate=1E-6, L=10, dev=mx.gpu()):
"""Generate the implementation of HMC"""
label_key = list(set(data_inputs.keys()) - set(['data']))[0]
exe, exe_params, exe_grads, _ = get_executor(sym, dev, data_inputs, initializer)
exe.arg_dict['data'][:] = X
exe.arg_dict[label_key][:] = Y
sample_pool = []
accept_num = 0
start = time.time()
for i in range(sample_num):
sample_params, is_accept = step_HMC(exe, exe_params, exe_grads, label_key, noise_precision,
prior_precision, L, learning_rate)
accept_num += is_accept
if (i + 1) % 10 == 0:
sample_pool.append(sample_params)
if (i + 1) % 100000 == 0:
end = time.time()
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start), "MSE:",
sample_test_regression(exe, X=X_test, Y=Y_test, sample_pool=sample_pool,
minibatch_size=Y.shape[0],
save_path='regression_HMC.txt'))
start = time.time()
exe.copy_params_from(sample_params)
print('accept ratio', accept_num / float(sample_num))
return sample_pool | python | def HMC(sym, data_inputs, X, Y, X_test, Y_test, sample_num,
initializer=None, noise_precision=1 / 9.0, prior_precision=0.1,
learning_rate=1E-6, L=10, dev=mx.gpu()):
"""Generate the implementation of HMC"""
label_key = list(set(data_inputs.keys()) - set(['data']))[0]
exe, exe_params, exe_grads, _ = get_executor(sym, dev, data_inputs, initializer)
exe.arg_dict['data'][:] = X
exe.arg_dict[label_key][:] = Y
sample_pool = []
accept_num = 0
start = time.time()
for i in range(sample_num):
sample_params, is_accept = step_HMC(exe, exe_params, exe_grads, label_key, noise_precision,
prior_precision, L, learning_rate)
accept_num += is_accept
if (i + 1) % 10 == 0:
sample_pool.append(sample_params)
if (i + 1) % 100000 == 0:
end = time.time()
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start), "MSE:",
sample_test_regression(exe, X=X_test, Y=Y_test, sample_pool=sample_pool,
minibatch_size=Y.shape[0],
save_path='regression_HMC.txt'))
start = time.time()
exe.copy_params_from(sample_params)
print('accept ratio', accept_num / float(sample_num))
return sample_pool | [
"def",
"HMC",
"(",
"sym",
",",
"data_inputs",
",",
"X",
",",
"Y",
",",
"X_test",
",",
"Y_test",
",",
"sample_num",
",",
"initializer",
"=",
"None",
",",
"noise_precision",
"=",
"1",
"/",
"9.0",
",",
"prior_precision",
"=",
"0.1",
",",
"learning_rate",
"=",
"1E-6",
",",
"L",
"=",
"10",
",",
"dev",
"=",
"mx",
".",
"gpu",
"(",
")",
")",
":",
"label_key",
"=",
"list",
"(",
"set",
"(",
"data_inputs",
".",
"keys",
"(",
")",
")",
"-",
"set",
"(",
"[",
"'data'",
"]",
")",
")",
"[",
"0",
"]",
"exe",
",",
"exe_params",
",",
"exe_grads",
",",
"_",
"=",
"get_executor",
"(",
"sym",
",",
"dev",
",",
"data_inputs",
",",
"initializer",
")",
"exe",
".",
"arg_dict",
"[",
"'data'",
"]",
"[",
":",
"]",
"=",
"X",
"exe",
".",
"arg_dict",
"[",
"label_key",
"]",
"[",
":",
"]",
"=",
"Y",
"sample_pool",
"=",
"[",
"]",
"accept_num",
"=",
"0",
"start",
"=",
"time",
".",
"time",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"sample_num",
")",
":",
"sample_params",
",",
"is_accept",
"=",
"step_HMC",
"(",
"exe",
",",
"exe_params",
",",
"exe_grads",
",",
"label_key",
",",
"noise_precision",
",",
"prior_precision",
",",
"L",
",",
"learning_rate",
")",
"accept_num",
"+=",
"is_accept",
"if",
"(",
"i",
"+",
"1",
")",
"%",
"10",
"==",
"0",
":",
"sample_pool",
".",
"append",
"(",
"sample_params",
")",
"if",
"(",
"i",
"+",
"1",
")",
"%",
"100000",
"==",
"0",
":",
"end",
"=",
"time",
".",
"time",
"(",
")",
"print",
"(",
"\"Current Iter Num: %d\"",
"%",
"(",
"i",
"+",
"1",
")",
",",
"\"Time Spent: %f\"",
"%",
"(",
"end",
"-",
"start",
")",
",",
"\"MSE:\"",
",",
"sample_test_regression",
"(",
"exe",
",",
"X",
"=",
"X_test",
",",
"Y",
"=",
"Y_test",
",",
"sample_pool",
"=",
"sample_pool",
",",
"minibatch_size",
"=",
"Y",
".",
"shape",
"[",
"0",
"]",
",",
"save_path",
"=",
"'regression_HMC.txt'",
")",
")",
"start",
"=",
"time",
".",
"time",
"(",
")",
"exe",
".",
"copy_params_from",
"(",
"sample_params",
")",
"print",
"(",
"'accept ratio'",
",",
"accept_num",
"/",
"float",
"(",
"sample_num",
")",
")",
"return",
"sample_pool"
] | Generate the implementation of HMC | [
"Generate",
"the",
"implementation",
"of",
"HMC"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/bayesian-methods/algos.py#L103-L130 |
23,821 | apache/incubator-mxnet | example/bayesian-methods/algos.py | SGD | def SGD(sym, data_inputs, X, Y, X_test, Y_test, total_iter_num,
lr=None,
lr_scheduler=None, prior_precision=1,
out_grad_f=None,
initializer=None,
minibatch_size=100, dev=mx.gpu()):
"""Generate the implementation of SGD"""
if out_grad_f is None:
label_key = list(set(data_inputs.keys()) - set(['data']))[0]
exe, params, params_grad, _ = get_executor(sym, dev, data_inputs, initializer)
optimizer = mx.optimizer.create('sgd', learning_rate=lr,
rescale_grad=X.shape[0] / minibatch_size,
lr_scheduler=lr_scheduler,
wd=prior_precision)
updater = mx.optimizer.get_updater(optimizer)
start = time.time()
for i in range(total_iter_num):
indices = numpy.random.randint(X.shape[0], size=minibatch_size)
X_batch = X[indices]
Y_batch = Y[indices]
exe.arg_dict['data'][:] = X_batch
if out_grad_f is None:
exe.arg_dict[label_key][:] = Y_batch
exe.forward(is_train=True)
exe.backward()
else:
exe.forward(is_train=True)
exe.backward(out_grad_f(exe.outputs, nd.array(Y_batch, ctx=dev)))
for k in params:
updater(k, params_grad[k], params[k])
if (i + 1) % 500 == 0:
end = time.time()
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start))
sample_test_acc(exe, X=X_test, Y=Y_test, label_num=10, minibatch_size=100)
start = time.time()
return exe, params, params_grad | python | def SGD(sym, data_inputs, X, Y, X_test, Y_test, total_iter_num,
lr=None,
lr_scheduler=None, prior_precision=1,
out_grad_f=None,
initializer=None,
minibatch_size=100, dev=mx.gpu()):
"""Generate the implementation of SGD"""
if out_grad_f is None:
label_key = list(set(data_inputs.keys()) - set(['data']))[0]
exe, params, params_grad, _ = get_executor(sym, dev, data_inputs, initializer)
optimizer = mx.optimizer.create('sgd', learning_rate=lr,
rescale_grad=X.shape[0] / minibatch_size,
lr_scheduler=lr_scheduler,
wd=prior_precision)
updater = mx.optimizer.get_updater(optimizer)
start = time.time()
for i in range(total_iter_num):
indices = numpy.random.randint(X.shape[0], size=minibatch_size)
X_batch = X[indices]
Y_batch = Y[indices]
exe.arg_dict['data'][:] = X_batch
if out_grad_f is None:
exe.arg_dict[label_key][:] = Y_batch
exe.forward(is_train=True)
exe.backward()
else:
exe.forward(is_train=True)
exe.backward(out_grad_f(exe.outputs, nd.array(Y_batch, ctx=dev)))
for k in params:
updater(k, params_grad[k], params[k])
if (i + 1) % 500 == 0:
end = time.time()
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start))
sample_test_acc(exe, X=X_test, Y=Y_test, label_num=10, minibatch_size=100)
start = time.time()
return exe, params, params_grad | [
"def",
"SGD",
"(",
"sym",
",",
"data_inputs",
",",
"X",
",",
"Y",
",",
"X_test",
",",
"Y_test",
",",
"total_iter_num",
",",
"lr",
"=",
"None",
",",
"lr_scheduler",
"=",
"None",
",",
"prior_precision",
"=",
"1",
",",
"out_grad_f",
"=",
"None",
",",
"initializer",
"=",
"None",
",",
"minibatch_size",
"=",
"100",
",",
"dev",
"=",
"mx",
".",
"gpu",
"(",
")",
")",
":",
"if",
"out_grad_f",
"is",
"None",
":",
"label_key",
"=",
"list",
"(",
"set",
"(",
"data_inputs",
".",
"keys",
"(",
")",
")",
"-",
"set",
"(",
"[",
"'data'",
"]",
")",
")",
"[",
"0",
"]",
"exe",
",",
"params",
",",
"params_grad",
",",
"_",
"=",
"get_executor",
"(",
"sym",
",",
"dev",
",",
"data_inputs",
",",
"initializer",
")",
"optimizer",
"=",
"mx",
".",
"optimizer",
".",
"create",
"(",
"'sgd'",
",",
"learning_rate",
"=",
"lr",
",",
"rescale_grad",
"=",
"X",
".",
"shape",
"[",
"0",
"]",
"/",
"minibatch_size",
",",
"lr_scheduler",
"=",
"lr_scheduler",
",",
"wd",
"=",
"prior_precision",
")",
"updater",
"=",
"mx",
".",
"optimizer",
".",
"get_updater",
"(",
"optimizer",
")",
"start",
"=",
"time",
".",
"time",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"total_iter_num",
")",
":",
"indices",
"=",
"numpy",
".",
"random",
".",
"randint",
"(",
"X",
".",
"shape",
"[",
"0",
"]",
",",
"size",
"=",
"minibatch_size",
")",
"X_batch",
"=",
"X",
"[",
"indices",
"]",
"Y_batch",
"=",
"Y",
"[",
"indices",
"]",
"exe",
".",
"arg_dict",
"[",
"'data'",
"]",
"[",
":",
"]",
"=",
"X_batch",
"if",
"out_grad_f",
"is",
"None",
":",
"exe",
".",
"arg_dict",
"[",
"label_key",
"]",
"[",
":",
"]",
"=",
"Y_batch",
"exe",
".",
"forward",
"(",
"is_train",
"=",
"True",
")",
"exe",
".",
"backward",
"(",
")",
"else",
":",
"exe",
".",
"forward",
"(",
"is_train",
"=",
"True",
")",
"exe",
".",
"backward",
"(",
"out_grad_f",
"(",
"exe",
".",
"outputs",
",",
"nd",
".",
"array",
"(",
"Y_batch",
",",
"ctx",
"=",
"dev",
")",
")",
")",
"for",
"k",
"in",
"params",
":",
"updater",
"(",
"k",
",",
"params_grad",
"[",
"k",
"]",
",",
"params",
"[",
"k",
"]",
")",
"if",
"(",
"i",
"+",
"1",
")",
"%",
"500",
"==",
"0",
":",
"end",
"=",
"time",
".",
"time",
"(",
")",
"print",
"(",
"\"Current Iter Num: %d\"",
"%",
"(",
"i",
"+",
"1",
")",
",",
"\"Time Spent: %f\"",
"%",
"(",
"end",
"-",
"start",
")",
")",
"sample_test_acc",
"(",
"exe",
",",
"X",
"=",
"X_test",
",",
"Y",
"=",
"Y_test",
",",
"label_num",
"=",
"10",
",",
"minibatch_size",
"=",
"100",
")",
"start",
"=",
"time",
".",
"time",
"(",
")",
"return",
"exe",
",",
"params",
",",
"params_grad"
] | Generate the implementation of SGD | [
"Generate",
"the",
"implementation",
"of",
"SGD"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/bayesian-methods/algos.py#L133-L168 |
23,822 | apache/incubator-mxnet | example/bayesian-methods/algos.py | SGLD | def SGLD(sym, X, Y, X_test, Y_test, total_iter_num,
data_inputs=None,
learning_rate=None,
lr_scheduler=None, prior_precision=1,
out_grad_f=None,
initializer=None,
minibatch_size=100, thin_interval=100, burn_in_iter_num=1000, task='classification',
dev=mx.gpu()):
"""Generate the implementation of SGLD"""
if out_grad_f is None:
label_key = list(set(data_inputs.keys()) - set(['data']))[0]
exe, params, params_grad, _ = get_executor(sym, dev, data_inputs, initializer)
optimizer = mx.optimizer.create('sgld', learning_rate=learning_rate,
rescale_grad=X.shape[0] / minibatch_size,
lr_scheduler=lr_scheduler,
wd=prior_precision)
updater = mx.optimizer.get_updater(optimizer)
sample_pool = []
start = time.time()
for i in range(total_iter_num):
indices = numpy.random.randint(X.shape[0], size=minibatch_size)
X_batch = X[indices]
Y_batch = Y[indices]
exe.arg_dict['data'][:] = X_batch
if out_grad_f is None:
exe.arg_dict[label_key][:] = Y_batch
exe.forward(is_train=True)
exe.backward()
else:
exe.forward(is_train=True)
exe.backward(out_grad_f(exe.outputs, nd.array(Y_batch, ctx=dev)))
for k in params:
updater(k, params_grad[k], params[k])
if i < burn_in_iter_num:
continue
else:
if (i - burn_in_iter_num) % thin_interval == 0:
if optimizer.lr_scheduler is not None:
lr = optimizer.lr_scheduler(optimizer.num_update)
else:
lr = learning_rate
sample_pool.append([lr, copy_param(exe)])
if (i + 1) % 100000 == 0:
end = time.time()
if task == 'classification':
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start))
test_correct, test_total, test_acc = \
sample_test_acc(exe, sample_pool=sample_pool, X=X_test, Y=Y_test, label_num=10,
minibatch_size=minibatch_size)
print("Test %d/%d=%f" % (test_correct, test_total, test_acc))
else:
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start), "MSE:",
sample_test_regression(exe=exe, sample_pool=sample_pool,
X=X_test,
Y=Y_test, minibatch_size=minibatch_size,
save_path='regression_SGLD.txt'))
start = time.time()
return exe, sample_pool | python | def SGLD(sym, X, Y, X_test, Y_test, total_iter_num,
data_inputs=None,
learning_rate=None,
lr_scheduler=None, prior_precision=1,
out_grad_f=None,
initializer=None,
minibatch_size=100, thin_interval=100, burn_in_iter_num=1000, task='classification',
dev=mx.gpu()):
"""Generate the implementation of SGLD"""
if out_grad_f is None:
label_key = list(set(data_inputs.keys()) - set(['data']))[0]
exe, params, params_grad, _ = get_executor(sym, dev, data_inputs, initializer)
optimizer = mx.optimizer.create('sgld', learning_rate=learning_rate,
rescale_grad=X.shape[0] / minibatch_size,
lr_scheduler=lr_scheduler,
wd=prior_precision)
updater = mx.optimizer.get_updater(optimizer)
sample_pool = []
start = time.time()
for i in range(total_iter_num):
indices = numpy.random.randint(X.shape[0], size=minibatch_size)
X_batch = X[indices]
Y_batch = Y[indices]
exe.arg_dict['data'][:] = X_batch
if out_grad_f is None:
exe.arg_dict[label_key][:] = Y_batch
exe.forward(is_train=True)
exe.backward()
else:
exe.forward(is_train=True)
exe.backward(out_grad_f(exe.outputs, nd.array(Y_batch, ctx=dev)))
for k in params:
updater(k, params_grad[k], params[k])
if i < burn_in_iter_num:
continue
else:
if (i - burn_in_iter_num) % thin_interval == 0:
if optimizer.lr_scheduler is not None:
lr = optimizer.lr_scheduler(optimizer.num_update)
else:
lr = learning_rate
sample_pool.append([lr, copy_param(exe)])
if (i + 1) % 100000 == 0:
end = time.time()
if task == 'classification':
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start))
test_correct, test_total, test_acc = \
sample_test_acc(exe, sample_pool=sample_pool, X=X_test, Y=Y_test, label_num=10,
minibatch_size=minibatch_size)
print("Test %d/%d=%f" % (test_correct, test_total, test_acc))
else:
print("Current Iter Num: %d" % (i + 1), "Time Spent: %f" % (end - start), "MSE:",
sample_test_regression(exe=exe, sample_pool=sample_pool,
X=X_test,
Y=Y_test, minibatch_size=minibatch_size,
save_path='regression_SGLD.txt'))
start = time.time()
return exe, sample_pool | [
"def",
"SGLD",
"(",
"sym",
",",
"X",
",",
"Y",
",",
"X_test",
",",
"Y_test",
",",
"total_iter_num",
",",
"data_inputs",
"=",
"None",
",",
"learning_rate",
"=",
"None",
",",
"lr_scheduler",
"=",
"None",
",",
"prior_precision",
"=",
"1",
",",
"out_grad_f",
"=",
"None",
",",
"initializer",
"=",
"None",
",",
"minibatch_size",
"=",
"100",
",",
"thin_interval",
"=",
"100",
",",
"burn_in_iter_num",
"=",
"1000",
",",
"task",
"=",
"'classification'",
",",
"dev",
"=",
"mx",
".",
"gpu",
"(",
")",
")",
":",
"if",
"out_grad_f",
"is",
"None",
":",
"label_key",
"=",
"list",
"(",
"set",
"(",
"data_inputs",
".",
"keys",
"(",
")",
")",
"-",
"set",
"(",
"[",
"'data'",
"]",
")",
")",
"[",
"0",
"]",
"exe",
",",
"params",
",",
"params_grad",
",",
"_",
"=",
"get_executor",
"(",
"sym",
",",
"dev",
",",
"data_inputs",
",",
"initializer",
")",
"optimizer",
"=",
"mx",
".",
"optimizer",
".",
"create",
"(",
"'sgld'",
",",
"learning_rate",
"=",
"learning_rate",
",",
"rescale_grad",
"=",
"X",
".",
"shape",
"[",
"0",
"]",
"/",
"minibatch_size",
",",
"lr_scheduler",
"=",
"lr_scheduler",
",",
"wd",
"=",
"prior_precision",
")",
"updater",
"=",
"mx",
".",
"optimizer",
".",
"get_updater",
"(",
"optimizer",
")",
"sample_pool",
"=",
"[",
"]",
"start",
"=",
"time",
".",
"time",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"total_iter_num",
")",
":",
"indices",
"=",
"numpy",
".",
"random",
".",
"randint",
"(",
"X",
".",
"shape",
"[",
"0",
"]",
",",
"size",
"=",
"minibatch_size",
")",
"X_batch",
"=",
"X",
"[",
"indices",
"]",
"Y_batch",
"=",
"Y",
"[",
"indices",
"]",
"exe",
".",
"arg_dict",
"[",
"'data'",
"]",
"[",
":",
"]",
"=",
"X_batch",
"if",
"out_grad_f",
"is",
"None",
":",
"exe",
".",
"arg_dict",
"[",
"label_key",
"]",
"[",
":",
"]",
"=",
"Y_batch",
"exe",
".",
"forward",
"(",
"is_train",
"=",
"True",
")",
"exe",
".",
"backward",
"(",
")",
"else",
":",
"exe",
".",
"forward",
"(",
"is_train",
"=",
"True",
")",
"exe",
".",
"backward",
"(",
"out_grad_f",
"(",
"exe",
".",
"outputs",
",",
"nd",
".",
"array",
"(",
"Y_batch",
",",
"ctx",
"=",
"dev",
")",
")",
")",
"for",
"k",
"in",
"params",
":",
"updater",
"(",
"k",
",",
"params_grad",
"[",
"k",
"]",
",",
"params",
"[",
"k",
"]",
")",
"if",
"i",
"<",
"burn_in_iter_num",
":",
"continue",
"else",
":",
"if",
"(",
"i",
"-",
"burn_in_iter_num",
")",
"%",
"thin_interval",
"==",
"0",
":",
"if",
"optimizer",
".",
"lr_scheduler",
"is",
"not",
"None",
":",
"lr",
"=",
"optimizer",
".",
"lr_scheduler",
"(",
"optimizer",
".",
"num_update",
")",
"else",
":",
"lr",
"=",
"learning_rate",
"sample_pool",
".",
"append",
"(",
"[",
"lr",
",",
"copy_param",
"(",
"exe",
")",
"]",
")",
"if",
"(",
"i",
"+",
"1",
")",
"%",
"100000",
"==",
"0",
":",
"end",
"=",
"time",
".",
"time",
"(",
")",
"if",
"task",
"==",
"'classification'",
":",
"print",
"(",
"\"Current Iter Num: %d\"",
"%",
"(",
"i",
"+",
"1",
")",
",",
"\"Time Spent: %f\"",
"%",
"(",
"end",
"-",
"start",
")",
")",
"test_correct",
",",
"test_total",
",",
"test_acc",
"=",
"sample_test_acc",
"(",
"exe",
",",
"sample_pool",
"=",
"sample_pool",
",",
"X",
"=",
"X_test",
",",
"Y",
"=",
"Y_test",
",",
"label_num",
"=",
"10",
",",
"minibatch_size",
"=",
"minibatch_size",
")",
"print",
"(",
"\"Test %d/%d=%f\"",
"%",
"(",
"test_correct",
",",
"test_total",
",",
"test_acc",
")",
")",
"else",
":",
"print",
"(",
"\"Current Iter Num: %d\"",
"%",
"(",
"i",
"+",
"1",
")",
",",
"\"Time Spent: %f\"",
"%",
"(",
"end",
"-",
"start",
")",
",",
"\"MSE:\"",
",",
"sample_test_regression",
"(",
"exe",
"=",
"exe",
",",
"sample_pool",
"=",
"sample_pool",
",",
"X",
"=",
"X_test",
",",
"Y",
"=",
"Y_test",
",",
"minibatch_size",
"=",
"minibatch_size",
",",
"save_path",
"=",
"'regression_SGLD.txt'",
")",
")",
"start",
"=",
"time",
".",
"time",
"(",
")",
"return",
"exe",
",",
"sample_pool"
] | Generate the implementation of SGLD | [
"Generate",
"the",
"implementation",
"of",
"SGLD"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/bayesian-methods/algos.py#L171-L228 |
23,823 | apache/incubator-mxnet | ci/build.py | get_platforms | def get_platforms(path: str = get_dockerfiles_path()) -> List[str]:
"""Get a list of architectures given our dockerfiles"""
dockerfiles = glob.glob(os.path.join(path, "Dockerfile.*"))
dockerfiles = list(filter(lambda x: x[-1] != '~', dockerfiles))
files = list(map(lambda x: re.sub(r"Dockerfile.(.*)", r"\1", x), dockerfiles))
platforms = list(map(lambda x: os.path.split(x)[1], sorted(files)))
return platforms | python | def get_platforms(path: str = get_dockerfiles_path()) -> List[str]:
"""Get a list of architectures given our dockerfiles"""
dockerfiles = glob.glob(os.path.join(path, "Dockerfile.*"))
dockerfiles = list(filter(lambda x: x[-1] != '~', dockerfiles))
files = list(map(lambda x: re.sub(r"Dockerfile.(.*)", r"\1", x), dockerfiles))
platforms = list(map(lambda x: os.path.split(x)[1], sorted(files)))
return platforms | [
"def",
"get_platforms",
"(",
"path",
":",
"str",
"=",
"get_dockerfiles_path",
"(",
")",
")",
"->",
"List",
"[",
"str",
"]",
":",
"dockerfiles",
"=",
"glob",
".",
"glob",
"(",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"\"Dockerfile.*\"",
")",
")",
"dockerfiles",
"=",
"list",
"(",
"filter",
"(",
"lambda",
"x",
":",
"x",
"[",
"-",
"1",
"]",
"!=",
"'~'",
",",
"dockerfiles",
")",
")",
"files",
"=",
"list",
"(",
"map",
"(",
"lambda",
"x",
":",
"re",
".",
"sub",
"(",
"r\"Dockerfile.(.*)\"",
",",
"r\"\\1\"",
",",
"x",
")",
",",
"dockerfiles",
")",
")",
"platforms",
"=",
"list",
"(",
"map",
"(",
"lambda",
"x",
":",
"os",
".",
"path",
".",
"split",
"(",
"x",
")",
"[",
"1",
"]",
",",
"sorted",
"(",
"files",
")",
")",
")",
"return",
"platforms"
] | Get a list of architectures given our dockerfiles | [
"Get",
"a",
"list",
"of",
"architectures",
"given",
"our",
"dockerfiles"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/ci/build.py#L93-L99 |
23,824 | apache/incubator-mxnet | ci/build.py | load_docker_cache | def load_docker_cache(tag, docker_registry) -> None:
"""Imports tagged container from the given docker registry"""
if docker_registry:
# noinspection PyBroadException
try:
import docker_cache
logging.info('Docker cache download is enabled from registry %s', docker_registry)
docker_cache.load_docker_cache(registry=docker_registry, docker_tag=tag)
except Exception:
logging.exception('Unable to retrieve Docker cache. Continue without...')
else:
logging.info('Distributed docker cache disabled') | python | def load_docker_cache(tag, docker_registry) -> None:
"""Imports tagged container from the given docker registry"""
if docker_registry:
# noinspection PyBroadException
try:
import docker_cache
logging.info('Docker cache download is enabled from registry %s', docker_registry)
docker_cache.load_docker_cache(registry=docker_registry, docker_tag=tag)
except Exception:
logging.exception('Unable to retrieve Docker cache. Continue without...')
else:
logging.info('Distributed docker cache disabled') | [
"def",
"load_docker_cache",
"(",
"tag",
",",
"docker_registry",
")",
"->",
"None",
":",
"if",
"docker_registry",
":",
"# noinspection PyBroadException",
"try",
":",
"import",
"docker_cache",
"logging",
".",
"info",
"(",
"'Docker cache download is enabled from registry %s'",
",",
"docker_registry",
")",
"docker_cache",
".",
"load_docker_cache",
"(",
"registry",
"=",
"docker_registry",
",",
"docker_tag",
"=",
"tag",
")",
"except",
"Exception",
":",
"logging",
".",
"exception",
"(",
"'Unable to retrieve Docker cache. Continue without...'",
")",
"else",
":",
"logging",
".",
"info",
"(",
"'Distributed docker cache disabled'",
")"
] | Imports tagged container from the given docker registry | [
"Imports",
"tagged",
"container",
"from",
"the",
"given",
"docker",
"registry"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/ci/build.py#L368-L379 |
23,825 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | _load_data | def _load_data(batch, targets, major_axis):
"""Load data into sliced arrays."""
if isinstance(batch, list):
new_batch = []
for i in range(len(targets)):
new_batch.append([b.data[i] for b in batch])
new_targets = [[dst for _, dst in d_target] for d_target in targets]
_load_general(new_batch, new_targets, major_axis)
else:
_load_general(batch.data, targets, major_axis) | python | def _load_data(batch, targets, major_axis):
"""Load data into sliced arrays."""
if isinstance(batch, list):
new_batch = []
for i in range(len(targets)):
new_batch.append([b.data[i] for b in batch])
new_targets = [[dst for _, dst in d_target] for d_target in targets]
_load_general(new_batch, new_targets, major_axis)
else:
_load_general(batch.data, targets, major_axis) | [
"def",
"_load_data",
"(",
"batch",
",",
"targets",
",",
"major_axis",
")",
":",
"if",
"isinstance",
"(",
"batch",
",",
"list",
")",
":",
"new_batch",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"targets",
")",
")",
":",
"new_batch",
".",
"append",
"(",
"[",
"b",
".",
"data",
"[",
"i",
"]",
"for",
"b",
"in",
"batch",
"]",
")",
"new_targets",
"=",
"[",
"[",
"dst",
"for",
"_",
",",
"dst",
"in",
"d_target",
"]",
"for",
"d_target",
"in",
"targets",
"]",
"_load_general",
"(",
"new_batch",
",",
"new_targets",
",",
"major_axis",
")",
"else",
":",
"_load_general",
"(",
"batch",
".",
"data",
",",
"targets",
",",
"major_axis",
")"
] | Load data into sliced arrays. | [
"Load",
"data",
"into",
"sliced",
"arrays",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L65-L74 |
23,826 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | _merge_multi_context | def _merge_multi_context(outputs, major_axis):
"""Merge outputs that lives on multiple context into one, so that they look
like living on one context.
"""
rets = []
for tensors, axis in zip(outputs, major_axis):
if axis >= 0:
# pylint: disable=no-member,protected-access
if len(tensors) == 1:
rets.append(tensors[0])
else:
# Concatenate if necessary
rets.append(nd.concat(*[tensor.as_in_context(tensors[0].context)
for tensor in tensors],
dim=axis))
# pylint: enable=no-member,protected-access
else:
# negative axis means the there is no batch_size axis, and all the
# results should be the same on each device. We simply take the
# first one, without checking they are actually the same
rets.append(tensors[0])
return rets | python | def _merge_multi_context(outputs, major_axis):
"""Merge outputs that lives on multiple context into one, so that they look
like living on one context.
"""
rets = []
for tensors, axis in zip(outputs, major_axis):
if axis >= 0:
# pylint: disable=no-member,protected-access
if len(tensors) == 1:
rets.append(tensors[0])
else:
# Concatenate if necessary
rets.append(nd.concat(*[tensor.as_in_context(tensors[0].context)
for tensor in tensors],
dim=axis))
# pylint: enable=no-member,protected-access
else:
# negative axis means the there is no batch_size axis, and all the
# results should be the same on each device. We simply take the
# first one, without checking they are actually the same
rets.append(tensors[0])
return rets | [
"def",
"_merge_multi_context",
"(",
"outputs",
",",
"major_axis",
")",
":",
"rets",
"=",
"[",
"]",
"for",
"tensors",
",",
"axis",
"in",
"zip",
"(",
"outputs",
",",
"major_axis",
")",
":",
"if",
"axis",
">=",
"0",
":",
"# pylint: disable=no-member,protected-access",
"if",
"len",
"(",
"tensors",
")",
"==",
"1",
":",
"rets",
".",
"append",
"(",
"tensors",
"[",
"0",
"]",
")",
"else",
":",
"# Concatenate if necessary",
"rets",
".",
"append",
"(",
"nd",
".",
"concat",
"(",
"*",
"[",
"tensor",
".",
"as_in_context",
"(",
"tensors",
"[",
"0",
"]",
".",
"context",
")",
"for",
"tensor",
"in",
"tensors",
"]",
",",
"dim",
"=",
"axis",
")",
")",
"# pylint: enable=no-member,protected-access",
"else",
":",
"# negative axis means the there is no batch_size axis, and all the",
"# results should be the same on each device. We simply take the",
"# first one, without checking they are actually the same",
"rets",
".",
"append",
"(",
"tensors",
"[",
"0",
"]",
")",
"return",
"rets"
] | Merge outputs that lives on multiple context into one, so that they look
like living on one context. | [
"Merge",
"outputs",
"that",
"lives",
"on",
"multiple",
"context",
"into",
"one",
"so",
"that",
"they",
"look",
"like",
"living",
"on",
"one",
"context",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L89-L110 |
23,827 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | _prepare_group2ctxs | def _prepare_group2ctxs(group2ctxs, ctx_len):
"""Prepare the group2contexts, will duplicate the context
if some ctx_group map to only one context.
"""
if group2ctxs is None:
return [None] * ctx_len
elif isinstance(group2ctxs, list):
assert(len(group2ctxs) == ctx_len), "length of group2ctxs\
should be %d" % ctx_len
return group2ctxs
elif isinstance(group2ctxs, dict):
ret = [{} for i in range(ctx_len)]
for k, v in group2ctxs.items():
ctxs = None
if isinstance(v, ctx.Context):
ctxs = [v] * ctx_len
else:
if len(v) == 1:
ctxs = v * ctx_len
else:
assert(len(v) == ctx_len), "length of group2ctxs[%s]\
should be %d or 1" % (k, ctx_len)
ctxs = v
for i in range(ctx_len):
ret[i][k] = ctxs[i]
return ret
else:
assert(False), "group2ctxs should be list of dict of str to context,\
or dict of str to context or list of context"
return False | python | def _prepare_group2ctxs(group2ctxs, ctx_len):
"""Prepare the group2contexts, will duplicate the context
if some ctx_group map to only one context.
"""
if group2ctxs is None:
return [None] * ctx_len
elif isinstance(group2ctxs, list):
assert(len(group2ctxs) == ctx_len), "length of group2ctxs\
should be %d" % ctx_len
return group2ctxs
elif isinstance(group2ctxs, dict):
ret = [{} for i in range(ctx_len)]
for k, v in group2ctxs.items():
ctxs = None
if isinstance(v, ctx.Context):
ctxs = [v] * ctx_len
else:
if len(v) == 1:
ctxs = v * ctx_len
else:
assert(len(v) == ctx_len), "length of group2ctxs[%s]\
should be %d or 1" % (k, ctx_len)
ctxs = v
for i in range(ctx_len):
ret[i][k] = ctxs[i]
return ret
else:
assert(False), "group2ctxs should be list of dict of str to context,\
or dict of str to context or list of context"
return False | [
"def",
"_prepare_group2ctxs",
"(",
"group2ctxs",
",",
"ctx_len",
")",
":",
"if",
"group2ctxs",
"is",
"None",
":",
"return",
"[",
"None",
"]",
"*",
"ctx_len",
"elif",
"isinstance",
"(",
"group2ctxs",
",",
"list",
")",
":",
"assert",
"(",
"len",
"(",
"group2ctxs",
")",
"==",
"ctx_len",
")",
",",
"\"length of group2ctxs\\\n should be %d\"",
"%",
"ctx_len",
"return",
"group2ctxs",
"elif",
"isinstance",
"(",
"group2ctxs",
",",
"dict",
")",
":",
"ret",
"=",
"[",
"{",
"}",
"for",
"i",
"in",
"range",
"(",
"ctx_len",
")",
"]",
"for",
"k",
",",
"v",
"in",
"group2ctxs",
".",
"items",
"(",
")",
":",
"ctxs",
"=",
"None",
"if",
"isinstance",
"(",
"v",
",",
"ctx",
".",
"Context",
")",
":",
"ctxs",
"=",
"[",
"v",
"]",
"*",
"ctx_len",
"else",
":",
"if",
"len",
"(",
"v",
")",
"==",
"1",
":",
"ctxs",
"=",
"v",
"*",
"ctx_len",
"else",
":",
"assert",
"(",
"len",
"(",
"v",
")",
"==",
"ctx_len",
")",
",",
"\"length of group2ctxs[%s]\\\n should be %d or 1\"",
"%",
"(",
"k",
",",
"ctx_len",
")",
"ctxs",
"=",
"v",
"for",
"i",
"in",
"range",
"(",
"ctx_len",
")",
":",
"ret",
"[",
"i",
"]",
"[",
"k",
"]",
"=",
"ctxs",
"[",
"i",
"]",
"return",
"ret",
"else",
":",
"assert",
"(",
"False",
")",
",",
"\"group2ctxs should be list of dict of str to context,\\\n or dict of str to context or list of context\"",
"return",
"False"
] | Prepare the group2contexts, will duplicate the context
if some ctx_group map to only one context. | [
"Prepare",
"the",
"group2contexts",
"will",
"duplicate",
"the",
"context",
"if",
"some",
"ctx_group",
"map",
"to",
"only",
"one",
"context",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L112-L141 |
23,828 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.decide_slices | def decide_slices(self, data_shapes):
"""Decide the slices for each context according to the workload.
Parameters
----------
data_shapes : list
list of (name, shape) specifying the shapes for the input data or label.
"""
assert len(data_shapes) > 0
major_axis = [DataDesc.get_batch_axis(x.layout) for x in data_shapes]
for (name, shape), axis in zip(data_shapes, major_axis):
if axis == -1:
continue
batch_size = shape[axis]
if self.batch_size is not None:
assert batch_size == self.batch_size, ("all data must have the same batch size: "
+ ("batch_size = %d, but " % self.batch_size)
+ ("%s has shape %s" % (name, shape)))
else:
self.batch_size = batch_size
self.slices = _split_input_slice(self.batch_size, self.workload)
return major_axis | python | def decide_slices(self, data_shapes):
"""Decide the slices for each context according to the workload.
Parameters
----------
data_shapes : list
list of (name, shape) specifying the shapes for the input data or label.
"""
assert len(data_shapes) > 0
major_axis = [DataDesc.get_batch_axis(x.layout) for x in data_shapes]
for (name, shape), axis in zip(data_shapes, major_axis):
if axis == -1:
continue
batch_size = shape[axis]
if self.batch_size is not None:
assert batch_size == self.batch_size, ("all data must have the same batch size: "
+ ("batch_size = %d, but " % self.batch_size)
+ ("%s has shape %s" % (name, shape)))
else:
self.batch_size = batch_size
self.slices = _split_input_slice(self.batch_size, self.workload)
return major_axis | [
"def",
"decide_slices",
"(",
"self",
",",
"data_shapes",
")",
":",
"assert",
"len",
"(",
"data_shapes",
")",
">",
"0",
"major_axis",
"=",
"[",
"DataDesc",
".",
"get_batch_axis",
"(",
"x",
".",
"layout",
")",
"for",
"x",
"in",
"data_shapes",
"]",
"for",
"(",
"name",
",",
"shape",
")",
",",
"axis",
"in",
"zip",
"(",
"data_shapes",
",",
"major_axis",
")",
":",
"if",
"axis",
"==",
"-",
"1",
":",
"continue",
"batch_size",
"=",
"shape",
"[",
"axis",
"]",
"if",
"self",
".",
"batch_size",
"is",
"not",
"None",
":",
"assert",
"batch_size",
"==",
"self",
".",
"batch_size",
",",
"(",
"\"all data must have the same batch size: \"",
"+",
"(",
"\"batch_size = %d, but \"",
"%",
"self",
".",
"batch_size",
")",
"+",
"(",
"\"%s has shape %s\"",
"%",
"(",
"name",
",",
"shape",
")",
")",
")",
"else",
":",
"self",
".",
"batch_size",
"=",
"batch_size",
"self",
".",
"slices",
"=",
"_split_input_slice",
"(",
"self",
".",
"batch_size",
",",
"self",
".",
"workload",
")",
"return",
"major_axis"
] | Decide the slices for each context according to the workload.
Parameters
----------
data_shapes : list
list of (name, shape) specifying the shapes for the input data or label. | [
"Decide",
"the",
"slices",
"for",
"each",
"context",
"according",
"to",
"the",
"workload",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L281-L305 |
23,829 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup._collect_arrays | def _collect_arrays(self):
"""Collect internal arrays from executors."""
# convenient data structures
self.data_arrays = [[(self.slices[i], e.arg_dict[name]) for i, e in enumerate(self.execs)]
for name, _ in self.data_shapes]
self.state_arrays = [[e.arg_dict[name] for e in self.execs]
for name in self.state_names]
if self.label_shapes is not None:
self.label_arrays = [[(self.slices[i], e.arg_dict[name])
for i, e in enumerate(self.execs)]
for name, _ in self.label_shapes]
else:
self.label_arrays = None
self.param_arrays = [[exec_.arg_arrays[i] for exec_ in self.execs]
for i, name in enumerate(self.arg_names)
if name in self.param_names]
if self.for_training:
self.grad_arrays = [[exec_.grad_arrays[i] for exec_ in self.execs]
for i, name in enumerate(self.arg_names)
if name in self.param_names]
else:
self.grad_arrays = None
data_names = [x[0] for x in self.data_shapes]
if self.inputs_need_grad:
self.input_grad_arrays = [[exec_.grad_arrays[self.arg_names.index(name)]
for exec_ in self.execs]
for name in data_names if name in self.arg_names]
else:
self.input_grad_arrays = None
self.aux_arrays = [[exec_.aux_arrays[i] for exec_ in self.execs]
for i in range(len(self.aux_names))] | python | def _collect_arrays(self):
"""Collect internal arrays from executors."""
# convenient data structures
self.data_arrays = [[(self.slices[i], e.arg_dict[name]) for i, e in enumerate(self.execs)]
for name, _ in self.data_shapes]
self.state_arrays = [[e.arg_dict[name] for e in self.execs]
for name in self.state_names]
if self.label_shapes is not None:
self.label_arrays = [[(self.slices[i], e.arg_dict[name])
for i, e in enumerate(self.execs)]
for name, _ in self.label_shapes]
else:
self.label_arrays = None
self.param_arrays = [[exec_.arg_arrays[i] for exec_ in self.execs]
for i, name in enumerate(self.arg_names)
if name in self.param_names]
if self.for_training:
self.grad_arrays = [[exec_.grad_arrays[i] for exec_ in self.execs]
for i, name in enumerate(self.arg_names)
if name in self.param_names]
else:
self.grad_arrays = None
data_names = [x[0] for x in self.data_shapes]
if self.inputs_need_grad:
self.input_grad_arrays = [[exec_.grad_arrays[self.arg_names.index(name)]
for exec_ in self.execs]
for name in data_names if name in self.arg_names]
else:
self.input_grad_arrays = None
self.aux_arrays = [[exec_.aux_arrays[i] for exec_ in self.execs]
for i in range(len(self.aux_names))] | [
"def",
"_collect_arrays",
"(",
"self",
")",
":",
"# convenient data structures",
"self",
".",
"data_arrays",
"=",
"[",
"[",
"(",
"self",
".",
"slices",
"[",
"i",
"]",
",",
"e",
".",
"arg_dict",
"[",
"name",
"]",
")",
"for",
"i",
",",
"e",
"in",
"enumerate",
"(",
"self",
".",
"execs",
")",
"]",
"for",
"name",
",",
"_",
"in",
"self",
".",
"data_shapes",
"]",
"self",
".",
"state_arrays",
"=",
"[",
"[",
"e",
".",
"arg_dict",
"[",
"name",
"]",
"for",
"e",
"in",
"self",
".",
"execs",
"]",
"for",
"name",
"in",
"self",
".",
"state_names",
"]",
"if",
"self",
".",
"label_shapes",
"is",
"not",
"None",
":",
"self",
".",
"label_arrays",
"=",
"[",
"[",
"(",
"self",
".",
"slices",
"[",
"i",
"]",
",",
"e",
".",
"arg_dict",
"[",
"name",
"]",
")",
"for",
"i",
",",
"e",
"in",
"enumerate",
"(",
"self",
".",
"execs",
")",
"]",
"for",
"name",
",",
"_",
"in",
"self",
".",
"label_shapes",
"]",
"else",
":",
"self",
".",
"label_arrays",
"=",
"None",
"self",
".",
"param_arrays",
"=",
"[",
"[",
"exec_",
".",
"arg_arrays",
"[",
"i",
"]",
"for",
"exec_",
"in",
"self",
".",
"execs",
"]",
"for",
"i",
",",
"name",
"in",
"enumerate",
"(",
"self",
".",
"arg_names",
")",
"if",
"name",
"in",
"self",
".",
"param_names",
"]",
"if",
"self",
".",
"for_training",
":",
"self",
".",
"grad_arrays",
"=",
"[",
"[",
"exec_",
".",
"grad_arrays",
"[",
"i",
"]",
"for",
"exec_",
"in",
"self",
".",
"execs",
"]",
"for",
"i",
",",
"name",
"in",
"enumerate",
"(",
"self",
".",
"arg_names",
")",
"if",
"name",
"in",
"self",
".",
"param_names",
"]",
"else",
":",
"self",
".",
"grad_arrays",
"=",
"None",
"data_names",
"=",
"[",
"x",
"[",
"0",
"]",
"for",
"x",
"in",
"self",
".",
"data_shapes",
"]",
"if",
"self",
".",
"inputs_need_grad",
":",
"self",
".",
"input_grad_arrays",
"=",
"[",
"[",
"exec_",
".",
"grad_arrays",
"[",
"self",
".",
"arg_names",
".",
"index",
"(",
"name",
")",
"]",
"for",
"exec_",
"in",
"self",
".",
"execs",
"]",
"for",
"name",
"in",
"data_names",
"if",
"name",
"in",
"self",
".",
"arg_names",
"]",
"else",
":",
"self",
".",
"input_grad_arrays",
"=",
"None",
"self",
".",
"aux_arrays",
"=",
"[",
"[",
"exec_",
".",
"aux_arrays",
"[",
"i",
"]",
"for",
"exec_",
"in",
"self",
".",
"execs",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"aux_names",
")",
")",
"]"
] | Collect internal arrays from executors. | [
"Collect",
"internal",
"arrays",
"from",
"executors",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L307-L342 |
23,830 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.bind_exec | def bind_exec(self, data_shapes, label_shapes, shared_group=None, reshape=False):
"""Bind executors on their respective devices.
Parameters
----------
data_shapes : list
label_shapes : list
shared_group : DataParallelExecutorGroup
reshape : bool
"""
assert reshape or not self.execs
self.batch_size = None
# calculate workload and bind executors
self.data_layouts = self.decide_slices(data_shapes)
if label_shapes is not None:
# call it to make sure labels has the same batch size as data
self.label_layouts = self.decide_slices(label_shapes)
for i in range(len(self.contexts)):
data_shapes_i = self._sliced_shape(data_shapes, i, self.data_layouts)
if label_shapes is not None:
label_shapes_i = self._sliced_shape(label_shapes, i, self.label_layouts)
else:
label_shapes_i = []
if reshape:
self.execs[i] = self._default_execs[i].reshape(
allow_up_sizing=True, **dict(data_shapes_i + label_shapes_i))
else:
self.execs.append(self._bind_ith_exec(i, data_shapes_i, label_shapes_i,
shared_group))
self.data_shapes = data_shapes
self.label_shapes = label_shapes
self.data_names = [i.name for i in self.data_shapes]
if label_shapes is not None:
self.label_names = [i.name for i in self.label_shapes]
self._collect_arrays() | python | def bind_exec(self, data_shapes, label_shapes, shared_group=None, reshape=False):
"""Bind executors on their respective devices.
Parameters
----------
data_shapes : list
label_shapes : list
shared_group : DataParallelExecutorGroup
reshape : bool
"""
assert reshape or not self.execs
self.batch_size = None
# calculate workload and bind executors
self.data_layouts = self.decide_slices(data_shapes)
if label_shapes is not None:
# call it to make sure labels has the same batch size as data
self.label_layouts = self.decide_slices(label_shapes)
for i in range(len(self.contexts)):
data_shapes_i = self._sliced_shape(data_shapes, i, self.data_layouts)
if label_shapes is not None:
label_shapes_i = self._sliced_shape(label_shapes, i, self.label_layouts)
else:
label_shapes_i = []
if reshape:
self.execs[i] = self._default_execs[i].reshape(
allow_up_sizing=True, **dict(data_shapes_i + label_shapes_i))
else:
self.execs.append(self._bind_ith_exec(i, data_shapes_i, label_shapes_i,
shared_group))
self.data_shapes = data_shapes
self.label_shapes = label_shapes
self.data_names = [i.name for i in self.data_shapes]
if label_shapes is not None:
self.label_names = [i.name for i in self.label_shapes]
self._collect_arrays() | [
"def",
"bind_exec",
"(",
"self",
",",
"data_shapes",
",",
"label_shapes",
",",
"shared_group",
"=",
"None",
",",
"reshape",
"=",
"False",
")",
":",
"assert",
"reshape",
"or",
"not",
"self",
".",
"execs",
"self",
".",
"batch_size",
"=",
"None",
"# calculate workload and bind executors",
"self",
".",
"data_layouts",
"=",
"self",
".",
"decide_slices",
"(",
"data_shapes",
")",
"if",
"label_shapes",
"is",
"not",
"None",
":",
"# call it to make sure labels has the same batch size as data",
"self",
".",
"label_layouts",
"=",
"self",
".",
"decide_slices",
"(",
"label_shapes",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"contexts",
")",
")",
":",
"data_shapes_i",
"=",
"self",
".",
"_sliced_shape",
"(",
"data_shapes",
",",
"i",
",",
"self",
".",
"data_layouts",
")",
"if",
"label_shapes",
"is",
"not",
"None",
":",
"label_shapes_i",
"=",
"self",
".",
"_sliced_shape",
"(",
"label_shapes",
",",
"i",
",",
"self",
".",
"label_layouts",
")",
"else",
":",
"label_shapes_i",
"=",
"[",
"]",
"if",
"reshape",
":",
"self",
".",
"execs",
"[",
"i",
"]",
"=",
"self",
".",
"_default_execs",
"[",
"i",
"]",
".",
"reshape",
"(",
"allow_up_sizing",
"=",
"True",
",",
"*",
"*",
"dict",
"(",
"data_shapes_i",
"+",
"label_shapes_i",
")",
")",
"else",
":",
"self",
".",
"execs",
".",
"append",
"(",
"self",
".",
"_bind_ith_exec",
"(",
"i",
",",
"data_shapes_i",
",",
"label_shapes_i",
",",
"shared_group",
")",
")",
"self",
".",
"data_shapes",
"=",
"data_shapes",
"self",
".",
"label_shapes",
"=",
"label_shapes",
"self",
".",
"data_names",
"=",
"[",
"i",
".",
"name",
"for",
"i",
"in",
"self",
".",
"data_shapes",
"]",
"if",
"label_shapes",
"is",
"not",
"None",
":",
"self",
".",
"label_names",
"=",
"[",
"i",
".",
"name",
"for",
"i",
"in",
"self",
".",
"label_shapes",
"]",
"self",
".",
"_collect_arrays",
"(",
")"
] | Bind executors on their respective devices.
Parameters
----------
data_shapes : list
label_shapes : list
shared_group : DataParallelExecutorGroup
reshape : bool | [
"Bind",
"executors",
"on",
"their",
"respective",
"devices",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L344-L382 |
23,831 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.reshape | def reshape(self, data_shapes, label_shapes):
"""Reshape executors.
Parameters
----------
data_shapes : list
label_shapes : list
"""
if data_shapes == self.data_shapes and label_shapes == self.label_shapes:
return
if self._default_execs is None:
self._default_execs = [i for i in self.execs]
self.bind_exec(data_shapes, label_shapes, reshape=True) | python | def reshape(self, data_shapes, label_shapes):
"""Reshape executors.
Parameters
----------
data_shapes : list
label_shapes : list
"""
if data_shapes == self.data_shapes and label_shapes == self.label_shapes:
return
if self._default_execs is None:
self._default_execs = [i for i in self.execs]
self.bind_exec(data_shapes, label_shapes, reshape=True) | [
"def",
"reshape",
"(",
"self",
",",
"data_shapes",
",",
"label_shapes",
")",
":",
"if",
"data_shapes",
"==",
"self",
".",
"data_shapes",
"and",
"label_shapes",
"==",
"self",
".",
"label_shapes",
":",
"return",
"if",
"self",
".",
"_default_execs",
"is",
"None",
":",
"self",
".",
"_default_execs",
"=",
"[",
"i",
"for",
"i",
"in",
"self",
".",
"execs",
"]",
"self",
".",
"bind_exec",
"(",
"data_shapes",
",",
"label_shapes",
",",
"reshape",
"=",
"True",
")"
] | Reshape executors.
Parameters
----------
data_shapes : list
label_shapes : list | [
"Reshape",
"executors",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L384-L396 |
23,832 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.set_params | def set_params(self, arg_params, aux_params, allow_extra=False):
"""Assign, i.e. copy parameters to all the executors.
Parameters
----------
arg_params : dict
A dictionary of name to `NDArray` parameter mapping.
aux_params : dict
A dictionary of name to `NDArray` auxiliary variable mapping.
allow_extra : boolean, optional
Whether allow extra parameters that are not needed by symbol.
If this is True, no error will be thrown when arg_params or aux_params
contain extra parameters that is not needed by the executor.
"""
for exec_ in self.execs:
exec_.copy_params_from(arg_params, aux_params, allow_extra_params=allow_extra) | python | def set_params(self, arg_params, aux_params, allow_extra=False):
"""Assign, i.e. copy parameters to all the executors.
Parameters
----------
arg_params : dict
A dictionary of name to `NDArray` parameter mapping.
aux_params : dict
A dictionary of name to `NDArray` auxiliary variable mapping.
allow_extra : boolean, optional
Whether allow extra parameters that are not needed by symbol.
If this is True, no error will be thrown when arg_params or aux_params
contain extra parameters that is not needed by the executor.
"""
for exec_ in self.execs:
exec_.copy_params_from(arg_params, aux_params, allow_extra_params=allow_extra) | [
"def",
"set_params",
"(",
"self",
",",
"arg_params",
",",
"aux_params",
",",
"allow_extra",
"=",
"False",
")",
":",
"for",
"exec_",
"in",
"self",
".",
"execs",
":",
"exec_",
".",
"copy_params_from",
"(",
"arg_params",
",",
"aux_params",
",",
"allow_extra_params",
"=",
"allow_extra",
")"
] | Assign, i.e. copy parameters to all the executors.
Parameters
----------
arg_params : dict
A dictionary of name to `NDArray` parameter mapping.
aux_params : dict
A dictionary of name to `NDArray` auxiliary variable mapping.
allow_extra : boolean, optional
Whether allow extra parameters that are not needed by symbol.
If this is True, no error will be thrown when arg_params or aux_params
contain extra parameters that is not needed by the executor. | [
"Assign",
"i",
".",
"e",
".",
"copy",
"parameters",
"to",
"all",
"the",
"executors",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L398-L413 |
23,833 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.get_params | def get_params(self, arg_params, aux_params):
""" Copy data from each executor to `arg_params` and `aux_params`.
Parameters
----------
arg_params : list of NDArray
Target parameter arrays.
aux_params : list of NDArray
Target aux arrays.
Notes
-----
- This function will inplace update the NDArrays in arg_params and aux_params.
"""
for name, block in zip(self.param_names, self.param_arrays):
weight = sum(w.copyto(ctx.cpu()) for w in block) / len(block)
weight.astype(arg_params[name].dtype).copyto(arg_params[name])
for name, block in zip(self.aux_names, self.aux_arrays):
weight = sum(w.copyto(ctx.cpu()) for w in block) / len(block)
weight.astype(aux_params[name].dtype).copyto(aux_params[name]) | python | def get_params(self, arg_params, aux_params):
""" Copy data from each executor to `arg_params` and `aux_params`.
Parameters
----------
arg_params : list of NDArray
Target parameter arrays.
aux_params : list of NDArray
Target aux arrays.
Notes
-----
- This function will inplace update the NDArrays in arg_params and aux_params.
"""
for name, block in zip(self.param_names, self.param_arrays):
weight = sum(w.copyto(ctx.cpu()) for w in block) / len(block)
weight.astype(arg_params[name].dtype).copyto(arg_params[name])
for name, block in zip(self.aux_names, self.aux_arrays):
weight = sum(w.copyto(ctx.cpu()) for w in block) / len(block)
weight.astype(aux_params[name].dtype).copyto(aux_params[name]) | [
"def",
"get_params",
"(",
"self",
",",
"arg_params",
",",
"aux_params",
")",
":",
"for",
"name",
",",
"block",
"in",
"zip",
"(",
"self",
".",
"param_names",
",",
"self",
".",
"param_arrays",
")",
":",
"weight",
"=",
"sum",
"(",
"w",
".",
"copyto",
"(",
"ctx",
".",
"cpu",
"(",
")",
")",
"for",
"w",
"in",
"block",
")",
"/",
"len",
"(",
"block",
")",
"weight",
".",
"astype",
"(",
"arg_params",
"[",
"name",
"]",
".",
"dtype",
")",
".",
"copyto",
"(",
"arg_params",
"[",
"name",
"]",
")",
"for",
"name",
",",
"block",
"in",
"zip",
"(",
"self",
".",
"aux_names",
",",
"self",
".",
"aux_arrays",
")",
":",
"weight",
"=",
"sum",
"(",
"w",
".",
"copyto",
"(",
"ctx",
".",
"cpu",
"(",
")",
")",
"for",
"w",
"in",
"block",
")",
"/",
"len",
"(",
"block",
")",
"weight",
".",
"astype",
"(",
"aux_params",
"[",
"name",
"]",
".",
"dtype",
")",
".",
"copyto",
"(",
"aux_params",
"[",
"name",
"]",
")"
] | Copy data from each executor to `arg_params` and `aux_params`.
Parameters
----------
arg_params : list of NDArray
Target parameter arrays.
aux_params : list of NDArray
Target aux arrays.
Notes
-----
- This function will inplace update the NDArrays in arg_params and aux_params. | [
"Copy",
"data",
"from",
"each",
"executor",
"to",
"arg_params",
"and",
"aux_params",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L415-L434 |
23,834 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.forward | def forward(self, data_batch, is_train=None):
"""Split `data_batch` according to workload and run forward on each devices.
Parameters
----------
data_batch : DataBatch
Or could be any object implementing similar interface.
is_train : bool
The hint for the backend, indicating whether we are during training phase.
Default is `None`, then the value `self.for_training` will be used.
Returns
-------
"""
_load_data(data_batch, self.data_arrays, self.data_layouts)
if is_train is None:
is_train = self.for_training
if isinstance(data_batch, list):
if self.label_arrays is not None and data_batch is not None and data_batch[0].label:
_load_label(data_batch, self.label_arrays, self.label_layouts)
else:
if self.label_arrays is not None and data_batch.label:
_load_label(data_batch, self.label_arrays, self.label_layouts)
for exec_ in self.execs:
exec_.forward(is_train=is_train) | python | def forward(self, data_batch, is_train=None):
"""Split `data_batch` according to workload and run forward on each devices.
Parameters
----------
data_batch : DataBatch
Or could be any object implementing similar interface.
is_train : bool
The hint for the backend, indicating whether we are during training phase.
Default is `None`, then the value `self.for_training` will be used.
Returns
-------
"""
_load_data(data_batch, self.data_arrays, self.data_layouts)
if is_train is None:
is_train = self.for_training
if isinstance(data_batch, list):
if self.label_arrays is not None and data_batch is not None and data_batch[0].label:
_load_label(data_batch, self.label_arrays, self.label_layouts)
else:
if self.label_arrays is not None and data_batch.label:
_load_label(data_batch, self.label_arrays, self.label_layouts)
for exec_ in self.execs:
exec_.forward(is_train=is_train) | [
"def",
"forward",
"(",
"self",
",",
"data_batch",
",",
"is_train",
"=",
"None",
")",
":",
"_load_data",
"(",
"data_batch",
",",
"self",
".",
"data_arrays",
",",
"self",
".",
"data_layouts",
")",
"if",
"is_train",
"is",
"None",
":",
"is_train",
"=",
"self",
".",
"for_training",
"if",
"isinstance",
"(",
"data_batch",
",",
"list",
")",
":",
"if",
"self",
".",
"label_arrays",
"is",
"not",
"None",
"and",
"data_batch",
"is",
"not",
"None",
"and",
"data_batch",
"[",
"0",
"]",
".",
"label",
":",
"_load_label",
"(",
"data_batch",
",",
"self",
".",
"label_arrays",
",",
"self",
".",
"label_layouts",
")",
"else",
":",
"if",
"self",
".",
"label_arrays",
"is",
"not",
"None",
"and",
"data_batch",
".",
"label",
":",
"_load_label",
"(",
"data_batch",
",",
"self",
".",
"label_arrays",
",",
"self",
".",
"label_layouts",
")",
"for",
"exec_",
"in",
"self",
".",
"execs",
":",
"exec_",
".",
"forward",
"(",
"is_train",
"=",
"is_train",
")"
] | Split `data_batch` according to workload and run forward on each devices.
Parameters
----------
data_batch : DataBatch
Or could be any object implementing similar interface.
is_train : bool
The hint for the backend, indicating whether we are during training phase.
Default is `None`, then the value `self.for_training` will be used.
Returns
------- | [
"Split",
"data_batch",
"according",
"to",
"workload",
"and",
"run",
"forward",
"on",
"each",
"devices",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L436-L462 |
23,835 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.get_output_shapes | def get_output_shapes(self):
"""Get the shapes of the outputs."""
outputs = self.execs[0].outputs
shapes = [out.shape for out in outputs]
concat_shapes = []
for key, the_shape, axis in zip(self.symbol.list_outputs(), shapes, self.output_layouts):
the_shape = list(the_shape)
if axis >= 0:
the_shape[axis] = self.batch_size
concat_shapes.append((key, tuple(the_shape)))
return concat_shapes | python | def get_output_shapes(self):
"""Get the shapes of the outputs."""
outputs = self.execs[0].outputs
shapes = [out.shape for out in outputs]
concat_shapes = []
for key, the_shape, axis in zip(self.symbol.list_outputs(), shapes, self.output_layouts):
the_shape = list(the_shape)
if axis >= 0:
the_shape[axis] = self.batch_size
concat_shapes.append((key, tuple(the_shape)))
return concat_shapes | [
"def",
"get_output_shapes",
"(",
"self",
")",
":",
"outputs",
"=",
"self",
".",
"execs",
"[",
"0",
"]",
".",
"outputs",
"shapes",
"=",
"[",
"out",
".",
"shape",
"for",
"out",
"in",
"outputs",
"]",
"concat_shapes",
"=",
"[",
"]",
"for",
"key",
",",
"the_shape",
",",
"axis",
"in",
"zip",
"(",
"self",
".",
"symbol",
".",
"list_outputs",
"(",
")",
",",
"shapes",
",",
"self",
".",
"output_layouts",
")",
":",
"the_shape",
"=",
"list",
"(",
"the_shape",
")",
"if",
"axis",
">=",
"0",
":",
"the_shape",
"[",
"axis",
"]",
"=",
"self",
".",
"batch_size",
"concat_shapes",
".",
"append",
"(",
"(",
"key",
",",
"tuple",
"(",
"the_shape",
")",
")",
")",
"return",
"concat_shapes"
] | Get the shapes of the outputs. | [
"Get",
"the",
"shapes",
"of",
"the",
"outputs",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L464-L475 |
23,836 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.get_outputs | def get_outputs(self, merge_multi_context=True, begin=0, end=None):
"""Get outputs of the previous forward computation.
If begin or end is specified, return [begin, end)-th outputs,
otherwise return all outputs.
Parameters
----------
merge_multi_context : bool
Default is `True`. In the case when data-parallelism is used, the outputs
will be collected from multiple devices. A `True` value indicate that we
should merge the collected results so that they look like from a single
executor.
begin : int
starting index of returned outputs in all outputs
end : int or None
ending index (excluded) of returned outputs.
Returns
-------
If `merge_multi_context` is ``True``, it is like ``[out1, out2]``. Otherwise, it
is like ``[[out1_dev1, out1_dev2], [out2_dev1, out2_dev2]]``. All the output
elements are `NDArray`.
"""
if end is None:
end = self.num_outputs
outputs = [[exec_.outputs[i] for exec_ in self.execs]
for i in range(begin, end)]
if merge_multi_context:
outputs = _merge_multi_context(outputs, self.output_layouts)
return outputs | python | def get_outputs(self, merge_multi_context=True, begin=0, end=None):
"""Get outputs of the previous forward computation.
If begin or end is specified, return [begin, end)-th outputs,
otherwise return all outputs.
Parameters
----------
merge_multi_context : bool
Default is `True`. In the case when data-parallelism is used, the outputs
will be collected from multiple devices. A `True` value indicate that we
should merge the collected results so that they look like from a single
executor.
begin : int
starting index of returned outputs in all outputs
end : int or None
ending index (excluded) of returned outputs.
Returns
-------
If `merge_multi_context` is ``True``, it is like ``[out1, out2]``. Otherwise, it
is like ``[[out1_dev1, out1_dev2], [out2_dev1, out2_dev2]]``. All the output
elements are `NDArray`.
"""
if end is None:
end = self.num_outputs
outputs = [[exec_.outputs[i] for exec_ in self.execs]
for i in range(begin, end)]
if merge_multi_context:
outputs = _merge_multi_context(outputs, self.output_layouts)
return outputs | [
"def",
"get_outputs",
"(",
"self",
",",
"merge_multi_context",
"=",
"True",
",",
"begin",
"=",
"0",
",",
"end",
"=",
"None",
")",
":",
"if",
"end",
"is",
"None",
":",
"end",
"=",
"self",
".",
"num_outputs",
"outputs",
"=",
"[",
"[",
"exec_",
".",
"outputs",
"[",
"i",
"]",
"for",
"exec_",
"in",
"self",
".",
"execs",
"]",
"for",
"i",
"in",
"range",
"(",
"begin",
",",
"end",
")",
"]",
"if",
"merge_multi_context",
":",
"outputs",
"=",
"_merge_multi_context",
"(",
"outputs",
",",
"self",
".",
"output_layouts",
")",
"return",
"outputs"
] | Get outputs of the previous forward computation.
If begin or end is specified, return [begin, end)-th outputs,
otherwise return all outputs.
Parameters
----------
merge_multi_context : bool
Default is `True`. In the case when data-parallelism is used, the outputs
will be collected from multiple devices. A `True` value indicate that we
should merge the collected results so that they look like from a single
executor.
begin : int
starting index of returned outputs in all outputs
end : int or None
ending index (excluded) of returned outputs.
Returns
-------
If `merge_multi_context` is ``True``, it is like ``[out1, out2]``. Otherwise, it
is like ``[[out1_dev1, out1_dev2], [out2_dev1, out2_dev2]]``. All the output
elements are `NDArray`. | [
"Get",
"outputs",
"of",
"the",
"previous",
"forward",
"computation",
".",
"If",
"begin",
"or",
"end",
"is",
"specified",
"return",
"[",
"begin",
"end",
")",
"-",
"th",
"outputs",
"otherwise",
"return",
"all",
"outputs",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L477-L506 |
23,837 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.set_states | def set_states(self, states=None, value=None):
"""Set value for states. Only one of states & value can be specified.
Parameters
----------
states : list of list of NDArrays
source states arrays formatted like [[state1_dev1, state1_dev2],
[state2_dev1, state2_dev2]].
value : number
a single scalar value for all state arrays.
"""
if states is not None:
assert value is None, "Only one of states & value can be specified."
_load_general(states, self.state_arrays, (0,)*len(states))
else:
assert value is not None, "At least one of states & value must be specified."
assert states is None, "Only one of states & value can be specified."
for d_dst in self.state_arrays:
for dst in d_dst:
dst[:] = value | python | def set_states(self, states=None, value=None):
"""Set value for states. Only one of states & value can be specified.
Parameters
----------
states : list of list of NDArrays
source states arrays formatted like [[state1_dev1, state1_dev2],
[state2_dev1, state2_dev2]].
value : number
a single scalar value for all state arrays.
"""
if states is not None:
assert value is None, "Only one of states & value can be specified."
_load_general(states, self.state_arrays, (0,)*len(states))
else:
assert value is not None, "At least one of states & value must be specified."
assert states is None, "Only one of states & value can be specified."
for d_dst in self.state_arrays:
for dst in d_dst:
dst[:] = value | [
"def",
"set_states",
"(",
"self",
",",
"states",
"=",
"None",
",",
"value",
"=",
"None",
")",
":",
"if",
"states",
"is",
"not",
"None",
":",
"assert",
"value",
"is",
"None",
",",
"\"Only one of states & value can be specified.\"",
"_load_general",
"(",
"states",
",",
"self",
".",
"state_arrays",
",",
"(",
"0",
",",
")",
"*",
"len",
"(",
"states",
")",
")",
"else",
":",
"assert",
"value",
"is",
"not",
"None",
",",
"\"At least one of states & value must be specified.\"",
"assert",
"states",
"is",
"None",
",",
"\"Only one of states & value can be specified.\"",
"for",
"d_dst",
"in",
"self",
".",
"state_arrays",
":",
"for",
"dst",
"in",
"d_dst",
":",
"dst",
"[",
":",
"]",
"=",
"value"
] | Set value for states. Only one of states & value can be specified.
Parameters
----------
states : list of list of NDArrays
source states arrays formatted like [[state1_dev1, state1_dev2],
[state2_dev1, state2_dev2]].
value : number
a single scalar value for all state arrays. | [
"Set",
"value",
"for",
"states",
".",
"Only",
"one",
"of",
"states",
"&",
"value",
"can",
"be",
"specified",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L529-L548 |
23,838 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.get_input_grads | def get_input_grads(self, merge_multi_context=True):
"""Get the gradients with respect to the inputs of the module.
Parameters
----------
merge_multi_context : bool
Defaults to ``True``. In the case when data-parallelism is used, the outputs
will be collected from multiple devices. A `True` value indicate that we
should merge the collected results so that they look like from a single
executor.
Returns
-------
If `merge_multi_context` is ``True``, it is like ``[grad1, grad2]``. Otherwise, it
is like ``[[grad1_dev1, grad1_dev2], [grad2_dev1, grad2_dev2]]``. All the output
elements are `NDArray`.
"""
assert self.inputs_need_grad
if merge_multi_context:
return _merge_multi_context(self.input_grad_arrays, self.data_layouts)
return self.input_grad_arrays | python | def get_input_grads(self, merge_multi_context=True):
"""Get the gradients with respect to the inputs of the module.
Parameters
----------
merge_multi_context : bool
Defaults to ``True``. In the case when data-parallelism is used, the outputs
will be collected from multiple devices. A `True` value indicate that we
should merge the collected results so that they look like from a single
executor.
Returns
-------
If `merge_multi_context` is ``True``, it is like ``[grad1, grad2]``. Otherwise, it
is like ``[[grad1_dev1, grad1_dev2], [grad2_dev1, grad2_dev2]]``. All the output
elements are `NDArray`.
"""
assert self.inputs_need_grad
if merge_multi_context:
return _merge_multi_context(self.input_grad_arrays, self.data_layouts)
return self.input_grad_arrays | [
"def",
"get_input_grads",
"(",
"self",
",",
"merge_multi_context",
"=",
"True",
")",
":",
"assert",
"self",
".",
"inputs_need_grad",
"if",
"merge_multi_context",
":",
"return",
"_merge_multi_context",
"(",
"self",
".",
"input_grad_arrays",
",",
"self",
".",
"data_layouts",
")",
"return",
"self",
".",
"input_grad_arrays"
] | Get the gradients with respect to the inputs of the module.
Parameters
----------
merge_multi_context : bool
Defaults to ``True``. In the case when data-parallelism is used, the outputs
will be collected from multiple devices. A `True` value indicate that we
should merge the collected results so that they look like from a single
executor.
Returns
-------
If `merge_multi_context` is ``True``, it is like ``[grad1, grad2]``. Otherwise, it
is like ``[[grad1_dev1, grad1_dev2], [grad2_dev1, grad2_dev2]]``. All the output
elements are `NDArray`. | [
"Get",
"the",
"gradients",
"with",
"respect",
"to",
"the",
"inputs",
"of",
"the",
"module",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L550-L570 |
23,839 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.backward | def backward(self, out_grads=None):
"""Run backward on all devices. A backward should be called after
a call to the forward function. Backward cannot be called unless
``self.for_training`` is ``True``.
Parameters
----------
out_grads : NDArray or list of NDArray, optional
Gradient on the outputs to be propagated back.
This parameter is only needed when bind is called
on outputs that are not a loss function.
"""
assert self.for_training, 're-bind with for_training=True to run backward'
if out_grads is None:
out_grads = []
for i, (exec_, islice) in enumerate(zip(self.execs, self.slices)):
out_grads_slice = []
for grad, axis in zip(out_grads, self.output_layouts):
if axis >= 0:
# pylint: disable=no-member
og_my_slice = nd.slice_axis(grad, axis=axis, begin=islice.start,
end=islice.stop)
out_grads_slice.append(og_my_slice.as_in_context(self.contexts[i]))
# pylint: enable=no-member
else:
out_grads_slice.append(grad.copyto(self.contexts[i]))
exec_.backward(out_grads=out_grads_slice) | python | def backward(self, out_grads=None):
"""Run backward on all devices. A backward should be called after
a call to the forward function. Backward cannot be called unless
``self.for_training`` is ``True``.
Parameters
----------
out_grads : NDArray or list of NDArray, optional
Gradient on the outputs to be propagated back.
This parameter is only needed when bind is called
on outputs that are not a loss function.
"""
assert self.for_training, 're-bind with for_training=True to run backward'
if out_grads is None:
out_grads = []
for i, (exec_, islice) in enumerate(zip(self.execs, self.slices)):
out_grads_slice = []
for grad, axis in zip(out_grads, self.output_layouts):
if axis >= 0:
# pylint: disable=no-member
og_my_slice = nd.slice_axis(grad, axis=axis, begin=islice.start,
end=islice.stop)
out_grads_slice.append(og_my_slice.as_in_context(self.contexts[i]))
# pylint: enable=no-member
else:
out_grads_slice.append(grad.copyto(self.contexts[i]))
exec_.backward(out_grads=out_grads_slice) | [
"def",
"backward",
"(",
"self",
",",
"out_grads",
"=",
"None",
")",
":",
"assert",
"self",
".",
"for_training",
",",
"'re-bind with for_training=True to run backward'",
"if",
"out_grads",
"is",
"None",
":",
"out_grads",
"=",
"[",
"]",
"for",
"i",
",",
"(",
"exec_",
",",
"islice",
")",
"in",
"enumerate",
"(",
"zip",
"(",
"self",
".",
"execs",
",",
"self",
".",
"slices",
")",
")",
":",
"out_grads_slice",
"=",
"[",
"]",
"for",
"grad",
",",
"axis",
"in",
"zip",
"(",
"out_grads",
",",
"self",
".",
"output_layouts",
")",
":",
"if",
"axis",
">=",
"0",
":",
"# pylint: disable=no-member",
"og_my_slice",
"=",
"nd",
".",
"slice_axis",
"(",
"grad",
",",
"axis",
"=",
"axis",
",",
"begin",
"=",
"islice",
".",
"start",
",",
"end",
"=",
"islice",
".",
"stop",
")",
"out_grads_slice",
".",
"append",
"(",
"og_my_slice",
".",
"as_in_context",
"(",
"self",
".",
"contexts",
"[",
"i",
"]",
")",
")",
"# pylint: enable=no-member",
"else",
":",
"out_grads_slice",
".",
"append",
"(",
"grad",
".",
"copyto",
"(",
"self",
".",
"contexts",
"[",
"i",
"]",
")",
")",
"exec_",
".",
"backward",
"(",
"out_grads",
"=",
"out_grads_slice",
")"
] | Run backward on all devices. A backward should be called after
a call to the forward function. Backward cannot be called unless
``self.for_training`` is ``True``.
Parameters
----------
out_grads : NDArray or list of NDArray, optional
Gradient on the outputs to be propagated back.
This parameter is only needed when bind is called
on outputs that are not a loss function. | [
"Run",
"backward",
"on",
"all",
"devices",
".",
"A",
"backward",
"should",
"be",
"called",
"after",
"a",
"call",
"to",
"the",
"forward",
"function",
".",
"Backward",
"cannot",
"be",
"called",
"unless",
"self",
".",
"for_training",
"is",
"True",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L572-L599 |
23,840 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup.update_metric | def update_metric(self, eval_metric, labels, pre_sliced):
"""Accumulate the performance according to `eval_metric` on all devices
by comparing outputs from [begin, end) to labels. By default use all
outputs.
Parameters
----------
eval_metric : EvalMetric
The metric used for evaluation.
labels : list of NDArray
Typically comes from `label` of a `DataBatch`.
pre_sliced : bool
Whether labels are already sliced.
begin : int
Starting index of used outputs.
end : int or None
Ending index of used outputs.
"""
for current_exec, (texec, islice) in enumerate(zip(self.execs, self.slices)):
if not pre_sliced:
labels_slice = []
for label, axis in zip(labels, self.label_layouts):
if axis == 0:
# slicing NDArray along axis 0 can avoid copying
labels_slice.append(label[islice])
elif axis > 0:
# pylint: disable=no-member
label_my_slice = nd.slice_axis(label, axis=axis, begin=islice.start,
end=islice.stop).as_in_context(label.context)
# pylint: enable=no-member
labels_slice.append(label_my_slice)
else:
labels_slice.append(label)
else:
labels_slice = labels[current_exec]
labels_ = OrderedDict(zip(self.label_names, labels_slice))
preds = OrderedDict(zip(self.output_names, texec.outputs))
eval_metric.update_dict(labels_, preds) | python | def update_metric(self, eval_metric, labels, pre_sliced):
"""Accumulate the performance according to `eval_metric` on all devices
by comparing outputs from [begin, end) to labels. By default use all
outputs.
Parameters
----------
eval_metric : EvalMetric
The metric used for evaluation.
labels : list of NDArray
Typically comes from `label` of a `DataBatch`.
pre_sliced : bool
Whether labels are already sliced.
begin : int
Starting index of used outputs.
end : int or None
Ending index of used outputs.
"""
for current_exec, (texec, islice) in enumerate(zip(self.execs, self.slices)):
if not pre_sliced:
labels_slice = []
for label, axis in zip(labels, self.label_layouts):
if axis == 0:
# slicing NDArray along axis 0 can avoid copying
labels_slice.append(label[islice])
elif axis > 0:
# pylint: disable=no-member
label_my_slice = nd.slice_axis(label, axis=axis, begin=islice.start,
end=islice.stop).as_in_context(label.context)
# pylint: enable=no-member
labels_slice.append(label_my_slice)
else:
labels_slice.append(label)
else:
labels_slice = labels[current_exec]
labels_ = OrderedDict(zip(self.label_names, labels_slice))
preds = OrderedDict(zip(self.output_names, texec.outputs))
eval_metric.update_dict(labels_, preds) | [
"def",
"update_metric",
"(",
"self",
",",
"eval_metric",
",",
"labels",
",",
"pre_sliced",
")",
":",
"for",
"current_exec",
",",
"(",
"texec",
",",
"islice",
")",
"in",
"enumerate",
"(",
"zip",
"(",
"self",
".",
"execs",
",",
"self",
".",
"slices",
")",
")",
":",
"if",
"not",
"pre_sliced",
":",
"labels_slice",
"=",
"[",
"]",
"for",
"label",
",",
"axis",
"in",
"zip",
"(",
"labels",
",",
"self",
".",
"label_layouts",
")",
":",
"if",
"axis",
"==",
"0",
":",
"# slicing NDArray along axis 0 can avoid copying",
"labels_slice",
".",
"append",
"(",
"label",
"[",
"islice",
"]",
")",
"elif",
"axis",
">",
"0",
":",
"# pylint: disable=no-member",
"label_my_slice",
"=",
"nd",
".",
"slice_axis",
"(",
"label",
",",
"axis",
"=",
"axis",
",",
"begin",
"=",
"islice",
".",
"start",
",",
"end",
"=",
"islice",
".",
"stop",
")",
".",
"as_in_context",
"(",
"label",
".",
"context",
")",
"# pylint: enable=no-member",
"labels_slice",
".",
"append",
"(",
"label_my_slice",
")",
"else",
":",
"labels_slice",
".",
"append",
"(",
"label",
")",
"else",
":",
"labels_slice",
"=",
"labels",
"[",
"current_exec",
"]",
"labels_",
"=",
"OrderedDict",
"(",
"zip",
"(",
"self",
".",
"label_names",
",",
"labels_slice",
")",
")",
"preds",
"=",
"OrderedDict",
"(",
"zip",
"(",
"self",
".",
"output_names",
",",
"texec",
".",
"outputs",
")",
")",
"eval_metric",
".",
"update_dict",
"(",
"labels_",
",",
"preds",
")"
] | Accumulate the performance according to `eval_metric` on all devices
by comparing outputs from [begin, end) to labels. By default use all
outputs.
Parameters
----------
eval_metric : EvalMetric
The metric used for evaluation.
labels : list of NDArray
Typically comes from `label` of a `DataBatch`.
pre_sliced : bool
Whether labels are already sliced.
begin : int
Starting index of used outputs.
end : int or None
Ending index of used outputs. | [
"Accumulate",
"the",
"performance",
"according",
"to",
"eval_metric",
"on",
"all",
"devices",
"by",
"comparing",
"outputs",
"from",
"[",
"begin",
"end",
")",
"to",
"labels",
".",
"By",
"default",
"use",
"all",
"outputs",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L601-L639 |
23,841 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup._bind_ith_exec | def _bind_ith_exec(self, i, data_shapes, label_shapes, shared_group):
"""Internal utility function to bind the i-th executor.
This function utilizes simple_bind python interface.
"""
shared_exec = None if shared_group is None else shared_group.execs[i]
context = self.contexts[i]
shared_data_arrays = self.shared_data_arrays[i]
input_shapes = dict(data_shapes)
if label_shapes is not None:
input_shapes.update(dict(label_shapes))
input_types = {x.name: x.dtype for x in data_shapes}
if label_shapes is not None:
input_types.update({x.name: x.dtype for x in label_shapes})
group2ctx = self.group2ctxs[i]
executor = self.symbol.simple_bind(ctx=context, grad_req=self.grad_req,
type_dict=input_types, shared_arg_names=self.param_names,
shared_exec=shared_exec, group2ctx=group2ctx,
shared_buffer=shared_data_arrays, **input_shapes)
self._total_exec_bytes += int(executor.debug_str().split('\n')[-3].split()[1])
return executor | python | def _bind_ith_exec(self, i, data_shapes, label_shapes, shared_group):
"""Internal utility function to bind the i-th executor.
This function utilizes simple_bind python interface.
"""
shared_exec = None if shared_group is None else shared_group.execs[i]
context = self.contexts[i]
shared_data_arrays = self.shared_data_arrays[i]
input_shapes = dict(data_shapes)
if label_shapes is not None:
input_shapes.update(dict(label_shapes))
input_types = {x.name: x.dtype for x in data_shapes}
if label_shapes is not None:
input_types.update({x.name: x.dtype for x in label_shapes})
group2ctx = self.group2ctxs[i]
executor = self.symbol.simple_bind(ctx=context, grad_req=self.grad_req,
type_dict=input_types, shared_arg_names=self.param_names,
shared_exec=shared_exec, group2ctx=group2ctx,
shared_buffer=shared_data_arrays, **input_shapes)
self._total_exec_bytes += int(executor.debug_str().split('\n')[-3].split()[1])
return executor | [
"def",
"_bind_ith_exec",
"(",
"self",
",",
"i",
",",
"data_shapes",
",",
"label_shapes",
",",
"shared_group",
")",
":",
"shared_exec",
"=",
"None",
"if",
"shared_group",
"is",
"None",
"else",
"shared_group",
".",
"execs",
"[",
"i",
"]",
"context",
"=",
"self",
".",
"contexts",
"[",
"i",
"]",
"shared_data_arrays",
"=",
"self",
".",
"shared_data_arrays",
"[",
"i",
"]",
"input_shapes",
"=",
"dict",
"(",
"data_shapes",
")",
"if",
"label_shapes",
"is",
"not",
"None",
":",
"input_shapes",
".",
"update",
"(",
"dict",
"(",
"label_shapes",
")",
")",
"input_types",
"=",
"{",
"x",
".",
"name",
":",
"x",
".",
"dtype",
"for",
"x",
"in",
"data_shapes",
"}",
"if",
"label_shapes",
"is",
"not",
"None",
":",
"input_types",
".",
"update",
"(",
"{",
"x",
".",
"name",
":",
"x",
".",
"dtype",
"for",
"x",
"in",
"label_shapes",
"}",
")",
"group2ctx",
"=",
"self",
".",
"group2ctxs",
"[",
"i",
"]",
"executor",
"=",
"self",
".",
"symbol",
".",
"simple_bind",
"(",
"ctx",
"=",
"context",
",",
"grad_req",
"=",
"self",
".",
"grad_req",
",",
"type_dict",
"=",
"input_types",
",",
"shared_arg_names",
"=",
"self",
".",
"param_names",
",",
"shared_exec",
"=",
"shared_exec",
",",
"group2ctx",
"=",
"group2ctx",
",",
"shared_buffer",
"=",
"shared_data_arrays",
",",
"*",
"*",
"input_shapes",
")",
"self",
".",
"_total_exec_bytes",
"+=",
"int",
"(",
"executor",
".",
"debug_str",
"(",
")",
".",
"split",
"(",
"'\\n'",
")",
"[",
"-",
"3",
"]",
".",
"split",
"(",
")",
"[",
"1",
"]",
")",
"return",
"executor"
] | Internal utility function to bind the i-th executor.
This function utilizes simple_bind python interface. | [
"Internal",
"utility",
"function",
"to",
"bind",
"the",
"i",
"-",
"th",
"executor",
".",
"This",
"function",
"utilizes",
"simple_bind",
"python",
"interface",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L641-L664 |
23,842 | apache/incubator-mxnet | python/mxnet/module/executor_group.py | DataParallelExecutorGroup._sliced_shape | def _sliced_shape(self, shapes, i, major_axis):
"""Get the sliced shapes for the i-th executor.
Parameters
----------
shapes : list of (str, tuple)
The original (name, shape) pairs.
i : int
Which executor we are dealing with.
"""
sliced_shapes = []
for desc, axis in zip(shapes, major_axis):
shape = list(desc.shape)
if axis >= 0:
shape[axis] = self.slices[i].stop - self.slices[i].start
sliced_shapes.append(DataDesc(desc.name, tuple(shape), desc.dtype, desc.layout))
return sliced_shapes | python | def _sliced_shape(self, shapes, i, major_axis):
"""Get the sliced shapes for the i-th executor.
Parameters
----------
shapes : list of (str, tuple)
The original (name, shape) pairs.
i : int
Which executor we are dealing with.
"""
sliced_shapes = []
for desc, axis in zip(shapes, major_axis):
shape = list(desc.shape)
if axis >= 0:
shape[axis] = self.slices[i].stop - self.slices[i].start
sliced_shapes.append(DataDesc(desc.name, tuple(shape), desc.dtype, desc.layout))
return sliced_shapes | [
"def",
"_sliced_shape",
"(",
"self",
",",
"shapes",
",",
"i",
",",
"major_axis",
")",
":",
"sliced_shapes",
"=",
"[",
"]",
"for",
"desc",
",",
"axis",
"in",
"zip",
"(",
"shapes",
",",
"major_axis",
")",
":",
"shape",
"=",
"list",
"(",
"desc",
".",
"shape",
")",
"if",
"axis",
">=",
"0",
":",
"shape",
"[",
"axis",
"]",
"=",
"self",
".",
"slices",
"[",
"i",
"]",
".",
"stop",
"-",
"self",
".",
"slices",
"[",
"i",
"]",
".",
"start",
"sliced_shapes",
".",
"append",
"(",
"DataDesc",
"(",
"desc",
".",
"name",
",",
"tuple",
"(",
"shape",
")",
",",
"desc",
".",
"dtype",
",",
"desc",
".",
"layout",
")",
")",
"return",
"sliced_shapes"
] | Get the sliced shapes for the i-th executor.
Parameters
----------
shapes : list of (str, tuple)
The original (name, shape) pairs.
i : int
Which executor we are dealing with. | [
"Get",
"the",
"sliced",
"shapes",
"for",
"the",
"i",
"-",
"th",
"executor",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/executor_group.py#L666-L682 |
23,843 | apache/incubator-mxnet | python/mxnet/name.py | NameManager.get | def get(self, name, hint):
"""Get the canonical name for a symbol.
This is the default implementation.
If the user specifies a name,
the user-specified name will be used.
When user does not specify a name, we automatically generate a
name based on the hint string.
Parameters
----------
name : str or None
The name specified by the user.
hint : str
A hint string, which can be used to generate name.
Returns
-------
full_name : str
A canonical name for the symbol.
"""
if name:
return name
if hint not in self._counter:
self._counter[hint] = 0
name = '%s%d' % (hint, self._counter[hint])
self._counter[hint] += 1
return name | python | def get(self, name, hint):
"""Get the canonical name for a symbol.
This is the default implementation.
If the user specifies a name,
the user-specified name will be used.
When user does not specify a name, we automatically generate a
name based on the hint string.
Parameters
----------
name : str or None
The name specified by the user.
hint : str
A hint string, which can be used to generate name.
Returns
-------
full_name : str
A canonical name for the symbol.
"""
if name:
return name
if hint not in self._counter:
self._counter[hint] = 0
name = '%s%d' % (hint, self._counter[hint])
self._counter[hint] += 1
return name | [
"def",
"get",
"(",
"self",
",",
"name",
",",
"hint",
")",
":",
"if",
"name",
":",
"return",
"name",
"if",
"hint",
"not",
"in",
"self",
".",
"_counter",
":",
"self",
".",
"_counter",
"[",
"hint",
"]",
"=",
"0",
"name",
"=",
"'%s%d'",
"%",
"(",
"hint",
",",
"self",
".",
"_counter",
"[",
"hint",
"]",
")",
"self",
".",
"_counter",
"[",
"hint",
"]",
"+=",
"1",
"return",
"name"
] | Get the canonical name for a symbol.
This is the default implementation.
If the user specifies a name,
the user-specified name will be used.
When user does not specify a name, we automatically generate a
name based on the hint string.
Parameters
----------
name : str or None
The name specified by the user.
hint : str
A hint string, which can be used to generate name.
Returns
-------
full_name : str
A canonical name for the symbol. | [
"Get",
"the",
"canonical",
"name",
"for",
"a",
"symbol",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/name.py#L36-L65 |
23,844 | apache/incubator-mxnet | example/rcnn/symnet/model.py | load_param | def load_param(params, ctx=None):
"""same as mx.model.load_checkpoint, but do not load symnet and will convert context"""
if ctx is None:
ctx = mx.cpu()
save_dict = mx.nd.load(params)
arg_params = {}
aux_params = {}
for k, v in save_dict.items():
tp, name = k.split(':', 1)
if tp == 'arg':
arg_params[name] = v.as_in_context(ctx)
if tp == 'aux':
aux_params[name] = v.as_in_context(ctx)
return arg_params, aux_params | python | def load_param(params, ctx=None):
"""same as mx.model.load_checkpoint, but do not load symnet and will convert context"""
if ctx is None:
ctx = mx.cpu()
save_dict = mx.nd.load(params)
arg_params = {}
aux_params = {}
for k, v in save_dict.items():
tp, name = k.split(':', 1)
if tp == 'arg':
arg_params[name] = v.as_in_context(ctx)
if tp == 'aux':
aux_params[name] = v.as_in_context(ctx)
return arg_params, aux_params | [
"def",
"load_param",
"(",
"params",
",",
"ctx",
"=",
"None",
")",
":",
"if",
"ctx",
"is",
"None",
":",
"ctx",
"=",
"mx",
".",
"cpu",
"(",
")",
"save_dict",
"=",
"mx",
".",
"nd",
".",
"load",
"(",
"params",
")",
"arg_params",
"=",
"{",
"}",
"aux_params",
"=",
"{",
"}",
"for",
"k",
",",
"v",
"in",
"save_dict",
".",
"items",
"(",
")",
":",
"tp",
",",
"name",
"=",
"k",
".",
"split",
"(",
"':'",
",",
"1",
")",
"if",
"tp",
"==",
"'arg'",
":",
"arg_params",
"[",
"name",
"]",
"=",
"v",
".",
"as_in_context",
"(",
"ctx",
")",
"if",
"tp",
"==",
"'aux'",
":",
"aux_params",
"[",
"name",
"]",
"=",
"v",
".",
"as_in_context",
"(",
"ctx",
")",
"return",
"arg_params",
",",
"aux_params"
] | same as mx.model.load_checkpoint, but do not load symnet and will convert context | [
"same",
"as",
"mx",
".",
"model",
".",
"load_checkpoint",
"but",
"do",
"not",
"load",
"symnet",
"and",
"will",
"convert",
"context"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rcnn/symnet/model.py#L21-L34 |
23,845 | apache/incubator-mxnet | python/mxnet/rnn/rnn.py | rnn_unroll | def rnn_unroll(cell, length, inputs=None, begin_state=None, input_prefix='', layout='NTC'):
"""Deprecated. Please use cell.unroll instead"""
warnings.warn('rnn_unroll is deprecated. Please call cell.unroll directly.')
return cell.unroll(length=length, inputs=inputs, begin_state=begin_state,
input_prefix=input_prefix, layout=layout) | python | def rnn_unroll(cell, length, inputs=None, begin_state=None, input_prefix='', layout='NTC'):
"""Deprecated. Please use cell.unroll instead"""
warnings.warn('rnn_unroll is deprecated. Please call cell.unroll directly.')
return cell.unroll(length=length, inputs=inputs, begin_state=begin_state,
input_prefix=input_prefix, layout=layout) | [
"def",
"rnn_unroll",
"(",
"cell",
",",
"length",
",",
"inputs",
"=",
"None",
",",
"begin_state",
"=",
"None",
",",
"input_prefix",
"=",
"''",
",",
"layout",
"=",
"'NTC'",
")",
":",
"warnings",
".",
"warn",
"(",
"'rnn_unroll is deprecated. Please call cell.unroll directly.'",
")",
"return",
"cell",
".",
"unroll",
"(",
"length",
"=",
"length",
",",
"inputs",
"=",
"inputs",
",",
"begin_state",
"=",
"begin_state",
",",
"input_prefix",
"=",
"input_prefix",
",",
"layout",
"=",
"layout",
")"
] | Deprecated. Please use cell.unroll instead | [
"Deprecated",
".",
"Please",
"use",
"cell",
".",
"unroll",
"instead"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn.py#L26-L30 |
23,846 | apache/incubator-mxnet | python/mxnet/rnn/rnn.py | save_rnn_checkpoint | def save_rnn_checkpoint(cells, prefix, epoch, symbol, arg_params, aux_params):
"""Save checkpoint for model using RNN cells.
Unpacks weight before saving.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
Prefix of model name.
epoch : int
The epoch number of the model.
symbol : Symbol
The input symbol
arg_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's weights.
aux_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's auxiliary states.
Notes
-----
- ``prefix-symbol.json`` will be saved for symbol.
- ``prefix-epoch.params`` will be saved for parameters.
"""
if isinstance(cells, BaseRNNCell):
cells = [cells]
for cell in cells:
arg_params = cell.unpack_weights(arg_params)
save_checkpoint(prefix, epoch, symbol, arg_params, aux_params) | python | def save_rnn_checkpoint(cells, prefix, epoch, symbol, arg_params, aux_params):
"""Save checkpoint for model using RNN cells.
Unpacks weight before saving.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
Prefix of model name.
epoch : int
The epoch number of the model.
symbol : Symbol
The input symbol
arg_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's weights.
aux_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's auxiliary states.
Notes
-----
- ``prefix-symbol.json`` will be saved for symbol.
- ``prefix-epoch.params`` will be saved for parameters.
"""
if isinstance(cells, BaseRNNCell):
cells = [cells]
for cell in cells:
arg_params = cell.unpack_weights(arg_params)
save_checkpoint(prefix, epoch, symbol, arg_params, aux_params) | [
"def",
"save_rnn_checkpoint",
"(",
"cells",
",",
"prefix",
",",
"epoch",
",",
"symbol",
",",
"arg_params",
",",
"aux_params",
")",
":",
"if",
"isinstance",
"(",
"cells",
",",
"BaseRNNCell",
")",
":",
"cells",
"=",
"[",
"cells",
"]",
"for",
"cell",
"in",
"cells",
":",
"arg_params",
"=",
"cell",
".",
"unpack_weights",
"(",
"arg_params",
")",
"save_checkpoint",
"(",
"prefix",
",",
"epoch",
",",
"symbol",
",",
"arg_params",
",",
"aux_params",
")"
] | Save checkpoint for model using RNN cells.
Unpacks weight before saving.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
Prefix of model name.
epoch : int
The epoch number of the model.
symbol : Symbol
The input symbol
arg_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's weights.
aux_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's auxiliary states.
Notes
-----
- ``prefix-symbol.json`` will be saved for symbol.
- ``prefix-epoch.params`` will be saved for parameters. | [
"Save",
"checkpoint",
"for",
"model",
"using",
"RNN",
"cells",
".",
"Unpacks",
"weight",
"before",
"saving",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn.py#L32-L60 |
23,847 | apache/incubator-mxnet | python/mxnet/rnn/rnn.py | load_rnn_checkpoint | def load_rnn_checkpoint(cells, prefix, epoch):
"""Load model checkpoint from file.
Pack weights after loading.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
Prefix of model name.
epoch : int
Epoch number of model we would like to load.
Returns
-------
symbol : Symbol
The symbol configuration of computation network.
arg_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's weights.
aux_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's auxiliary states.
Notes
-----
- symbol will be loaded from ``prefix-symbol.json``.
- parameters will be loaded from ``prefix-epoch.params``.
"""
sym, arg, aux = load_checkpoint(prefix, epoch)
if isinstance(cells, BaseRNNCell):
cells = [cells]
for cell in cells:
arg = cell.pack_weights(arg)
return sym, arg, aux | python | def load_rnn_checkpoint(cells, prefix, epoch):
"""Load model checkpoint from file.
Pack weights after loading.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
Prefix of model name.
epoch : int
Epoch number of model we would like to load.
Returns
-------
symbol : Symbol
The symbol configuration of computation network.
arg_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's weights.
aux_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's auxiliary states.
Notes
-----
- symbol will be loaded from ``prefix-symbol.json``.
- parameters will be loaded from ``prefix-epoch.params``.
"""
sym, arg, aux = load_checkpoint(prefix, epoch)
if isinstance(cells, BaseRNNCell):
cells = [cells]
for cell in cells:
arg = cell.pack_weights(arg)
return sym, arg, aux | [
"def",
"load_rnn_checkpoint",
"(",
"cells",
",",
"prefix",
",",
"epoch",
")",
":",
"sym",
",",
"arg",
",",
"aux",
"=",
"load_checkpoint",
"(",
"prefix",
",",
"epoch",
")",
"if",
"isinstance",
"(",
"cells",
",",
"BaseRNNCell",
")",
":",
"cells",
"=",
"[",
"cells",
"]",
"for",
"cell",
"in",
"cells",
":",
"arg",
"=",
"cell",
".",
"pack_weights",
"(",
"arg",
")",
"return",
"sym",
",",
"arg",
",",
"aux"
] | Load model checkpoint from file.
Pack weights after loading.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
Prefix of model name.
epoch : int
Epoch number of model we would like to load.
Returns
-------
symbol : Symbol
The symbol configuration of computation network.
arg_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's weights.
aux_params : dict of str to NDArray
Model parameter, dict of name to NDArray of net's auxiliary states.
Notes
-----
- symbol will be loaded from ``prefix-symbol.json``.
- parameters will be loaded from ``prefix-epoch.params``. | [
"Load",
"model",
"checkpoint",
"from",
"file",
".",
"Pack",
"weights",
"after",
"loading",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn.py#L62-L95 |
23,848 | apache/incubator-mxnet | python/mxnet/rnn/rnn.py | do_rnn_checkpoint | def do_rnn_checkpoint(cells, prefix, period=1):
"""Make a callback to checkpoint Module to prefix every epoch.
unpacks weights used by cells before saving.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
The file prefix to checkpoint to
period : int
How many epochs to wait before checkpointing. Default is 1.
Returns
-------
callback : function
The callback function that can be passed as iter_end_callback to fit.
"""
period = int(max(1, period))
# pylint: disable=unused-argument
def _callback(iter_no, sym=None, arg=None, aux=None):
"""The checkpoint function."""
if (iter_no + 1) % period == 0:
save_rnn_checkpoint(cells, prefix, iter_no+1, sym, arg, aux)
return _callback | python | def do_rnn_checkpoint(cells, prefix, period=1):
"""Make a callback to checkpoint Module to prefix every epoch.
unpacks weights used by cells before saving.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
The file prefix to checkpoint to
period : int
How many epochs to wait before checkpointing. Default is 1.
Returns
-------
callback : function
The callback function that can be passed as iter_end_callback to fit.
"""
period = int(max(1, period))
# pylint: disable=unused-argument
def _callback(iter_no, sym=None, arg=None, aux=None):
"""The checkpoint function."""
if (iter_no + 1) % period == 0:
save_rnn_checkpoint(cells, prefix, iter_no+1, sym, arg, aux)
return _callback | [
"def",
"do_rnn_checkpoint",
"(",
"cells",
",",
"prefix",
",",
"period",
"=",
"1",
")",
":",
"period",
"=",
"int",
"(",
"max",
"(",
"1",
",",
"period",
")",
")",
"# pylint: disable=unused-argument",
"def",
"_callback",
"(",
"iter_no",
",",
"sym",
"=",
"None",
",",
"arg",
"=",
"None",
",",
"aux",
"=",
"None",
")",
":",
"\"\"\"The checkpoint function.\"\"\"",
"if",
"(",
"iter_no",
"+",
"1",
")",
"%",
"period",
"==",
"0",
":",
"save_rnn_checkpoint",
"(",
"cells",
",",
"prefix",
",",
"iter_no",
"+",
"1",
",",
"sym",
",",
"arg",
",",
"aux",
")",
"return",
"_callback"
] | Make a callback to checkpoint Module to prefix every epoch.
unpacks weights used by cells before saving.
Parameters
----------
cells : mxnet.rnn.RNNCell or list of RNNCells
The RNN cells used by this symbol.
prefix : str
The file prefix to checkpoint to
period : int
How many epochs to wait before checkpointing. Default is 1.
Returns
-------
callback : function
The callback function that can be passed as iter_end_callback to fit. | [
"Make",
"a",
"callback",
"to",
"checkpoint",
"Module",
"to",
"prefix",
"every",
"epoch",
".",
"unpacks",
"weights",
"used",
"by",
"cells",
"before",
"saving",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/rnn/rnn.py#L97-L121 |
23,849 | apache/incubator-mxnet | python/mxnet/gluon/nn/basic_layers.py | Sequential.hybridize | def hybridize(self, active=True, **kwargs):
"""Activates or deactivates `HybridBlock` s recursively. Has no effect on
non-hybrid children.
Parameters
----------
active : bool, default True
Whether to turn hybrid on or off.
**kwargs : string
Additional flags for hybridized operator.
"""
if self._children and all(isinstance(c, HybridBlock) for c in self._children.values()):
warnings.warn(
"All children of this Sequential layer '%s' are HybridBlocks. Consider "
"using HybridSequential for the best performance."%self.prefix, stacklevel=2)
super(Sequential, self).hybridize(active, **kwargs) | python | def hybridize(self, active=True, **kwargs):
"""Activates or deactivates `HybridBlock` s recursively. Has no effect on
non-hybrid children.
Parameters
----------
active : bool, default True
Whether to turn hybrid on or off.
**kwargs : string
Additional flags for hybridized operator.
"""
if self._children and all(isinstance(c, HybridBlock) for c in self._children.values()):
warnings.warn(
"All children of this Sequential layer '%s' are HybridBlocks. Consider "
"using HybridSequential for the best performance."%self.prefix, stacklevel=2)
super(Sequential, self).hybridize(active, **kwargs) | [
"def",
"hybridize",
"(",
"self",
",",
"active",
"=",
"True",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
".",
"_children",
"and",
"all",
"(",
"isinstance",
"(",
"c",
",",
"HybridBlock",
")",
"for",
"c",
"in",
"self",
".",
"_children",
".",
"values",
"(",
")",
")",
":",
"warnings",
".",
"warn",
"(",
"\"All children of this Sequential layer '%s' are HybridBlocks. Consider \"",
"\"using HybridSequential for the best performance.\"",
"%",
"self",
".",
"prefix",
",",
"stacklevel",
"=",
"2",
")",
"super",
"(",
"Sequential",
",",
"self",
")",
".",
"hybridize",
"(",
"active",
",",
"*",
"*",
"kwargs",
")"
] | Activates or deactivates `HybridBlock` s recursively. Has no effect on
non-hybrid children.
Parameters
----------
active : bool, default True
Whether to turn hybrid on or off.
**kwargs : string
Additional flags for hybridized operator. | [
"Activates",
"or",
"deactivates",
"HybridBlock",
"s",
"recursively",
".",
"Has",
"no",
"effect",
"on",
"non",
"-",
"hybrid",
"children",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/nn/basic_layers.py#L77-L92 |
23,850 | apache/incubator-mxnet | example/ctc/lstm_ocr_infer.py | read_img | def read_img(path):
""" Reads image specified by path into numpy.ndarray"""
img = cv2.resize(cv2.imread(path, 0), (80, 30)).astype(np.float32) / 255
img = np.expand_dims(img.transpose(1, 0), 0)
return img | python | def read_img(path):
""" Reads image specified by path into numpy.ndarray"""
img = cv2.resize(cv2.imread(path, 0), (80, 30)).astype(np.float32) / 255
img = np.expand_dims(img.transpose(1, 0), 0)
return img | [
"def",
"read_img",
"(",
"path",
")",
":",
"img",
"=",
"cv2",
".",
"resize",
"(",
"cv2",
".",
"imread",
"(",
"path",
",",
"0",
")",
",",
"(",
"80",
",",
"30",
")",
")",
".",
"astype",
"(",
"np",
".",
"float32",
")",
"/",
"255",
"img",
"=",
"np",
".",
"expand_dims",
"(",
"img",
".",
"transpose",
"(",
"1",
",",
"0",
")",
",",
"0",
")",
"return",
"img"
] | Reads image specified by path into numpy.ndarray | [
"Reads",
"image",
"specified",
"by",
"path",
"into",
"numpy",
".",
"ndarray"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/lstm_ocr_infer.py#L32-L36 |
23,851 | apache/incubator-mxnet | example/ctc/lstm_ocr_infer.py | lstm_init_states | def lstm_init_states(batch_size):
""" Returns a tuple of names and zero arrays for LSTM init states"""
hp = Hyperparams()
init_shapes = lstm.init_states(batch_size=batch_size, num_lstm_layer=hp.num_lstm_layer, num_hidden=hp.num_hidden)
init_names = [s[0] for s in init_shapes]
init_arrays = [mx.nd.zeros(x[1]) for x in init_shapes]
return init_names, init_arrays | python | def lstm_init_states(batch_size):
""" Returns a tuple of names and zero arrays for LSTM init states"""
hp = Hyperparams()
init_shapes = lstm.init_states(batch_size=batch_size, num_lstm_layer=hp.num_lstm_layer, num_hidden=hp.num_hidden)
init_names = [s[0] for s in init_shapes]
init_arrays = [mx.nd.zeros(x[1]) for x in init_shapes]
return init_names, init_arrays | [
"def",
"lstm_init_states",
"(",
"batch_size",
")",
":",
"hp",
"=",
"Hyperparams",
"(",
")",
"init_shapes",
"=",
"lstm",
".",
"init_states",
"(",
"batch_size",
"=",
"batch_size",
",",
"num_lstm_layer",
"=",
"hp",
".",
"num_lstm_layer",
",",
"num_hidden",
"=",
"hp",
".",
"num_hidden",
")",
"init_names",
"=",
"[",
"s",
"[",
"0",
"]",
"for",
"s",
"in",
"init_shapes",
"]",
"init_arrays",
"=",
"[",
"mx",
".",
"nd",
".",
"zeros",
"(",
"x",
"[",
"1",
"]",
")",
"for",
"x",
"in",
"init_shapes",
"]",
"return",
"init_names",
",",
"init_arrays"
] | Returns a tuple of names and zero arrays for LSTM init states | [
"Returns",
"a",
"tuple",
"of",
"names",
"and",
"zero",
"arrays",
"for",
"LSTM",
"init",
"states"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/lstm_ocr_infer.py#L39-L45 |
23,852 | apache/incubator-mxnet | example/ctc/lstm_ocr_infer.py | load_module | def load_module(prefix, epoch, data_names, data_shapes):
"""Loads the model from checkpoint specified by prefix and epoch, binds it
to an executor, and sets its parameters and returns a mx.mod.Module
"""
sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch)
# We don't need CTC loss for prediction, just a simple softmax will suffice.
# We get the output of the layer just before the loss layer ('pred_fc') and add softmax on top
pred_fc = sym.get_internals()['pred_fc_output']
sym = mx.sym.softmax(data=pred_fc)
mod = mx.mod.Module(symbol=sym, context=mx.cpu(), data_names=data_names, label_names=None)
mod.bind(for_training=False, data_shapes=data_shapes)
mod.set_params(arg_params, aux_params, allow_missing=False)
return mod | python | def load_module(prefix, epoch, data_names, data_shapes):
"""Loads the model from checkpoint specified by prefix and epoch, binds it
to an executor, and sets its parameters and returns a mx.mod.Module
"""
sym, arg_params, aux_params = mx.model.load_checkpoint(prefix, epoch)
# We don't need CTC loss for prediction, just a simple softmax will suffice.
# We get the output of the layer just before the loss layer ('pred_fc') and add softmax on top
pred_fc = sym.get_internals()['pred_fc_output']
sym = mx.sym.softmax(data=pred_fc)
mod = mx.mod.Module(symbol=sym, context=mx.cpu(), data_names=data_names, label_names=None)
mod.bind(for_training=False, data_shapes=data_shapes)
mod.set_params(arg_params, aux_params, allow_missing=False)
return mod | [
"def",
"load_module",
"(",
"prefix",
",",
"epoch",
",",
"data_names",
",",
"data_shapes",
")",
":",
"sym",
",",
"arg_params",
",",
"aux_params",
"=",
"mx",
".",
"model",
".",
"load_checkpoint",
"(",
"prefix",
",",
"epoch",
")",
"# We don't need CTC loss for prediction, just a simple softmax will suffice.",
"# We get the output of the layer just before the loss layer ('pred_fc') and add softmax on top",
"pred_fc",
"=",
"sym",
".",
"get_internals",
"(",
")",
"[",
"'pred_fc_output'",
"]",
"sym",
"=",
"mx",
".",
"sym",
".",
"softmax",
"(",
"data",
"=",
"pred_fc",
")",
"mod",
"=",
"mx",
".",
"mod",
".",
"Module",
"(",
"symbol",
"=",
"sym",
",",
"context",
"=",
"mx",
".",
"cpu",
"(",
")",
",",
"data_names",
"=",
"data_names",
",",
"label_names",
"=",
"None",
")",
"mod",
".",
"bind",
"(",
"for_training",
"=",
"False",
",",
"data_shapes",
"=",
"data_shapes",
")",
"mod",
".",
"set_params",
"(",
"arg_params",
",",
"aux_params",
",",
"allow_missing",
"=",
"False",
")",
"return",
"mod"
] | Loads the model from checkpoint specified by prefix and epoch, binds it
to an executor, and sets its parameters and returns a mx.mod.Module | [
"Loads",
"the",
"model",
"from",
"checkpoint",
"specified",
"by",
"prefix",
"and",
"epoch",
"binds",
"it",
"to",
"an",
"executor",
"and",
"sets",
"its",
"parameters",
"and",
"returns",
"a",
"mx",
".",
"mod",
".",
"Module"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/lstm_ocr_infer.py#L48-L62 |
23,853 | apache/incubator-mxnet | amalgamation/python/mxnet_predict.py | c_str | def c_str(string):
""""Convert a python string to C string."""
if not isinstance(string, str):
string = string.decode('ascii')
return ctypes.c_char_p(string.encode('utf-8')) | python | def c_str(string):
""""Convert a python string to C string."""
if not isinstance(string, str):
string = string.decode('ascii')
return ctypes.c_char_p(string.encode('utf-8')) | [
"def",
"c_str",
"(",
"string",
")",
":",
"if",
"not",
"isinstance",
"(",
"string",
",",
"str",
")",
":",
"string",
"=",
"string",
".",
"decode",
"(",
"'ascii'",
")",
"return",
"ctypes",
".",
"c_char_p",
"(",
"string",
".",
"encode",
"(",
"'utf-8'",
")",
")"
] | Convert a python string to C string. | [
"Convert",
"a",
"python",
"string",
"to",
"C",
"string",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/python/mxnet_predict.py#L40-L44 |
23,854 | apache/incubator-mxnet | amalgamation/python/mxnet_predict.py | _find_lib_path | def _find_lib_path():
"""Find mxnet library."""
curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
amalgamation_lib_path = os.path.join(curr_path, '../../lib/libmxnet_predict.so')
if os.path.exists(amalgamation_lib_path) and os.path.isfile(amalgamation_lib_path):
lib_path = [amalgamation_lib_path]
return lib_path
else:
logging.info('Cannot find libmxnet_predict.so. Will search for MXNet library using libinfo.py then.')
try:
from mxnet.libinfo import find_lib_path
lib_path = find_lib_path()
return lib_path
except ImportError:
libinfo_path = os.path.join(curr_path, '../../python/mxnet/libinfo.py')
if os.path.exists(libinfo_path) and os.path.isfile(libinfo_path):
libinfo = {'__file__': libinfo_path}
exec(compile(open(libinfo_path, "rb").read(), libinfo_path, 'exec'), libinfo, libinfo)
lib_path = libinfo['find_lib_path']()
return lib_path
else:
raise RuntimeError('Cannot find libinfo.py at %s.' % libinfo_path) | python | def _find_lib_path():
"""Find mxnet library."""
curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
amalgamation_lib_path = os.path.join(curr_path, '../../lib/libmxnet_predict.so')
if os.path.exists(amalgamation_lib_path) and os.path.isfile(amalgamation_lib_path):
lib_path = [amalgamation_lib_path]
return lib_path
else:
logging.info('Cannot find libmxnet_predict.so. Will search for MXNet library using libinfo.py then.')
try:
from mxnet.libinfo import find_lib_path
lib_path = find_lib_path()
return lib_path
except ImportError:
libinfo_path = os.path.join(curr_path, '../../python/mxnet/libinfo.py')
if os.path.exists(libinfo_path) and os.path.isfile(libinfo_path):
libinfo = {'__file__': libinfo_path}
exec(compile(open(libinfo_path, "rb").read(), libinfo_path, 'exec'), libinfo, libinfo)
lib_path = libinfo['find_lib_path']()
return lib_path
else:
raise RuntimeError('Cannot find libinfo.py at %s.' % libinfo_path) | [
"def",
"_find_lib_path",
"(",
")",
":",
"curr_path",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"__file__",
")",
")",
")",
"amalgamation_lib_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"curr_path",
",",
"'../../lib/libmxnet_predict.so'",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"amalgamation_lib_path",
")",
"and",
"os",
".",
"path",
".",
"isfile",
"(",
"amalgamation_lib_path",
")",
":",
"lib_path",
"=",
"[",
"amalgamation_lib_path",
"]",
"return",
"lib_path",
"else",
":",
"logging",
".",
"info",
"(",
"'Cannot find libmxnet_predict.so. Will search for MXNet library using libinfo.py then.'",
")",
"try",
":",
"from",
"mxnet",
".",
"libinfo",
"import",
"find_lib_path",
"lib_path",
"=",
"find_lib_path",
"(",
")",
"return",
"lib_path",
"except",
"ImportError",
":",
"libinfo_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"curr_path",
",",
"'../../python/mxnet/libinfo.py'",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"libinfo_path",
")",
"and",
"os",
".",
"path",
".",
"isfile",
"(",
"libinfo_path",
")",
":",
"libinfo",
"=",
"{",
"'__file__'",
":",
"libinfo_path",
"}",
"exec",
"(",
"compile",
"(",
"open",
"(",
"libinfo_path",
",",
"\"rb\"",
")",
".",
"read",
"(",
")",
",",
"libinfo_path",
",",
"'exec'",
")",
",",
"libinfo",
",",
"libinfo",
")",
"lib_path",
"=",
"libinfo",
"[",
"'find_lib_path'",
"]",
"(",
")",
"return",
"lib_path",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Cannot find libinfo.py at %s.'",
"%",
"libinfo_path",
")"
] | Find mxnet library. | [
"Find",
"mxnet",
"library",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/python/mxnet_predict.py#L52-L73 |
23,855 | apache/incubator-mxnet | amalgamation/python/mxnet_predict.py | _load_lib | def _load_lib():
"""Load libary by searching possible path."""
lib_path = _find_lib_path()
lib = ctypes.cdll.LoadLibrary(lib_path[0])
# DMatrix functions
lib.MXGetLastError.restype = ctypes.c_char_p
return lib | python | def _load_lib():
"""Load libary by searching possible path."""
lib_path = _find_lib_path()
lib = ctypes.cdll.LoadLibrary(lib_path[0])
# DMatrix functions
lib.MXGetLastError.restype = ctypes.c_char_p
return lib | [
"def",
"_load_lib",
"(",
")",
":",
"lib_path",
"=",
"_find_lib_path",
"(",
")",
"lib",
"=",
"ctypes",
".",
"cdll",
".",
"LoadLibrary",
"(",
"lib_path",
"[",
"0",
"]",
")",
"# DMatrix functions",
"lib",
".",
"MXGetLastError",
".",
"restype",
"=",
"ctypes",
".",
"c_char_p",
"return",
"lib"
] | Load libary by searching possible path. | [
"Load",
"libary",
"by",
"searching",
"possible",
"path",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/python/mxnet_predict.py#L76-L82 |
23,856 | apache/incubator-mxnet | amalgamation/python/mxnet_predict.py | load_ndarray_file | def load_ndarray_file(nd_bytes):
"""Load ndarray file and return as list of numpy array.
Parameters
----------
nd_bytes : str or bytes
The internal ndarray bytes
Returns
-------
out : dict of str to numpy array or list of numpy array
The output list or dict, depending on whether the saved type is list or dict.
"""
handle = NDListHandle()
olen = mx_uint()
nd_bytes = bytearray(nd_bytes)
ptr = (ctypes.c_char * len(nd_bytes)).from_buffer(nd_bytes)
_check_call(_LIB.MXNDListCreate(
ptr, len(nd_bytes),
ctypes.byref(handle), ctypes.byref(olen)))
keys = []
arrs = []
for i in range(olen.value):
key = ctypes.c_char_p()
cptr = mx_float_p()
pdata = ctypes.POINTER(mx_uint)()
ndim = mx_uint()
_check_call(_LIB.MXNDListGet(
handle, mx_uint(i), ctypes.byref(key),
ctypes.byref(cptr), ctypes.byref(pdata), ctypes.byref(ndim)))
shape = tuple(pdata[:ndim.value])
dbuffer = (mx_float * np.prod(shape)).from_address(ctypes.addressof(cptr.contents))
ret = np.frombuffer(dbuffer, dtype=np.float32).reshape(shape)
ret = np.array(ret, dtype=np.float32)
keys.append(py_str(key.value))
arrs.append(ret)
_check_call(_LIB.MXNDListFree(handle))
if len(keys) == 0 or len(keys[0]) == 0:
return arrs
else:
return {keys[i] : arrs[i] for i in range(len(keys))} | python | def load_ndarray_file(nd_bytes):
"""Load ndarray file and return as list of numpy array.
Parameters
----------
nd_bytes : str or bytes
The internal ndarray bytes
Returns
-------
out : dict of str to numpy array or list of numpy array
The output list or dict, depending on whether the saved type is list or dict.
"""
handle = NDListHandle()
olen = mx_uint()
nd_bytes = bytearray(nd_bytes)
ptr = (ctypes.c_char * len(nd_bytes)).from_buffer(nd_bytes)
_check_call(_LIB.MXNDListCreate(
ptr, len(nd_bytes),
ctypes.byref(handle), ctypes.byref(olen)))
keys = []
arrs = []
for i in range(olen.value):
key = ctypes.c_char_p()
cptr = mx_float_p()
pdata = ctypes.POINTER(mx_uint)()
ndim = mx_uint()
_check_call(_LIB.MXNDListGet(
handle, mx_uint(i), ctypes.byref(key),
ctypes.byref(cptr), ctypes.byref(pdata), ctypes.byref(ndim)))
shape = tuple(pdata[:ndim.value])
dbuffer = (mx_float * np.prod(shape)).from_address(ctypes.addressof(cptr.contents))
ret = np.frombuffer(dbuffer, dtype=np.float32).reshape(shape)
ret = np.array(ret, dtype=np.float32)
keys.append(py_str(key.value))
arrs.append(ret)
_check_call(_LIB.MXNDListFree(handle))
if len(keys) == 0 or len(keys[0]) == 0:
return arrs
else:
return {keys[i] : arrs[i] for i in range(len(keys))} | [
"def",
"load_ndarray_file",
"(",
"nd_bytes",
")",
":",
"handle",
"=",
"NDListHandle",
"(",
")",
"olen",
"=",
"mx_uint",
"(",
")",
"nd_bytes",
"=",
"bytearray",
"(",
"nd_bytes",
")",
"ptr",
"=",
"(",
"ctypes",
".",
"c_char",
"*",
"len",
"(",
"nd_bytes",
")",
")",
".",
"from_buffer",
"(",
"nd_bytes",
")",
"_check_call",
"(",
"_LIB",
".",
"MXNDListCreate",
"(",
"ptr",
",",
"len",
"(",
"nd_bytes",
")",
",",
"ctypes",
".",
"byref",
"(",
"handle",
")",
",",
"ctypes",
".",
"byref",
"(",
"olen",
")",
")",
")",
"keys",
"=",
"[",
"]",
"arrs",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"olen",
".",
"value",
")",
":",
"key",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"cptr",
"=",
"mx_float_p",
"(",
")",
"pdata",
"=",
"ctypes",
".",
"POINTER",
"(",
"mx_uint",
")",
"(",
")",
"ndim",
"=",
"mx_uint",
"(",
")",
"_check_call",
"(",
"_LIB",
".",
"MXNDListGet",
"(",
"handle",
",",
"mx_uint",
"(",
"i",
")",
",",
"ctypes",
".",
"byref",
"(",
"key",
")",
",",
"ctypes",
".",
"byref",
"(",
"cptr",
")",
",",
"ctypes",
".",
"byref",
"(",
"pdata",
")",
",",
"ctypes",
".",
"byref",
"(",
"ndim",
")",
")",
")",
"shape",
"=",
"tuple",
"(",
"pdata",
"[",
":",
"ndim",
".",
"value",
"]",
")",
"dbuffer",
"=",
"(",
"mx_float",
"*",
"np",
".",
"prod",
"(",
"shape",
")",
")",
".",
"from_address",
"(",
"ctypes",
".",
"addressof",
"(",
"cptr",
".",
"contents",
")",
")",
"ret",
"=",
"np",
".",
"frombuffer",
"(",
"dbuffer",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
".",
"reshape",
"(",
"shape",
")",
"ret",
"=",
"np",
".",
"array",
"(",
"ret",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
"keys",
".",
"append",
"(",
"py_str",
"(",
"key",
".",
"value",
")",
")",
"arrs",
".",
"append",
"(",
"ret",
")",
"_check_call",
"(",
"_LIB",
".",
"MXNDListFree",
"(",
"handle",
")",
")",
"if",
"len",
"(",
"keys",
")",
"==",
"0",
"or",
"len",
"(",
"keys",
"[",
"0",
"]",
")",
"==",
"0",
":",
"return",
"arrs",
"else",
":",
"return",
"{",
"keys",
"[",
"i",
"]",
":",
"arrs",
"[",
"i",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"keys",
")",
")",
"}"
] | Load ndarray file and return as list of numpy array.
Parameters
----------
nd_bytes : str or bytes
The internal ndarray bytes
Returns
-------
out : dict of str to numpy array or list of numpy array
The output list or dict, depending on whether the saved type is list or dict. | [
"Load",
"ndarray",
"file",
"and",
"return",
"as",
"list",
"of",
"numpy",
"array",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/python/mxnet_predict.py#L234-L276 |
23,857 | apache/incubator-mxnet | amalgamation/python/mxnet_predict.py | Predictor.forward | def forward(self, **kwargs):
"""Perform forward to get the output.
Parameters
----------
**kwargs
Keyword arguments of input variable name to data.
Examples
--------
>>> predictor.forward(data=mydata)
>>> out = predictor.get_output(0)
"""
for k, v in kwargs.items():
if not isinstance(v, np.ndarray):
raise ValueError("Expect numpy ndarray as input")
v = np.asarray(v, dtype=np.float32, order='C')
_check_call(_LIB.MXPredSetInput(
self.handle, c_str(k),
v.ctypes.data_as(mx_float_p),
mx_uint(v.size)))
_check_call(_LIB.MXPredForward(self.handle)) | python | def forward(self, **kwargs):
"""Perform forward to get the output.
Parameters
----------
**kwargs
Keyword arguments of input variable name to data.
Examples
--------
>>> predictor.forward(data=mydata)
>>> out = predictor.get_output(0)
"""
for k, v in kwargs.items():
if not isinstance(v, np.ndarray):
raise ValueError("Expect numpy ndarray as input")
v = np.asarray(v, dtype=np.float32, order='C')
_check_call(_LIB.MXPredSetInput(
self.handle, c_str(k),
v.ctypes.data_as(mx_float_p),
mx_uint(v.size)))
_check_call(_LIB.MXPredForward(self.handle)) | [
"def",
"forward",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"if",
"not",
"isinstance",
"(",
"v",
",",
"np",
".",
"ndarray",
")",
":",
"raise",
"ValueError",
"(",
"\"Expect numpy ndarray as input\"",
")",
"v",
"=",
"np",
".",
"asarray",
"(",
"v",
",",
"dtype",
"=",
"np",
".",
"float32",
",",
"order",
"=",
"'C'",
")",
"_check_call",
"(",
"_LIB",
".",
"MXPredSetInput",
"(",
"self",
".",
"handle",
",",
"c_str",
"(",
"k",
")",
",",
"v",
".",
"ctypes",
".",
"data_as",
"(",
"mx_float_p",
")",
",",
"mx_uint",
"(",
"v",
".",
"size",
")",
")",
")",
"_check_call",
"(",
"_LIB",
".",
"MXPredForward",
"(",
"self",
".",
"handle",
")",
")"
] | Perform forward to get the output.
Parameters
----------
**kwargs
Keyword arguments of input variable name to data.
Examples
--------
>>> predictor.forward(data=mydata)
>>> out = predictor.get_output(0) | [
"Perform",
"forward",
"to",
"get",
"the",
"output",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/python/mxnet_predict.py#L150-L171 |
23,858 | apache/incubator-mxnet | amalgamation/python/mxnet_predict.py | Predictor.reshape | def reshape(self, input_shapes):
"""Change the input shape of the predictor.
Parameters
----------
input_shapes : dict of str to tuple
The new shape of input data.
Examples
--------
>>> predictor.reshape({'data':data_shape_tuple})
"""
indptr = [0]
sdata = []
keys = []
for k, v in input_shapes.items():
if not isinstance(v, tuple):
raise ValueError("Expect input_shapes to be dict str->tuple")
keys.append(c_str(k))
sdata.extend(v)
indptr.append(len(sdata))
new_handle = PredictorHandle()
_check_call(_LIB.MXPredReshape(
mx_uint(len(indptr) - 1),
c_array(ctypes.c_char_p, keys),
c_array(mx_uint, indptr),
c_array(mx_uint, sdata),
self.handle,
ctypes.byref(new_handle)))
_check_call(_LIB.MXPredFree(self.handle))
self.handle = new_handle | python | def reshape(self, input_shapes):
"""Change the input shape of the predictor.
Parameters
----------
input_shapes : dict of str to tuple
The new shape of input data.
Examples
--------
>>> predictor.reshape({'data':data_shape_tuple})
"""
indptr = [0]
sdata = []
keys = []
for k, v in input_shapes.items():
if not isinstance(v, tuple):
raise ValueError("Expect input_shapes to be dict str->tuple")
keys.append(c_str(k))
sdata.extend(v)
indptr.append(len(sdata))
new_handle = PredictorHandle()
_check_call(_LIB.MXPredReshape(
mx_uint(len(indptr) - 1),
c_array(ctypes.c_char_p, keys),
c_array(mx_uint, indptr),
c_array(mx_uint, sdata),
self.handle,
ctypes.byref(new_handle)))
_check_call(_LIB.MXPredFree(self.handle))
self.handle = new_handle | [
"def",
"reshape",
"(",
"self",
",",
"input_shapes",
")",
":",
"indptr",
"=",
"[",
"0",
"]",
"sdata",
"=",
"[",
"]",
"keys",
"=",
"[",
"]",
"for",
"k",
",",
"v",
"in",
"input_shapes",
".",
"items",
"(",
")",
":",
"if",
"not",
"isinstance",
"(",
"v",
",",
"tuple",
")",
":",
"raise",
"ValueError",
"(",
"\"Expect input_shapes to be dict str->tuple\"",
")",
"keys",
".",
"append",
"(",
"c_str",
"(",
"k",
")",
")",
"sdata",
".",
"extend",
"(",
"v",
")",
"indptr",
".",
"append",
"(",
"len",
"(",
"sdata",
")",
")",
"new_handle",
"=",
"PredictorHandle",
"(",
")",
"_check_call",
"(",
"_LIB",
".",
"MXPredReshape",
"(",
"mx_uint",
"(",
"len",
"(",
"indptr",
")",
"-",
"1",
")",
",",
"c_array",
"(",
"ctypes",
".",
"c_char_p",
",",
"keys",
")",
",",
"c_array",
"(",
"mx_uint",
",",
"indptr",
")",
",",
"c_array",
"(",
"mx_uint",
",",
"sdata",
")",
",",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"new_handle",
")",
")",
")",
"_check_call",
"(",
"_LIB",
".",
"MXPredFree",
"(",
"self",
".",
"handle",
")",
")",
"self",
".",
"handle",
"=",
"new_handle"
] | Change the input shape of the predictor.
Parameters
----------
input_shapes : dict of str to tuple
The new shape of input data.
Examples
--------
>>> predictor.reshape({'data':data_shape_tuple}) | [
"Change",
"the",
"input",
"shape",
"of",
"the",
"predictor",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/python/mxnet_predict.py#L173-L204 |
23,859 | apache/incubator-mxnet | amalgamation/python/mxnet_predict.py | Predictor.get_output | def get_output(self, index):
"""Get the index-th output.
Parameters
----------
index : int
The index of output.
Returns
-------
out : numpy array.
The output array.
"""
pdata = ctypes.POINTER(mx_uint)()
ndim = mx_uint()
_check_call(_LIB.MXPredGetOutputShape(
self.handle, index,
ctypes.byref(pdata),
ctypes.byref(ndim)))
shape = tuple(pdata[:ndim.value])
data = np.empty(shape, dtype=np.float32)
_check_call(_LIB.MXPredGetOutput(
self.handle, mx_uint(index),
data.ctypes.data_as(mx_float_p),
mx_uint(data.size)))
return data | python | def get_output(self, index):
"""Get the index-th output.
Parameters
----------
index : int
The index of output.
Returns
-------
out : numpy array.
The output array.
"""
pdata = ctypes.POINTER(mx_uint)()
ndim = mx_uint()
_check_call(_LIB.MXPredGetOutputShape(
self.handle, index,
ctypes.byref(pdata),
ctypes.byref(ndim)))
shape = tuple(pdata[:ndim.value])
data = np.empty(shape, dtype=np.float32)
_check_call(_LIB.MXPredGetOutput(
self.handle, mx_uint(index),
data.ctypes.data_as(mx_float_p),
mx_uint(data.size)))
return data | [
"def",
"get_output",
"(",
"self",
",",
"index",
")",
":",
"pdata",
"=",
"ctypes",
".",
"POINTER",
"(",
"mx_uint",
")",
"(",
")",
"ndim",
"=",
"mx_uint",
"(",
")",
"_check_call",
"(",
"_LIB",
".",
"MXPredGetOutputShape",
"(",
"self",
".",
"handle",
",",
"index",
",",
"ctypes",
".",
"byref",
"(",
"pdata",
")",
",",
"ctypes",
".",
"byref",
"(",
"ndim",
")",
")",
")",
"shape",
"=",
"tuple",
"(",
"pdata",
"[",
":",
"ndim",
".",
"value",
"]",
")",
"data",
"=",
"np",
".",
"empty",
"(",
"shape",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
"_check_call",
"(",
"_LIB",
".",
"MXPredGetOutput",
"(",
"self",
".",
"handle",
",",
"mx_uint",
"(",
"index",
")",
",",
"data",
".",
"ctypes",
".",
"data_as",
"(",
"mx_float_p",
")",
",",
"mx_uint",
"(",
"data",
".",
"size",
")",
")",
")",
"return",
"data"
] | Get the index-th output.
Parameters
----------
index : int
The index of output.
Returns
-------
out : numpy array.
The output array. | [
"Get",
"the",
"index",
"-",
"th",
"output",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/amalgamation/python/mxnet_predict.py#L206-L231 |
23,860 | apache/incubator-mxnet | example/reinforcement-learning/dqn/atari_game.py | AtariGame.begin_episode | def begin_episode(self, max_episode_step=DEFAULT_MAX_EPISODE_STEP):
"""
Begin an episode of a game instance. We can play the game for a maximum of
`max_episode_step` and after that, we are forced to restart
"""
if self.episode_step > self.max_episode_step or self.ale.game_over():
self.start()
else:
for i in range(self.screen_buffer_length):
self.ale.act(0)
self.ale.getScreenGrayscale(self.screen_buffer[i % self.screen_buffer_length, :, :])
self.max_episode_step = max_episode_step
self.start_lives = self.ale.lives()
self.episode_reward = 0
self.episode_step = 0 | python | def begin_episode(self, max_episode_step=DEFAULT_MAX_EPISODE_STEP):
"""
Begin an episode of a game instance. We can play the game for a maximum of
`max_episode_step` and after that, we are forced to restart
"""
if self.episode_step > self.max_episode_step or self.ale.game_over():
self.start()
else:
for i in range(self.screen_buffer_length):
self.ale.act(0)
self.ale.getScreenGrayscale(self.screen_buffer[i % self.screen_buffer_length, :, :])
self.max_episode_step = max_episode_step
self.start_lives = self.ale.lives()
self.episode_reward = 0
self.episode_step = 0 | [
"def",
"begin_episode",
"(",
"self",
",",
"max_episode_step",
"=",
"DEFAULT_MAX_EPISODE_STEP",
")",
":",
"if",
"self",
".",
"episode_step",
">",
"self",
".",
"max_episode_step",
"or",
"self",
".",
"ale",
".",
"game_over",
"(",
")",
":",
"self",
".",
"start",
"(",
")",
"else",
":",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"screen_buffer_length",
")",
":",
"self",
".",
"ale",
".",
"act",
"(",
"0",
")",
"self",
".",
"ale",
".",
"getScreenGrayscale",
"(",
"self",
".",
"screen_buffer",
"[",
"i",
"%",
"self",
".",
"screen_buffer_length",
",",
":",
",",
":",
"]",
")",
"self",
".",
"max_episode_step",
"=",
"max_episode_step",
"self",
".",
"start_lives",
"=",
"self",
".",
"ale",
".",
"lives",
"(",
")",
"self",
".",
"episode_reward",
"=",
"0",
"self",
".",
"episode_step",
"=",
"0"
] | Begin an episode of a game instance. We can play the game for a maximum of
`max_episode_step` and after that, we are forced to restart | [
"Begin",
"an",
"episode",
"of",
"a",
"game",
"instance",
".",
"We",
"can",
"play",
"the",
"game",
"for",
"a",
"maximum",
"of",
"max_episode_step",
"and",
"after",
"that",
"we",
"are",
"forced",
"to",
"restart"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/reinforcement-learning/dqn/atari_game.py#L112-L126 |
23,861 | apache/incubator-mxnet | python/mxnet/gluon/rnn/rnn_cell.py | RecurrentCell.forward | def forward(self, inputs, states):
"""Unrolls the recurrent cell for one time step.
Parameters
----------
inputs : sym.Variable
Input symbol, 2D, of shape (batch_size * num_units).
states : list of sym.Variable
RNN state from previous step or the output of begin_state().
Returns
-------
output : Symbol
Symbol corresponding to the output from the RNN when unrolling
for a single time step.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state()`.
This can be used as an input state to the next time step
of this RNN.
See Also
--------
begin_state: This function can provide the states for the first time step.
unroll: This function unrolls an RNN for a given number of (>=1) time steps.
"""
# pylint: disable= arguments-differ
self._counter += 1
return super(RecurrentCell, self).forward(inputs, states) | python | def forward(self, inputs, states):
"""Unrolls the recurrent cell for one time step.
Parameters
----------
inputs : sym.Variable
Input symbol, 2D, of shape (batch_size * num_units).
states : list of sym.Variable
RNN state from previous step or the output of begin_state().
Returns
-------
output : Symbol
Symbol corresponding to the output from the RNN when unrolling
for a single time step.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state()`.
This can be used as an input state to the next time step
of this RNN.
See Also
--------
begin_state: This function can provide the states for the first time step.
unroll: This function unrolls an RNN for a given number of (>=1) time steps.
"""
# pylint: disable= arguments-differ
self._counter += 1
return super(RecurrentCell, self).forward(inputs, states) | [
"def",
"forward",
"(",
"self",
",",
"inputs",
",",
"states",
")",
":",
"# pylint: disable= arguments-differ",
"self",
".",
"_counter",
"+=",
"1",
"return",
"super",
"(",
"RecurrentCell",
",",
"self",
")",
".",
"forward",
"(",
"inputs",
",",
"states",
")"
] | Unrolls the recurrent cell for one time step.
Parameters
----------
inputs : sym.Variable
Input symbol, 2D, of shape (batch_size * num_units).
states : list of sym.Variable
RNN state from previous step or the output of begin_state().
Returns
-------
output : Symbol
Symbol corresponding to the output from the RNN when unrolling
for a single time step.
states : list of Symbol
The new state of this RNN after this unrolling.
The type of this symbol is same as the output of `begin_state()`.
This can be used as an input state to the next time step
of this RNN.
See Also
--------
begin_state: This function can provide the states for the first time step.
unroll: This function unrolls an RNN for a given number of (>=1) time steps. | [
"Unrolls",
"the",
"recurrent",
"cell",
"for",
"one",
"time",
"step",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/rnn/rnn_cell.py#L284-L312 |
23,862 | apache/incubator-mxnet | python/mxnet/module/base_module.py | _check_input_names | def _check_input_names(symbol, names, typename, throw):
"""Check that all input names are in symbol's arguments."""
args = symbol.list_arguments()
for name in names:
if name in args:
continue
candidates = [arg for arg in args if
not arg.endswith('_weight') and
not arg.endswith('_bias') and
not arg.endswith('_gamma') and
not arg.endswith('_beta')]
msg = "\033[91mYou created Module with Module(..., %s_names=%s) but " \
"input with name '%s' is not found in symbol.list_arguments(). " \
"Did you mean one of:\n\t%s\033[0m"%(
typename, str(names), name, '\n\t'.join(candidates))
if throw:
raise ValueError(msg)
else:
warnings.warn(msg) | python | def _check_input_names(symbol, names, typename, throw):
"""Check that all input names are in symbol's arguments."""
args = symbol.list_arguments()
for name in names:
if name in args:
continue
candidates = [arg for arg in args if
not arg.endswith('_weight') and
not arg.endswith('_bias') and
not arg.endswith('_gamma') and
not arg.endswith('_beta')]
msg = "\033[91mYou created Module with Module(..., %s_names=%s) but " \
"input with name '%s' is not found in symbol.list_arguments(). " \
"Did you mean one of:\n\t%s\033[0m"%(
typename, str(names), name, '\n\t'.join(candidates))
if throw:
raise ValueError(msg)
else:
warnings.warn(msg) | [
"def",
"_check_input_names",
"(",
"symbol",
",",
"names",
",",
"typename",
",",
"throw",
")",
":",
"args",
"=",
"symbol",
".",
"list_arguments",
"(",
")",
"for",
"name",
"in",
"names",
":",
"if",
"name",
"in",
"args",
":",
"continue",
"candidates",
"=",
"[",
"arg",
"for",
"arg",
"in",
"args",
"if",
"not",
"arg",
".",
"endswith",
"(",
"'_weight'",
")",
"and",
"not",
"arg",
".",
"endswith",
"(",
"'_bias'",
")",
"and",
"not",
"arg",
".",
"endswith",
"(",
"'_gamma'",
")",
"and",
"not",
"arg",
".",
"endswith",
"(",
"'_beta'",
")",
"]",
"msg",
"=",
"\"\\033[91mYou created Module with Module(..., %s_names=%s) but \"",
"\"input with name '%s' is not found in symbol.list_arguments(). \"",
"\"Did you mean one of:\\n\\t%s\\033[0m\"",
"%",
"(",
"typename",
",",
"str",
"(",
"names",
")",
",",
"name",
",",
"'\\n\\t'",
".",
"join",
"(",
"candidates",
")",
")",
"if",
"throw",
":",
"raise",
"ValueError",
"(",
"msg",
")",
"else",
":",
"warnings",
".",
"warn",
"(",
"msg",
")"
] | Check that all input names are in symbol's arguments. | [
"Check",
"that",
"all",
"input",
"names",
"are",
"in",
"symbol",
"s",
"arguments",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L37-L55 |
23,863 | apache/incubator-mxnet | python/mxnet/module/base_module.py | _check_names_match | def _check_names_match(data_names, data_shapes, name, throw):
"""Check that input names matches input data descriptors."""
actual = [x[0] for x in data_shapes]
if sorted(data_names) != sorted(actual):
msg = "Data provided by %s_shapes don't match names specified by %s_names (%s vs. %s)"%(
name, name, str(data_shapes), str(data_names))
if throw:
raise ValueError(msg)
else:
warnings.warn(msg) | python | def _check_names_match(data_names, data_shapes, name, throw):
"""Check that input names matches input data descriptors."""
actual = [x[0] for x in data_shapes]
if sorted(data_names) != sorted(actual):
msg = "Data provided by %s_shapes don't match names specified by %s_names (%s vs. %s)"%(
name, name, str(data_shapes), str(data_names))
if throw:
raise ValueError(msg)
else:
warnings.warn(msg) | [
"def",
"_check_names_match",
"(",
"data_names",
",",
"data_shapes",
",",
"name",
",",
"throw",
")",
":",
"actual",
"=",
"[",
"x",
"[",
"0",
"]",
"for",
"x",
"in",
"data_shapes",
"]",
"if",
"sorted",
"(",
"data_names",
")",
"!=",
"sorted",
"(",
"actual",
")",
":",
"msg",
"=",
"\"Data provided by %s_shapes don't match names specified by %s_names (%s vs. %s)\"",
"%",
"(",
"name",
",",
"name",
",",
"str",
"(",
"data_shapes",
")",
",",
"str",
"(",
"data_names",
")",
")",
"if",
"throw",
":",
"raise",
"ValueError",
"(",
"msg",
")",
"else",
":",
"warnings",
".",
"warn",
"(",
"msg",
")"
] | Check that input names matches input data descriptors. | [
"Check",
"that",
"input",
"names",
"matches",
"input",
"data",
"descriptors",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L58-L67 |
23,864 | apache/incubator-mxnet | python/mxnet/module/base_module.py | _parse_data_desc | def _parse_data_desc(data_names, label_names, data_shapes, label_shapes):
"""parse data_attrs into DataDesc format and check that names match"""
data_shapes = [x if isinstance(x, DataDesc) else DataDesc(*x) for x in data_shapes]
_check_names_match(data_names, data_shapes, 'data', True)
if label_shapes is not None:
label_shapes = [x if isinstance(x, DataDesc) else DataDesc(*x) for x in label_shapes]
_check_names_match(label_names, label_shapes, 'label', False)
else:
_check_names_match(label_names, [], 'label', False)
return data_shapes, label_shapes | python | def _parse_data_desc(data_names, label_names, data_shapes, label_shapes):
"""parse data_attrs into DataDesc format and check that names match"""
data_shapes = [x if isinstance(x, DataDesc) else DataDesc(*x) for x in data_shapes]
_check_names_match(data_names, data_shapes, 'data', True)
if label_shapes is not None:
label_shapes = [x if isinstance(x, DataDesc) else DataDesc(*x) for x in label_shapes]
_check_names_match(label_names, label_shapes, 'label', False)
else:
_check_names_match(label_names, [], 'label', False)
return data_shapes, label_shapes | [
"def",
"_parse_data_desc",
"(",
"data_names",
",",
"label_names",
",",
"data_shapes",
",",
"label_shapes",
")",
":",
"data_shapes",
"=",
"[",
"x",
"if",
"isinstance",
"(",
"x",
",",
"DataDesc",
")",
"else",
"DataDesc",
"(",
"*",
"x",
")",
"for",
"x",
"in",
"data_shapes",
"]",
"_check_names_match",
"(",
"data_names",
",",
"data_shapes",
",",
"'data'",
",",
"True",
")",
"if",
"label_shapes",
"is",
"not",
"None",
":",
"label_shapes",
"=",
"[",
"x",
"if",
"isinstance",
"(",
"x",
",",
"DataDesc",
")",
"else",
"DataDesc",
"(",
"*",
"x",
")",
"for",
"x",
"in",
"label_shapes",
"]",
"_check_names_match",
"(",
"label_names",
",",
"label_shapes",
",",
"'label'",
",",
"False",
")",
"else",
":",
"_check_names_match",
"(",
"label_names",
",",
"[",
"]",
",",
"'label'",
",",
"False",
")",
"return",
"data_shapes",
",",
"label_shapes"
] | parse data_attrs into DataDesc format and check that names match | [
"parse",
"data_attrs",
"into",
"DataDesc",
"format",
"and",
"check",
"that",
"names",
"match"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L70-L79 |
23,865 | apache/incubator-mxnet | python/mxnet/module/base_module.py | BaseModule.forward_backward | def forward_backward(self, data_batch):
"""A convenient function that calls both ``forward`` and ``backward``."""
self.forward(data_batch, is_train=True)
self.backward() | python | def forward_backward(self, data_batch):
"""A convenient function that calls both ``forward`` and ``backward``."""
self.forward(data_batch, is_train=True)
self.backward() | [
"def",
"forward_backward",
"(",
"self",
",",
"data_batch",
")",
":",
"self",
".",
"forward",
"(",
"data_batch",
",",
"is_train",
"=",
"True",
")",
"self",
".",
"backward",
"(",
")"
] | A convenient function that calls both ``forward`` and ``backward``. | [
"A",
"convenient",
"function",
"that",
"calls",
"both",
"forward",
"and",
"backward",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L193-L196 |
23,866 | apache/incubator-mxnet | python/mxnet/module/base_module.py | BaseModule.score | def score(self, eval_data, eval_metric, num_batch=None, batch_end_callback=None,
score_end_callback=None,
reset=True, epoch=0, sparse_row_id_fn=None):
"""Runs prediction on ``eval_data`` and evaluates the performance according to
the given ``eval_metric``.
Checkout `Module Tutorial <http://mxnet.io/tutorials/basic/module.html>`_ to see
a end-to-end use-case.
Parameters
----------
eval_data : DataIter
Evaluation data to run prediction on.
eval_metric : EvalMetric or list of EvalMetrics
Evaluation metric to use.
num_batch : int
Number of batches to run. Defaults to ``None``, indicating run until the `DataIter`
finishes.
batch_end_callback : function
Could also be a list of functions.
reset : bool
Defaults to ``True``. Indicates whether we should reset `eval_data` before starting
evaluating.
epoch : int
Defaults to 0. For compatibility, this will be passed to callbacks (if any).
During training, this will correspond to the training epoch number.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
Examples
--------
>>> # An example of using score for prediction.
>>> # Evaluate accuracy on val_dataiter
>>> metric = mx.metric.Accuracy()
>>> mod.score(val_dataiter, metric)
>>> mod.score(val_dataiter, ['mse', 'acc'])
"""
assert self.binded and self.params_initialized
if reset:
eval_data.reset()
if not isinstance(eval_metric, metric.EvalMetric):
eval_metric = metric.create(eval_metric)
eval_metric.reset()
actual_num_batch = 0
for nbatch, eval_batch in enumerate(eval_data):
if num_batch is not None and nbatch == num_batch:
break
self.prepare(eval_batch, sparse_row_id_fn=sparse_row_id_fn)
self.forward(eval_batch, is_train=False)
if isinstance(eval_batch, list):
self.update_metric(eval_metric, [eb.label for eb in eval_batch], pre_sliced=True)
else:
self.update_metric(eval_metric, eval_batch.label)
if batch_end_callback is not None:
batch_end_params = BatchEndParam(epoch=epoch,
nbatch=nbatch,
eval_metric=eval_metric,
locals=locals())
for callback in _as_list(batch_end_callback):
callback(batch_end_params)
actual_num_batch += 1
if score_end_callback:
params = BatchEndParam(epoch=epoch,
nbatch=actual_num_batch,
eval_metric=eval_metric,
locals=locals())
for callback in _as_list(score_end_callback):
callback(params)
return eval_metric.get_name_value() | python | def score(self, eval_data, eval_metric, num_batch=None, batch_end_callback=None,
score_end_callback=None,
reset=True, epoch=0, sparse_row_id_fn=None):
"""Runs prediction on ``eval_data`` and evaluates the performance according to
the given ``eval_metric``.
Checkout `Module Tutorial <http://mxnet.io/tutorials/basic/module.html>`_ to see
a end-to-end use-case.
Parameters
----------
eval_data : DataIter
Evaluation data to run prediction on.
eval_metric : EvalMetric or list of EvalMetrics
Evaluation metric to use.
num_batch : int
Number of batches to run. Defaults to ``None``, indicating run until the `DataIter`
finishes.
batch_end_callback : function
Could also be a list of functions.
reset : bool
Defaults to ``True``. Indicates whether we should reset `eval_data` before starting
evaluating.
epoch : int
Defaults to 0. For compatibility, this will be passed to callbacks (if any).
During training, this will correspond to the training epoch number.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
Examples
--------
>>> # An example of using score for prediction.
>>> # Evaluate accuracy on val_dataiter
>>> metric = mx.metric.Accuracy()
>>> mod.score(val_dataiter, metric)
>>> mod.score(val_dataiter, ['mse', 'acc'])
"""
assert self.binded and self.params_initialized
if reset:
eval_data.reset()
if not isinstance(eval_metric, metric.EvalMetric):
eval_metric = metric.create(eval_metric)
eval_metric.reset()
actual_num_batch = 0
for nbatch, eval_batch in enumerate(eval_data):
if num_batch is not None and nbatch == num_batch:
break
self.prepare(eval_batch, sparse_row_id_fn=sparse_row_id_fn)
self.forward(eval_batch, is_train=False)
if isinstance(eval_batch, list):
self.update_metric(eval_metric, [eb.label for eb in eval_batch], pre_sliced=True)
else:
self.update_metric(eval_metric, eval_batch.label)
if batch_end_callback is not None:
batch_end_params = BatchEndParam(epoch=epoch,
nbatch=nbatch,
eval_metric=eval_metric,
locals=locals())
for callback in _as_list(batch_end_callback):
callback(batch_end_params)
actual_num_batch += 1
if score_end_callback:
params = BatchEndParam(epoch=epoch,
nbatch=actual_num_batch,
eval_metric=eval_metric,
locals=locals())
for callback in _as_list(score_end_callback):
callback(params)
return eval_metric.get_name_value() | [
"def",
"score",
"(",
"self",
",",
"eval_data",
",",
"eval_metric",
",",
"num_batch",
"=",
"None",
",",
"batch_end_callback",
"=",
"None",
",",
"score_end_callback",
"=",
"None",
",",
"reset",
"=",
"True",
",",
"epoch",
"=",
"0",
",",
"sparse_row_id_fn",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"if",
"reset",
":",
"eval_data",
".",
"reset",
"(",
")",
"if",
"not",
"isinstance",
"(",
"eval_metric",
",",
"metric",
".",
"EvalMetric",
")",
":",
"eval_metric",
"=",
"metric",
".",
"create",
"(",
"eval_metric",
")",
"eval_metric",
".",
"reset",
"(",
")",
"actual_num_batch",
"=",
"0",
"for",
"nbatch",
",",
"eval_batch",
"in",
"enumerate",
"(",
"eval_data",
")",
":",
"if",
"num_batch",
"is",
"not",
"None",
"and",
"nbatch",
"==",
"num_batch",
":",
"break",
"self",
".",
"prepare",
"(",
"eval_batch",
",",
"sparse_row_id_fn",
"=",
"sparse_row_id_fn",
")",
"self",
".",
"forward",
"(",
"eval_batch",
",",
"is_train",
"=",
"False",
")",
"if",
"isinstance",
"(",
"eval_batch",
",",
"list",
")",
":",
"self",
".",
"update_metric",
"(",
"eval_metric",
",",
"[",
"eb",
".",
"label",
"for",
"eb",
"in",
"eval_batch",
"]",
",",
"pre_sliced",
"=",
"True",
")",
"else",
":",
"self",
".",
"update_metric",
"(",
"eval_metric",
",",
"eval_batch",
".",
"label",
")",
"if",
"batch_end_callback",
"is",
"not",
"None",
":",
"batch_end_params",
"=",
"BatchEndParam",
"(",
"epoch",
"=",
"epoch",
",",
"nbatch",
"=",
"nbatch",
",",
"eval_metric",
"=",
"eval_metric",
",",
"locals",
"=",
"locals",
"(",
")",
")",
"for",
"callback",
"in",
"_as_list",
"(",
"batch_end_callback",
")",
":",
"callback",
"(",
"batch_end_params",
")",
"actual_num_batch",
"+=",
"1",
"if",
"score_end_callback",
":",
"params",
"=",
"BatchEndParam",
"(",
"epoch",
"=",
"epoch",
",",
"nbatch",
"=",
"actual_num_batch",
",",
"eval_metric",
"=",
"eval_metric",
",",
"locals",
"=",
"locals",
"(",
")",
")",
"for",
"callback",
"in",
"_as_list",
"(",
"score_end_callback",
")",
":",
"callback",
"(",
"params",
")",
"return",
"eval_metric",
".",
"get_name_value",
"(",
")"
] | Runs prediction on ``eval_data`` and evaluates the performance according to
the given ``eval_metric``.
Checkout `Module Tutorial <http://mxnet.io/tutorials/basic/module.html>`_ to see
a end-to-end use-case.
Parameters
----------
eval_data : DataIter
Evaluation data to run prediction on.
eval_metric : EvalMetric or list of EvalMetrics
Evaluation metric to use.
num_batch : int
Number of batches to run. Defaults to ``None``, indicating run until the `DataIter`
finishes.
batch_end_callback : function
Could also be a list of functions.
reset : bool
Defaults to ``True``. Indicates whether we should reset `eval_data` before starting
evaluating.
epoch : int
Defaults to 0. For compatibility, this will be passed to callbacks (if any).
During training, this will correspond to the training epoch number.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
Examples
--------
>>> # An example of using score for prediction.
>>> # Evaluate accuracy on val_dataiter
>>> metric = mx.metric.Accuracy()
>>> mod.score(val_dataiter, metric)
>>> mod.score(val_dataiter, ['mse', 'acc']) | [
"Runs",
"prediction",
"on",
"eval_data",
"and",
"evaluates",
"the",
"performance",
"according",
"to",
"the",
"given",
"eval_metric",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L198-L276 |
23,867 | apache/incubator-mxnet | python/mxnet/module/base_module.py | BaseModule.iter_predict | def iter_predict(self, eval_data, num_batch=None, reset=True, sparse_row_id_fn=None):
"""Iterates over predictions.
Examples
--------
>>> for pred, i_batch, batch in module.iter_predict(eval_data):
... # pred is a list of outputs from the module
... # i_batch is a integer
... # batch is the data batch from the data iterator
Parameters
----------
eval_data : DataIter
Evaluation data to run prediction on.
num_batch : int
Default is ``None``, indicating running all the batches in the data iterator.
reset : bool
Default is ``True``, indicating whether we should reset the data iter before start
doing prediction.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
"""
assert self.binded and self.params_initialized
if reset:
eval_data.reset()
for nbatch, eval_batch in enumerate(eval_data):
if num_batch is not None and nbatch == num_batch:
break
self.prepare(eval_batch, sparse_row_id_fn=sparse_row_id_fn)
self.forward(eval_batch, is_train=False)
pad = eval_batch.pad
outputs = [out[0:out.shape[0]-pad] for out in self.get_outputs()]
yield (outputs, nbatch, eval_batch) | python | def iter_predict(self, eval_data, num_batch=None, reset=True, sparse_row_id_fn=None):
"""Iterates over predictions.
Examples
--------
>>> for pred, i_batch, batch in module.iter_predict(eval_data):
... # pred is a list of outputs from the module
... # i_batch is a integer
... # batch is the data batch from the data iterator
Parameters
----------
eval_data : DataIter
Evaluation data to run prediction on.
num_batch : int
Default is ``None``, indicating running all the batches in the data iterator.
reset : bool
Default is ``True``, indicating whether we should reset the data iter before start
doing prediction.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
"""
assert self.binded and self.params_initialized
if reset:
eval_data.reset()
for nbatch, eval_batch in enumerate(eval_data):
if num_batch is not None and nbatch == num_batch:
break
self.prepare(eval_batch, sparse_row_id_fn=sparse_row_id_fn)
self.forward(eval_batch, is_train=False)
pad = eval_batch.pad
outputs = [out[0:out.shape[0]-pad] for out in self.get_outputs()]
yield (outputs, nbatch, eval_batch) | [
"def",
"iter_predict",
"(",
"self",
",",
"eval_data",
",",
"num_batch",
"=",
"None",
",",
"reset",
"=",
"True",
",",
"sparse_row_id_fn",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"if",
"reset",
":",
"eval_data",
".",
"reset",
"(",
")",
"for",
"nbatch",
",",
"eval_batch",
"in",
"enumerate",
"(",
"eval_data",
")",
":",
"if",
"num_batch",
"is",
"not",
"None",
"and",
"nbatch",
"==",
"num_batch",
":",
"break",
"self",
".",
"prepare",
"(",
"eval_batch",
",",
"sparse_row_id_fn",
"=",
"sparse_row_id_fn",
")",
"self",
".",
"forward",
"(",
"eval_batch",
",",
"is_train",
"=",
"False",
")",
"pad",
"=",
"eval_batch",
".",
"pad",
"outputs",
"=",
"[",
"out",
"[",
"0",
":",
"out",
".",
"shape",
"[",
"0",
"]",
"-",
"pad",
"]",
"for",
"out",
"in",
"self",
".",
"get_outputs",
"(",
")",
"]",
"yield",
"(",
"outputs",
",",
"nbatch",
",",
"eval_batch",
")"
] | Iterates over predictions.
Examples
--------
>>> for pred, i_batch, batch in module.iter_predict(eval_data):
... # pred is a list of outputs from the module
... # i_batch is a integer
... # batch is the data batch from the data iterator
Parameters
----------
eval_data : DataIter
Evaluation data to run prediction on.
num_batch : int
Default is ``None``, indicating running all the batches in the data iterator.
reset : bool
Default is ``True``, indicating whether we should reset the data iter before start
doing prediction.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull. | [
"Iterates",
"over",
"predictions",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L278-L316 |
23,868 | apache/incubator-mxnet | python/mxnet/module/base_module.py | BaseModule.predict | def predict(self, eval_data, num_batch=None, merge_batches=True, reset=True,
always_output_list=False, sparse_row_id_fn=None):
"""Runs prediction and collects the outputs.
When `merge_batches` is ``True`` (by default), the return value will be a list
``[out1, out2, out3]``, where each element is formed by concatenating the outputs for
all the mini-batches. When `always_output_list` is ``False`` (as by default),
then in the case of a single output, `out1` is returned instead of ``[out1]``.
When `merge_batches` is ``False``, the return value will be a nested list like
``[[out1_batch1, out2_batch1], [out1_batch2], ...]``. This mode is useful because
in some cases (e.g. bucketing), the module does not necessarily produce the same
number of outputs.
The objects in the results have type `NDArray`. If you need to work with a numpy array,
just call ``.asnumpy()`` on each `NDArray`.
Parameters
----------
eval_data : DataIter or NDArray or numpy array
Evaluation data to run prediction on.
num_batch : int
Defaults to ``None``, indicates running all the batches in the data iterator.
merge_batches : bool
Defaults to ``True``, see above for return values.
reset : bool
Defaults to ``True``, indicates whether we should reset the data iter before
doing prediction.
always_output_list : bool
Defaults to ``False``, see above for return values.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
Returns
-------
list of NDArray or list of list of NDArray
Prediction results.
Examples
--------
>>> # An example of using `predict` for prediction.
>>> # Predict on the first 10 batches of val_dataiter
>>> mod.predict(eval_data=val_dataiter, num_batch=10)
"""
assert self.binded and self.params_initialized
if isinstance(eval_data, (ndarray.NDArray, np.ndarray)):
if isinstance(eval_data, np.ndarray):
eval_data = ndarray.array(eval_data)
self.forward(DataBatch([eval_data]))
return self.get_outputs()[0]
if not isinstance(eval_data, DataIter):
raise ValueError('eval_data must be of type NDArray or DataIter')
if reset:
eval_data.reset()
output_list = []
for nbatch, eval_batch in enumerate(eval_data):
if num_batch is not None and nbatch == num_batch:
break
self.prepare(eval_batch, sparse_row_id_fn=sparse_row_id_fn)
self.forward(eval_batch, is_train=False)
pad = eval_batch.pad
outputs = [out[0:out.shape[0]-pad].copy() for out in self.get_outputs()]
output_list.append(outputs)
if len(output_list) == 0:
return output_list
if merge_batches:
num_outputs = len(output_list[0])
for out in output_list:
assert len(out) == num_outputs, \
'Cannot merge batches, as num of outputs is not the same ' + \
'in mini-batches. Maybe bucketing is used?'
output_list2 = [ndarray.concatenate([out[i] for out in output_list])
for i in range(num_outputs)]
if num_outputs == 1 and not always_output_list:
return output_list2[0]
return output_list2
return output_list | python | def predict(self, eval_data, num_batch=None, merge_batches=True, reset=True,
always_output_list=False, sparse_row_id_fn=None):
"""Runs prediction and collects the outputs.
When `merge_batches` is ``True`` (by default), the return value will be a list
``[out1, out2, out3]``, where each element is formed by concatenating the outputs for
all the mini-batches. When `always_output_list` is ``False`` (as by default),
then in the case of a single output, `out1` is returned instead of ``[out1]``.
When `merge_batches` is ``False``, the return value will be a nested list like
``[[out1_batch1, out2_batch1], [out1_batch2], ...]``. This mode is useful because
in some cases (e.g. bucketing), the module does not necessarily produce the same
number of outputs.
The objects in the results have type `NDArray`. If you need to work with a numpy array,
just call ``.asnumpy()`` on each `NDArray`.
Parameters
----------
eval_data : DataIter or NDArray or numpy array
Evaluation data to run prediction on.
num_batch : int
Defaults to ``None``, indicates running all the batches in the data iterator.
merge_batches : bool
Defaults to ``True``, see above for return values.
reset : bool
Defaults to ``True``, indicates whether we should reset the data iter before
doing prediction.
always_output_list : bool
Defaults to ``False``, see above for return values.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
Returns
-------
list of NDArray or list of list of NDArray
Prediction results.
Examples
--------
>>> # An example of using `predict` for prediction.
>>> # Predict on the first 10 batches of val_dataiter
>>> mod.predict(eval_data=val_dataiter, num_batch=10)
"""
assert self.binded and self.params_initialized
if isinstance(eval_data, (ndarray.NDArray, np.ndarray)):
if isinstance(eval_data, np.ndarray):
eval_data = ndarray.array(eval_data)
self.forward(DataBatch([eval_data]))
return self.get_outputs()[0]
if not isinstance(eval_data, DataIter):
raise ValueError('eval_data must be of type NDArray or DataIter')
if reset:
eval_data.reset()
output_list = []
for nbatch, eval_batch in enumerate(eval_data):
if num_batch is not None and nbatch == num_batch:
break
self.prepare(eval_batch, sparse_row_id_fn=sparse_row_id_fn)
self.forward(eval_batch, is_train=False)
pad = eval_batch.pad
outputs = [out[0:out.shape[0]-pad].copy() for out in self.get_outputs()]
output_list.append(outputs)
if len(output_list) == 0:
return output_list
if merge_batches:
num_outputs = len(output_list[0])
for out in output_list:
assert len(out) == num_outputs, \
'Cannot merge batches, as num of outputs is not the same ' + \
'in mini-batches. Maybe bucketing is used?'
output_list2 = [ndarray.concatenate([out[i] for out in output_list])
for i in range(num_outputs)]
if num_outputs == 1 and not always_output_list:
return output_list2[0]
return output_list2
return output_list | [
"def",
"predict",
"(",
"self",
",",
"eval_data",
",",
"num_batch",
"=",
"None",
",",
"merge_batches",
"=",
"True",
",",
"reset",
"=",
"True",
",",
"always_output_list",
"=",
"False",
",",
"sparse_row_id_fn",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"if",
"isinstance",
"(",
"eval_data",
",",
"(",
"ndarray",
".",
"NDArray",
",",
"np",
".",
"ndarray",
")",
")",
":",
"if",
"isinstance",
"(",
"eval_data",
",",
"np",
".",
"ndarray",
")",
":",
"eval_data",
"=",
"ndarray",
".",
"array",
"(",
"eval_data",
")",
"self",
".",
"forward",
"(",
"DataBatch",
"(",
"[",
"eval_data",
"]",
")",
")",
"return",
"self",
".",
"get_outputs",
"(",
")",
"[",
"0",
"]",
"if",
"not",
"isinstance",
"(",
"eval_data",
",",
"DataIter",
")",
":",
"raise",
"ValueError",
"(",
"'eval_data must be of type NDArray or DataIter'",
")",
"if",
"reset",
":",
"eval_data",
".",
"reset",
"(",
")",
"output_list",
"=",
"[",
"]",
"for",
"nbatch",
",",
"eval_batch",
"in",
"enumerate",
"(",
"eval_data",
")",
":",
"if",
"num_batch",
"is",
"not",
"None",
"and",
"nbatch",
"==",
"num_batch",
":",
"break",
"self",
".",
"prepare",
"(",
"eval_batch",
",",
"sparse_row_id_fn",
"=",
"sparse_row_id_fn",
")",
"self",
".",
"forward",
"(",
"eval_batch",
",",
"is_train",
"=",
"False",
")",
"pad",
"=",
"eval_batch",
".",
"pad",
"outputs",
"=",
"[",
"out",
"[",
"0",
":",
"out",
".",
"shape",
"[",
"0",
"]",
"-",
"pad",
"]",
".",
"copy",
"(",
")",
"for",
"out",
"in",
"self",
".",
"get_outputs",
"(",
")",
"]",
"output_list",
".",
"append",
"(",
"outputs",
")",
"if",
"len",
"(",
"output_list",
")",
"==",
"0",
":",
"return",
"output_list",
"if",
"merge_batches",
":",
"num_outputs",
"=",
"len",
"(",
"output_list",
"[",
"0",
"]",
")",
"for",
"out",
"in",
"output_list",
":",
"assert",
"len",
"(",
"out",
")",
"==",
"num_outputs",
",",
"'Cannot merge batches, as num of outputs is not the same '",
"+",
"'in mini-batches. Maybe bucketing is used?'",
"output_list2",
"=",
"[",
"ndarray",
".",
"concatenate",
"(",
"[",
"out",
"[",
"i",
"]",
"for",
"out",
"in",
"output_list",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"num_outputs",
")",
"]",
"if",
"num_outputs",
"==",
"1",
"and",
"not",
"always_output_list",
":",
"return",
"output_list2",
"[",
"0",
"]",
"return",
"output_list2",
"return",
"output_list"
] | Runs prediction and collects the outputs.
When `merge_batches` is ``True`` (by default), the return value will be a list
``[out1, out2, out3]``, where each element is formed by concatenating the outputs for
all the mini-batches. When `always_output_list` is ``False`` (as by default),
then in the case of a single output, `out1` is returned instead of ``[out1]``.
When `merge_batches` is ``False``, the return value will be a nested list like
``[[out1_batch1, out2_batch1], [out1_batch2], ...]``. This mode is useful because
in some cases (e.g. bucketing), the module does not necessarily produce the same
number of outputs.
The objects in the results have type `NDArray`. If you need to work with a numpy array,
just call ``.asnumpy()`` on each `NDArray`.
Parameters
----------
eval_data : DataIter or NDArray or numpy array
Evaluation data to run prediction on.
num_batch : int
Defaults to ``None``, indicates running all the batches in the data iterator.
merge_batches : bool
Defaults to ``True``, see above for return values.
reset : bool
Defaults to ``True``, indicates whether we should reset the data iter before
doing prediction.
always_output_list : bool
Defaults to ``False``, see above for return values.
sparse_row_id_fn : A callback function
The function takes `data_batch` as an input and returns a dict of
str -> NDArray. The resulting dict is used for pulling row_sparse
parameters from the kvstore, where the str key is the name of the param,
and the value is the row id of the param to pull.
Returns
-------
list of NDArray or list of list of NDArray
Prediction results.
Examples
--------
>>> # An example of using `predict` for prediction.
>>> # Predict on the first 10 batches of val_dataiter
>>> mod.predict(eval_data=val_dataiter, num_batch=10) | [
"Runs",
"prediction",
"and",
"collects",
"the",
"outputs",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L318-L407 |
23,869 | apache/incubator-mxnet | python/mxnet/module/base_module.py | BaseModule.load_params | def load_params(self, fname):
"""Loads model parameters from file.
Parameters
----------
fname : str
Path to input param file.
Examples
--------
>>> # An example of loading module parameters.
>>> mod.load_params('myfile')
"""
save_dict = ndarray.load(fname)
arg_params = {}
aux_params = {}
for k, value in save_dict.items():
arg_type, name = k.split(':', 1)
if arg_type == 'arg':
arg_params[name] = value
elif arg_type == 'aux':
aux_params[name] = value
else:
raise ValueError("Invalid param file " + fname)
self.set_params(arg_params, aux_params) | python | def load_params(self, fname):
"""Loads model parameters from file.
Parameters
----------
fname : str
Path to input param file.
Examples
--------
>>> # An example of loading module parameters.
>>> mod.load_params('myfile')
"""
save_dict = ndarray.load(fname)
arg_params = {}
aux_params = {}
for k, value in save_dict.items():
arg_type, name = k.split(':', 1)
if arg_type == 'arg':
arg_params[name] = value
elif arg_type == 'aux':
aux_params[name] = value
else:
raise ValueError("Invalid param file " + fname)
self.set_params(arg_params, aux_params) | [
"def",
"load_params",
"(",
"self",
",",
"fname",
")",
":",
"save_dict",
"=",
"ndarray",
".",
"load",
"(",
"fname",
")",
"arg_params",
"=",
"{",
"}",
"aux_params",
"=",
"{",
"}",
"for",
"k",
",",
"value",
"in",
"save_dict",
".",
"items",
"(",
")",
":",
"arg_type",
",",
"name",
"=",
"k",
".",
"split",
"(",
"':'",
",",
"1",
")",
"if",
"arg_type",
"==",
"'arg'",
":",
"arg_params",
"[",
"name",
"]",
"=",
"value",
"elif",
"arg_type",
"==",
"'aux'",
":",
"aux_params",
"[",
"name",
"]",
"=",
"value",
"else",
":",
"raise",
"ValueError",
"(",
"\"Invalid param file \"",
"+",
"fname",
")",
"self",
".",
"set_params",
"(",
"arg_params",
",",
"aux_params",
")"
] | Loads model parameters from file.
Parameters
----------
fname : str
Path to input param file.
Examples
--------
>>> # An example of loading module parameters.
>>> mod.load_params('myfile') | [
"Loads",
"model",
"parameters",
"from",
"file",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/base_module.py#L719-L743 |
23,870 | apache/incubator-mxnet | python/mxnet/libinfo.py | find_include_path | def find_include_path():
"""Find MXNet included header files.
Returns
-------
incl_path : string
Path to the header files.
"""
incl_from_env = os.environ.get('MXNET_INCLUDE_PATH')
if incl_from_env:
if os.path.isdir(incl_from_env):
if not os.path.isabs(incl_from_env):
logging.warning("MXNET_INCLUDE_PATH should be an absolute path, instead of: %s",
incl_from_env)
else:
return incl_from_env
else:
logging.warning("MXNET_INCLUDE_PATH '%s' doesn't exist", incl_from_env)
curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
# include path in pip package
pip_incl_path = os.path.join(curr_path, 'include/')
if os.path.isdir(pip_incl_path):
return pip_incl_path
else:
# include path if build from source
src_incl_path = os.path.join(curr_path, '../../include/')
if os.path.isdir(src_incl_path):
return src_incl_path
else:
raise RuntimeError('Cannot find the MXNet include path in either ' + pip_incl_path +
' or ' + src_incl_path + '\n') | python | def find_include_path():
"""Find MXNet included header files.
Returns
-------
incl_path : string
Path to the header files.
"""
incl_from_env = os.environ.get('MXNET_INCLUDE_PATH')
if incl_from_env:
if os.path.isdir(incl_from_env):
if not os.path.isabs(incl_from_env):
logging.warning("MXNET_INCLUDE_PATH should be an absolute path, instead of: %s",
incl_from_env)
else:
return incl_from_env
else:
logging.warning("MXNET_INCLUDE_PATH '%s' doesn't exist", incl_from_env)
curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
# include path in pip package
pip_incl_path = os.path.join(curr_path, 'include/')
if os.path.isdir(pip_incl_path):
return pip_incl_path
else:
# include path if build from source
src_incl_path = os.path.join(curr_path, '../../include/')
if os.path.isdir(src_incl_path):
return src_incl_path
else:
raise RuntimeError('Cannot find the MXNet include path in either ' + pip_incl_path +
' or ' + src_incl_path + '\n') | [
"def",
"find_include_path",
"(",
")",
":",
"incl_from_env",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'MXNET_INCLUDE_PATH'",
")",
"if",
"incl_from_env",
":",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"incl_from_env",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"isabs",
"(",
"incl_from_env",
")",
":",
"logging",
".",
"warning",
"(",
"\"MXNET_INCLUDE_PATH should be an absolute path, instead of: %s\"",
",",
"incl_from_env",
")",
"else",
":",
"return",
"incl_from_env",
"else",
":",
"logging",
".",
"warning",
"(",
"\"MXNET_INCLUDE_PATH '%s' doesn't exist\"",
",",
"incl_from_env",
")",
"curr_path",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"expanduser",
"(",
"__file__",
")",
")",
")",
"# include path in pip package",
"pip_incl_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"curr_path",
",",
"'include/'",
")",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"pip_incl_path",
")",
":",
"return",
"pip_incl_path",
"else",
":",
"# include path if build from source",
"src_incl_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"curr_path",
",",
"'../../include/'",
")",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"src_incl_path",
")",
":",
"return",
"src_incl_path",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Cannot find the MXNet include path in either '",
"+",
"pip_incl_path",
"+",
"' or '",
"+",
"src_incl_path",
"+",
"'\\n'",
")"
] | Find MXNet included header files.
Returns
-------
incl_path : string
Path to the header files. | [
"Find",
"MXNet",
"included",
"header",
"files",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/libinfo.py#L79-L110 |
23,871 | apache/incubator-mxnet | example/ctc/captcha_generator.py | CaptchaGen.image | def image(self, captcha_str):
"""Generate a greyscale captcha image representing number string
Parameters
----------
captcha_str: str
string a characters for captcha image
Returns
-------
numpy.ndarray
Generated greyscale image in np.ndarray float type with values normalized to [0, 1]
"""
img = self.captcha.generate(captcha_str)
img = np.fromstring(img.getvalue(), dtype='uint8')
img = cv2.imdecode(img, cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (self.h, self.w))
img = img.transpose(1, 0)
img = np.multiply(img, 1 / 255.0)
return img | python | def image(self, captcha_str):
"""Generate a greyscale captcha image representing number string
Parameters
----------
captcha_str: str
string a characters for captcha image
Returns
-------
numpy.ndarray
Generated greyscale image in np.ndarray float type with values normalized to [0, 1]
"""
img = self.captcha.generate(captcha_str)
img = np.fromstring(img.getvalue(), dtype='uint8')
img = cv2.imdecode(img, cv2.IMREAD_GRAYSCALE)
img = cv2.resize(img, (self.h, self.w))
img = img.transpose(1, 0)
img = np.multiply(img, 1 / 255.0)
return img | [
"def",
"image",
"(",
"self",
",",
"captcha_str",
")",
":",
"img",
"=",
"self",
".",
"captcha",
".",
"generate",
"(",
"captcha_str",
")",
"img",
"=",
"np",
".",
"fromstring",
"(",
"img",
".",
"getvalue",
"(",
")",
",",
"dtype",
"=",
"'uint8'",
")",
"img",
"=",
"cv2",
".",
"imdecode",
"(",
"img",
",",
"cv2",
".",
"IMREAD_GRAYSCALE",
")",
"img",
"=",
"cv2",
".",
"resize",
"(",
"img",
",",
"(",
"self",
".",
"h",
",",
"self",
".",
"w",
")",
")",
"img",
"=",
"img",
".",
"transpose",
"(",
"1",
",",
"0",
")",
"img",
"=",
"np",
".",
"multiply",
"(",
"img",
",",
"1",
"/",
"255.0",
")",
"return",
"img"
] | Generate a greyscale captcha image representing number string
Parameters
----------
captcha_str: str
string a characters for captcha image
Returns
-------
numpy.ndarray
Generated greyscale image in np.ndarray float type with values normalized to [0, 1] | [
"Generate",
"a",
"greyscale",
"captcha",
"image",
"representing",
"number",
"string"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/captcha_generator.py#L48-L67 |
23,872 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer.register | def register(klass):
"""Registers a new optimizer.
Once an optimizer is registered, we can create an instance of this
optimizer with `create_optimizer` later.
Examples
--------
>>> @mx.optimizer.Optimizer.register
... class MyOptimizer(mx.optimizer.Optimizer):
... pass
>>> optim = mx.optimizer.Optimizer.create_optimizer('MyOptimizer')
>>> print(type(optim))
<class '__main__.MyOptimizer'>
"""
assert(isinstance(klass, type))
name = klass.__name__.lower()
if name in Optimizer.opt_registry:
warnings.warn('WARNING: New optimizer %s.%s is overriding '
'existing optimizer %s.%s' %
(klass.__module__, klass.__name__,
Optimizer.opt_registry[name].__module__,
Optimizer.opt_registry[name].__name__))
Optimizer.opt_registry[name] = klass
return klass | python | def register(klass):
"""Registers a new optimizer.
Once an optimizer is registered, we can create an instance of this
optimizer with `create_optimizer` later.
Examples
--------
>>> @mx.optimizer.Optimizer.register
... class MyOptimizer(mx.optimizer.Optimizer):
... pass
>>> optim = mx.optimizer.Optimizer.create_optimizer('MyOptimizer')
>>> print(type(optim))
<class '__main__.MyOptimizer'>
"""
assert(isinstance(klass, type))
name = klass.__name__.lower()
if name in Optimizer.opt_registry:
warnings.warn('WARNING: New optimizer %s.%s is overriding '
'existing optimizer %s.%s' %
(klass.__module__, klass.__name__,
Optimizer.opt_registry[name].__module__,
Optimizer.opt_registry[name].__name__))
Optimizer.opt_registry[name] = klass
return klass | [
"def",
"register",
"(",
"klass",
")",
":",
"assert",
"(",
"isinstance",
"(",
"klass",
",",
"type",
")",
")",
"name",
"=",
"klass",
".",
"__name__",
".",
"lower",
"(",
")",
"if",
"name",
"in",
"Optimizer",
".",
"opt_registry",
":",
"warnings",
".",
"warn",
"(",
"'WARNING: New optimizer %s.%s is overriding '",
"'existing optimizer %s.%s'",
"%",
"(",
"klass",
".",
"__module__",
",",
"klass",
".",
"__name__",
",",
"Optimizer",
".",
"opt_registry",
"[",
"name",
"]",
".",
"__module__",
",",
"Optimizer",
".",
"opt_registry",
"[",
"name",
"]",
".",
"__name__",
")",
")",
"Optimizer",
".",
"opt_registry",
"[",
"name",
"]",
"=",
"klass",
"return",
"klass"
] | Registers a new optimizer.
Once an optimizer is registered, we can create an instance of this
optimizer with `create_optimizer` later.
Examples
--------
>>> @mx.optimizer.Optimizer.register
... class MyOptimizer(mx.optimizer.Optimizer):
... pass
>>> optim = mx.optimizer.Optimizer.create_optimizer('MyOptimizer')
>>> print(type(optim))
<class '__main__.MyOptimizer'> | [
"Registers",
"a",
"new",
"optimizer",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L129-L154 |
23,873 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer.create_optimizer | def create_optimizer(name, **kwargs):
"""Instantiates an optimizer with a given name and kwargs.
.. note:: We can use the alias `create` for ``Optimizer.create_optimizer``.
Parameters
----------
name: str
Name of the optimizer. Should be the name
of a subclass of Optimizer. Case insensitive.
kwargs: dict
Parameters for the optimizer.
Returns
-------
Optimizer
An instantiated optimizer.
Examples
--------
>>> sgd = mx.optimizer.Optimizer.create_optimizer('sgd')
>>> type(sgd)
<class 'mxnet.optimizer.SGD'>
>>> adam = mx.optimizer.create('adam', learning_rate=.1)
>>> type(adam)
<class 'mxnet.optimizer.Adam'>
"""
if name.lower() in Optimizer.opt_registry:
return Optimizer.opt_registry[name.lower()](**kwargs)
else:
raise ValueError('Cannot find optimizer %s' % name) | python | def create_optimizer(name, **kwargs):
"""Instantiates an optimizer with a given name and kwargs.
.. note:: We can use the alias `create` for ``Optimizer.create_optimizer``.
Parameters
----------
name: str
Name of the optimizer. Should be the name
of a subclass of Optimizer. Case insensitive.
kwargs: dict
Parameters for the optimizer.
Returns
-------
Optimizer
An instantiated optimizer.
Examples
--------
>>> sgd = mx.optimizer.Optimizer.create_optimizer('sgd')
>>> type(sgd)
<class 'mxnet.optimizer.SGD'>
>>> adam = mx.optimizer.create('adam', learning_rate=.1)
>>> type(adam)
<class 'mxnet.optimizer.Adam'>
"""
if name.lower() in Optimizer.opt_registry:
return Optimizer.opt_registry[name.lower()](**kwargs)
else:
raise ValueError('Cannot find optimizer %s' % name) | [
"def",
"create_optimizer",
"(",
"name",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"name",
".",
"lower",
"(",
")",
"in",
"Optimizer",
".",
"opt_registry",
":",
"return",
"Optimizer",
".",
"opt_registry",
"[",
"name",
".",
"lower",
"(",
")",
"]",
"(",
"*",
"*",
"kwargs",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'Cannot find optimizer %s'",
"%",
"name",
")"
] | Instantiates an optimizer with a given name and kwargs.
.. note:: We can use the alias `create` for ``Optimizer.create_optimizer``.
Parameters
----------
name: str
Name of the optimizer. Should be the name
of a subclass of Optimizer. Case insensitive.
kwargs: dict
Parameters for the optimizer.
Returns
-------
Optimizer
An instantiated optimizer.
Examples
--------
>>> sgd = mx.optimizer.Optimizer.create_optimizer('sgd')
>>> type(sgd)
<class 'mxnet.optimizer.SGD'>
>>> adam = mx.optimizer.create('adam', learning_rate=.1)
>>> type(adam)
<class 'mxnet.optimizer.Adam'> | [
"Instantiates",
"an",
"optimizer",
"with",
"a",
"given",
"name",
"and",
"kwargs",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L157-L188 |
23,874 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer.create_state_multi_precision | def create_state_multi_precision(self, index, weight):
"""Creates auxiliary state for a given weight, including FP32 high
precision copy if original weight is FP16.
This method is provided to perform automatic mixed precision training
for optimizers that do not support it themselves.
Parameters
----------
index : int
An unique index to identify the weight.
weight : NDArray
The weight.
Returns
-------
state : any obj
The state associated with the weight.
"""
weight_master_copy = None
if self.multi_precision and weight.dtype == numpy.float16:
weight_master_copy = weight.astype(numpy.float32)
return (weight_master_copy,) + (self.create_state(index, weight_master_copy),)
if weight.dtype == numpy.float16 and not self.multi_precision:
warnings.warn("Accumulating with float16 in optimizer can lead to "
"poor accuracy or slow convergence. "
"Consider using multi_precision=True option of the "
"optimizer")
return self.create_state(index, weight) | python | def create_state_multi_precision(self, index, weight):
"""Creates auxiliary state for a given weight, including FP32 high
precision copy if original weight is FP16.
This method is provided to perform automatic mixed precision training
for optimizers that do not support it themselves.
Parameters
----------
index : int
An unique index to identify the weight.
weight : NDArray
The weight.
Returns
-------
state : any obj
The state associated with the weight.
"""
weight_master_copy = None
if self.multi_precision and weight.dtype == numpy.float16:
weight_master_copy = weight.astype(numpy.float32)
return (weight_master_copy,) + (self.create_state(index, weight_master_copy),)
if weight.dtype == numpy.float16 and not self.multi_precision:
warnings.warn("Accumulating with float16 in optimizer can lead to "
"poor accuracy or slow convergence. "
"Consider using multi_precision=True option of the "
"optimizer")
return self.create_state(index, weight) | [
"def",
"create_state_multi_precision",
"(",
"self",
",",
"index",
",",
"weight",
")",
":",
"weight_master_copy",
"=",
"None",
"if",
"self",
".",
"multi_precision",
"and",
"weight",
".",
"dtype",
"==",
"numpy",
".",
"float16",
":",
"weight_master_copy",
"=",
"weight",
".",
"astype",
"(",
"numpy",
".",
"float32",
")",
"return",
"(",
"weight_master_copy",
",",
")",
"+",
"(",
"self",
".",
"create_state",
"(",
"index",
",",
"weight_master_copy",
")",
",",
")",
"if",
"weight",
".",
"dtype",
"==",
"numpy",
".",
"float16",
"and",
"not",
"self",
".",
"multi_precision",
":",
"warnings",
".",
"warn",
"(",
"\"Accumulating with float16 in optimizer can lead to \"",
"\"poor accuracy or slow convergence. \"",
"\"Consider using multi_precision=True option of the \"",
"\"optimizer\"",
")",
"return",
"self",
".",
"create_state",
"(",
"index",
",",
"weight",
")"
] | Creates auxiliary state for a given weight, including FP32 high
precision copy if original weight is FP16.
This method is provided to perform automatic mixed precision training
for optimizers that do not support it themselves.
Parameters
----------
index : int
An unique index to identify the weight.
weight : NDArray
The weight.
Returns
-------
state : any obj
The state associated with the weight. | [
"Creates",
"auxiliary",
"state",
"for",
"a",
"given",
"weight",
"including",
"FP32",
"high",
"precision",
"copy",
"if",
"original",
"weight",
"is",
"FP16",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L218-L246 |
23,875 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer.update_multi_precision | def update_multi_precision(self, index, weight, grad, state):
"""Updates the given parameter using the corresponding gradient and state.
Mixed precision version.
Parameters
----------
index : int
The unique index of the parameter into the individual learning
rates and weight decays. Learning rates and weight decay
may be set via `set_lr_mult()` and `set_wd_mult()`, respectively.
weight : NDArray
The parameter to be updated.
grad : NDArray
The gradient of the objective with respect to this parameter.
state : any obj
The state returned by `create_state()`.
"""
if self.multi_precision and weight.dtype == numpy.float16:
# Wrapper for mixed precision
weight_master_copy = state[0]
original_state = state[1]
grad32 = grad.astype(numpy.float32)
self.update(index, weight_master_copy, grad32, original_state)
cast(weight_master_copy, dtype=weight.dtype, out=weight)
else:
self.update(index, weight, grad, state) | python | def update_multi_precision(self, index, weight, grad, state):
"""Updates the given parameter using the corresponding gradient and state.
Mixed precision version.
Parameters
----------
index : int
The unique index of the parameter into the individual learning
rates and weight decays. Learning rates and weight decay
may be set via `set_lr_mult()` and `set_wd_mult()`, respectively.
weight : NDArray
The parameter to be updated.
grad : NDArray
The gradient of the objective with respect to this parameter.
state : any obj
The state returned by `create_state()`.
"""
if self.multi_precision and weight.dtype == numpy.float16:
# Wrapper for mixed precision
weight_master_copy = state[0]
original_state = state[1]
grad32 = grad.astype(numpy.float32)
self.update(index, weight_master_copy, grad32, original_state)
cast(weight_master_copy, dtype=weight.dtype, out=weight)
else:
self.update(index, weight, grad, state) | [
"def",
"update_multi_precision",
"(",
"self",
",",
"index",
",",
"weight",
",",
"grad",
",",
"state",
")",
":",
"if",
"self",
".",
"multi_precision",
"and",
"weight",
".",
"dtype",
"==",
"numpy",
".",
"float16",
":",
"# Wrapper for mixed precision",
"weight_master_copy",
"=",
"state",
"[",
"0",
"]",
"original_state",
"=",
"state",
"[",
"1",
"]",
"grad32",
"=",
"grad",
".",
"astype",
"(",
"numpy",
".",
"float32",
")",
"self",
".",
"update",
"(",
"index",
",",
"weight_master_copy",
",",
"grad32",
",",
"original_state",
")",
"cast",
"(",
"weight_master_copy",
",",
"dtype",
"=",
"weight",
".",
"dtype",
",",
"out",
"=",
"weight",
")",
"else",
":",
"self",
".",
"update",
"(",
"index",
",",
"weight",
",",
"grad",
",",
"state",
")"
] | Updates the given parameter using the corresponding gradient and state.
Mixed precision version.
Parameters
----------
index : int
The unique index of the parameter into the individual learning
rates and weight decays. Learning rates and weight decay
may be set via `set_lr_mult()` and `set_wd_mult()`, respectively.
weight : NDArray
The parameter to be updated.
grad : NDArray
The gradient of the objective with respect to this parameter.
state : any obj
The state returned by `create_state()`. | [
"Updates",
"the",
"given",
"parameter",
"using",
"the",
"corresponding",
"gradient",
"and",
"state",
".",
"Mixed",
"precision",
"version",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L266-L291 |
23,876 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer.set_lr_mult | def set_lr_mult(self, args_lr_mult):
"""Sets an individual learning rate multiplier for each parameter.
If you specify a learning rate multiplier for a parameter, then
the learning rate for the parameter will be set as the product of
the global learning rate `self.lr` and its multiplier.
.. note:: The default learning rate multiplier of a `Variable`
can be set with `lr_mult` argument in the constructor.
Parameters
----------
args_lr_mult : dict of str/int to float
For each of its key-value entries, the learning rate multipler for the
parameter specified in the key will be set as the given value.
You can specify the parameter with either its name or its index.
If you use the name, you should pass `sym` in the constructor,
and the name you specified in the key of `args_lr_mult` should match
the name of the parameter in `sym`. If you use the index, it should
correspond to the index of the parameter used in the `update` method.
Specifying a parameter by its index is only supported for backward
compatibility, and we recommend to use the name instead.
"""
self.lr_mult = {}
if self.sym_info:
attr, arg_names = self.sym_info
for name in arg_names:
if name in attr and '__lr_mult__' in attr[name]:
self.lr_mult[name] = float(attr[name]['__lr_mult__'])
self.lr_mult.update(args_lr_mult) | python | def set_lr_mult(self, args_lr_mult):
"""Sets an individual learning rate multiplier for each parameter.
If you specify a learning rate multiplier for a parameter, then
the learning rate for the parameter will be set as the product of
the global learning rate `self.lr` and its multiplier.
.. note:: The default learning rate multiplier of a `Variable`
can be set with `lr_mult` argument in the constructor.
Parameters
----------
args_lr_mult : dict of str/int to float
For each of its key-value entries, the learning rate multipler for the
parameter specified in the key will be set as the given value.
You can specify the parameter with either its name or its index.
If you use the name, you should pass `sym` in the constructor,
and the name you specified in the key of `args_lr_mult` should match
the name of the parameter in `sym`. If you use the index, it should
correspond to the index of the parameter used in the `update` method.
Specifying a parameter by its index is only supported for backward
compatibility, and we recommend to use the name instead.
"""
self.lr_mult = {}
if self.sym_info:
attr, arg_names = self.sym_info
for name in arg_names:
if name in attr and '__lr_mult__' in attr[name]:
self.lr_mult[name] = float(attr[name]['__lr_mult__'])
self.lr_mult.update(args_lr_mult) | [
"def",
"set_lr_mult",
"(",
"self",
",",
"args_lr_mult",
")",
":",
"self",
".",
"lr_mult",
"=",
"{",
"}",
"if",
"self",
".",
"sym_info",
":",
"attr",
",",
"arg_names",
"=",
"self",
".",
"sym_info",
"for",
"name",
"in",
"arg_names",
":",
"if",
"name",
"in",
"attr",
"and",
"'__lr_mult__'",
"in",
"attr",
"[",
"name",
"]",
":",
"self",
".",
"lr_mult",
"[",
"name",
"]",
"=",
"float",
"(",
"attr",
"[",
"name",
"]",
"[",
"'__lr_mult__'",
"]",
")",
"self",
".",
"lr_mult",
".",
"update",
"(",
"args_lr_mult",
")"
] | Sets an individual learning rate multiplier for each parameter.
If you specify a learning rate multiplier for a parameter, then
the learning rate for the parameter will be set as the product of
the global learning rate `self.lr` and its multiplier.
.. note:: The default learning rate multiplier of a `Variable`
can be set with `lr_mult` argument in the constructor.
Parameters
----------
args_lr_mult : dict of str/int to float
For each of its key-value entries, the learning rate multipler for the
parameter specified in the key will be set as the given value.
You can specify the parameter with either its name or its index.
If you use the name, you should pass `sym` in the constructor,
and the name you specified in the key of `args_lr_mult` should match
the name of the parameter in `sym`. If you use the index, it should
correspond to the index of the parameter used in the `update` method.
Specifying a parameter by its index is only supported for backward
compatibility, and we recommend to use the name instead. | [
"Sets",
"an",
"individual",
"learning",
"rate",
"multiplier",
"for",
"each",
"parameter",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L314-L345 |
23,877 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer.set_wd_mult | def set_wd_mult(self, args_wd_mult):
"""Sets an individual weight decay multiplier for each parameter.
By default, if `param_idx2name` was provided in the
constructor, the weight decay multipler is set as 0 for all
parameters whose name don't end with ``_weight`` or
``_gamma``.
.. note:: The default weight decay multiplier for a `Variable`
can be set with its `wd_mult` argument in the constructor.
Parameters
----------
args_wd_mult : dict of string/int to float
For each of its key-value entries, the weight decay multipler for the
parameter specified in the key will be set as the given value.
You can specify the parameter with either its name or its index.
If you use the name, you should pass `sym` in the constructor,
and the name you specified in the key of `args_lr_mult` should match
the name of the parameter in `sym`. If you use the index, it should
correspond to the index of the parameter used in the `update` method.
Specifying a parameter by its index is only supported for backward
compatibility, and we recommend to use the name instead.
"""
self.wd_mult = {}
for n in self.idx2name.values():
if not (n.endswith('_weight') or n.endswith('_gamma')):
self.wd_mult[n] = 0.0
if self.sym_info:
attr, arg_names = self.sym_info
for name in arg_names:
if name in attr and '__wd_mult__' in attr[name]:
self.wd_mult[name] = float(attr[name]['__wd_mult__'])
self.wd_mult.update(args_wd_mult) | python | def set_wd_mult(self, args_wd_mult):
"""Sets an individual weight decay multiplier for each parameter.
By default, if `param_idx2name` was provided in the
constructor, the weight decay multipler is set as 0 for all
parameters whose name don't end with ``_weight`` or
``_gamma``.
.. note:: The default weight decay multiplier for a `Variable`
can be set with its `wd_mult` argument in the constructor.
Parameters
----------
args_wd_mult : dict of string/int to float
For each of its key-value entries, the weight decay multipler for the
parameter specified in the key will be set as the given value.
You can specify the parameter with either its name or its index.
If you use the name, you should pass `sym` in the constructor,
and the name you specified in the key of `args_lr_mult` should match
the name of the parameter in `sym`. If you use the index, it should
correspond to the index of the parameter used in the `update` method.
Specifying a parameter by its index is only supported for backward
compatibility, and we recommend to use the name instead.
"""
self.wd_mult = {}
for n in self.idx2name.values():
if not (n.endswith('_weight') or n.endswith('_gamma')):
self.wd_mult[n] = 0.0
if self.sym_info:
attr, arg_names = self.sym_info
for name in arg_names:
if name in attr and '__wd_mult__' in attr[name]:
self.wd_mult[name] = float(attr[name]['__wd_mult__'])
self.wd_mult.update(args_wd_mult) | [
"def",
"set_wd_mult",
"(",
"self",
",",
"args_wd_mult",
")",
":",
"self",
".",
"wd_mult",
"=",
"{",
"}",
"for",
"n",
"in",
"self",
".",
"idx2name",
".",
"values",
"(",
")",
":",
"if",
"not",
"(",
"n",
".",
"endswith",
"(",
"'_weight'",
")",
"or",
"n",
".",
"endswith",
"(",
"'_gamma'",
")",
")",
":",
"self",
".",
"wd_mult",
"[",
"n",
"]",
"=",
"0.0",
"if",
"self",
".",
"sym_info",
":",
"attr",
",",
"arg_names",
"=",
"self",
".",
"sym_info",
"for",
"name",
"in",
"arg_names",
":",
"if",
"name",
"in",
"attr",
"and",
"'__wd_mult__'",
"in",
"attr",
"[",
"name",
"]",
":",
"self",
".",
"wd_mult",
"[",
"name",
"]",
"=",
"float",
"(",
"attr",
"[",
"name",
"]",
"[",
"'__wd_mult__'",
"]",
")",
"self",
".",
"wd_mult",
".",
"update",
"(",
"args_wd_mult",
")"
] | Sets an individual weight decay multiplier for each parameter.
By default, if `param_idx2name` was provided in the
constructor, the weight decay multipler is set as 0 for all
parameters whose name don't end with ``_weight`` or
``_gamma``.
.. note:: The default weight decay multiplier for a `Variable`
can be set with its `wd_mult` argument in the constructor.
Parameters
----------
args_wd_mult : dict of string/int to float
For each of its key-value entries, the weight decay multipler for the
parameter specified in the key will be set as the given value.
You can specify the parameter with either its name or its index.
If you use the name, you should pass `sym` in the constructor,
and the name you specified in the key of `args_lr_mult` should match
the name of the parameter in `sym`. If you use the index, it should
correspond to the index of the parameter used in the `update` method.
Specifying a parameter by its index is only supported for backward
compatibility, and we recommend to use the name instead. | [
"Sets",
"an",
"individual",
"weight",
"decay",
"multiplier",
"for",
"each",
"parameter",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L347-L382 |
23,878 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer._set_current_context | def _set_current_context(self, device_id):
"""Sets the number of the currently handled device.
Parameters
----------
device_id : int
The number of current device.
"""
if device_id not in self._all_index_update_counts:
self._all_index_update_counts[device_id] = {}
self._index_update_count = self._all_index_update_counts[device_id] | python | def _set_current_context(self, device_id):
"""Sets the number of the currently handled device.
Parameters
----------
device_id : int
The number of current device.
"""
if device_id not in self._all_index_update_counts:
self._all_index_update_counts[device_id] = {}
self._index_update_count = self._all_index_update_counts[device_id] | [
"def",
"_set_current_context",
"(",
"self",
",",
"device_id",
")",
":",
"if",
"device_id",
"not",
"in",
"self",
".",
"_all_index_update_counts",
":",
"self",
".",
"_all_index_update_counts",
"[",
"device_id",
"]",
"=",
"{",
"}",
"self",
".",
"_index_update_count",
"=",
"self",
".",
"_all_index_update_counts",
"[",
"device_id",
"]"
] | Sets the number of the currently handled device.
Parameters
----------
device_id : int
The number of current device. | [
"Sets",
"the",
"number",
"of",
"the",
"currently",
"handled",
"device",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L384-L394 |
23,879 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer._update_count | def _update_count(self, index):
"""Updates num_update.
Parameters
----------
index : int or list of int
The index to be updated.
"""
if not isinstance(index, (list, tuple)):
index = [index]
for idx in index:
if idx not in self._index_update_count:
self._index_update_count[idx] = self.begin_num_update
self._index_update_count[idx] += 1
self.num_update = max(self._index_update_count[idx], self.num_update) | python | def _update_count(self, index):
"""Updates num_update.
Parameters
----------
index : int or list of int
The index to be updated.
"""
if not isinstance(index, (list, tuple)):
index = [index]
for idx in index:
if idx not in self._index_update_count:
self._index_update_count[idx] = self.begin_num_update
self._index_update_count[idx] += 1
self.num_update = max(self._index_update_count[idx], self.num_update) | [
"def",
"_update_count",
"(",
"self",
",",
"index",
")",
":",
"if",
"not",
"isinstance",
"(",
"index",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"index",
"=",
"[",
"index",
"]",
"for",
"idx",
"in",
"index",
":",
"if",
"idx",
"not",
"in",
"self",
".",
"_index_update_count",
":",
"self",
".",
"_index_update_count",
"[",
"idx",
"]",
"=",
"self",
".",
"begin_num_update",
"self",
".",
"_index_update_count",
"[",
"idx",
"]",
"+=",
"1",
"self",
".",
"num_update",
"=",
"max",
"(",
"self",
".",
"_index_update_count",
"[",
"idx",
"]",
",",
"self",
".",
"num_update",
")"
] | Updates num_update.
Parameters
----------
index : int or list of int
The index to be updated. | [
"Updates",
"num_update",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L396-L410 |
23,880 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Optimizer._get_lrs | def _get_lrs(self, indices):
"""Gets the learning rates given the indices of the weights.
Parameters
----------
indices : list of int
Indices corresponding to weights.
Returns
-------
lrs : list of float
Learning rates for those indices.
"""
if self.lr_scheduler is not None:
lr = self.lr_scheduler(self.num_update)
else:
lr = self.lr
lrs = [lr for _ in indices]
for i, index in enumerate(indices):
if index in self.param_dict:
lrs[i] *= self.param_dict[index].lr_mult
elif index in self.lr_mult:
lrs[i] *= self.lr_mult[index]
elif index in self.idx2name:
lrs[i] *= self.lr_mult.get(self.idx2name[index], 1.0)
return lrs | python | def _get_lrs(self, indices):
"""Gets the learning rates given the indices of the weights.
Parameters
----------
indices : list of int
Indices corresponding to weights.
Returns
-------
lrs : list of float
Learning rates for those indices.
"""
if self.lr_scheduler is not None:
lr = self.lr_scheduler(self.num_update)
else:
lr = self.lr
lrs = [lr for _ in indices]
for i, index in enumerate(indices):
if index in self.param_dict:
lrs[i] *= self.param_dict[index].lr_mult
elif index in self.lr_mult:
lrs[i] *= self.lr_mult[index]
elif index in self.idx2name:
lrs[i] *= self.lr_mult.get(self.idx2name[index], 1.0)
return lrs | [
"def",
"_get_lrs",
"(",
"self",
",",
"indices",
")",
":",
"if",
"self",
".",
"lr_scheduler",
"is",
"not",
"None",
":",
"lr",
"=",
"self",
".",
"lr_scheduler",
"(",
"self",
".",
"num_update",
")",
"else",
":",
"lr",
"=",
"self",
".",
"lr",
"lrs",
"=",
"[",
"lr",
"for",
"_",
"in",
"indices",
"]",
"for",
"i",
",",
"index",
"in",
"enumerate",
"(",
"indices",
")",
":",
"if",
"index",
"in",
"self",
".",
"param_dict",
":",
"lrs",
"[",
"i",
"]",
"*=",
"self",
".",
"param_dict",
"[",
"index",
"]",
".",
"lr_mult",
"elif",
"index",
"in",
"self",
".",
"lr_mult",
":",
"lrs",
"[",
"i",
"]",
"*=",
"self",
".",
"lr_mult",
"[",
"index",
"]",
"elif",
"index",
"in",
"self",
".",
"idx2name",
":",
"lrs",
"[",
"i",
"]",
"*=",
"self",
".",
"lr_mult",
".",
"get",
"(",
"self",
".",
"idx2name",
"[",
"index",
"]",
",",
"1.0",
")",
"return",
"lrs"
] | Gets the learning rates given the indices of the weights.
Parameters
----------
indices : list of int
Indices corresponding to weights.
Returns
-------
lrs : list of float
Learning rates for those indices. | [
"Gets",
"the",
"learning",
"rates",
"given",
"the",
"indices",
"of",
"the",
"weights",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L412-L438 |
23,881 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Updater.sync_state_context | def sync_state_context(self, state, context):
"""sync state context."""
if isinstance(state, NDArray):
return state.as_in_context(context)
elif isinstance(state, (tuple, list)):
synced_state = (self.sync_state_context(i, context) for i in state)
if isinstance(state, tuple):
return tuple(synced_state)
else:
return list(synced_state)
else:
return state | python | def sync_state_context(self, state, context):
"""sync state context."""
if isinstance(state, NDArray):
return state.as_in_context(context)
elif isinstance(state, (tuple, list)):
synced_state = (self.sync_state_context(i, context) for i in state)
if isinstance(state, tuple):
return tuple(synced_state)
else:
return list(synced_state)
else:
return state | [
"def",
"sync_state_context",
"(",
"self",
",",
"state",
",",
"context",
")",
":",
"if",
"isinstance",
"(",
"state",
",",
"NDArray",
")",
":",
"return",
"state",
".",
"as_in_context",
"(",
"context",
")",
"elif",
"isinstance",
"(",
"state",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"synced_state",
"=",
"(",
"self",
".",
"sync_state_context",
"(",
"i",
",",
"context",
")",
"for",
"i",
"in",
"state",
")",
"if",
"isinstance",
"(",
"state",
",",
"tuple",
")",
":",
"return",
"tuple",
"(",
"synced_state",
")",
"else",
":",
"return",
"list",
"(",
"synced_state",
")",
"else",
":",
"return",
"state"
] | sync state context. | [
"sync",
"state",
"context",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L1679-L1690 |
23,882 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Updater.set_states | def set_states(self, states):
"""Sets updater states."""
states = pickle.loads(states)
if isinstance(states, tuple) and len(states) == 2:
self.states, self.optimizer = states
else:
self.states = states
self.states_synced = dict.fromkeys(self.states.keys(), False) | python | def set_states(self, states):
"""Sets updater states."""
states = pickle.loads(states)
if isinstance(states, tuple) and len(states) == 2:
self.states, self.optimizer = states
else:
self.states = states
self.states_synced = dict.fromkeys(self.states.keys(), False) | [
"def",
"set_states",
"(",
"self",
",",
"states",
")",
":",
"states",
"=",
"pickle",
".",
"loads",
"(",
"states",
")",
"if",
"isinstance",
"(",
"states",
",",
"tuple",
")",
"and",
"len",
"(",
"states",
")",
"==",
"2",
":",
"self",
".",
"states",
",",
"self",
".",
"optimizer",
"=",
"states",
"else",
":",
"self",
".",
"states",
"=",
"states",
"self",
".",
"states_synced",
"=",
"dict",
".",
"fromkeys",
"(",
"self",
".",
"states",
".",
"keys",
"(",
")",
",",
"False",
")"
] | Sets updater states. | [
"Sets",
"updater",
"states",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L1692-L1699 |
23,883 | apache/incubator-mxnet | python/mxnet/optimizer/optimizer.py | Updater.get_states | def get_states(self, dump_optimizer=False):
"""Gets updater states.
Parameters
----------
dump_optimizer : bool, default False
Whether to also save the optimizer itself. This would also save optimizer
information such as learning rate and weight decay schedules.
"""
return pickle.dumps((self.states, self.optimizer) if dump_optimizer else self.states) | python | def get_states(self, dump_optimizer=False):
"""Gets updater states.
Parameters
----------
dump_optimizer : bool, default False
Whether to also save the optimizer itself. This would also save optimizer
information such as learning rate and weight decay schedules.
"""
return pickle.dumps((self.states, self.optimizer) if dump_optimizer else self.states) | [
"def",
"get_states",
"(",
"self",
",",
"dump_optimizer",
"=",
"False",
")",
":",
"return",
"pickle",
".",
"dumps",
"(",
"(",
"self",
".",
"states",
",",
"self",
".",
"optimizer",
")",
"if",
"dump_optimizer",
"else",
"self",
".",
"states",
")"
] | Gets updater states.
Parameters
----------
dump_optimizer : bool, default False
Whether to also save the optimizer itself. This would also save optimizer
information such as learning rate and weight decay schedules. | [
"Gets",
"updater",
"states",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/optimizer/optimizer.py#L1701-L1710 |
23,884 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.from_frames | def from_frames(self, path):
"""
Read from frames
"""
frames_path = sorted([os.path.join(path, x) for x in os.listdir(path)])
frames = [ndimage.imread(frame_path) for frame_path in frames_path]
self.handle_type(frames)
return self | python | def from_frames(self, path):
"""
Read from frames
"""
frames_path = sorted([os.path.join(path, x) for x in os.listdir(path)])
frames = [ndimage.imread(frame_path) for frame_path in frames_path]
self.handle_type(frames)
return self | [
"def",
"from_frames",
"(",
"self",
",",
"path",
")",
":",
"frames_path",
"=",
"sorted",
"(",
"[",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"x",
")",
"for",
"x",
"in",
"os",
".",
"listdir",
"(",
"path",
")",
"]",
")",
"frames",
"=",
"[",
"ndimage",
".",
"imread",
"(",
"frame_path",
")",
"for",
"frame_path",
"in",
"frames_path",
"]",
"self",
".",
"handle_type",
"(",
"frames",
")",
"return",
"self"
] | Read from frames | [
"Read",
"from",
"frames"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L71-L78 |
23,885 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.from_video | def from_video(self, path):
"""
Read from videos
"""
frames = self.get_video_frames(path)
self.handle_type(frames)
return self | python | def from_video(self, path):
"""
Read from videos
"""
frames = self.get_video_frames(path)
self.handle_type(frames)
return self | [
"def",
"from_video",
"(",
"self",
",",
"path",
")",
":",
"frames",
"=",
"self",
".",
"get_video_frames",
"(",
"path",
")",
"self",
".",
"handle_type",
"(",
"frames",
")",
"return",
"self"
] | Read from videos | [
"Read",
"from",
"videos"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L80-L86 |
23,886 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.handle_type | def handle_type(self, frames):
"""
Config video types
"""
if self.vtype == 'mouth':
self.process_frames_mouth(frames)
elif self.vtype == 'face':
self.process_frames_face(frames)
else:
raise Exception('Video type not found') | python | def handle_type(self, frames):
"""
Config video types
"""
if self.vtype == 'mouth':
self.process_frames_mouth(frames)
elif self.vtype == 'face':
self.process_frames_face(frames)
else:
raise Exception('Video type not found') | [
"def",
"handle_type",
"(",
"self",
",",
"frames",
")",
":",
"if",
"self",
".",
"vtype",
"==",
"'mouth'",
":",
"self",
".",
"process_frames_mouth",
"(",
"frames",
")",
"elif",
"self",
".",
"vtype",
"==",
"'face'",
":",
"self",
".",
"process_frames_face",
"(",
"frames",
")",
"else",
":",
"raise",
"Exception",
"(",
"'Video type not found'",
")"
] | Config video types | [
"Config",
"video",
"types"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L95-L104 |
23,887 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.process_frames_face | def process_frames_face(self, frames):
"""
Preprocess from frames using face detector
"""
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(self.face_predictor_path)
mouth_frames = self.get_frames_mouth(detector, predictor, frames)
self.face = np.array(frames)
self.mouth = np.array(mouth_frames)
if mouth_frames[0] is not None:
self.set_data(mouth_frames) | python | def process_frames_face(self, frames):
"""
Preprocess from frames using face detector
"""
detector = dlib.get_frontal_face_detector()
predictor = dlib.shape_predictor(self.face_predictor_path)
mouth_frames = self.get_frames_mouth(detector, predictor, frames)
self.face = np.array(frames)
self.mouth = np.array(mouth_frames)
if mouth_frames[0] is not None:
self.set_data(mouth_frames) | [
"def",
"process_frames_face",
"(",
"self",
",",
"frames",
")",
":",
"detector",
"=",
"dlib",
".",
"get_frontal_face_detector",
"(",
")",
"predictor",
"=",
"dlib",
".",
"shape_predictor",
"(",
"self",
".",
"face_predictor_path",
")",
"mouth_frames",
"=",
"self",
".",
"get_frames_mouth",
"(",
"detector",
",",
"predictor",
",",
"frames",
")",
"self",
".",
"face",
"=",
"np",
".",
"array",
"(",
"frames",
")",
"self",
".",
"mouth",
"=",
"np",
".",
"array",
"(",
"mouth_frames",
")",
"if",
"mouth_frames",
"[",
"0",
"]",
"is",
"not",
"None",
":",
"self",
".",
"set_data",
"(",
"mouth_frames",
")"
] | Preprocess from frames using face detector | [
"Preprocess",
"from",
"frames",
"using",
"face",
"detector"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L106-L116 |
23,888 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.process_frames_mouth | def process_frames_mouth(self, frames):
"""
Preprocess from frames using mouth detector
"""
self.face = np.array(frames)
self.mouth = np.array(frames)
self.set_data(frames) | python | def process_frames_mouth(self, frames):
"""
Preprocess from frames using mouth detector
"""
self.face = np.array(frames)
self.mouth = np.array(frames)
self.set_data(frames) | [
"def",
"process_frames_mouth",
"(",
"self",
",",
"frames",
")",
":",
"self",
".",
"face",
"=",
"np",
".",
"array",
"(",
"frames",
")",
"self",
".",
"mouth",
"=",
"np",
".",
"array",
"(",
"frames",
")",
"self",
".",
"set_data",
"(",
"frames",
")"
] | Preprocess from frames using mouth detector | [
"Preprocess",
"from",
"frames",
"using",
"mouth",
"detector"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L118-L124 |
23,889 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.get_frames_mouth | def get_frames_mouth(self, detector, predictor, frames):
"""
Get frames using mouth crop
"""
mouth_width = 100
mouth_height = 50
horizontal_pad = 0.19
normalize_ratio = None
mouth_frames = []
for frame in frames:
dets = detector(frame, 1)
shape = None
for det in dets:
shape = predictor(frame, det)
i = -1
if shape is None: # Detector doesn't detect face, just return None
return [None]
mouth_points = []
for part in shape.parts():
i += 1
if i < 48: # Only take mouth region
continue
mouth_points.append((part.x, part.y))
np_mouth_points = np.array(mouth_points)
mouth_centroid = np.mean(np_mouth_points[:, -2:], axis=0)
if normalize_ratio is None:
mouth_left = np.min(np_mouth_points[:, :-1]) * (1.0 - horizontal_pad)
mouth_right = np.max(np_mouth_points[:, :-1]) * (1.0 + horizontal_pad)
normalize_ratio = mouth_width / float(mouth_right - mouth_left)
new_img_shape = (int(frame.shape[0] * normalize_ratio),
int(frame.shape[1] * normalize_ratio))
resized_img = imresize(frame, new_img_shape)
mouth_centroid_norm = mouth_centroid * normalize_ratio
mouth_l = int(mouth_centroid_norm[0] - mouth_width / 2)
mouth_r = int(mouth_centroid_norm[0] + mouth_width / 2)
mouth_t = int(mouth_centroid_norm[1] - mouth_height / 2)
mouth_b = int(mouth_centroid_norm[1] + mouth_height / 2)
mouth_crop_image = resized_img[mouth_t:mouth_b, mouth_l:mouth_r]
mouth_frames.append(mouth_crop_image)
return mouth_frames | python | def get_frames_mouth(self, detector, predictor, frames):
"""
Get frames using mouth crop
"""
mouth_width = 100
mouth_height = 50
horizontal_pad = 0.19
normalize_ratio = None
mouth_frames = []
for frame in frames:
dets = detector(frame, 1)
shape = None
for det in dets:
shape = predictor(frame, det)
i = -1
if shape is None: # Detector doesn't detect face, just return None
return [None]
mouth_points = []
for part in shape.parts():
i += 1
if i < 48: # Only take mouth region
continue
mouth_points.append((part.x, part.y))
np_mouth_points = np.array(mouth_points)
mouth_centroid = np.mean(np_mouth_points[:, -2:], axis=0)
if normalize_ratio is None:
mouth_left = np.min(np_mouth_points[:, :-1]) * (1.0 - horizontal_pad)
mouth_right = np.max(np_mouth_points[:, :-1]) * (1.0 + horizontal_pad)
normalize_ratio = mouth_width / float(mouth_right - mouth_left)
new_img_shape = (int(frame.shape[0] * normalize_ratio),
int(frame.shape[1] * normalize_ratio))
resized_img = imresize(frame, new_img_shape)
mouth_centroid_norm = mouth_centroid * normalize_ratio
mouth_l = int(mouth_centroid_norm[0] - mouth_width / 2)
mouth_r = int(mouth_centroid_norm[0] + mouth_width / 2)
mouth_t = int(mouth_centroid_norm[1] - mouth_height / 2)
mouth_b = int(mouth_centroid_norm[1] + mouth_height / 2)
mouth_crop_image = resized_img[mouth_t:mouth_b, mouth_l:mouth_r]
mouth_frames.append(mouth_crop_image)
return mouth_frames | [
"def",
"get_frames_mouth",
"(",
"self",
",",
"detector",
",",
"predictor",
",",
"frames",
")",
":",
"mouth_width",
"=",
"100",
"mouth_height",
"=",
"50",
"horizontal_pad",
"=",
"0.19",
"normalize_ratio",
"=",
"None",
"mouth_frames",
"=",
"[",
"]",
"for",
"frame",
"in",
"frames",
":",
"dets",
"=",
"detector",
"(",
"frame",
",",
"1",
")",
"shape",
"=",
"None",
"for",
"det",
"in",
"dets",
":",
"shape",
"=",
"predictor",
"(",
"frame",
",",
"det",
")",
"i",
"=",
"-",
"1",
"if",
"shape",
"is",
"None",
":",
"# Detector doesn't detect face, just return None",
"return",
"[",
"None",
"]",
"mouth_points",
"=",
"[",
"]",
"for",
"part",
"in",
"shape",
".",
"parts",
"(",
")",
":",
"i",
"+=",
"1",
"if",
"i",
"<",
"48",
":",
"# Only take mouth region",
"continue",
"mouth_points",
".",
"append",
"(",
"(",
"part",
".",
"x",
",",
"part",
".",
"y",
")",
")",
"np_mouth_points",
"=",
"np",
".",
"array",
"(",
"mouth_points",
")",
"mouth_centroid",
"=",
"np",
".",
"mean",
"(",
"np_mouth_points",
"[",
":",
",",
"-",
"2",
":",
"]",
",",
"axis",
"=",
"0",
")",
"if",
"normalize_ratio",
"is",
"None",
":",
"mouth_left",
"=",
"np",
".",
"min",
"(",
"np_mouth_points",
"[",
":",
",",
":",
"-",
"1",
"]",
")",
"*",
"(",
"1.0",
"-",
"horizontal_pad",
")",
"mouth_right",
"=",
"np",
".",
"max",
"(",
"np_mouth_points",
"[",
":",
",",
":",
"-",
"1",
"]",
")",
"*",
"(",
"1.0",
"+",
"horizontal_pad",
")",
"normalize_ratio",
"=",
"mouth_width",
"/",
"float",
"(",
"mouth_right",
"-",
"mouth_left",
")",
"new_img_shape",
"=",
"(",
"int",
"(",
"frame",
".",
"shape",
"[",
"0",
"]",
"*",
"normalize_ratio",
")",
",",
"int",
"(",
"frame",
".",
"shape",
"[",
"1",
"]",
"*",
"normalize_ratio",
")",
")",
"resized_img",
"=",
"imresize",
"(",
"frame",
",",
"new_img_shape",
")",
"mouth_centroid_norm",
"=",
"mouth_centroid",
"*",
"normalize_ratio",
"mouth_l",
"=",
"int",
"(",
"mouth_centroid_norm",
"[",
"0",
"]",
"-",
"mouth_width",
"/",
"2",
")",
"mouth_r",
"=",
"int",
"(",
"mouth_centroid_norm",
"[",
"0",
"]",
"+",
"mouth_width",
"/",
"2",
")",
"mouth_t",
"=",
"int",
"(",
"mouth_centroid_norm",
"[",
"1",
"]",
"-",
"mouth_height",
"/",
"2",
")",
"mouth_b",
"=",
"int",
"(",
"mouth_centroid_norm",
"[",
"1",
"]",
"+",
"mouth_height",
"/",
"2",
")",
"mouth_crop_image",
"=",
"resized_img",
"[",
"mouth_t",
":",
"mouth_b",
",",
"mouth_l",
":",
"mouth_r",
"]",
"mouth_frames",
".",
"append",
"(",
"mouth_crop_image",
")",
"return",
"mouth_frames"
] | Get frames using mouth crop | [
"Get",
"frames",
"using",
"mouth",
"crop"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L126-L173 |
23,890 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.get_video_frames | def get_video_frames(self, path):
"""
Get video frames
"""
videogen = skvideo.io.vreader(path)
frames = np.array([frame for frame in videogen])
return frames | python | def get_video_frames(self, path):
"""
Get video frames
"""
videogen = skvideo.io.vreader(path)
frames = np.array([frame for frame in videogen])
return frames | [
"def",
"get_video_frames",
"(",
"self",
",",
"path",
")",
":",
"videogen",
"=",
"skvideo",
".",
"io",
".",
"vreader",
"(",
"path",
")",
"frames",
"=",
"np",
".",
"array",
"(",
"[",
"frame",
"for",
"frame",
"in",
"videogen",
"]",
")",
"return",
"frames"
] | Get video frames | [
"Get",
"video",
"frames"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L175-L181 |
23,891 | apache/incubator-mxnet | example/gluon/lipnet/utils/preprocess_data.py | Video.set_data | def set_data(self, frames):
"""
Prepare the input of model
"""
data_frames = []
for frame in frames:
#frame H x W x C
frame = frame.swapaxes(0, 1) # swap width and height to form format W x H x C
if len(frame.shape) < 3:
frame = np.array([frame]).swapaxes(0, 2).swapaxes(0, 1) # Add grayscale channel
data_frames.append(frame)
frames_n = len(data_frames)
data_frames = np.array(data_frames) # T x W x H x C
data_frames = np.rollaxis(data_frames, 3) # C x T x W x H
data_frames = data_frames.swapaxes(2, 3) # C x T x H x W = NCDHW
self.data = data_frames
self.length = frames_n | python | def set_data(self, frames):
"""
Prepare the input of model
"""
data_frames = []
for frame in frames:
#frame H x W x C
frame = frame.swapaxes(0, 1) # swap width and height to form format W x H x C
if len(frame.shape) < 3:
frame = np.array([frame]).swapaxes(0, 2).swapaxes(0, 1) # Add grayscale channel
data_frames.append(frame)
frames_n = len(data_frames)
data_frames = np.array(data_frames) # T x W x H x C
data_frames = np.rollaxis(data_frames, 3) # C x T x W x H
data_frames = data_frames.swapaxes(2, 3) # C x T x H x W = NCDHW
self.data = data_frames
self.length = frames_n | [
"def",
"set_data",
"(",
"self",
",",
"frames",
")",
":",
"data_frames",
"=",
"[",
"]",
"for",
"frame",
"in",
"frames",
":",
"#frame H x W x C",
"frame",
"=",
"frame",
".",
"swapaxes",
"(",
"0",
",",
"1",
")",
"# swap width and height to form format W x H x C",
"if",
"len",
"(",
"frame",
".",
"shape",
")",
"<",
"3",
":",
"frame",
"=",
"np",
".",
"array",
"(",
"[",
"frame",
"]",
")",
".",
"swapaxes",
"(",
"0",
",",
"2",
")",
".",
"swapaxes",
"(",
"0",
",",
"1",
")",
"# Add grayscale channel",
"data_frames",
".",
"append",
"(",
"frame",
")",
"frames_n",
"=",
"len",
"(",
"data_frames",
")",
"data_frames",
"=",
"np",
".",
"array",
"(",
"data_frames",
")",
"# T x W x H x C",
"data_frames",
"=",
"np",
".",
"rollaxis",
"(",
"data_frames",
",",
"3",
")",
"# C x T x W x H",
"data_frames",
"=",
"data_frames",
".",
"swapaxes",
"(",
"2",
",",
"3",
")",
"# C x T x H x W = NCDHW",
"self",
".",
"data",
"=",
"data_frames",
"self",
".",
"length",
"=",
"frames_n"
] | Prepare the input of model | [
"Prepare",
"the",
"input",
"of",
"model"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/preprocess_data.py#L183-L200 |
23,892 | apache/incubator-mxnet | example/gluon/style_transfer/utils.py | subtract_imagenet_mean_preprocess_batch | def subtract_imagenet_mean_preprocess_batch(batch):
"""Subtract ImageNet mean pixel-wise from a BGR image."""
batch = F.swapaxes(batch,0, 1)
(r, g, b) = F.split(batch, num_outputs=3, axis=0)
r = r - 123.680
g = g - 116.779
b = b - 103.939
batch = F.concat(b, g, r, dim=0)
batch = F.swapaxes(batch,0, 1)
return batch | python | def subtract_imagenet_mean_preprocess_batch(batch):
"""Subtract ImageNet mean pixel-wise from a BGR image."""
batch = F.swapaxes(batch,0, 1)
(r, g, b) = F.split(batch, num_outputs=3, axis=0)
r = r - 123.680
g = g - 116.779
b = b - 103.939
batch = F.concat(b, g, r, dim=0)
batch = F.swapaxes(batch,0, 1)
return batch | [
"def",
"subtract_imagenet_mean_preprocess_batch",
"(",
"batch",
")",
":",
"batch",
"=",
"F",
".",
"swapaxes",
"(",
"batch",
",",
"0",
",",
"1",
")",
"(",
"r",
",",
"g",
",",
"b",
")",
"=",
"F",
".",
"split",
"(",
"batch",
",",
"num_outputs",
"=",
"3",
",",
"axis",
"=",
"0",
")",
"r",
"=",
"r",
"-",
"123.680",
"g",
"=",
"g",
"-",
"116.779",
"b",
"=",
"b",
"-",
"103.939",
"batch",
"=",
"F",
".",
"concat",
"(",
"b",
",",
"g",
",",
"r",
",",
"dim",
"=",
"0",
")",
"batch",
"=",
"F",
".",
"swapaxes",
"(",
"batch",
",",
"0",
",",
"1",
")",
"return",
"batch"
] | Subtract ImageNet mean pixel-wise from a BGR image. | [
"Subtract",
"ImageNet",
"mean",
"pixel",
"-",
"wise",
"from",
"a",
"BGR",
"image",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/style_transfer/utils.py#L69-L78 |
23,893 | apache/incubator-mxnet | example/gluon/style_transfer/utils.py | imagenet_clamp_batch | def imagenet_clamp_batch(batch, low, high):
""" Not necessary in practice """
F.clip(batch[:,0,:,:],low-123.680, high-123.680)
F.clip(batch[:,1,:,:],low-116.779, high-116.779)
F.clip(batch[:,2,:,:],low-103.939, high-103.939) | python | def imagenet_clamp_batch(batch, low, high):
""" Not necessary in practice """
F.clip(batch[:,0,:,:],low-123.680, high-123.680)
F.clip(batch[:,1,:,:],low-116.779, high-116.779)
F.clip(batch[:,2,:,:],low-103.939, high-103.939) | [
"def",
"imagenet_clamp_batch",
"(",
"batch",
",",
"low",
",",
"high",
")",
":",
"F",
".",
"clip",
"(",
"batch",
"[",
":",
",",
"0",
",",
":",
",",
":",
"]",
",",
"low",
"-",
"123.680",
",",
"high",
"-",
"123.680",
")",
"F",
".",
"clip",
"(",
"batch",
"[",
":",
",",
"1",
",",
":",
",",
":",
"]",
",",
"low",
"-",
"116.779",
",",
"high",
"-",
"116.779",
")",
"F",
".",
"clip",
"(",
"batch",
"[",
":",
",",
"2",
",",
":",
",",
":",
"]",
",",
"low",
"-",
"103.939",
",",
"high",
"-",
"103.939",
")"
] | Not necessary in practice | [
"Not",
"necessary",
"in",
"practice"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/style_transfer/utils.py#L95-L99 |
23,894 | apache/incubator-mxnet | example/gluon/audio/urban_sounds/train.py | evaluate_accuracy | def evaluate_accuracy(data_iterator, net):
"""Function to evaluate accuracy of any data iterator passed to it as an argument"""
acc = mx.metric.Accuracy()
for data, label in data_iterator:
output = net(data)
predictions = nd.argmax(output, axis=1)
predictions = predictions.reshape((-1, 1))
acc.update(preds=predictions, labels=label)
return acc.get()[1] | python | def evaluate_accuracy(data_iterator, net):
"""Function to evaluate accuracy of any data iterator passed to it as an argument"""
acc = mx.metric.Accuracy()
for data, label in data_iterator:
output = net(data)
predictions = nd.argmax(output, axis=1)
predictions = predictions.reshape((-1, 1))
acc.update(preds=predictions, labels=label)
return acc.get()[1] | [
"def",
"evaluate_accuracy",
"(",
"data_iterator",
",",
"net",
")",
":",
"acc",
"=",
"mx",
".",
"metric",
".",
"Accuracy",
"(",
")",
"for",
"data",
",",
"label",
"in",
"data_iterator",
":",
"output",
"=",
"net",
"(",
"data",
")",
"predictions",
"=",
"nd",
".",
"argmax",
"(",
"output",
",",
"axis",
"=",
"1",
")",
"predictions",
"=",
"predictions",
".",
"reshape",
"(",
"(",
"-",
"1",
",",
"1",
")",
")",
"acc",
".",
"update",
"(",
"preds",
"=",
"predictions",
",",
"labels",
"=",
"label",
")",
"return",
"acc",
".",
"get",
"(",
")",
"[",
"1",
"]"
] | Function to evaluate accuracy of any data iterator passed to it as an argument | [
"Function",
"to",
"evaluate",
"accuracy",
"of",
"any",
"data",
"iterator",
"passed",
"to",
"it",
"as",
"an",
"argument"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/audio/urban_sounds/train.py#L29-L37 |
23,895 | apache/incubator-mxnet | python/mxnet/engine.py | set_bulk_size | def set_bulk_size(size):
"""Set size limit on bulk execution.
Bulk execution bundles many operators to run together.
This can improve performance when running a lot of small
operators sequentially.
Parameters
----------
size : int
Maximum number of operators that can be bundled in a bulk.
Returns
-------
int
Previous bulk size.
"""
prev = ctypes.c_int()
check_call(_LIB.MXEngineSetBulkSize(
ctypes.c_int(size), ctypes.byref(prev)))
return prev.value | python | def set_bulk_size(size):
"""Set size limit on bulk execution.
Bulk execution bundles many operators to run together.
This can improve performance when running a lot of small
operators sequentially.
Parameters
----------
size : int
Maximum number of operators that can be bundled in a bulk.
Returns
-------
int
Previous bulk size.
"""
prev = ctypes.c_int()
check_call(_LIB.MXEngineSetBulkSize(
ctypes.c_int(size), ctypes.byref(prev)))
return prev.value | [
"def",
"set_bulk_size",
"(",
"size",
")",
":",
"prev",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXEngineSetBulkSize",
"(",
"ctypes",
".",
"c_int",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"prev",
")",
")",
")",
"return",
"prev",
".",
"value"
] | Set size limit on bulk execution.
Bulk execution bundles many operators to run together.
This can improve performance when running a lot of small
operators sequentially.
Parameters
----------
size : int
Maximum number of operators that can be bundled in a bulk.
Returns
-------
int
Previous bulk size. | [
"Set",
"size",
"limit",
"on",
"bulk",
"execution",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/engine.py#L26-L46 |
23,896 | apache/incubator-mxnet | example/gluon/lipnet/BeamSearch.py | applyLM | def applyLM(parentBeam, childBeam, classes, lm):
"""
calculate LM score of child beam by taking score from parent beam and bigram probability of last two chars
"""
if lm and not childBeam.lmApplied:
c1 = classes[parentBeam.labeling[-1] if parentBeam.labeling else classes.index(' ')] # first char
c2 = classes[childBeam.labeling[-1]] # second char
lmFactor = 0.01 # influence of language model
bigramProb = lm.getCharBigram(c1, c2) ** lmFactor # probability of seeing first and second char next to each other
childBeam.prText = parentBeam.prText * bigramProb # probability of char sequence
childBeam.lmApplied = True | python | def applyLM(parentBeam, childBeam, classes, lm):
"""
calculate LM score of child beam by taking score from parent beam and bigram probability of last two chars
"""
if lm and not childBeam.lmApplied:
c1 = classes[parentBeam.labeling[-1] if parentBeam.labeling else classes.index(' ')] # first char
c2 = classes[childBeam.labeling[-1]] # second char
lmFactor = 0.01 # influence of language model
bigramProb = lm.getCharBigram(c1, c2) ** lmFactor # probability of seeing first and second char next to each other
childBeam.prText = parentBeam.prText * bigramProb # probability of char sequence
childBeam.lmApplied = True | [
"def",
"applyLM",
"(",
"parentBeam",
",",
"childBeam",
",",
"classes",
",",
"lm",
")",
":",
"if",
"lm",
"and",
"not",
"childBeam",
".",
"lmApplied",
":",
"c1",
"=",
"classes",
"[",
"parentBeam",
".",
"labeling",
"[",
"-",
"1",
"]",
"if",
"parentBeam",
".",
"labeling",
"else",
"classes",
".",
"index",
"(",
"' '",
")",
"]",
"# first char",
"c2",
"=",
"classes",
"[",
"childBeam",
".",
"labeling",
"[",
"-",
"1",
"]",
"]",
"# second char",
"lmFactor",
"=",
"0.01",
"# influence of language model",
"bigramProb",
"=",
"lm",
".",
"getCharBigram",
"(",
"c1",
",",
"c2",
")",
"**",
"lmFactor",
"# probability of seeing first and second char next to each other",
"childBeam",
".",
"prText",
"=",
"parentBeam",
".",
"prText",
"*",
"bigramProb",
"# probability of char sequence",
"childBeam",
".",
"lmApplied",
"=",
"True"
] | calculate LM score of child beam by taking score from parent beam and bigram probability of last two chars | [
"calculate",
"LM",
"score",
"of",
"child",
"beam",
"by",
"taking",
"score",
"from",
"parent",
"beam",
"and",
"bigram",
"probability",
"of",
"last",
"two",
"chars"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/BeamSearch.py#L64-L74 |
23,897 | apache/incubator-mxnet | example/gluon/lipnet/BeamSearch.py | addBeam | def addBeam(beamState, labeling):
"""
add beam if it does not yet exist
"""
if labeling not in beamState.entries:
beamState.entries[labeling] = BeamEntry() | python | def addBeam(beamState, labeling):
"""
add beam if it does not yet exist
"""
if labeling not in beamState.entries:
beamState.entries[labeling] = BeamEntry() | [
"def",
"addBeam",
"(",
"beamState",
",",
"labeling",
")",
":",
"if",
"labeling",
"not",
"in",
"beamState",
".",
"entries",
":",
"beamState",
".",
"entries",
"[",
"labeling",
"]",
"=",
"BeamEntry",
"(",
")"
] | add beam if it does not yet exist | [
"add",
"beam",
"if",
"it",
"does",
"not",
"yet",
"exist"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/BeamSearch.py#L76-L81 |
23,898 | apache/incubator-mxnet | example/gluon/lipnet/BeamSearch.py | ctcBeamSearch | def ctcBeamSearch(mat, classes, lm, k, beamWidth):
"""
beam search as described by the paper of Hwang et al. and the paper of Graves et al.
"""
blankIdx = len(classes)
maxT, maxC = mat.shape
# initialise beam state
last = BeamState()
labeling = ()
last.entries[labeling] = BeamEntry()
last.entries[labeling].prBlank = 1
last.entries[labeling].prTotal = 1
# go over all time-steps
for t in range(maxT):
curr = BeamState()
# get beam-labelings of best beams
bestLabelings = last.sort()[0:beamWidth]
# go over best beams
for labeling in bestLabelings:
# probability of paths ending with a non-blank
prNonBlank = 0
# in case of non-empty beam
if labeling:
# probability of paths with repeated last char at the end
try:
prNonBlank = last.entries[labeling].prNonBlank * mat[t, labeling[-1]]
except FloatingPointError:
prNonBlank = 0
# probability of paths ending with a blank
prBlank = (last.entries[labeling].prTotal) * mat[t, blankIdx]
# add beam at current time-step if needed
addBeam(curr, labeling)
# fill in data
curr.entries[labeling].labeling = labeling
curr.entries[labeling].prNonBlank += prNonBlank
curr.entries[labeling].prBlank += prBlank
curr.entries[labeling].prTotal += prBlank + prNonBlank
curr.entries[labeling].prText = last.entries[labeling].prText # beam-labeling not changed, therefore also LM score unchanged from
curr.entries[labeling].lmApplied = True # LM already applied at previous time-step for this beam-labeling
# extend current beam-labeling
for c in range(maxC - 1):
# add new char to current beam-labeling
newLabeling = labeling + (c,)
# if new labeling contains duplicate char at the end, only consider paths ending with a blank
if labeling and labeling[-1] == c:
prNonBlank = mat[t, c] * last.entries[labeling].prBlank
else:
prNonBlank = mat[t, c] * last.entries[labeling].prTotal
# add beam at current time-step if needed
addBeam(curr, newLabeling)
# fill in data
curr.entries[newLabeling].labeling = newLabeling
curr.entries[newLabeling].prNonBlank += prNonBlank
curr.entries[newLabeling].prTotal += prNonBlank
# apply LM
applyLM(curr.entries[labeling], curr.entries[newLabeling], classes, lm)
# set new beam state
last = curr
# normalise LM scores according to beam-labeling-length
last.norm()
# sort by probability
bestLabelings = last.sort()[:k] # get most probable labeling
output = []
for bestLabeling in bestLabelings:
# map labels to chars
res = ''
for l in bestLabeling:
res += classes[l]
output.append(res)
return output | python | def ctcBeamSearch(mat, classes, lm, k, beamWidth):
"""
beam search as described by the paper of Hwang et al. and the paper of Graves et al.
"""
blankIdx = len(classes)
maxT, maxC = mat.shape
# initialise beam state
last = BeamState()
labeling = ()
last.entries[labeling] = BeamEntry()
last.entries[labeling].prBlank = 1
last.entries[labeling].prTotal = 1
# go over all time-steps
for t in range(maxT):
curr = BeamState()
# get beam-labelings of best beams
bestLabelings = last.sort()[0:beamWidth]
# go over best beams
for labeling in bestLabelings:
# probability of paths ending with a non-blank
prNonBlank = 0
# in case of non-empty beam
if labeling:
# probability of paths with repeated last char at the end
try:
prNonBlank = last.entries[labeling].prNonBlank * mat[t, labeling[-1]]
except FloatingPointError:
prNonBlank = 0
# probability of paths ending with a blank
prBlank = (last.entries[labeling].prTotal) * mat[t, blankIdx]
# add beam at current time-step if needed
addBeam(curr, labeling)
# fill in data
curr.entries[labeling].labeling = labeling
curr.entries[labeling].prNonBlank += prNonBlank
curr.entries[labeling].prBlank += prBlank
curr.entries[labeling].prTotal += prBlank + prNonBlank
curr.entries[labeling].prText = last.entries[labeling].prText # beam-labeling not changed, therefore also LM score unchanged from
curr.entries[labeling].lmApplied = True # LM already applied at previous time-step for this beam-labeling
# extend current beam-labeling
for c in range(maxC - 1):
# add new char to current beam-labeling
newLabeling = labeling + (c,)
# if new labeling contains duplicate char at the end, only consider paths ending with a blank
if labeling and labeling[-1] == c:
prNonBlank = mat[t, c] * last.entries[labeling].prBlank
else:
prNonBlank = mat[t, c] * last.entries[labeling].prTotal
# add beam at current time-step if needed
addBeam(curr, newLabeling)
# fill in data
curr.entries[newLabeling].labeling = newLabeling
curr.entries[newLabeling].prNonBlank += prNonBlank
curr.entries[newLabeling].prTotal += prNonBlank
# apply LM
applyLM(curr.entries[labeling], curr.entries[newLabeling], classes, lm)
# set new beam state
last = curr
# normalise LM scores according to beam-labeling-length
last.norm()
# sort by probability
bestLabelings = last.sort()[:k] # get most probable labeling
output = []
for bestLabeling in bestLabelings:
# map labels to chars
res = ''
for l in bestLabeling:
res += classes[l]
output.append(res)
return output | [
"def",
"ctcBeamSearch",
"(",
"mat",
",",
"classes",
",",
"lm",
",",
"k",
",",
"beamWidth",
")",
":",
"blankIdx",
"=",
"len",
"(",
"classes",
")",
"maxT",
",",
"maxC",
"=",
"mat",
".",
"shape",
"# initialise beam state",
"last",
"=",
"BeamState",
"(",
")",
"labeling",
"=",
"(",
")",
"last",
".",
"entries",
"[",
"labeling",
"]",
"=",
"BeamEntry",
"(",
")",
"last",
".",
"entries",
"[",
"labeling",
"]",
".",
"prBlank",
"=",
"1",
"last",
".",
"entries",
"[",
"labeling",
"]",
".",
"prTotal",
"=",
"1",
"# go over all time-steps",
"for",
"t",
"in",
"range",
"(",
"maxT",
")",
":",
"curr",
"=",
"BeamState",
"(",
")",
"# get beam-labelings of best beams",
"bestLabelings",
"=",
"last",
".",
"sort",
"(",
")",
"[",
"0",
":",
"beamWidth",
"]",
"# go over best beams",
"for",
"labeling",
"in",
"bestLabelings",
":",
"# probability of paths ending with a non-blank",
"prNonBlank",
"=",
"0",
"# in case of non-empty beam",
"if",
"labeling",
":",
"# probability of paths with repeated last char at the end",
"try",
":",
"prNonBlank",
"=",
"last",
".",
"entries",
"[",
"labeling",
"]",
".",
"prNonBlank",
"*",
"mat",
"[",
"t",
",",
"labeling",
"[",
"-",
"1",
"]",
"]",
"except",
"FloatingPointError",
":",
"prNonBlank",
"=",
"0",
"# probability of paths ending with a blank",
"prBlank",
"=",
"(",
"last",
".",
"entries",
"[",
"labeling",
"]",
".",
"prTotal",
")",
"*",
"mat",
"[",
"t",
",",
"blankIdx",
"]",
"# add beam at current time-step if needed",
"addBeam",
"(",
"curr",
",",
"labeling",
")",
"# fill in data",
"curr",
".",
"entries",
"[",
"labeling",
"]",
".",
"labeling",
"=",
"labeling",
"curr",
".",
"entries",
"[",
"labeling",
"]",
".",
"prNonBlank",
"+=",
"prNonBlank",
"curr",
".",
"entries",
"[",
"labeling",
"]",
".",
"prBlank",
"+=",
"prBlank",
"curr",
".",
"entries",
"[",
"labeling",
"]",
".",
"prTotal",
"+=",
"prBlank",
"+",
"prNonBlank",
"curr",
".",
"entries",
"[",
"labeling",
"]",
".",
"prText",
"=",
"last",
".",
"entries",
"[",
"labeling",
"]",
".",
"prText",
"# beam-labeling not changed, therefore also LM score unchanged from",
"curr",
".",
"entries",
"[",
"labeling",
"]",
".",
"lmApplied",
"=",
"True",
"# LM already applied at previous time-step for this beam-labeling",
"# extend current beam-labeling",
"for",
"c",
"in",
"range",
"(",
"maxC",
"-",
"1",
")",
":",
"# add new char to current beam-labeling",
"newLabeling",
"=",
"labeling",
"+",
"(",
"c",
",",
")",
"# if new labeling contains duplicate char at the end, only consider paths ending with a blank",
"if",
"labeling",
"and",
"labeling",
"[",
"-",
"1",
"]",
"==",
"c",
":",
"prNonBlank",
"=",
"mat",
"[",
"t",
",",
"c",
"]",
"*",
"last",
".",
"entries",
"[",
"labeling",
"]",
".",
"prBlank",
"else",
":",
"prNonBlank",
"=",
"mat",
"[",
"t",
",",
"c",
"]",
"*",
"last",
".",
"entries",
"[",
"labeling",
"]",
".",
"prTotal",
"# add beam at current time-step if needed",
"addBeam",
"(",
"curr",
",",
"newLabeling",
")",
"# fill in data",
"curr",
".",
"entries",
"[",
"newLabeling",
"]",
".",
"labeling",
"=",
"newLabeling",
"curr",
".",
"entries",
"[",
"newLabeling",
"]",
".",
"prNonBlank",
"+=",
"prNonBlank",
"curr",
".",
"entries",
"[",
"newLabeling",
"]",
".",
"prTotal",
"+=",
"prNonBlank",
"# apply LM",
"applyLM",
"(",
"curr",
".",
"entries",
"[",
"labeling",
"]",
",",
"curr",
".",
"entries",
"[",
"newLabeling",
"]",
",",
"classes",
",",
"lm",
")",
"# set new beam state",
"last",
"=",
"curr",
"# normalise LM scores according to beam-labeling-length",
"last",
".",
"norm",
"(",
")",
"# sort by probability",
"bestLabelings",
"=",
"last",
".",
"sort",
"(",
")",
"[",
":",
"k",
"]",
"# get most probable labeling",
"output",
"=",
"[",
"]",
"for",
"bestLabeling",
"in",
"bestLabelings",
":",
"# map labels to chars",
"res",
"=",
"''",
"for",
"l",
"in",
"bestLabeling",
":",
"res",
"+=",
"classes",
"[",
"l",
"]",
"output",
".",
"append",
"(",
"res",
")",
"return",
"output"
] | beam search as described by the paper of Hwang et al. and the paper of Graves et al. | [
"beam",
"search",
"as",
"described",
"by",
"the",
"paper",
"of",
"Hwang",
"et",
"al",
".",
"and",
"the",
"paper",
"of",
"Graves",
"et",
"al",
"."
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/BeamSearch.py#L83-L170 |
23,899 | apache/incubator-mxnet | example/gluon/lipnet/BeamSearch.py | BeamState.norm | def norm(self):
"""
length-normalise LM score
"""
for (k, _) in self.entries.items():
labelingLen = len(self.entries[k].labeling)
self.entries[k].prText = self.entries[k].prText ** (1.0 / (labelingLen if labelingLen else 1.0)) | python | def norm(self):
"""
length-normalise LM score
"""
for (k, _) in self.entries.items():
labelingLen = len(self.entries[k].labeling)
self.entries[k].prText = self.entries[k].prText ** (1.0 / (labelingLen if labelingLen else 1.0)) | [
"def",
"norm",
"(",
"self",
")",
":",
"for",
"(",
"k",
",",
"_",
")",
"in",
"self",
".",
"entries",
".",
"items",
"(",
")",
":",
"labelingLen",
"=",
"len",
"(",
"self",
".",
"entries",
"[",
"k",
"]",
".",
"labeling",
")",
"self",
".",
"entries",
"[",
"k",
"]",
".",
"prText",
"=",
"self",
".",
"entries",
"[",
"k",
"]",
".",
"prText",
"**",
"(",
"1.0",
"/",
"(",
"labelingLen",
"if",
"labelingLen",
"else",
"1.0",
")",
")"
] | length-normalise LM score | [
"length",
"-",
"normalise",
"LM",
"score"
] | 1af29e9c060a4c7d60eeaacba32afdb9a7775ba7 | https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/BeamSearch.py#L48-L54 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.