repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
apache/incubator-mxnet
|
example/ssd/dataset/mscoco.py
|
Coco._load_all
|
def _load_all(self, anno_file, shuffle):
"""
initialize all entries given annotation json file
Parameters:
----------
anno_file: str
annotation json file
shuffle: bool
whether to shuffle image list
"""
image_set_index = []
labels = []
coco = COCO(anno_file)
img_ids = coco.getImgIds()
# deal with class names
cats = [cat['name'] for cat in coco.loadCats(coco.getCatIds())]
class_to_coco_ind = dict(zip(cats, coco.getCatIds()))
class_to_ind = dict(zip(self.classes, range(len(self.classes))))
coco_ind_to_class_ind = dict([(class_to_coco_ind[cls], class_to_ind[cls])
for cls in self.classes[0:]])
for img_id in img_ids:
# filename
image_info = coco.loadImgs(img_id)[0]
filename = image_info["file_name"]
subdir = filename.split('_')[1]
height = image_info["height"]
width = image_info["width"]
# label
anno_ids = coco.getAnnIds(imgIds=img_id)
annos = coco.loadAnns(anno_ids)
label = []
for anno in annos:
cat_id = coco_ind_to_class_ind[anno['category_id']]
bbox = anno["bbox"]
assert len(bbox) == 4
xmin = float(bbox[0]) / width
ymin = float(bbox[1]) / height
xmax = xmin + float(bbox[2]) / width
ymax = ymin + float(bbox[3]) / height
label.append([cat_id, xmin, ymin, xmax, ymax, 0])
if label:
labels.append(np.array(label))
image_set_index.append(os.path.join(subdir, filename))
if shuffle:
import random
indices = list(range(len(image_set_index)))
random.shuffle(indices)
image_set_index = [image_set_index[i] for i in indices]
labels = [labels[i] for i in indices]
# store the results
self.image_set_index = image_set_index
self.labels = labels
|
python
|
def _load_all(self, anno_file, shuffle):
"""
initialize all entries given annotation json file
Parameters:
----------
anno_file: str
annotation json file
shuffle: bool
whether to shuffle image list
"""
image_set_index = []
labels = []
coco = COCO(anno_file)
img_ids = coco.getImgIds()
# deal with class names
cats = [cat['name'] for cat in coco.loadCats(coco.getCatIds())]
class_to_coco_ind = dict(zip(cats, coco.getCatIds()))
class_to_ind = dict(zip(self.classes, range(len(self.classes))))
coco_ind_to_class_ind = dict([(class_to_coco_ind[cls], class_to_ind[cls])
for cls in self.classes[0:]])
for img_id in img_ids:
# filename
image_info = coco.loadImgs(img_id)[0]
filename = image_info["file_name"]
subdir = filename.split('_')[1]
height = image_info["height"]
width = image_info["width"]
# label
anno_ids = coco.getAnnIds(imgIds=img_id)
annos = coco.loadAnns(anno_ids)
label = []
for anno in annos:
cat_id = coco_ind_to_class_ind[anno['category_id']]
bbox = anno["bbox"]
assert len(bbox) == 4
xmin = float(bbox[0]) / width
ymin = float(bbox[1]) / height
xmax = xmin + float(bbox[2]) / width
ymax = ymin + float(bbox[3]) / height
label.append([cat_id, xmin, ymin, xmax, ymax, 0])
if label:
labels.append(np.array(label))
image_set_index.append(os.path.join(subdir, filename))
if shuffle:
import random
indices = list(range(len(image_set_index)))
random.shuffle(indices)
image_set_index = [image_set_index[i] for i in indices]
labels = [labels[i] for i in indices]
# store the results
self.image_set_index = image_set_index
self.labels = labels
|
[
"def",
"_load_all",
"(",
"self",
",",
"anno_file",
",",
"shuffle",
")",
":",
"image_set_index",
"=",
"[",
"]",
"labels",
"=",
"[",
"]",
"coco",
"=",
"COCO",
"(",
"anno_file",
")",
"img_ids",
"=",
"coco",
".",
"getImgIds",
"(",
")",
"# deal with class names",
"cats",
"=",
"[",
"cat",
"[",
"'name'",
"]",
"for",
"cat",
"in",
"coco",
".",
"loadCats",
"(",
"coco",
".",
"getCatIds",
"(",
")",
")",
"]",
"class_to_coco_ind",
"=",
"dict",
"(",
"zip",
"(",
"cats",
",",
"coco",
".",
"getCatIds",
"(",
")",
")",
")",
"class_to_ind",
"=",
"dict",
"(",
"zip",
"(",
"self",
".",
"classes",
",",
"range",
"(",
"len",
"(",
"self",
".",
"classes",
")",
")",
")",
")",
"coco_ind_to_class_ind",
"=",
"dict",
"(",
"[",
"(",
"class_to_coco_ind",
"[",
"cls",
"]",
",",
"class_to_ind",
"[",
"cls",
"]",
")",
"for",
"cls",
"in",
"self",
".",
"classes",
"[",
"0",
":",
"]",
"]",
")",
"for",
"img_id",
"in",
"img_ids",
":",
"# filename",
"image_info",
"=",
"coco",
".",
"loadImgs",
"(",
"img_id",
")",
"[",
"0",
"]",
"filename",
"=",
"image_info",
"[",
"\"file_name\"",
"]",
"subdir",
"=",
"filename",
".",
"split",
"(",
"'_'",
")",
"[",
"1",
"]",
"height",
"=",
"image_info",
"[",
"\"height\"",
"]",
"width",
"=",
"image_info",
"[",
"\"width\"",
"]",
"# label",
"anno_ids",
"=",
"coco",
".",
"getAnnIds",
"(",
"imgIds",
"=",
"img_id",
")",
"annos",
"=",
"coco",
".",
"loadAnns",
"(",
"anno_ids",
")",
"label",
"=",
"[",
"]",
"for",
"anno",
"in",
"annos",
":",
"cat_id",
"=",
"coco_ind_to_class_ind",
"[",
"anno",
"[",
"'category_id'",
"]",
"]",
"bbox",
"=",
"anno",
"[",
"\"bbox\"",
"]",
"assert",
"len",
"(",
"bbox",
")",
"==",
"4",
"xmin",
"=",
"float",
"(",
"bbox",
"[",
"0",
"]",
")",
"/",
"width",
"ymin",
"=",
"float",
"(",
"bbox",
"[",
"1",
"]",
")",
"/",
"height",
"xmax",
"=",
"xmin",
"+",
"float",
"(",
"bbox",
"[",
"2",
"]",
")",
"/",
"width",
"ymax",
"=",
"ymin",
"+",
"float",
"(",
"bbox",
"[",
"3",
"]",
")",
"/",
"height",
"label",
".",
"append",
"(",
"[",
"cat_id",
",",
"xmin",
",",
"ymin",
",",
"xmax",
",",
"ymax",
",",
"0",
"]",
")",
"if",
"label",
":",
"labels",
".",
"append",
"(",
"np",
".",
"array",
"(",
"label",
")",
")",
"image_set_index",
".",
"append",
"(",
"os",
".",
"path",
".",
"join",
"(",
"subdir",
",",
"filename",
")",
")",
"if",
"shuffle",
":",
"import",
"random",
"indices",
"=",
"list",
"(",
"range",
"(",
"len",
"(",
"image_set_index",
")",
")",
")",
"random",
".",
"shuffle",
"(",
"indices",
")",
"image_set_index",
"=",
"[",
"image_set_index",
"[",
"i",
"]",
"for",
"i",
"in",
"indices",
"]",
"labels",
"=",
"[",
"labels",
"[",
"i",
"]",
"for",
"i",
"in",
"indices",
"]",
"# store the results",
"self",
".",
"image_set_index",
"=",
"image_set_index",
"self",
".",
"labels",
"=",
"labels"
] |
initialize all entries given annotation json file
Parameters:
----------
anno_file: str
annotation json file
shuffle: bool
whether to shuffle image list
|
[
"initialize",
"all",
"entries",
"given",
"annotation",
"json",
"file"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/dataset/mscoco.py#L85-L138
|
train
|
apache/incubator-mxnet
|
example/rnn/word_lm/module.py
|
CustomStatefulModule.init_params
|
def init_params(self, initializer=mx.init.Uniform(0.01), **kwargs):
"""Initializes the parameters and auxiliary states.
"""
self._module.init_params(initializer=initializer, **kwargs)
|
python
|
def init_params(self, initializer=mx.init.Uniform(0.01), **kwargs):
"""Initializes the parameters and auxiliary states.
"""
self._module.init_params(initializer=initializer, **kwargs)
|
[
"def",
"init_params",
"(",
"self",
",",
"initializer",
"=",
"mx",
".",
"init",
".",
"Uniform",
"(",
"0.01",
")",
",",
"*",
"*",
"kwargs",
")",
":",
"self",
".",
"_module",
".",
"init_params",
"(",
"initializer",
"=",
"initializer",
",",
"*",
"*",
"kwargs",
")"
] |
Initializes the parameters and auxiliary states.
|
[
"Initializes",
"the",
"parameters",
"and",
"auxiliary",
"states",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/word_lm/module.py#L61-L64
|
train
|
apache/incubator-mxnet
|
example/rnn/word_lm/module.py
|
CustomStatefulModule.forward
|
def forward(self, data_batch, is_train=None, carry_state=True):
"""Forward computation. States from previous forward computation are carried
to the current iteration if `carry_state` is set to `True`.
"""
# propagate states from the previous iteration
if carry_state:
if isinstance(self._next_states, (int, float)):
self._module.set_states(value=self._next_states)
else:
self._module.set_states(states=self._next_states)
self._module.forward(data_batch, is_train=is_train)
outputs = self._module.get_outputs(merge_multi_context=False)
self._next_states = outputs[:-1]
|
python
|
def forward(self, data_batch, is_train=None, carry_state=True):
"""Forward computation. States from previous forward computation are carried
to the current iteration if `carry_state` is set to `True`.
"""
# propagate states from the previous iteration
if carry_state:
if isinstance(self._next_states, (int, float)):
self._module.set_states(value=self._next_states)
else:
self._module.set_states(states=self._next_states)
self._module.forward(data_batch, is_train=is_train)
outputs = self._module.get_outputs(merge_multi_context=False)
self._next_states = outputs[:-1]
|
[
"def",
"forward",
"(",
"self",
",",
"data_batch",
",",
"is_train",
"=",
"None",
",",
"carry_state",
"=",
"True",
")",
":",
"# propagate states from the previous iteration",
"if",
"carry_state",
":",
"if",
"isinstance",
"(",
"self",
".",
"_next_states",
",",
"(",
"int",
",",
"float",
")",
")",
":",
"self",
".",
"_module",
".",
"set_states",
"(",
"value",
"=",
"self",
".",
"_next_states",
")",
"else",
":",
"self",
".",
"_module",
".",
"set_states",
"(",
"states",
"=",
"self",
".",
"_next_states",
")",
"self",
".",
"_module",
".",
"forward",
"(",
"data_batch",
",",
"is_train",
"=",
"is_train",
")",
"outputs",
"=",
"self",
".",
"_module",
".",
"get_outputs",
"(",
"merge_multi_context",
"=",
"False",
")",
"self",
".",
"_next_states",
"=",
"outputs",
"[",
":",
"-",
"1",
"]"
] |
Forward computation. States from previous forward computation are carried
to the current iteration if `carry_state` is set to `True`.
|
[
"Forward",
"computation",
".",
"States",
"from",
"previous",
"forward",
"computation",
"are",
"carried",
"to",
"the",
"current",
"iteration",
"if",
"carry_state",
"is",
"set",
"to",
"True",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/word_lm/module.py#L78-L90
|
train
|
apache/incubator-mxnet
|
example/rnn/word_lm/module.py
|
CustomStatefulModule.update
|
def update(self, max_norm=None):
"""Updates parameters according to the installed optimizer and the gradients computed
in the previous forward-backward batch. Gradients are clipped by their global norm
if `max_norm` is set.
Parameters
----------
max_norm: float, optional
If set, clip values of all gradients the ratio of the sum of their norms.
"""
if max_norm is not None:
self._clip_by_global_norm(max_norm)
self._module.update()
|
python
|
def update(self, max_norm=None):
"""Updates parameters according to the installed optimizer and the gradients computed
in the previous forward-backward batch. Gradients are clipped by their global norm
if `max_norm` is set.
Parameters
----------
max_norm: float, optional
If set, clip values of all gradients the ratio of the sum of their norms.
"""
if max_norm is not None:
self._clip_by_global_norm(max_norm)
self._module.update()
|
[
"def",
"update",
"(",
"self",
",",
"max_norm",
"=",
"None",
")",
":",
"if",
"max_norm",
"is",
"not",
"None",
":",
"self",
".",
"_clip_by_global_norm",
"(",
"max_norm",
")",
"self",
".",
"_module",
".",
"update",
"(",
")"
] |
Updates parameters according to the installed optimizer and the gradients computed
in the previous forward-backward batch. Gradients are clipped by their global norm
if `max_norm` is set.
Parameters
----------
max_norm: float, optional
If set, clip values of all gradients the ratio of the sum of their norms.
|
[
"Updates",
"parameters",
"according",
"to",
"the",
"installed",
"optimizer",
"and",
"the",
"gradients",
"computed",
"in",
"the",
"previous",
"forward",
"-",
"backward",
"batch",
".",
"Gradients",
"are",
"clipped",
"by",
"their",
"global",
"norm",
"if",
"max_norm",
"is",
"set",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/word_lm/module.py#L92-L104
|
train
|
apache/incubator-mxnet
|
example/rnn/word_lm/module.py
|
CustomStatefulModule._clip_by_global_norm
|
def _clip_by_global_norm(self, max_norm):
"""Clips gradient norm.
The norm is computed over all gradients together, as if they were
concatenated into a single vector. Gradients are modified in-place.
The method is first used in
`[ICML2013] On the difficulty of training recurrent neural networks`
Parameters
----------
max_norm : float or int
The maximum clipping threshold of the gradient norm.
Returns
-------
norm_val : float
The computed norm of the gradients.
"""
assert self._module.binded and self._module.params_initialized \
and self._module.optimizer_initialized
grad_array = []
for grad in self._module._exec_group.grad_arrays:
grad_array += grad
return mx.gluon.utils.clip_global_norm(grad_array, max_norm)
|
python
|
def _clip_by_global_norm(self, max_norm):
"""Clips gradient norm.
The norm is computed over all gradients together, as if they were
concatenated into a single vector. Gradients are modified in-place.
The method is first used in
`[ICML2013] On the difficulty of training recurrent neural networks`
Parameters
----------
max_norm : float or int
The maximum clipping threshold of the gradient norm.
Returns
-------
norm_val : float
The computed norm of the gradients.
"""
assert self._module.binded and self._module.params_initialized \
and self._module.optimizer_initialized
grad_array = []
for grad in self._module._exec_group.grad_arrays:
grad_array += grad
return mx.gluon.utils.clip_global_norm(grad_array, max_norm)
|
[
"def",
"_clip_by_global_norm",
"(",
"self",
",",
"max_norm",
")",
":",
"assert",
"self",
".",
"_module",
".",
"binded",
"and",
"self",
".",
"_module",
".",
"params_initialized",
"and",
"self",
".",
"_module",
".",
"optimizer_initialized",
"grad_array",
"=",
"[",
"]",
"for",
"grad",
"in",
"self",
".",
"_module",
".",
"_exec_group",
".",
"grad_arrays",
":",
"grad_array",
"+=",
"grad",
"return",
"mx",
".",
"gluon",
".",
"utils",
".",
"clip_global_norm",
"(",
"grad_array",
",",
"max_norm",
")"
] |
Clips gradient norm.
The norm is computed over all gradients together, as if they were
concatenated into a single vector. Gradients are modified in-place.
The method is first used in
`[ICML2013] On the difficulty of training recurrent neural networks`
Parameters
----------
max_norm : float or int
The maximum clipping threshold of the gradient norm.
Returns
-------
norm_val : float
The computed norm of the gradients.
|
[
"Clips",
"gradient",
"norm",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/word_lm/module.py#L106-L129
|
train
|
apache/incubator-mxnet
|
example/gluon/dc_gan/dcgan.py
|
visual
|
def visual(title, X, name):
"""Image visualization and preservation
:param title: title
:param X: images to visualized
:param name: saved picture`s name
:return:
"""
assert len(X.shape) == 4
X = X.transpose((0, 2, 3, 1))
X = np.clip((X - np.min(X))*(255.0/(np.max(X) - np.min(X))), 0, 255).astype(np.uint8)
n = np.ceil(np.sqrt(X.shape[0]))
buff = np.zeros((int(n*X.shape[1]), int(n*X.shape[2]), int(X.shape[3])), dtype=np.uint8)
for i, img in enumerate(X):
fill_buf(buff, i, img, X.shape[1:3])
buff = buff[:, :, ::-1]
plt.imshow(buff)
plt.title(title)
plt.savefig(name)
|
python
|
def visual(title, X, name):
"""Image visualization and preservation
:param title: title
:param X: images to visualized
:param name: saved picture`s name
:return:
"""
assert len(X.shape) == 4
X = X.transpose((0, 2, 3, 1))
X = np.clip((X - np.min(X))*(255.0/(np.max(X) - np.min(X))), 0, 255).astype(np.uint8)
n = np.ceil(np.sqrt(X.shape[0]))
buff = np.zeros((int(n*X.shape[1]), int(n*X.shape[2]), int(X.shape[3])), dtype=np.uint8)
for i, img in enumerate(X):
fill_buf(buff, i, img, X.shape[1:3])
buff = buff[:, :, ::-1]
plt.imshow(buff)
plt.title(title)
plt.savefig(name)
|
[
"def",
"visual",
"(",
"title",
",",
"X",
",",
"name",
")",
":",
"assert",
"len",
"(",
"X",
".",
"shape",
")",
"==",
"4",
"X",
"=",
"X",
".",
"transpose",
"(",
"(",
"0",
",",
"2",
",",
"3",
",",
"1",
")",
")",
"X",
"=",
"np",
".",
"clip",
"(",
"(",
"X",
"-",
"np",
".",
"min",
"(",
"X",
")",
")",
"*",
"(",
"255.0",
"/",
"(",
"np",
".",
"max",
"(",
"X",
")",
"-",
"np",
".",
"min",
"(",
"X",
")",
")",
")",
",",
"0",
",",
"255",
")",
".",
"astype",
"(",
"np",
".",
"uint8",
")",
"n",
"=",
"np",
".",
"ceil",
"(",
"np",
".",
"sqrt",
"(",
"X",
".",
"shape",
"[",
"0",
"]",
")",
")",
"buff",
"=",
"np",
".",
"zeros",
"(",
"(",
"int",
"(",
"n",
"*",
"X",
".",
"shape",
"[",
"1",
"]",
")",
",",
"int",
"(",
"n",
"*",
"X",
".",
"shape",
"[",
"2",
"]",
")",
",",
"int",
"(",
"X",
".",
"shape",
"[",
"3",
"]",
")",
")",
",",
"dtype",
"=",
"np",
".",
"uint8",
")",
"for",
"i",
",",
"img",
"in",
"enumerate",
"(",
"X",
")",
":",
"fill_buf",
"(",
"buff",
",",
"i",
",",
"img",
",",
"X",
".",
"shape",
"[",
"1",
":",
"3",
"]",
")",
"buff",
"=",
"buff",
"[",
":",
",",
":",
",",
":",
":",
"-",
"1",
"]",
"plt",
".",
"imshow",
"(",
"buff",
")",
"plt",
".",
"title",
"(",
"title",
")",
"plt",
".",
"savefig",
"(",
"name",
")"
] |
Image visualization and preservation
:param title: title
:param X: images to visualized
:param name: saved picture`s name
:return:
|
[
"Image",
"visualization",
"and",
"preservation",
":",
"param",
"title",
":",
"title",
":",
"param",
"X",
":",
"images",
"to",
"visualized",
":",
"param",
"name",
":",
"saved",
"picture",
"s",
"name",
":",
"return",
":"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/dc_gan/dcgan.py#L52-L69
|
train
|
apache/incubator-mxnet
|
example/gluon/dc_gan/dcgan.py
|
transformer
|
def transformer(data, label):
"""Get the translation of images"""
# resize to 64x64
data = mx.image.imresize(data, 64, 64)
# transpose from (64, 64, 3) to (3, 64, 64)
data = mx.nd.transpose(data, (2, 0, 1))
# normalize to [-1, 1]
data = data.astype(np.float32)/128 - 1
# if image is greyscale, repeat 3 times to get RGB image.
if data.shape[0] == 1:
data = mx.nd.tile(data, (3, 1, 1))
return data, label
|
python
|
def transformer(data, label):
"""Get the translation of images"""
# resize to 64x64
data = mx.image.imresize(data, 64, 64)
# transpose from (64, 64, 3) to (3, 64, 64)
data = mx.nd.transpose(data, (2, 0, 1))
# normalize to [-1, 1]
data = data.astype(np.float32)/128 - 1
# if image is greyscale, repeat 3 times to get RGB image.
if data.shape[0] == 1:
data = mx.nd.tile(data, (3, 1, 1))
return data, label
|
[
"def",
"transformer",
"(",
"data",
",",
"label",
")",
":",
"# resize to 64x64",
"data",
"=",
"mx",
".",
"image",
".",
"imresize",
"(",
"data",
",",
"64",
",",
"64",
")",
"# transpose from (64, 64, 3) to (3, 64, 64)",
"data",
"=",
"mx",
".",
"nd",
".",
"transpose",
"(",
"data",
",",
"(",
"2",
",",
"0",
",",
"1",
")",
")",
"# normalize to [-1, 1]",
"data",
"=",
"data",
".",
"astype",
"(",
"np",
".",
"float32",
")",
"/",
"128",
"-",
"1",
"# if image is greyscale, repeat 3 times to get RGB image.",
"if",
"data",
".",
"shape",
"[",
"0",
"]",
"==",
"1",
":",
"data",
"=",
"mx",
".",
"nd",
".",
"tile",
"(",
"data",
",",
"(",
"3",
",",
"1",
",",
"1",
")",
")",
"return",
"data",
",",
"label"
] |
Get the translation of images
|
[
"Get",
"the",
"translation",
"of",
"images"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/dc_gan/dcgan.py#L117-L128
|
train
|
apache/incubator-mxnet
|
example/gluon/dc_gan/dcgan.py
|
get_dataset
|
def get_dataset(dataset_name):
"""Load the dataset and split it to train/valid data
:param dataset_name: string
Returns:
train_data: int array
training dataset
val_data: int array
valid dataset
"""
# mnist
if dataset == "mnist":
train_data = gluon.data.DataLoader(
gluon.data.vision.MNIST('./data', train=True, transform=transformer),
batch_size, shuffle=True, last_batch='discard')
val_data = gluon.data.DataLoader(
gluon.data.vision.MNIST('./data', train=False, transform=transformer),
batch_size, shuffle=False)
# cifar10
elif dataset == "cifar10":
train_data = gluon.data.DataLoader(
gluon.data.vision.CIFAR10('./data', train=True, transform=transformer),
batch_size, shuffle=True, last_batch='discard')
val_data = gluon.data.DataLoader(
gluon.data.vision.CIFAR10('./data', train=False, transform=transformer),
batch_size, shuffle=False)
return train_data, val_data
|
python
|
def get_dataset(dataset_name):
"""Load the dataset and split it to train/valid data
:param dataset_name: string
Returns:
train_data: int array
training dataset
val_data: int array
valid dataset
"""
# mnist
if dataset == "mnist":
train_data = gluon.data.DataLoader(
gluon.data.vision.MNIST('./data', train=True, transform=transformer),
batch_size, shuffle=True, last_batch='discard')
val_data = gluon.data.DataLoader(
gluon.data.vision.MNIST('./data', train=False, transform=transformer),
batch_size, shuffle=False)
# cifar10
elif dataset == "cifar10":
train_data = gluon.data.DataLoader(
gluon.data.vision.CIFAR10('./data', train=True, transform=transformer),
batch_size, shuffle=True, last_batch='discard')
val_data = gluon.data.DataLoader(
gluon.data.vision.CIFAR10('./data', train=False, transform=transformer),
batch_size, shuffle=False)
return train_data, val_data
|
[
"def",
"get_dataset",
"(",
"dataset_name",
")",
":",
"# mnist",
"if",
"dataset",
"==",
"\"mnist\"",
":",
"train_data",
"=",
"gluon",
".",
"data",
".",
"DataLoader",
"(",
"gluon",
".",
"data",
".",
"vision",
".",
"MNIST",
"(",
"'./data'",
",",
"train",
"=",
"True",
",",
"transform",
"=",
"transformer",
")",
",",
"batch_size",
",",
"shuffle",
"=",
"True",
",",
"last_batch",
"=",
"'discard'",
")",
"val_data",
"=",
"gluon",
".",
"data",
".",
"DataLoader",
"(",
"gluon",
".",
"data",
".",
"vision",
".",
"MNIST",
"(",
"'./data'",
",",
"train",
"=",
"False",
",",
"transform",
"=",
"transformer",
")",
",",
"batch_size",
",",
"shuffle",
"=",
"False",
")",
"# cifar10",
"elif",
"dataset",
"==",
"\"cifar10\"",
":",
"train_data",
"=",
"gluon",
".",
"data",
".",
"DataLoader",
"(",
"gluon",
".",
"data",
".",
"vision",
".",
"CIFAR10",
"(",
"'./data'",
",",
"train",
"=",
"True",
",",
"transform",
"=",
"transformer",
")",
",",
"batch_size",
",",
"shuffle",
"=",
"True",
",",
"last_batch",
"=",
"'discard'",
")",
"val_data",
"=",
"gluon",
".",
"data",
".",
"DataLoader",
"(",
"gluon",
".",
"data",
".",
"vision",
".",
"CIFAR10",
"(",
"'./data'",
",",
"train",
"=",
"False",
",",
"transform",
"=",
"transformer",
")",
",",
"batch_size",
",",
"shuffle",
"=",
"False",
")",
"return",
"train_data",
",",
"val_data"
] |
Load the dataset and split it to train/valid data
:param dataset_name: string
Returns:
train_data: int array
training dataset
val_data: int array
valid dataset
|
[
"Load",
"the",
"dataset",
"and",
"split",
"it",
"to",
"train",
"/",
"valid",
"data"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/dc_gan/dcgan.py#L132-L162
|
train
|
apache/incubator-mxnet
|
example/gluon/dc_gan/dcgan.py
|
get_netG
|
def get_netG():
"""Get net G"""
# build the generator
netG = nn.Sequential()
with netG.name_scope():
# input is Z, going into a convolution
netG.add(nn.Conv2DTranspose(ngf * 8, 4, 1, 0, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf*8) x 4 x 4
netG.add(nn.Conv2DTranspose(ngf * 4, 4, 2, 1, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf*4) x 8 x 8
netG.add(nn.Conv2DTranspose(ngf * 2, 4, 2, 1, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf*2) x 16 x 16
netG.add(nn.Conv2DTranspose(ngf, 4, 2, 1, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf) x 32 x 32
netG.add(nn.Conv2DTranspose(nc, 4, 2, 1, use_bias=False))
netG.add(nn.Activation('tanh'))
# state size. (nc) x 64 x 64
return netG
|
python
|
def get_netG():
"""Get net G"""
# build the generator
netG = nn.Sequential()
with netG.name_scope():
# input is Z, going into a convolution
netG.add(nn.Conv2DTranspose(ngf * 8, 4, 1, 0, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf*8) x 4 x 4
netG.add(nn.Conv2DTranspose(ngf * 4, 4, 2, 1, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf*4) x 8 x 8
netG.add(nn.Conv2DTranspose(ngf * 2, 4, 2, 1, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf*2) x 16 x 16
netG.add(nn.Conv2DTranspose(ngf, 4, 2, 1, use_bias=False))
netG.add(nn.BatchNorm())
netG.add(nn.Activation('relu'))
# state size. (ngf) x 32 x 32
netG.add(nn.Conv2DTranspose(nc, 4, 2, 1, use_bias=False))
netG.add(nn.Activation('tanh'))
# state size. (nc) x 64 x 64
return netG
|
[
"def",
"get_netG",
"(",
")",
":",
"# build the generator",
"netG",
"=",
"nn",
".",
"Sequential",
"(",
")",
"with",
"netG",
".",
"name_scope",
"(",
")",
":",
"# input is Z, going into a convolution",
"netG",
".",
"add",
"(",
"nn",
".",
"Conv2DTranspose",
"(",
"ngf",
"*",
"8",
",",
"4",
",",
"1",
",",
"0",
",",
"use_bias",
"=",
"False",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"Activation",
"(",
"'relu'",
")",
")",
"# state size. (ngf*8) x 4 x 4",
"netG",
".",
"add",
"(",
"nn",
".",
"Conv2DTranspose",
"(",
"ngf",
"*",
"4",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"Activation",
"(",
"'relu'",
")",
")",
"# state size. (ngf*4) x 8 x 8",
"netG",
".",
"add",
"(",
"nn",
".",
"Conv2DTranspose",
"(",
"ngf",
"*",
"2",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"Activation",
"(",
"'relu'",
")",
")",
"# state size. (ngf*2) x 16 x 16",
"netG",
".",
"add",
"(",
"nn",
".",
"Conv2DTranspose",
"(",
"ngf",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"Activation",
"(",
"'relu'",
")",
")",
"# state size. (ngf) x 32 x 32",
"netG",
".",
"add",
"(",
"nn",
".",
"Conv2DTranspose",
"(",
"nc",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netG",
".",
"add",
"(",
"nn",
".",
"Activation",
"(",
"'tanh'",
")",
")",
"# state size. (nc) x 64 x 64",
"return",
"netG"
] |
Get net G
|
[
"Get",
"net",
"G"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/dc_gan/dcgan.py#L165-L191
|
train
|
apache/incubator-mxnet
|
example/gluon/dc_gan/dcgan.py
|
get_netD
|
def get_netD():
"""Get the netD"""
# build the discriminator
netD = nn.Sequential()
with netD.name_scope():
# input is (nc) x 64 x 64
netD.add(nn.Conv2D(ndf, 4, 2, 1, use_bias=False))
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf) x 32 x 32
netD.add(nn.Conv2D(ndf * 2, 4, 2, 1, use_bias=False))
netD.add(nn.BatchNorm())
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf*2) x 16 x 16
netD.add(nn.Conv2D(ndf * 4, 4, 2, 1, use_bias=False))
netD.add(nn.BatchNorm())
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf*4) x 8 x 8
netD.add(nn.Conv2D(ndf * 8, 4, 2, 1, use_bias=False))
netD.add(nn.BatchNorm())
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf*8) x 4 x 4
netD.add(nn.Conv2D(2, 4, 1, 0, use_bias=False))
# state size. 2 x 1 x 1
return netD
|
python
|
def get_netD():
"""Get the netD"""
# build the discriminator
netD = nn.Sequential()
with netD.name_scope():
# input is (nc) x 64 x 64
netD.add(nn.Conv2D(ndf, 4, 2, 1, use_bias=False))
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf) x 32 x 32
netD.add(nn.Conv2D(ndf * 2, 4, 2, 1, use_bias=False))
netD.add(nn.BatchNorm())
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf*2) x 16 x 16
netD.add(nn.Conv2D(ndf * 4, 4, 2, 1, use_bias=False))
netD.add(nn.BatchNorm())
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf*4) x 8 x 8
netD.add(nn.Conv2D(ndf * 8, 4, 2, 1, use_bias=False))
netD.add(nn.BatchNorm())
netD.add(nn.LeakyReLU(0.2))
# state size. (ndf*8) x 4 x 4
netD.add(nn.Conv2D(2, 4, 1, 0, use_bias=False))
# state size. 2 x 1 x 1
return netD
|
[
"def",
"get_netD",
"(",
")",
":",
"# build the discriminator",
"netD",
"=",
"nn",
".",
"Sequential",
"(",
")",
"with",
"netD",
".",
"name_scope",
"(",
")",
":",
"# input is (nc) x 64 x 64",
"netD",
".",
"add",
"(",
"nn",
".",
"Conv2D",
"(",
"ndf",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netD",
".",
"add",
"(",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"# state size. (ndf) x 32 x 32",
"netD",
".",
"add",
"(",
"nn",
".",
"Conv2D",
"(",
"ndf",
"*",
"2",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netD",
".",
"add",
"(",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"netD",
".",
"add",
"(",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"# state size. (ndf*2) x 16 x 16",
"netD",
".",
"add",
"(",
"nn",
".",
"Conv2D",
"(",
"ndf",
"*",
"4",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netD",
".",
"add",
"(",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"netD",
".",
"add",
"(",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"# state size. (ndf*4) x 8 x 8",
"netD",
".",
"add",
"(",
"nn",
".",
"Conv2D",
"(",
"ndf",
"*",
"8",
",",
"4",
",",
"2",
",",
"1",
",",
"use_bias",
"=",
"False",
")",
")",
"netD",
".",
"add",
"(",
"nn",
".",
"BatchNorm",
"(",
")",
")",
"netD",
".",
"add",
"(",
"nn",
".",
"LeakyReLU",
"(",
"0.2",
")",
")",
"# state size. (ndf*8) x 4 x 4",
"netD",
".",
"add",
"(",
"nn",
".",
"Conv2D",
"(",
"2",
",",
"4",
",",
"1",
",",
"0",
",",
"use_bias",
"=",
"False",
")",
")",
"# state size. 2 x 1 x 1",
"return",
"netD"
] |
Get the netD
|
[
"Get",
"the",
"netD"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/dc_gan/dcgan.py#L194-L218
|
train
|
apache/incubator-mxnet
|
example/gluon/dc_gan/dcgan.py
|
get_configurations
|
def get_configurations(netG, netD):
"""Get configurations for net"""
# loss
loss = gluon.loss.SoftmaxCrossEntropyLoss()
# initialize the generator and the discriminator
netG.initialize(mx.init.Normal(0.02), ctx=ctx)
netD.initialize(mx.init.Normal(0.02), ctx=ctx)
# trainer for the generator and the discriminator
trainerG = gluon.Trainer(netG.collect_params(), 'adam', {'learning_rate': opt.lr, 'beta1': opt.beta1})
trainerD = gluon.Trainer(netD.collect_params(), 'adam', {'learning_rate': opt.lr, 'beta1': opt.beta1})
return loss, trainerG, trainerD
|
python
|
def get_configurations(netG, netD):
"""Get configurations for net"""
# loss
loss = gluon.loss.SoftmaxCrossEntropyLoss()
# initialize the generator and the discriminator
netG.initialize(mx.init.Normal(0.02), ctx=ctx)
netD.initialize(mx.init.Normal(0.02), ctx=ctx)
# trainer for the generator and the discriminator
trainerG = gluon.Trainer(netG.collect_params(), 'adam', {'learning_rate': opt.lr, 'beta1': opt.beta1})
trainerD = gluon.Trainer(netD.collect_params(), 'adam', {'learning_rate': opt.lr, 'beta1': opt.beta1})
return loss, trainerG, trainerD
|
[
"def",
"get_configurations",
"(",
"netG",
",",
"netD",
")",
":",
"# loss",
"loss",
"=",
"gluon",
".",
"loss",
".",
"SoftmaxCrossEntropyLoss",
"(",
")",
"# initialize the generator and the discriminator",
"netG",
".",
"initialize",
"(",
"mx",
".",
"init",
".",
"Normal",
"(",
"0.02",
")",
",",
"ctx",
"=",
"ctx",
")",
"netD",
".",
"initialize",
"(",
"mx",
".",
"init",
".",
"Normal",
"(",
"0.02",
")",
",",
"ctx",
"=",
"ctx",
")",
"# trainer for the generator and the discriminator",
"trainerG",
"=",
"gluon",
".",
"Trainer",
"(",
"netG",
".",
"collect_params",
"(",
")",
",",
"'adam'",
",",
"{",
"'learning_rate'",
":",
"opt",
".",
"lr",
",",
"'beta1'",
":",
"opt",
".",
"beta1",
"}",
")",
"trainerD",
"=",
"gluon",
".",
"Trainer",
"(",
"netD",
".",
"collect_params",
"(",
")",
",",
"'adam'",
",",
"{",
"'learning_rate'",
":",
"opt",
".",
"lr",
",",
"'beta1'",
":",
"opt",
".",
"beta1",
"}",
")",
"return",
"loss",
",",
"trainerG",
",",
"trainerD"
] |
Get configurations for net
|
[
"Get",
"configurations",
"for",
"net"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/dc_gan/dcgan.py#L221-L234
|
train
|
apache/incubator-mxnet
|
example/gluon/dc_gan/dcgan.py
|
main
|
def main():
"""Entry point to dcgan"""
print("|------- new changes!!!!!!!!!")
# to get the dataset and net configuration
train_data, val_data = get_dataset(dataset)
netG = get_netG()
netD = get_netD()
loss, trainerG, trainerD = get_configurations(netG, netD)
# set labels
real_label = mx.nd.ones((opt.batch_size,), ctx=ctx)
fake_label = mx.nd.zeros((opt.batch_size,), ctx=ctx)
metric = mx.metric.Accuracy()
print('Training... ')
stamp = datetime.now().strftime('%Y_%m_%d-%H_%M')
iter = 0
# to metric the network
loss_d = []
loss_g = []
inception_score = []
for epoch in range(opt.nepoch):
tic = time.time()
btic = time.time()
for data, _ in train_data:
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
# train with real_t
data = data.as_in_context(ctx)
noise = mx.nd.random.normal(0, 1, shape=(opt.batch_size, nz, 1, 1), ctx=ctx)
with autograd.record():
output = netD(data)
# reshape output from (opt.batch_size, 2, 1, 1) to (opt.batch_size, 2)
output = output.reshape((opt.batch_size, 2))
errD_real = loss(output, real_label)
metric.update([real_label, ], [output, ])
with autograd.record():
fake = netG(noise)
output = netD(fake.detach())
output = output.reshape((opt.batch_size, 2))
errD_fake = loss(output, fake_label)
errD = errD_real + errD_fake
errD.backward()
metric.update([fake_label,], [output,])
trainerD.step(opt.batch_size)
############################
# (2) Update G network: maximize log(D(G(z)))
###########################
with autograd.record():
output = netD(fake)
output = output.reshape((-1, 2))
errG = loss(output, real_label)
errG.backward()
trainerG.step(opt.batch_size)
name, acc = metric.get()
logging.info('discriminator loss = %f, generator loss = %f, binary training acc = %f at iter %d epoch %d'
, mx.nd.mean(errD).asscalar(), mx.nd.mean(errG).asscalar(), acc, iter, epoch)
if iter % niter == 0:
visual('gout', fake.asnumpy(), name=os.path.join(outf, 'fake_img_iter_%d.png' % iter))
visual('data', data.asnumpy(), name=os.path.join(outf, 'real_img_iter_%d.png' % iter))
# record the metric data
loss_d.append(errD)
loss_g.append(errG)
if opt.inception_score:
score, _ = get_inception_score(fake)
inception_score.append(score)
iter = iter + 1
btic = time.time()
name, acc = metric.get()
metric.reset()
logging.info('\nbinary training acc at epoch %d: %s=%f', epoch, name, acc)
logging.info('time: %f', time.time() - tic)
# save check_point
if check_point:
netG.save_parameters(os.path.join(outf, 'generator_epoch_%d.params' %epoch))
netD.save_parameters(os.path.join(outf, 'discriminator_epoch_%d.params' % epoch))
# save parameter
netG.save_parameters(os.path.join(outf, 'generator.params'))
netD.save_parameters(os.path.join(outf, 'discriminator.params'))
# visualization the inception_score as a picture
if opt.inception_score:
ins_save(inception_score)
|
python
|
def main():
"""Entry point to dcgan"""
print("|------- new changes!!!!!!!!!")
# to get the dataset and net configuration
train_data, val_data = get_dataset(dataset)
netG = get_netG()
netD = get_netD()
loss, trainerG, trainerD = get_configurations(netG, netD)
# set labels
real_label = mx.nd.ones((opt.batch_size,), ctx=ctx)
fake_label = mx.nd.zeros((opt.batch_size,), ctx=ctx)
metric = mx.metric.Accuracy()
print('Training... ')
stamp = datetime.now().strftime('%Y_%m_%d-%H_%M')
iter = 0
# to metric the network
loss_d = []
loss_g = []
inception_score = []
for epoch in range(opt.nepoch):
tic = time.time()
btic = time.time()
for data, _ in train_data:
############################
# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))
###########################
# train with real_t
data = data.as_in_context(ctx)
noise = mx.nd.random.normal(0, 1, shape=(opt.batch_size, nz, 1, 1), ctx=ctx)
with autograd.record():
output = netD(data)
# reshape output from (opt.batch_size, 2, 1, 1) to (opt.batch_size, 2)
output = output.reshape((opt.batch_size, 2))
errD_real = loss(output, real_label)
metric.update([real_label, ], [output, ])
with autograd.record():
fake = netG(noise)
output = netD(fake.detach())
output = output.reshape((opt.batch_size, 2))
errD_fake = loss(output, fake_label)
errD = errD_real + errD_fake
errD.backward()
metric.update([fake_label,], [output,])
trainerD.step(opt.batch_size)
############################
# (2) Update G network: maximize log(D(G(z)))
###########################
with autograd.record():
output = netD(fake)
output = output.reshape((-1, 2))
errG = loss(output, real_label)
errG.backward()
trainerG.step(opt.batch_size)
name, acc = metric.get()
logging.info('discriminator loss = %f, generator loss = %f, binary training acc = %f at iter %d epoch %d'
, mx.nd.mean(errD).asscalar(), mx.nd.mean(errG).asscalar(), acc, iter, epoch)
if iter % niter == 0:
visual('gout', fake.asnumpy(), name=os.path.join(outf, 'fake_img_iter_%d.png' % iter))
visual('data', data.asnumpy(), name=os.path.join(outf, 'real_img_iter_%d.png' % iter))
# record the metric data
loss_d.append(errD)
loss_g.append(errG)
if opt.inception_score:
score, _ = get_inception_score(fake)
inception_score.append(score)
iter = iter + 1
btic = time.time()
name, acc = metric.get()
metric.reset()
logging.info('\nbinary training acc at epoch %d: %s=%f', epoch, name, acc)
logging.info('time: %f', time.time() - tic)
# save check_point
if check_point:
netG.save_parameters(os.path.join(outf, 'generator_epoch_%d.params' %epoch))
netD.save_parameters(os.path.join(outf, 'discriminator_epoch_%d.params' % epoch))
# save parameter
netG.save_parameters(os.path.join(outf, 'generator.params'))
netD.save_parameters(os.path.join(outf, 'discriminator.params'))
# visualization the inception_score as a picture
if opt.inception_score:
ins_save(inception_score)
|
[
"def",
"main",
"(",
")",
":",
"print",
"(",
"\"|------- new changes!!!!!!!!!\"",
")",
"# to get the dataset and net configuration",
"train_data",
",",
"val_data",
"=",
"get_dataset",
"(",
"dataset",
")",
"netG",
"=",
"get_netG",
"(",
")",
"netD",
"=",
"get_netD",
"(",
")",
"loss",
",",
"trainerG",
",",
"trainerD",
"=",
"get_configurations",
"(",
"netG",
",",
"netD",
")",
"# set labels",
"real_label",
"=",
"mx",
".",
"nd",
".",
"ones",
"(",
"(",
"opt",
".",
"batch_size",
",",
")",
",",
"ctx",
"=",
"ctx",
")",
"fake_label",
"=",
"mx",
".",
"nd",
".",
"zeros",
"(",
"(",
"opt",
".",
"batch_size",
",",
")",
",",
"ctx",
"=",
"ctx",
")",
"metric",
"=",
"mx",
".",
"metric",
".",
"Accuracy",
"(",
")",
"print",
"(",
"'Training... '",
")",
"stamp",
"=",
"datetime",
".",
"now",
"(",
")",
".",
"strftime",
"(",
"'%Y_%m_%d-%H_%M'",
")",
"iter",
"=",
"0",
"# to metric the network",
"loss_d",
"=",
"[",
"]",
"loss_g",
"=",
"[",
"]",
"inception_score",
"=",
"[",
"]",
"for",
"epoch",
"in",
"range",
"(",
"opt",
".",
"nepoch",
")",
":",
"tic",
"=",
"time",
".",
"time",
"(",
")",
"btic",
"=",
"time",
".",
"time",
"(",
")",
"for",
"data",
",",
"_",
"in",
"train_data",
":",
"############################",
"# (1) Update D network: maximize log(D(x)) + log(1 - D(G(z)))",
"###########################",
"# train with real_t",
"data",
"=",
"data",
".",
"as_in_context",
"(",
"ctx",
")",
"noise",
"=",
"mx",
".",
"nd",
".",
"random",
".",
"normal",
"(",
"0",
",",
"1",
",",
"shape",
"=",
"(",
"opt",
".",
"batch_size",
",",
"nz",
",",
"1",
",",
"1",
")",
",",
"ctx",
"=",
"ctx",
")",
"with",
"autograd",
".",
"record",
"(",
")",
":",
"output",
"=",
"netD",
"(",
"data",
")",
"# reshape output from (opt.batch_size, 2, 1, 1) to (opt.batch_size, 2)",
"output",
"=",
"output",
".",
"reshape",
"(",
"(",
"opt",
".",
"batch_size",
",",
"2",
")",
")",
"errD_real",
"=",
"loss",
"(",
"output",
",",
"real_label",
")",
"metric",
".",
"update",
"(",
"[",
"real_label",
",",
"]",
",",
"[",
"output",
",",
"]",
")",
"with",
"autograd",
".",
"record",
"(",
")",
":",
"fake",
"=",
"netG",
"(",
"noise",
")",
"output",
"=",
"netD",
"(",
"fake",
".",
"detach",
"(",
")",
")",
"output",
"=",
"output",
".",
"reshape",
"(",
"(",
"opt",
".",
"batch_size",
",",
"2",
")",
")",
"errD_fake",
"=",
"loss",
"(",
"output",
",",
"fake_label",
")",
"errD",
"=",
"errD_real",
"+",
"errD_fake",
"errD",
".",
"backward",
"(",
")",
"metric",
".",
"update",
"(",
"[",
"fake_label",
",",
"]",
",",
"[",
"output",
",",
"]",
")",
"trainerD",
".",
"step",
"(",
"opt",
".",
"batch_size",
")",
"############################",
"# (2) Update G network: maximize log(D(G(z)))",
"###########################",
"with",
"autograd",
".",
"record",
"(",
")",
":",
"output",
"=",
"netD",
"(",
"fake",
")",
"output",
"=",
"output",
".",
"reshape",
"(",
"(",
"-",
"1",
",",
"2",
")",
")",
"errG",
"=",
"loss",
"(",
"output",
",",
"real_label",
")",
"errG",
".",
"backward",
"(",
")",
"trainerG",
".",
"step",
"(",
"opt",
".",
"batch_size",
")",
"name",
",",
"acc",
"=",
"metric",
".",
"get",
"(",
")",
"logging",
".",
"info",
"(",
"'discriminator loss = %f, generator loss = %f, binary training acc = %f at iter %d epoch %d'",
",",
"mx",
".",
"nd",
".",
"mean",
"(",
"errD",
")",
".",
"asscalar",
"(",
")",
",",
"mx",
".",
"nd",
".",
"mean",
"(",
"errG",
")",
".",
"asscalar",
"(",
")",
",",
"acc",
",",
"iter",
",",
"epoch",
")",
"if",
"iter",
"%",
"niter",
"==",
"0",
":",
"visual",
"(",
"'gout'",
",",
"fake",
".",
"asnumpy",
"(",
")",
",",
"name",
"=",
"os",
".",
"path",
".",
"join",
"(",
"outf",
",",
"'fake_img_iter_%d.png'",
"%",
"iter",
")",
")",
"visual",
"(",
"'data'",
",",
"data",
".",
"asnumpy",
"(",
")",
",",
"name",
"=",
"os",
".",
"path",
".",
"join",
"(",
"outf",
",",
"'real_img_iter_%d.png'",
"%",
"iter",
")",
")",
"# record the metric data",
"loss_d",
".",
"append",
"(",
"errD",
")",
"loss_g",
".",
"append",
"(",
"errG",
")",
"if",
"opt",
".",
"inception_score",
":",
"score",
",",
"_",
"=",
"get_inception_score",
"(",
"fake",
")",
"inception_score",
".",
"append",
"(",
"score",
")",
"iter",
"=",
"iter",
"+",
"1",
"btic",
"=",
"time",
".",
"time",
"(",
")",
"name",
",",
"acc",
"=",
"metric",
".",
"get",
"(",
")",
"metric",
".",
"reset",
"(",
")",
"logging",
".",
"info",
"(",
"'\\nbinary training acc at epoch %d: %s=%f'",
",",
"epoch",
",",
"name",
",",
"acc",
")",
"logging",
".",
"info",
"(",
"'time: %f'",
",",
"time",
".",
"time",
"(",
")",
"-",
"tic",
")",
"# save check_point",
"if",
"check_point",
":",
"netG",
".",
"save_parameters",
"(",
"os",
".",
"path",
".",
"join",
"(",
"outf",
",",
"'generator_epoch_%d.params'",
"%",
"epoch",
")",
")",
"netD",
".",
"save_parameters",
"(",
"os",
".",
"path",
".",
"join",
"(",
"outf",
",",
"'discriminator_epoch_%d.params'",
"%",
"epoch",
")",
")",
"# save parameter",
"netG",
".",
"save_parameters",
"(",
"os",
".",
"path",
".",
"join",
"(",
"outf",
",",
"'generator.params'",
")",
")",
"netD",
".",
"save_parameters",
"(",
"os",
".",
"path",
".",
"join",
"(",
"outf",
",",
"'discriminator.params'",
")",
")",
"# visualization the inception_score as a picture",
"if",
"opt",
".",
"inception_score",
":",
"ins_save",
"(",
"inception_score",
")"
] |
Entry point to dcgan
|
[
"Entry",
"point",
"to",
"dcgan"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/dc_gan/dcgan.py#L249-L348
|
train
|
apache/incubator-mxnet
|
python/mxnet/log.py
|
getLogger
|
def getLogger(name=None, filename=None, filemode=None, level=WARNING):
"""Gets a customized logger.
.. note:: `getLogger` is deprecated. Use `get_logger` instead.
"""
warnings.warn("getLogger is deprecated, Use get_logger instead.",
DeprecationWarning, stacklevel=2)
return get_logger(name, filename, filemode, level)
|
python
|
def getLogger(name=None, filename=None, filemode=None, level=WARNING):
"""Gets a customized logger.
.. note:: `getLogger` is deprecated. Use `get_logger` instead.
"""
warnings.warn("getLogger is deprecated, Use get_logger instead.",
DeprecationWarning, stacklevel=2)
return get_logger(name, filename, filemode, level)
|
[
"def",
"getLogger",
"(",
"name",
"=",
"None",
",",
"filename",
"=",
"None",
",",
"filemode",
"=",
"None",
",",
"level",
"=",
"WARNING",
")",
":",
"warnings",
".",
"warn",
"(",
"\"getLogger is deprecated, Use get_logger instead.\"",
",",
"DeprecationWarning",
",",
"stacklevel",
"=",
"2",
")",
"return",
"get_logger",
"(",
"name",
",",
"filename",
",",
"filemode",
",",
"level",
")"
] |
Gets a customized logger.
.. note:: `getLogger` is deprecated. Use `get_logger` instead.
|
[
"Gets",
"a",
"customized",
"logger",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/log.py#L80-L88
|
train
|
apache/incubator-mxnet
|
python/mxnet/log.py
|
get_logger
|
def get_logger(name=None, filename=None, filemode=None, level=WARNING):
"""Gets a customized logger.
Parameters
----------
name: str, optional
Name of the logger.
filename: str, optional
The filename to which the logger's output will be sent.
filemode: str, optional
The file mode to open the file (corresponding to `filename`),
default is 'a' if `filename` is not ``None``.
level: int, optional
The `logging` level for the logger.
See: https://docs.python.org/2/library/logging.html#logging-levels
Returns
-------
Logger
A customized `Logger` object.
Example
-------
## get_logger call with default parameters.
>>> from mxnet.log import get_logger
>>> logger = get_logger("Test")
>>> logger.warn("Hello World")
W0505 00:29:47 3525 <stdin>:<module>:1] Hello World
## get_logger call with WARNING level.
>>> import logging
>>> logger = get_logger("Test2", level=logging.WARNING)
>>> logger.warn("Hello World")
W0505 00:30:50 3525 <stdin>:<module>:1] Hello World
>>> logger.debug("Hello World") # This doesn't return anything as the level is logging.WARNING.
## get_logger call with DEBUG level.
>>> logger = get_logger("Test3", level=logging.DEBUG)
>>> logger.debug("Hello World") # Logs the debug output as the level is logging.DEBUG.
D0505 00:31:30 3525 <stdin>:<module>:1] Hello World
"""
logger = logging.getLogger(name)
if name is not None and not getattr(logger, '_init_done', None):
logger._init_done = True
if filename:
mode = filemode if filemode else 'a'
hdlr = logging.FileHandler(filename, mode)
else:
hdlr = logging.StreamHandler() # pylint: disable=redefined-variable-type
# the `_Formatter` contain some escape character to
# represent color, which is not suitable for FileHandler,
# (TODO) maybe we can add another Formatter for FileHandler.
hdlr.setFormatter(_Formatter())
logger.addHandler(hdlr)
logger.setLevel(level)
return logger
|
python
|
def get_logger(name=None, filename=None, filemode=None, level=WARNING):
"""Gets a customized logger.
Parameters
----------
name: str, optional
Name of the logger.
filename: str, optional
The filename to which the logger's output will be sent.
filemode: str, optional
The file mode to open the file (corresponding to `filename`),
default is 'a' if `filename` is not ``None``.
level: int, optional
The `logging` level for the logger.
See: https://docs.python.org/2/library/logging.html#logging-levels
Returns
-------
Logger
A customized `Logger` object.
Example
-------
## get_logger call with default parameters.
>>> from mxnet.log import get_logger
>>> logger = get_logger("Test")
>>> logger.warn("Hello World")
W0505 00:29:47 3525 <stdin>:<module>:1] Hello World
## get_logger call with WARNING level.
>>> import logging
>>> logger = get_logger("Test2", level=logging.WARNING)
>>> logger.warn("Hello World")
W0505 00:30:50 3525 <stdin>:<module>:1] Hello World
>>> logger.debug("Hello World") # This doesn't return anything as the level is logging.WARNING.
## get_logger call with DEBUG level.
>>> logger = get_logger("Test3", level=logging.DEBUG)
>>> logger.debug("Hello World") # Logs the debug output as the level is logging.DEBUG.
D0505 00:31:30 3525 <stdin>:<module>:1] Hello World
"""
logger = logging.getLogger(name)
if name is not None and not getattr(logger, '_init_done', None):
logger._init_done = True
if filename:
mode = filemode if filemode else 'a'
hdlr = logging.FileHandler(filename, mode)
else:
hdlr = logging.StreamHandler() # pylint: disable=redefined-variable-type
# the `_Formatter` contain some escape character to
# represent color, which is not suitable for FileHandler,
# (TODO) maybe we can add another Formatter for FileHandler.
hdlr.setFormatter(_Formatter())
logger.addHandler(hdlr)
logger.setLevel(level)
return logger
|
[
"def",
"get_logger",
"(",
"name",
"=",
"None",
",",
"filename",
"=",
"None",
",",
"filemode",
"=",
"None",
",",
"level",
"=",
"WARNING",
")",
":",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"name",
")",
"if",
"name",
"is",
"not",
"None",
"and",
"not",
"getattr",
"(",
"logger",
",",
"'_init_done'",
",",
"None",
")",
":",
"logger",
".",
"_init_done",
"=",
"True",
"if",
"filename",
":",
"mode",
"=",
"filemode",
"if",
"filemode",
"else",
"'a'",
"hdlr",
"=",
"logging",
".",
"FileHandler",
"(",
"filename",
",",
"mode",
")",
"else",
":",
"hdlr",
"=",
"logging",
".",
"StreamHandler",
"(",
")",
"# pylint: disable=redefined-variable-type",
"# the `_Formatter` contain some escape character to",
"# represent color, which is not suitable for FileHandler,",
"# (TODO) maybe we can add another Formatter for FileHandler.",
"hdlr",
".",
"setFormatter",
"(",
"_Formatter",
"(",
")",
")",
"logger",
".",
"addHandler",
"(",
"hdlr",
")",
"logger",
".",
"setLevel",
"(",
"level",
")",
"return",
"logger"
] |
Gets a customized logger.
Parameters
----------
name: str, optional
Name of the logger.
filename: str, optional
The filename to which the logger's output will be sent.
filemode: str, optional
The file mode to open the file (corresponding to `filename`),
default is 'a' if `filename` is not ``None``.
level: int, optional
The `logging` level for the logger.
See: https://docs.python.org/2/library/logging.html#logging-levels
Returns
-------
Logger
A customized `Logger` object.
Example
-------
## get_logger call with default parameters.
>>> from mxnet.log import get_logger
>>> logger = get_logger("Test")
>>> logger.warn("Hello World")
W0505 00:29:47 3525 <stdin>:<module>:1] Hello World
## get_logger call with WARNING level.
>>> import logging
>>> logger = get_logger("Test2", level=logging.WARNING)
>>> logger.warn("Hello World")
W0505 00:30:50 3525 <stdin>:<module>:1] Hello World
>>> logger.debug("Hello World") # This doesn't return anything as the level is logging.WARNING.
## get_logger call with DEBUG level.
>>> logger = get_logger("Test3", level=logging.DEBUG)
>>> logger.debug("Hello World") # Logs the debug output as the level is logging.DEBUG.
D0505 00:31:30 3525 <stdin>:<module>:1] Hello World
|
[
"Gets",
"a",
"customized",
"logger",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/log.py#L90-L145
|
train
|
apache/incubator-mxnet
|
example/gluon/sn_gan/data.py
|
transformer
|
def transformer(data, label):
""" data preparation """
data = mx.image.imresize(data, IMAGE_SIZE, IMAGE_SIZE)
data = mx.nd.transpose(data, (2, 0, 1))
data = data.astype(np.float32) / 128.0 - 1
return data, label
|
python
|
def transformer(data, label):
""" data preparation """
data = mx.image.imresize(data, IMAGE_SIZE, IMAGE_SIZE)
data = mx.nd.transpose(data, (2, 0, 1))
data = data.astype(np.float32) / 128.0 - 1
return data, label
|
[
"def",
"transformer",
"(",
"data",
",",
"label",
")",
":",
"data",
"=",
"mx",
".",
"image",
".",
"imresize",
"(",
"data",
",",
"IMAGE_SIZE",
",",
"IMAGE_SIZE",
")",
"data",
"=",
"mx",
".",
"nd",
".",
"transpose",
"(",
"data",
",",
"(",
"2",
",",
"0",
",",
"1",
")",
")",
"data",
"=",
"data",
".",
"astype",
"(",
"np",
".",
"float32",
")",
"/",
"128.0",
"-",
"1",
"return",
"data",
",",
"label"
] |
data preparation
|
[
"data",
"preparation"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/sn_gan/data.py#L30-L35
|
train
|
apache/incubator-mxnet
|
example/gluon/sn_gan/data.py
|
get_training_data
|
def get_training_data(batch_size):
""" helper function to get dataloader"""
return gluon.data.DataLoader(
CIFAR10(train=True, transform=transformer),
batch_size=batch_size, shuffle=True, last_batch='discard')
|
python
|
def get_training_data(batch_size):
""" helper function to get dataloader"""
return gluon.data.DataLoader(
CIFAR10(train=True, transform=transformer),
batch_size=batch_size, shuffle=True, last_batch='discard')
|
[
"def",
"get_training_data",
"(",
"batch_size",
")",
":",
"return",
"gluon",
".",
"data",
".",
"DataLoader",
"(",
"CIFAR10",
"(",
"train",
"=",
"True",
",",
"transform",
"=",
"transformer",
")",
",",
"batch_size",
"=",
"batch_size",
",",
"shuffle",
"=",
"True",
",",
"last_batch",
"=",
"'discard'",
")"
] |
helper function to get dataloader
|
[
"helper",
"function",
"to",
"get",
"dataloader"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/sn_gan/data.py#L38-L42
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/model_zoo/vision/resnet.py
|
get_resnet
|
def get_resnet(version, num_layers, pretrained=False, ctx=cpu(),
root=os.path.join(base.data_dir(), 'models'), **kwargs):
r"""ResNet V1 model from `"Deep Residual Learning for Image Recognition"
<http://arxiv.org/abs/1512.03385>`_ paper.
ResNet V2 model from `"Identity Mappings in Deep Residual Networks"
<https://arxiv.org/abs/1603.05027>`_ paper.
Parameters
----------
version : int
Version of ResNet. Options are 1, 2.
num_layers : int
Numbers of layers. Options are 18, 34, 50, 101, 152.
pretrained : bool, default False
Whether to load the pretrained weights for model.
ctx : Context, default CPU
The context in which to load the pretrained weights.
root : str, default $MXNET_HOME/models
Location for keeping the model parameters.
"""
assert num_layers in resnet_spec, \
"Invalid number of layers: %d. Options are %s"%(
num_layers, str(resnet_spec.keys()))
block_type, layers, channels = resnet_spec[num_layers]
assert version >= 1 and version <= 2, \
"Invalid resnet version: %d. Options are 1 and 2."%version
resnet_class = resnet_net_versions[version-1]
block_class = resnet_block_versions[version-1][block_type]
net = resnet_class(block_class, layers, channels, **kwargs)
if pretrained:
from ..model_store import get_model_file
net.load_parameters(get_model_file('resnet%d_v%d'%(num_layers, version),
root=root), ctx=ctx)
return net
|
python
|
def get_resnet(version, num_layers, pretrained=False, ctx=cpu(),
root=os.path.join(base.data_dir(), 'models'), **kwargs):
r"""ResNet V1 model from `"Deep Residual Learning for Image Recognition"
<http://arxiv.org/abs/1512.03385>`_ paper.
ResNet V2 model from `"Identity Mappings in Deep Residual Networks"
<https://arxiv.org/abs/1603.05027>`_ paper.
Parameters
----------
version : int
Version of ResNet. Options are 1, 2.
num_layers : int
Numbers of layers. Options are 18, 34, 50, 101, 152.
pretrained : bool, default False
Whether to load the pretrained weights for model.
ctx : Context, default CPU
The context in which to load the pretrained weights.
root : str, default $MXNET_HOME/models
Location for keeping the model parameters.
"""
assert num_layers in resnet_spec, \
"Invalid number of layers: %d. Options are %s"%(
num_layers, str(resnet_spec.keys()))
block_type, layers, channels = resnet_spec[num_layers]
assert version >= 1 and version <= 2, \
"Invalid resnet version: %d. Options are 1 and 2."%version
resnet_class = resnet_net_versions[version-1]
block_class = resnet_block_versions[version-1][block_type]
net = resnet_class(block_class, layers, channels, **kwargs)
if pretrained:
from ..model_store import get_model_file
net.load_parameters(get_model_file('resnet%d_v%d'%(num_layers, version),
root=root), ctx=ctx)
return net
|
[
"def",
"get_resnet",
"(",
"version",
",",
"num_layers",
",",
"pretrained",
"=",
"False",
",",
"ctx",
"=",
"cpu",
"(",
")",
",",
"root",
"=",
"os",
".",
"path",
".",
"join",
"(",
"base",
".",
"data_dir",
"(",
")",
",",
"'models'",
")",
",",
"*",
"*",
"kwargs",
")",
":",
"assert",
"num_layers",
"in",
"resnet_spec",
",",
"\"Invalid number of layers: %d. Options are %s\"",
"%",
"(",
"num_layers",
",",
"str",
"(",
"resnet_spec",
".",
"keys",
"(",
")",
")",
")",
"block_type",
",",
"layers",
",",
"channels",
"=",
"resnet_spec",
"[",
"num_layers",
"]",
"assert",
"version",
">=",
"1",
"and",
"version",
"<=",
"2",
",",
"\"Invalid resnet version: %d. Options are 1 and 2.\"",
"%",
"version",
"resnet_class",
"=",
"resnet_net_versions",
"[",
"version",
"-",
"1",
"]",
"block_class",
"=",
"resnet_block_versions",
"[",
"version",
"-",
"1",
"]",
"[",
"block_type",
"]",
"net",
"=",
"resnet_class",
"(",
"block_class",
",",
"layers",
",",
"channels",
",",
"*",
"*",
"kwargs",
")",
"if",
"pretrained",
":",
"from",
".",
".",
"model_store",
"import",
"get_model_file",
"net",
".",
"load_parameters",
"(",
"get_model_file",
"(",
"'resnet%d_v%d'",
"%",
"(",
"num_layers",
",",
"version",
")",
",",
"root",
"=",
"root",
")",
",",
"ctx",
"=",
"ctx",
")",
"return",
"net"
] |
r"""ResNet V1 model from `"Deep Residual Learning for Image Recognition"
<http://arxiv.org/abs/1512.03385>`_ paper.
ResNet V2 model from `"Identity Mappings in Deep Residual Networks"
<https://arxiv.org/abs/1603.05027>`_ paper.
Parameters
----------
version : int
Version of ResNet. Options are 1, 2.
num_layers : int
Numbers of layers. Options are 18, 34, 50, 101, 152.
pretrained : bool, default False
Whether to load the pretrained weights for model.
ctx : Context, default CPU
The context in which to load the pretrained weights.
root : str, default $MXNET_HOME/models
Location for keeping the model parameters.
|
[
"r",
"ResNet",
"V1",
"model",
"from",
"Deep",
"Residual",
"Learning",
"for",
"Image",
"Recognition",
"<http",
":",
"//",
"arxiv",
".",
"org",
"/",
"abs",
"/",
"1512",
".",
"03385",
">",
"_",
"paper",
".",
"ResNet",
"V2",
"model",
"from",
"Identity",
"Mappings",
"in",
"Deep",
"Residual",
"Networks",
"<https",
":",
"//",
"arxiv",
".",
"org",
"/",
"abs",
"/",
"1603",
".",
"05027",
">",
"_",
"paper",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/model_zoo/vision/resnet.py#L359-L392
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/random.py
|
_random_helper
|
def _random_helper(random, sampler, params, shape, dtype, kwargs):
"""Helper function for random generators."""
if isinstance(params[0], Symbol):
for i in params[1:]:
assert isinstance(i, Symbol), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return sampler(*params, shape=shape, dtype=dtype, **kwargs)
elif isinstance(params[0], numeric_types):
for i in params[1:]:
assert isinstance(i, numeric_types), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return random(*params, shape=shape, dtype=dtype, **kwargs)
raise ValueError("Distribution parameters must be either Symbol or numbers, "
"but got %s."%type(params[0]))
|
python
|
def _random_helper(random, sampler, params, shape, dtype, kwargs):
"""Helper function for random generators."""
if isinstance(params[0], Symbol):
for i in params[1:]:
assert isinstance(i, Symbol), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return sampler(*params, shape=shape, dtype=dtype, **kwargs)
elif isinstance(params[0], numeric_types):
for i in params[1:]:
assert isinstance(i, numeric_types), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return random(*params, shape=shape, dtype=dtype, **kwargs)
raise ValueError("Distribution parameters must be either Symbol or numbers, "
"but got %s."%type(params[0]))
|
[
"def",
"_random_helper",
"(",
"random",
",",
"sampler",
",",
"params",
",",
"shape",
",",
"dtype",
",",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"params",
"[",
"0",
"]",
",",
"Symbol",
")",
":",
"for",
"i",
"in",
"params",
"[",
"1",
":",
"]",
":",
"assert",
"isinstance",
"(",
"i",
",",
"Symbol",
")",
",",
"\"Distribution parameters must all have the same type, but got \"",
"\"both %s and %s.\"",
"%",
"(",
"type",
"(",
"params",
"[",
"0",
"]",
")",
",",
"type",
"(",
"i",
")",
")",
"return",
"sampler",
"(",
"*",
"params",
",",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
",",
"*",
"*",
"kwargs",
")",
"elif",
"isinstance",
"(",
"params",
"[",
"0",
"]",
",",
"numeric_types",
")",
":",
"for",
"i",
"in",
"params",
"[",
"1",
":",
"]",
":",
"assert",
"isinstance",
"(",
"i",
",",
"numeric_types",
")",
",",
"\"Distribution parameters must all have the same type, but got \"",
"\"both %s and %s.\"",
"%",
"(",
"type",
"(",
"params",
"[",
"0",
"]",
")",
",",
"type",
"(",
"i",
")",
")",
"return",
"random",
"(",
"*",
"params",
",",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
",",
"*",
"*",
"kwargs",
")",
"raise",
"ValueError",
"(",
"\"Distribution parameters must be either Symbol or numbers, \"",
"\"but got %s.\"",
"%",
"type",
"(",
"params",
"[",
"0",
"]",
")",
")"
] |
Helper function for random generators.
|
[
"Helper",
"function",
"for",
"random",
"generators",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/random.py#L29-L45
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/random.py
|
poisson
|
def poisson(lam=1, shape=_Null, dtype=_Null, **kwargs):
"""Draw random samples from a Poisson distribution.
Samples are distributed according to a Poisson distribution parametrized
by *lambda* (rate). Samples will always be returned as a floating point data type.
Parameters
----------
lam : float or Symbol, optional
Expectation of interval, should be >= 0.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `lam` is
a scalar, output shape will be `(m, n)`. If `lam`
is an Symbol with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `lam`.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
Returns
-------
Symbol
If input `shape` has dimensions, e.g., `(m, n)`, and `lam` is
a scalar, output shape will be `(m, n)`. If `lam`
is an Symbol with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `lam`.
"""
return _random_helper(_internal._random_poisson, _internal._sample_poisson,
[lam], shape, dtype, kwargs)
|
python
|
def poisson(lam=1, shape=_Null, dtype=_Null, **kwargs):
"""Draw random samples from a Poisson distribution.
Samples are distributed according to a Poisson distribution parametrized
by *lambda* (rate). Samples will always be returned as a floating point data type.
Parameters
----------
lam : float or Symbol, optional
Expectation of interval, should be >= 0.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `lam` is
a scalar, output shape will be `(m, n)`. If `lam`
is an Symbol with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `lam`.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
Returns
-------
Symbol
If input `shape` has dimensions, e.g., `(m, n)`, and `lam` is
a scalar, output shape will be `(m, n)`. If `lam`
is an Symbol with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `lam`.
"""
return _random_helper(_internal._random_poisson, _internal._sample_poisson,
[lam], shape, dtype, kwargs)
|
[
"def",
"poisson",
"(",
"lam",
"=",
"1",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_poisson",
",",
"_internal",
".",
"_sample_poisson",
",",
"[",
"lam",
"]",
",",
"shape",
",",
"dtype",
",",
"kwargs",
")"
] |
Draw random samples from a Poisson distribution.
Samples are distributed according to a Poisson distribution parametrized
by *lambda* (rate). Samples will always be returned as a floating point data type.
Parameters
----------
lam : float or Symbol, optional
Expectation of interval, should be >= 0.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `lam` is
a scalar, output shape will be `(m, n)`. If `lam`
is an Symbol with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `lam`.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
Returns
-------
Symbol
If input `shape` has dimensions, e.g., `(m, n)`, and `lam` is
a scalar, output shape will be `(m, n)`. If `lam`
is an Symbol with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `lam`.
|
[
"Draw",
"random",
"samples",
"from",
"a",
"Poisson",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/random.py#L116-L143
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/random.py
|
generalized_negative_binomial
|
def generalized_negative_binomial(mu=1, alpha=1, shape=_Null, dtype=_Null, **kwargs):
"""Draw random samples from a generalized negative binomial distribution.
Samples are distributed according to a generalized negative binomial
distribution parametrized by *mu* (mean) and *alpha* (dispersion).
*alpha* is defined as *1/k* where *k* is the failure limit of the
number of unsuccessful experiments (generalized to real numbers).
Samples will always be returned as a floating point data type.
Parameters
----------
mu : float or Symbol, optional
Mean of the negative binomial distribution.
alpha : float or Symbol, optional
Alpha (dispersion) parameter of the negative binomial distribution.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `mu` and
`alpha` are scalars, output shape will be `(m, n)`. If `mu` and `alpha`
are Symbols with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
Returns
-------
Symbol
If input `shape` has dimensions, e.g., `(m, n)`, and `mu` and
`alpha` are scalars, returned Symbol will resolve to shape `(m, n)`. If `mu`
and `alpha` are Symbols with shape, e.g., `(x, y)`, returned Symbol will resolve
to shape `(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair.
"""
return _random_helper(_internal._random_generalized_negative_binomial,
_internal._sample_generalized_negative_binomial,
[mu, alpha], shape, dtype, kwargs)
|
python
|
def generalized_negative_binomial(mu=1, alpha=1, shape=_Null, dtype=_Null, **kwargs):
"""Draw random samples from a generalized negative binomial distribution.
Samples are distributed according to a generalized negative binomial
distribution parametrized by *mu* (mean) and *alpha* (dispersion).
*alpha* is defined as *1/k* where *k* is the failure limit of the
number of unsuccessful experiments (generalized to real numbers).
Samples will always be returned as a floating point data type.
Parameters
----------
mu : float or Symbol, optional
Mean of the negative binomial distribution.
alpha : float or Symbol, optional
Alpha (dispersion) parameter of the negative binomial distribution.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `mu` and
`alpha` are scalars, output shape will be `(m, n)`. If `mu` and `alpha`
are Symbols with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
Returns
-------
Symbol
If input `shape` has dimensions, e.g., `(m, n)`, and `mu` and
`alpha` are scalars, returned Symbol will resolve to shape `(m, n)`. If `mu`
and `alpha` are Symbols with shape, e.g., `(x, y)`, returned Symbol will resolve
to shape `(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair.
"""
return _random_helper(_internal._random_generalized_negative_binomial,
_internal._sample_generalized_negative_binomial,
[mu, alpha], shape, dtype, kwargs)
|
[
"def",
"generalized_negative_binomial",
"(",
"mu",
"=",
"1",
",",
"alpha",
"=",
"1",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_generalized_negative_binomial",
",",
"_internal",
".",
"_sample_generalized_negative_binomial",
",",
"[",
"mu",
",",
"alpha",
"]",
",",
"shape",
",",
"dtype",
",",
"kwargs",
")"
] |
Draw random samples from a generalized negative binomial distribution.
Samples are distributed according to a generalized negative binomial
distribution parametrized by *mu* (mean) and *alpha* (dispersion).
*alpha* is defined as *1/k* where *k* is the failure limit of the
number of unsuccessful experiments (generalized to real numbers).
Samples will always be returned as a floating point data type.
Parameters
----------
mu : float or Symbol, optional
Mean of the negative binomial distribution.
alpha : float or Symbol, optional
Alpha (dispersion) parameter of the negative binomial distribution.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `mu` and
`alpha` are scalars, output shape will be `(m, n)`. If `mu` and `alpha`
are Symbols with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
Returns
-------
Symbol
If input `shape` has dimensions, e.g., `(m, n)`, and `mu` and
`alpha` are scalars, returned Symbol will resolve to shape `(m, n)`. If `mu`
and `alpha` are Symbols with shape, e.g., `(x, y)`, returned Symbol will resolve
to shape `(x, y, m, n)`, where `m*n` samples are drawn for each `[mu, alpha)` pair.
|
[
"Draw",
"random",
"samples",
"from",
"a",
"generalized",
"negative",
"binomial",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/random.py#L248-L281
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/random.py
|
multinomial
|
def multinomial(data, shape=_Null, get_prob=True, dtype='int32', **kwargs):
"""Concurrent sampling from multiple multinomial distributions.
.. note:: The input distribution must be normalized, i.e. `data` must sum to
1 along its last dimension.
Parameters
----------
data : Symbol
An *n* dimensional array whose last dimension has length `k`, where
`k` is the number of possible outcomes of each multinomial distribution.
For example, data with shape `(m, n, k)` specifies `m*n` multinomial
distributions each with `k` possible outcomes.
shape : int or tuple of ints, optional
The number of samples to draw from each distribution. If shape is empty
one sample will be drawn from each distribution.
get_prob : bool, optional
If true, a second array containing log likelihood of the drawn
samples will also be returned.
This is usually used for reinforcement learning, where you can provide
reward as head gradient w.r.t. this array to estimate gradient.
dtype : str or numpy.dtype, optional
Data type of the sample output array. The default is int32.
Note that the data type of the log likelihood array is the same with that of `data`.
Returns
-------
Symbol
For input `data` with `n` dimensions and shape `(d1, d2, ..., dn-1, k)`, and input
`shape` with shape `(s1, s2, ..., sx)`, returns a Symbol that resovles to shape
`(d1, d2, ... dn-1, s1, s2, ..., sx)`. The `s1, s2, ... sx` dimensions of the
returned Symbol's resolved value will consist of 0-indexed values sampled from each
respective multinomial distribution provided in the `k` dimension of `data`.
For the case `n`=1, and `x`=1 (one shape dimension), returned Symbol will resolve to
shape `(s1,)`.
If `get_prob` is set to True, this function returns a Symbol that will resolve to a list of
outputs: `[ndarray_output, log_likelihood_output]`, where `log_likelihood_output` will resolve
to the same shape as the sampled outputs in ndarray_output.
"""
return _internal._sample_multinomial(data, shape, get_prob, dtype=dtype, **kwargs)
|
python
|
def multinomial(data, shape=_Null, get_prob=True, dtype='int32', **kwargs):
"""Concurrent sampling from multiple multinomial distributions.
.. note:: The input distribution must be normalized, i.e. `data` must sum to
1 along its last dimension.
Parameters
----------
data : Symbol
An *n* dimensional array whose last dimension has length `k`, where
`k` is the number of possible outcomes of each multinomial distribution.
For example, data with shape `(m, n, k)` specifies `m*n` multinomial
distributions each with `k` possible outcomes.
shape : int or tuple of ints, optional
The number of samples to draw from each distribution. If shape is empty
one sample will be drawn from each distribution.
get_prob : bool, optional
If true, a second array containing log likelihood of the drawn
samples will also be returned.
This is usually used for reinforcement learning, where you can provide
reward as head gradient w.r.t. this array to estimate gradient.
dtype : str or numpy.dtype, optional
Data type of the sample output array. The default is int32.
Note that the data type of the log likelihood array is the same with that of `data`.
Returns
-------
Symbol
For input `data` with `n` dimensions and shape `(d1, d2, ..., dn-1, k)`, and input
`shape` with shape `(s1, s2, ..., sx)`, returns a Symbol that resovles to shape
`(d1, d2, ... dn-1, s1, s2, ..., sx)`. The `s1, s2, ... sx` dimensions of the
returned Symbol's resolved value will consist of 0-indexed values sampled from each
respective multinomial distribution provided in the `k` dimension of `data`.
For the case `n`=1, and `x`=1 (one shape dimension), returned Symbol will resolve to
shape `(s1,)`.
If `get_prob` is set to True, this function returns a Symbol that will resolve to a list of
outputs: `[ndarray_output, log_likelihood_output]`, where `log_likelihood_output` will resolve
to the same shape as the sampled outputs in ndarray_output.
"""
return _internal._sample_multinomial(data, shape, get_prob, dtype=dtype, **kwargs)
|
[
"def",
"multinomial",
"(",
"data",
",",
"shape",
"=",
"_Null",
",",
"get_prob",
"=",
"True",
",",
"dtype",
"=",
"'int32'",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_internal",
".",
"_sample_multinomial",
"(",
"data",
",",
"shape",
",",
"get_prob",
",",
"dtype",
"=",
"dtype",
",",
"*",
"*",
"kwargs",
")"
] |
Concurrent sampling from multiple multinomial distributions.
.. note:: The input distribution must be normalized, i.e. `data` must sum to
1 along its last dimension.
Parameters
----------
data : Symbol
An *n* dimensional array whose last dimension has length `k`, where
`k` is the number of possible outcomes of each multinomial distribution.
For example, data with shape `(m, n, k)` specifies `m*n` multinomial
distributions each with `k` possible outcomes.
shape : int or tuple of ints, optional
The number of samples to draw from each distribution. If shape is empty
one sample will be drawn from each distribution.
get_prob : bool, optional
If true, a second array containing log likelihood of the drawn
samples will also be returned.
This is usually used for reinforcement learning, where you can provide
reward as head gradient w.r.t. this array to estimate gradient.
dtype : str or numpy.dtype, optional
Data type of the sample output array. The default is int32.
Note that the data type of the log likelihood array is the same with that of `data`.
Returns
-------
Symbol
For input `data` with `n` dimensions and shape `(d1, d2, ..., dn-1, k)`, and input
`shape` with shape `(s1, s2, ..., sx)`, returns a Symbol that resovles to shape
`(d1, d2, ... dn-1, s1, s2, ..., sx)`. The `s1, s2, ... sx` dimensions of the
returned Symbol's resolved value will consist of 0-indexed values sampled from each
respective multinomial distribution provided in the `k` dimension of `data`.
For the case `n`=1, and `x`=1 (one shape dimension), returned Symbol will resolve to
shape `(s1,)`.
If `get_prob` is set to True, this function returns a Symbol that will resolve to a list of
outputs: `[ndarray_output, log_likelihood_output]`, where `log_likelihood_output` will resolve
to the same shape as the sampled outputs in ndarray_output.
|
[
"Concurrent",
"sampling",
"from",
"multiple",
"multinomial",
"distributions",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/random.py#L284-L325
|
train
|
apache/incubator-mxnet
|
example/ssd/symbol/legacy_vgg16_ssd_300.py
|
get_symbol_train
|
def get_symbol_train(num_classes=20, nms_thresh=0.5, force_suppress=False,
nms_topk=400, **kwargs):
"""
Single-shot multi-box detection with VGG 16 layers ConvNet
This is a modified version, with fc6/fc7 layers replaced by conv layers
And the network is slightly smaller than original VGG 16 network
This is a training network with losses
Parameters:
----------
num_classes: int
number of object classes not including background
nms_thresh : float
non-maximum suppression threshold
force_suppress : boolean
whether suppress different class objects
nms_topk : int
apply NMS to top K detections
Returns:
----------
mx.Symbol
"""
data = mx.symbol.Variable(name="data")
label = mx.symbol.Variable(name="label")
# group 1
conv1_1 = mx.symbol.Convolution(
data=data, kernel=(3, 3), pad=(1, 1), num_filter=64, name="conv1_1")
relu1_1 = mx.symbol.Activation(data=conv1_1, act_type="relu", name="relu1_1")
conv1_2 = mx.symbol.Convolution(
data=relu1_1, kernel=(3, 3), pad=(1, 1), num_filter=64, name="conv1_2")
relu1_2 = mx.symbol.Activation(data=conv1_2, act_type="relu", name="relu1_2")
pool1 = mx.symbol.Pooling(
data=relu1_2, pool_type="max", kernel=(2, 2), stride=(2, 2), name="pool1")
# group 2
conv2_1 = mx.symbol.Convolution(
data=pool1, kernel=(3, 3), pad=(1, 1), num_filter=128, name="conv2_1")
relu2_1 = mx.symbol.Activation(data=conv2_1, act_type="relu", name="relu2_1")
conv2_2 = mx.symbol.Convolution(
data=relu2_1, kernel=(3, 3), pad=(1, 1), num_filter=128, name="conv2_2")
relu2_2 = mx.symbol.Activation(data=conv2_2, act_type="relu", name="relu2_2")
pool2 = mx.symbol.Pooling(
data=relu2_2, pool_type="max", kernel=(2, 2), stride=(2, 2), name="pool2")
# group 3
conv3_1 = mx.symbol.Convolution(
data=pool2, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_1")
relu3_1 = mx.symbol.Activation(data=conv3_1, act_type="relu", name="relu3_1")
conv3_2 = mx.symbol.Convolution(
data=relu3_1, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_2")
relu3_2 = mx.symbol.Activation(data=conv3_2, act_type="relu", name="relu3_2")
conv3_3 = mx.symbol.Convolution(
data=relu3_2, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_3")
relu3_3 = mx.symbol.Activation(data=conv3_3, act_type="relu", name="relu3_3")
pool3 = mx.symbol.Pooling(
data=relu3_3, pool_type="max", kernel=(2, 2), stride=(2, 2), \
pooling_convention="full", name="pool3")
# group 4
conv4_1 = mx.symbol.Convolution(
data=pool3, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_1")
relu4_1 = mx.symbol.Activation(data=conv4_1, act_type="relu", name="relu4_1")
conv4_2 = mx.symbol.Convolution(
data=relu4_1, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_2")
relu4_2 = mx.symbol.Activation(data=conv4_2, act_type="relu", name="relu4_2")
conv4_3 = mx.symbol.Convolution(
data=relu4_2, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_3")
relu4_3 = mx.symbol.Activation(data=conv4_3, act_type="relu", name="relu4_3")
pool4 = mx.symbol.Pooling(
data=relu4_3, pool_type="max", kernel=(2, 2), stride=(2, 2), name="pool4")
# group 5
conv5_1 = mx.symbol.Convolution(
data=pool4, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_1")
relu5_1 = mx.symbol.Activation(data=conv5_1, act_type="relu", name="relu5_1")
conv5_2 = mx.symbol.Convolution(
data=relu5_1, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_2")
relu5_2 = mx.symbol.Activation(data=conv5_2, act_type="relu", name="relu5_2")
conv5_3 = mx.symbol.Convolution(
data=relu5_2, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_3")
relu5_3 = mx.symbol.Activation(data=conv5_3, act_type="relu", name="relu5_3")
pool5 = mx.symbol.Pooling(
data=relu5_3, pool_type="max", kernel=(3, 3), stride=(1, 1),
pad=(1,1), name="pool5")
# group 6
conv6 = mx.symbol.Convolution(
data=pool5, kernel=(3, 3), pad=(6, 6), dilate=(6, 6),
num_filter=1024, name="conv6")
relu6 = mx.symbol.Activation(data=conv6, act_type="relu", name="relu6")
# drop6 = mx.symbol.Dropout(data=relu6, p=0.5, name="drop6")
# group 7
conv7 = mx.symbol.Convolution(
data=relu6, kernel=(1, 1), pad=(0, 0), num_filter=1024, name="conv7")
relu7 = mx.symbol.Activation(data=conv7, act_type="relu", name="relu7")
# drop7 = mx.symbol.Dropout(data=relu7, p=0.5, name="drop7")
### ssd extra layers ###
conv8_1, relu8_1 = legacy_conv_act_layer(relu7, "8_1", 256, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv8_2, relu8_2 = legacy_conv_act_layer(relu8_1, "8_2", 512, kernel=(3,3), pad=(1,1), \
stride=(2,2), act_type="relu", use_batchnorm=False)
conv9_1, relu9_1 = legacy_conv_act_layer(relu8_2, "9_1", 128, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv9_2, relu9_2 = legacy_conv_act_layer(relu9_1, "9_2", 256, kernel=(3,3), pad=(1,1), \
stride=(2,2), act_type="relu", use_batchnorm=False)
conv10_1, relu10_1 = legacy_conv_act_layer(relu9_2, "10_1", 128, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv10_2, relu10_2 = legacy_conv_act_layer(relu10_1, "10_2", 256, kernel=(3,3), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv11_1, relu11_1 = legacy_conv_act_layer(relu10_2, "11_1", 128, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv11_2, relu11_2 = legacy_conv_act_layer(relu11_1, "11_2", 256, kernel=(3,3), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
# specific parameters for VGG16 network
from_layers = [relu4_3, relu7, relu8_2, relu9_2, relu10_2, relu11_2]
sizes = [[.1, .141], [.2,.272], [.37, .447], [.54, .619], [.71, .79], [.88, .961]]
ratios = [[1,2,.5], [1,2,.5,3,1./3], [1,2,.5,3,1./3], [1,2,.5,3,1./3], \
[1,2,.5], [1,2,.5]]
normalizations = [20, -1, -1, -1, -1, -1]
steps = [ x / 300.0 for x in [8, 16, 32, 64, 100, 300]]
num_channels = [512]
loc_preds, cls_preds, anchor_boxes = multibox_layer(from_layers, \
num_classes, sizes=sizes, ratios=ratios, normalization=normalizations, \
num_channels=num_channels, clip=False, interm_layer=0, steps=steps)
tmp = mx.symbol.contrib.MultiBoxTarget(
*[anchor_boxes, label, cls_preds], overlap_threshold=.5, \
ignore_label=-1, negative_mining_ratio=3, minimum_negative_samples=0, \
negative_mining_thresh=.5, variances=(0.1, 0.1, 0.2, 0.2),
name="multibox_target")
loc_target = tmp[0]
loc_target_mask = tmp[1]
cls_target = tmp[2]
cls_prob = mx.symbol.SoftmaxOutput(data=cls_preds, label=cls_target, \
ignore_label=-1, use_ignore=True, grad_scale=1., multi_output=True, \
normalization='valid', name="cls_prob")
loc_loss_ = mx.symbol.smooth_l1(name="loc_loss_", \
data=loc_target_mask * (loc_preds - loc_target), scalar=1.0)
loc_loss = mx.symbol.MakeLoss(loc_loss_, grad_scale=1., \
normalization='valid', name="loc_loss")
# monitoring training status
cls_label = mx.symbol.MakeLoss(data=cls_target, grad_scale=0, name="cls_label")
det = mx.symbol.contrib.MultiBoxDetection(*[cls_prob, loc_preds, anchor_boxes], \
name="detection", nms_threshold=nms_thresh, force_suppress=force_suppress,
variances=(0.1, 0.1, 0.2, 0.2), nms_topk=nms_topk)
det = mx.symbol.MakeLoss(data=det, grad_scale=0, name="det_out")
# group output
out = mx.symbol.Group([cls_prob, loc_loss, cls_label, det])
return out
|
python
|
def get_symbol_train(num_classes=20, nms_thresh=0.5, force_suppress=False,
nms_topk=400, **kwargs):
"""
Single-shot multi-box detection with VGG 16 layers ConvNet
This is a modified version, with fc6/fc7 layers replaced by conv layers
And the network is slightly smaller than original VGG 16 network
This is a training network with losses
Parameters:
----------
num_classes: int
number of object classes not including background
nms_thresh : float
non-maximum suppression threshold
force_suppress : boolean
whether suppress different class objects
nms_topk : int
apply NMS to top K detections
Returns:
----------
mx.Symbol
"""
data = mx.symbol.Variable(name="data")
label = mx.symbol.Variable(name="label")
# group 1
conv1_1 = mx.symbol.Convolution(
data=data, kernel=(3, 3), pad=(1, 1), num_filter=64, name="conv1_1")
relu1_1 = mx.symbol.Activation(data=conv1_1, act_type="relu", name="relu1_1")
conv1_2 = mx.symbol.Convolution(
data=relu1_1, kernel=(3, 3), pad=(1, 1), num_filter=64, name="conv1_2")
relu1_2 = mx.symbol.Activation(data=conv1_2, act_type="relu", name="relu1_2")
pool1 = mx.symbol.Pooling(
data=relu1_2, pool_type="max", kernel=(2, 2), stride=(2, 2), name="pool1")
# group 2
conv2_1 = mx.symbol.Convolution(
data=pool1, kernel=(3, 3), pad=(1, 1), num_filter=128, name="conv2_1")
relu2_1 = mx.symbol.Activation(data=conv2_1, act_type="relu", name="relu2_1")
conv2_2 = mx.symbol.Convolution(
data=relu2_1, kernel=(3, 3), pad=(1, 1), num_filter=128, name="conv2_2")
relu2_2 = mx.symbol.Activation(data=conv2_2, act_type="relu", name="relu2_2")
pool2 = mx.symbol.Pooling(
data=relu2_2, pool_type="max", kernel=(2, 2), stride=(2, 2), name="pool2")
# group 3
conv3_1 = mx.symbol.Convolution(
data=pool2, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_1")
relu3_1 = mx.symbol.Activation(data=conv3_1, act_type="relu", name="relu3_1")
conv3_2 = mx.symbol.Convolution(
data=relu3_1, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_2")
relu3_2 = mx.symbol.Activation(data=conv3_2, act_type="relu", name="relu3_2")
conv3_3 = mx.symbol.Convolution(
data=relu3_2, kernel=(3, 3), pad=(1, 1), num_filter=256, name="conv3_3")
relu3_3 = mx.symbol.Activation(data=conv3_3, act_type="relu", name="relu3_3")
pool3 = mx.symbol.Pooling(
data=relu3_3, pool_type="max", kernel=(2, 2), stride=(2, 2), \
pooling_convention="full", name="pool3")
# group 4
conv4_1 = mx.symbol.Convolution(
data=pool3, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_1")
relu4_1 = mx.symbol.Activation(data=conv4_1, act_type="relu", name="relu4_1")
conv4_2 = mx.symbol.Convolution(
data=relu4_1, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_2")
relu4_2 = mx.symbol.Activation(data=conv4_2, act_type="relu", name="relu4_2")
conv4_3 = mx.symbol.Convolution(
data=relu4_2, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv4_3")
relu4_3 = mx.symbol.Activation(data=conv4_3, act_type="relu", name="relu4_3")
pool4 = mx.symbol.Pooling(
data=relu4_3, pool_type="max", kernel=(2, 2), stride=(2, 2), name="pool4")
# group 5
conv5_1 = mx.symbol.Convolution(
data=pool4, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_1")
relu5_1 = mx.symbol.Activation(data=conv5_1, act_type="relu", name="relu5_1")
conv5_2 = mx.symbol.Convolution(
data=relu5_1, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_2")
relu5_2 = mx.symbol.Activation(data=conv5_2, act_type="relu", name="relu5_2")
conv5_3 = mx.symbol.Convolution(
data=relu5_2, kernel=(3, 3), pad=(1, 1), num_filter=512, name="conv5_3")
relu5_3 = mx.symbol.Activation(data=conv5_3, act_type="relu", name="relu5_3")
pool5 = mx.symbol.Pooling(
data=relu5_3, pool_type="max", kernel=(3, 3), stride=(1, 1),
pad=(1,1), name="pool5")
# group 6
conv6 = mx.symbol.Convolution(
data=pool5, kernel=(3, 3), pad=(6, 6), dilate=(6, 6),
num_filter=1024, name="conv6")
relu6 = mx.symbol.Activation(data=conv6, act_type="relu", name="relu6")
# drop6 = mx.symbol.Dropout(data=relu6, p=0.5, name="drop6")
# group 7
conv7 = mx.symbol.Convolution(
data=relu6, kernel=(1, 1), pad=(0, 0), num_filter=1024, name="conv7")
relu7 = mx.symbol.Activation(data=conv7, act_type="relu", name="relu7")
# drop7 = mx.symbol.Dropout(data=relu7, p=0.5, name="drop7")
### ssd extra layers ###
conv8_1, relu8_1 = legacy_conv_act_layer(relu7, "8_1", 256, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv8_2, relu8_2 = legacy_conv_act_layer(relu8_1, "8_2", 512, kernel=(3,3), pad=(1,1), \
stride=(2,2), act_type="relu", use_batchnorm=False)
conv9_1, relu9_1 = legacy_conv_act_layer(relu8_2, "9_1", 128, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv9_2, relu9_2 = legacy_conv_act_layer(relu9_1, "9_2", 256, kernel=(3,3), pad=(1,1), \
stride=(2,2), act_type="relu", use_batchnorm=False)
conv10_1, relu10_1 = legacy_conv_act_layer(relu9_2, "10_1", 128, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv10_2, relu10_2 = legacy_conv_act_layer(relu10_1, "10_2", 256, kernel=(3,3), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv11_1, relu11_1 = legacy_conv_act_layer(relu10_2, "11_1", 128, kernel=(1,1), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
conv11_2, relu11_2 = legacy_conv_act_layer(relu11_1, "11_2", 256, kernel=(3,3), pad=(0,0), \
stride=(1,1), act_type="relu", use_batchnorm=False)
# specific parameters for VGG16 network
from_layers = [relu4_3, relu7, relu8_2, relu9_2, relu10_2, relu11_2]
sizes = [[.1, .141], [.2,.272], [.37, .447], [.54, .619], [.71, .79], [.88, .961]]
ratios = [[1,2,.5], [1,2,.5,3,1./3], [1,2,.5,3,1./3], [1,2,.5,3,1./3], \
[1,2,.5], [1,2,.5]]
normalizations = [20, -1, -1, -1, -1, -1]
steps = [ x / 300.0 for x in [8, 16, 32, 64, 100, 300]]
num_channels = [512]
loc_preds, cls_preds, anchor_boxes = multibox_layer(from_layers, \
num_classes, sizes=sizes, ratios=ratios, normalization=normalizations, \
num_channels=num_channels, clip=False, interm_layer=0, steps=steps)
tmp = mx.symbol.contrib.MultiBoxTarget(
*[anchor_boxes, label, cls_preds], overlap_threshold=.5, \
ignore_label=-1, negative_mining_ratio=3, minimum_negative_samples=0, \
negative_mining_thresh=.5, variances=(0.1, 0.1, 0.2, 0.2),
name="multibox_target")
loc_target = tmp[0]
loc_target_mask = tmp[1]
cls_target = tmp[2]
cls_prob = mx.symbol.SoftmaxOutput(data=cls_preds, label=cls_target, \
ignore_label=-1, use_ignore=True, grad_scale=1., multi_output=True, \
normalization='valid', name="cls_prob")
loc_loss_ = mx.symbol.smooth_l1(name="loc_loss_", \
data=loc_target_mask * (loc_preds - loc_target), scalar=1.0)
loc_loss = mx.symbol.MakeLoss(loc_loss_, grad_scale=1., \
normalization='valid', name="loc_loss")
# monitoring training status
cls_label = mx.symbol.MakeLoss(data=cls_target, grad_scale=0, name="cls_label")
det = mx.symbol.contrib.MultiBoxDetection(*[cls_prob, loc_preds, anchor_boxes], \
name="detection", nms_threshold=nms_thresh, force_suppress=force_suppress,
variances=(0.1, 0.1, 0.2, 0.2), nms_topk=nms_topk)
det = mx.symbol.MakeLoss(data=det, grad_scale=0, name="det_out")
# group output
out = mx.symbol.Group([cls_prob, loc_loss, cls_label, det])
return out
|
[
"def",
"get_symbol_train",
"(",
"num_classes",
"=",
"20",
",",
"nms_thresh",
"=",
"0.5",
",",
"force_suppress",
"=",
"False",
",",
"nms_topk",
"=",
"400",
",",
"*",
"*",
"kwargs",
")",
":",
"data",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"name",
"=",
"\"data\"",
")",
"label",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"name",
"=",
"\"label\"",
")",
"# group 1",
"conv1_1",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"data",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"64",
",",
"name",
"=",
"\"conv1_1\"",
")",
"relu1_1",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv1_1",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu1_1\"",
")",
"conv1_2",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu1_1",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"64",
",",
"name",
"=",
"\"conv1_2\"",
")",
"relu1_2",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv1_2",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu1_2\"",
")",
"pool1",
"=",
"mx",
".",
"symbol",
".",
"Pooling",
"(",
"data",
"=",
"relu1_2",
",",
"pool_type",
"=",
"\"max\"",
",",
"kernel",
"=",
"(",
"2",
",",
"2",
")",
",",
"stride",
"=",
"(",
"2",
",",
"2",
")",
",",
"name",
"=",
"\"pool1\"",
")",
"# group 2",
"conv2_1",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"pool1",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"128",
",",
"name",
"=",
"\"conv2_1\"",
")",
"relu2_1",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv2_1",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu2_1\"",
")",
"conv2_2",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu2_1",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"128",
",",
"name",
"=",
"\"conv2_2\"",
")",
"relu2_2",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv2_2",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu2_2\"",
")",
"pool2",
"=",
"mx",
".",
"symbol",
".",
"Pooling",
"(",
"data",
"=",
"relu2_2",
",",
"pool_type",
"=",
"\"max\"",
",",
"kernel",
"=",
"(",
"2",
",",
"2",
")",
",",
"stride",
"=",
"(",
"2",
",",
"2",
")",
",",
"name",
"=",
"\"pool2\"",
")",
"# group 3",
"conv3_1",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"pool2",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"256",
",",
"name",
"=",
"\"conv3_1\"",
")",
"relu3_1",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv3_1",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu3_1\"",
")",
"conv3_2",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu3_1",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"256",
",",
"name",
"=",
"\"conv3_2\"",
")",
"relu3_2",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv3_2",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu3_2\"",
")",
"conv3_3",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu3_2",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"256",
",",
"name",
"=",
"\"conv3_3\"",
")",
"relu3_3",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv3_3",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu3_3\"",
")",
"pool3",
"=",
"mx",
".",
"symbol",
".",
"Pooling",
"(",
"data",
"=",
"relu3_3",
",",
"pool_type",
"=",
"\"max\"",
",",
"kernel",
"=",
"(",
"2",
",",
"2",
")",
",",
"stride",
"=",
"(",
"2",
",",
"2",
")",
",",
"pooling_convention",
"=",
"\"full\"",
",",
"name",
"=",
"\"pool3\"",
")",
"# group 4",
"conv4_1",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"pool3",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"512",
",",
"name",
"=",
"\"conv4_1\"",
")",
"relu4_1",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv4_1",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu4_1\"",
")",
"conv4_2",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu4_1",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"512",
",",
"name",
"=",
"\"conv4_2\"",
")",
"relu4_2",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv4_2",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu4_2\"",
")",
"conv4_3",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu4_2",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"512",
",",
"name",
"=",
"\"conv4_3\"",
")",
"relu4_3",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv4_3",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu4_3\"",
")",
"pool4",
"=",
"mx",
".",
"symbol",
".",
"Pooling",
"(",
"data",
"=",
"relu4_3",
",",
"pool_type",
"=",
"\"max\"",
",",
"kernel",
"=",
"(",
"2",
",",
"2",
")",
",",
"stride",
"=",
"(",
"2",
",",
"2",
")",
",",
"name",
"=",
"\"pool4\"",
")",
"# group 5",
"conv5_1",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"pool4",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"512",
",",
"name",
"=",
"\"conv5_1\"",
")",
"relu5_1",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv5_1",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu5_1\"",
")",
"conv5_2",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu5_1",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"512",
",",
"name",
"=",
"\"conv5_2\"",
")",
"relu5_2",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv5_2",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu5_2\"",
")",
"conv5_3",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu5_2",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"512",
",",
"name",
"=",
"\"conv5_3\"",
")",
"relu5_3",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv5_3",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu5_3\"",
")",
"pool5",
"=",
"mx",
".",
"symbol",
".",
"Pooling",
"(",
"data",
"=",
"relu5_3",
",",
"pool_type",
"=",
"\"max\"",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"name",
"=",
"\"pool5\"",
")",
"# group 6",
"conv6",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"pool5",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"6",
",",
"6",
")",
",",
"dilate",
"=",
"(",
"6",
",",
"6",
")",
",",
"num_filter",
"=",
"1024",
",",
"name",
"=",
"\"conv6\"",
")",
"relu6",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv6",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu6\"",
")",
"# drop6 = mx.symbol.Dropout(data=relu6, p=0.5, name=\"drop6\")",
"# group 7",
"conv7",
"=",
"mx",
".",
"symbol",
".",
"Convolution",
"(",
"data",
"=",
"relu6",
",",
"kernel",
"=",
"(",
"1",
",",
"1",
")",
",",
"pad",
"=",
"(",
"0",
",",
"0",
")",
",",
"num_filter",
"=",
"1024",
",",
"name",
"=",
"\"conv7\"",
")",
"relu7",
"=",
"mx",
".",
"symbol",
".",
"Activation",
"(",
"data",
"=",
"conv7",
",",
"act_type",
"=",
"\"relu\"",
",",
"name",
"=",
"\"relu7\"",
")",
"# drop7 = mx.symbol.Dropout(data=relu7, p=0.5, name=\"drop7\")",
"### ssd extra layers ###",
"conv8_1",
",",
"relu8_1",
"=",
"legacy_conv_act_layer",
"(",
"relu7",
",",
"\"8_1\"",
",",
"256",
",",
"kernel",
"=",
"(",
"1",
",",
"1",
")",
",",
"pad",
"=",
"(",
"0",
",",
"0",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"conv8_2",
",",
"relu8_2",
"=",
"legacy_conv_act_layer",
"(",
"relu8_1",
",",
"\"8_2\"",
",",
"512",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"stride",
"=",
"(",
"2",
",",
"2",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"conv9_1",
",",
"relu9_1",
"=",
"legacy_conv_act_layer",
"(",
"relu8_2",
",",
"\"9_1\"",
",",
"128",
",",
"kernel",
"=",
"(",
"1",
",",
"1",
")",
",",
"pad",
"=",
"(",
"0",
",",
"0",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"conv9_2",
",",
"relu9_2",
"=",
"legacy_conv_act_layer",
"(",
"relu9_1",
",",
"\"9_2\"",
",",
"256",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"1",
",",
"1",
")",
",",
"stride",
"=",
"(",
"2",
",",
"2",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"conv10_1",
",",
"relu10_1",
"=",
"legacy_conv_act_layer",
"(",
"relu9_2",
",",
"\"10_1\"",
",",
"128",
",",
"kernel",
"=",
"(",
"1",
",",
"1",
")",
",",
"pad",
"=",
"(",
"0",
",",
"0",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"conv10_2",
",",
"relu10_2",
"=",
"legacy_conv_act_layer",
"(",
"relu10_1",
",",
"\"10_2\"",
",",
"256",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"0",
",",
"0",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"conv11_1",
",",
"relu11_1",
"=",
"legacy_conv_act_layer",
"(",
"relu10_2",
",",
"\"11_1\"",
",",
"128",
",",
"kernel",
"=",
"(",
"1",
",",
"1",
")",
",",
"pad",
"=",
"(",
"0",
",",
"0",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"conv11_2",
",",
"relu11_2",
"=",
"legacy_conv_act_layer",
"(",
"relu11_1",
",",
"\"11_2\"",
",",
"256",
",",
"kernel",
"=",
"(",
"3",
",",
"3",
")",
",",
"pad",
"=",
"(",
"0",
",",
"0",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
")",
",",
"act_type",
"=",
"\"relu\"",
",",
"use_batchnorm",
"=",
"False",
")",
"# specific parameters for VGG16 network",
"from_layers",
"=",
"[",
"relu4_3",
",",
"relu7",
",",
"relu8_2",
",",
"relu9_2",
",",
"relu10_2",
",",
"relu11_2",
"]",
"sizes",
"=",
"[",
"[",
".1",
",",
".141",
"]",
",",
"[",
".2",
",",
".272",
"]",
",",
"[",
".37",
",",
".447",
"]",
",",
"[",
".54",
",",
".619",
"]",
",",
"[",
".71",
",",
".79",
"]",
",",
"[",
".88",
",",
".961",
"]",
"]",
"ratios",
"=",
"[",
"[",
"1",
",",
"2",
",",
".5",
"]",
",",
"[",
"1",
",",
"2",
",",
".5",
",",
"3",
",",
"1.",
"/",
"3",
"]",
",",
"[",
"1",
",",
"2",
",",
".5",
",",
"3",
",",
"1.",
"/",
"3",
"]",
",",
"[",
"1",
",",
"2",
",",
".5",
",",
"3",
",",
"1.",
"/",
"3",
"]",
",",
"[",
"1",
",",
"2",
",",
".5",
"]",
",",
"[",
"1",
",",
"2",
",",
".5",
"]",
"]",
"normalizations",
"=",
"[",
"20",
",",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
"]",
"steps",
"=",
"[",
"x",
"/",
"300.0",
"for",
"x",
"in",
"[",
"8",
",",
"16",
",",
"32",
",",
"64",
",",
"100",
",",
"300",
"]",
"]",
"num_channels",
"=",
"[",
"512",
"]",
"loc_preds",
",",
"cls_preds",
",",
"anchor_boxes",
"=",
"multibox_layer",
"(",
"from_layers",
",",
"num_classes",
",",
"sizes",
"=",
"sizes",
",",
"ratios",
"=",
"ratios",
",",
"normalization",
"=",
"normalizations",
",",
"num_channels",
"=",
"num_channels",
",",
"clip",
"=",
"False",
",",
"interm_layer",
"=",
"0",
",",
"steps",
"=",
"steps",
")",
"tmp",
"=",
"mx",
".",
"symbol",
".",
"contrib",
".",
"MultiBoxTarget",
"(",
"*",
"[",
"anchor_boxes",
",",
"label",
",",
"cls_preds",
"]",
",",
"overlap_threshold",
"=",
".5",
",",
"ignore_label",
"=",
"-",
"1",
",",
"negative_mining_ratio",
"=",
"3",
",",
"minimum_negative_samples",
"=",
"0",
",",
"negative_mining_thresh",
"=",
".5",
",",
"variances",
"=",
"(",
"0.1",
",",
"0.1",
",",
"0.2",
",",
"0.2",
")",
",",
"name",
"=",
"\"multibox_target\"",
")",
"loc_target",
"=",
"tmp",
"[",
"0",
"]",
"loc_target_mask",
"=",
"tmp",
"[",
"1",
"]",
"cls_target",
"=",
"tmp",
"[",
"2",
"]",
"cls_prob",
"=",
"mx",
".",
"symbol",
".",
"SoftmaxOutput",
"(",
"data",
"=",
"cls_preds",
",",
"label",
"=",
"cls_target",
",",
"ignore_label",
"=",
"-",
"1",
",",
"use_ignore",
"=",
"True",
",",
"grad_scale",
"=",
"1.",
",",
"multi_output",
"=",
"True",
",",
"normalization",
"=",
"'valid'",
",",
"name",
"=",
"\"cls_prob\"",
")",
"loc_loss_",
"=",
"mx",
".",
"symbol",
".",
"smooth_l1",
"(",
"name",
"=",
"\"loc_loss_\"",
",",
"data",
"=",
"loc_target_mask",
"*",
"(",
"loc_preds",
"-",
"loc_target",
")",
",",
"scalar",
"=",
"1.0",
")",
"loc_loss",
"=",
"mx",
".",
"symbol",
".",
"MakeLoss",
"(",
"loc_loss_",
",",
"grad_scale",
"=",
"1.",
",",
"normalization",
"=",
"'valid'",
",",
"name",
"=",
"\"loc_loss\"",
")",
"# monitoring training status",
"cls_label",
"=",
"mx",
".",
"symbol",
".",
"MakeLoss",
"(",
"data",
"=",
"cls_target",
",",
"grad_scale",
"=",
"0",
",",
"name",
"=",
"\"cls_label\"",
")",
"det",
"=",
"mx",
".",
"symbol",
".",
"contrib",
".",
"MultiBoxDetection",
"(",
"*",
"[",
"cls_prob",
",",
"loc_preds",
",",
"anchor_boxes",
"]",
",",
"name",
"=",
"\"detection\"",
",",
"nms_threshold",
"=",
"nms_thresh",
",",
"force_suppress",
"=",
"force_suppress",
",",
"variances",
"=",
"(",
"0.1",
",",
"0.1",
",",
"0.2",
",",
"0.2",
")",
",",
"nms_topk",
"=",
"nms_topk",
")",
"det",
"=",
"mx",
".",
"symbol",
".",
"MakeLoss",
"(",
"data",
"=",
"det",
",",
"grad_scale",
"=",
"0",
",",
"name",
"=",
"\"det_out\"",
")",
"# group output",
"out",
"=",
"mx",
".",
"symbol",
".",
"Group",
"(",
"[",
"cls_prob",
",",
"loc_loss",
",",
"cls_label",
",",
"det",
"]",
")",
"return",
"out"
] |
Single-shot multi-box detection with VGG 16 layers ConvNet
This is a modified version, with fc6/fc7 layers replaced by conv layers
And the network is slightly smaller than original VGG 16 network
This is a training network with losses
Parameters:
----------
num_classes: int
number of object classes not including background
nms_thresh : float
non-maximum suppression threshold
force_suppress : boolean
whether suppress different class objects
nms_topk : int
apply NMS to top K detections
Returns:
----------
mx.Symbol
|
[
"Single",
"-",
"shot",
"multi",
"-",
"box",
"detection",
"with",
"VGG",
"16",
"layers",
"ConvNet",
"This",
"is",
"a",
"modified",
"version",
"with",
"fc6",
"/",
"fc7",
"layers",
"replaced",
"by",
"conv",
"layers",
"And",
"the",
"network",
"is",
"slightly",
"smaller",
"than",
"original",
"VGG",
"16",
"network",
"This",
"is",
"a",
"training",
"network",
"with",
"losses"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/symbol/legacy_vgg16_ssd_300.py#L22-L173
|
train
|
apache/incubator-mxnet
|
example/ssd/symbol/legacy_vgg16_ssd_300.py
|
get_symbol
|
def get_symbol(num_classes=20, nms_thresh=0.5, force_suppress=False,
nms_topk=400, **kwargs):
"""
Single-shot multi-box detection with VGG 16 layers ConvNet
This is a modified version, with fc6/fc7 layers replaced by conv layers
And the network is slightly smaller than original VGG 16 network
This is the detection network
Parameters:
----------
num_classes: int
number of object classes not including background
nms_thresh : float
threshold of overlap for non-maximum suppression
force_suppress : boolean
whether suppress different class objects
nms_topk : int
apply NMS to top K detections
Returns:
----------
mx.Symbol
"""
net = get_symbol_train(num_classes)
cls_preds = net.get_internals()["multibox_cls_pred_output"]
loc_preds = net.get_internals()["multibox_loc_pred_output"]
anchor_boxes = net.get_internals()["multibox_anchors_output"]
cls_prob = mx.symbol.softmax(data=cls_preds, axis=1, name='cls_prob')
out = mx.symbol.contrib.MultiBoxDetection(*[cls_prob, loc_preds, anchor_boxes], \
name="detection", nms_threshold=nms_thresh, force_suppress=force_suppress,
variances=(0.1, 0.1, 0.2, 0.2), nms_topk=nms_topk)
return out
|
python
|
def get_symbol(num_classes=20, nms_thresh=0.5, force_suppress=False,
nms_topk=400, **kwargs):
"""
Single-shot multi-box detection with VGG 16 layers ConvNet
This is a modified version, with fc6/fc7 layers replaced by conv layers
And the network is slightly smaller than original VGG 16 network
This is the detection network
Parameters:
----------
num_classes: int
number of object classes not including background
nms_thresh : float
threshold of overlap for non-maximum suppression
force_suppress : boolean
whether suppress different class objects
nms_topk : int
apply NMS to top K detections
Returns:
----------
mx.Symbol
"""
net = get_symbol_train(num_classes)
cls_preds = net.get_internals()["multibox_cls_pred_output"]
loc_preds = net.get_internals()["multibox_loc_pred_output"]
anchor_boxes = net.get_internals()["multibox_anchors_output"]
cls_prob = mx.symbol.softmax(data=cls_preds, axis=1, name='cls_prob')
out = mx.symbol.contrib.MultiBoxDetection(*[cls_prob, loc_preds, anchor_boxes], \
name="detection", nms_threshold=nms_thresh, force_suppress=force_suppress,
variances=(0.1, 0.1, 0.2, 0.2), nms_topk=nms_topk)
return out
|
[
"def",
"get_symbol",
"(",
"num_classes",
"=",
"20",
",",
"nms_thresh",
"=",
"0.5",
",",
"force_suppress",
"=",
"False",
",",
"nms_topk",
"=",
"400",
",",
"*",
"*",
"kwargs",
")",
":",
"net",
"=",
"get_symbol_train",
"(",
"num_classes",
")",
"cls_preds",
"=",
"net",
".",
"get_internals",
"(",
")",
"[",
"\"multibox_cls_pred_output\"",
"]",
"loc_preds",
"=",
"net",
".",
"get_internals",
"(",
")",
"[",
"\"multibox_loc_pred_output\"",
"]",
"anchor_boxes",
"=",
"net",
".",
"get_internals",
"(",
")",
"[",
"\"multibox_anchors_output\"",
"]",
"cls_prob",
"=",
"mx",
".",
"symbol",
".",
"softmax",
"(",
"data",
"=",
"cls_preds",
",",
"axis",
"=",
"1",
",",
"name",
"=",
"'cls_prob'",
")",
"out",
"=",
"mx",
".",
"symbol",
".",
"contrib",
".",
"MultiBoxDetection",
"(",
"*",
"[",
"cls_prob",
",",
"loc_preds",
",",
"anchor_boxes",
"]",
",",
"name",
"=",
"\"detection\"",
",",
"nms_threshold",
"=",
"nms_thresh",
",",
"force_suppress",
"=",
"force_suppress",
",",
"variances",
"=",
"(",
"0.1",
",",
"0.1",
",",
"0.2",
",",
"0.2",
")",
",",
"nms_topk",
"=",
"nms_topk",
")",
"return",
"out"
] |
Single-shot multi-box detection with VGG 16 layers ConvNet
This is a modified version, with fc6/fc7 layers replaced by conv layers
And the network is slightly smaller than original VGG 16 network
This is the detection network
Parameters:
----------
num_classes: int
number of object classes not including background
nms_thresh : float
threshold of overlap for non-maximum suppression
force_suppress : boolean
whether suppress different class objects
nms_topk : int
apply NMS to top K detections
Returns:
----------
mx.Symbol
|
[
"Single",
"-",
"shot",
"multi",
"-",
"box",
"detection",
"with",
"VGG",
"16",
"layers",
"ConvNet",
"This",
"is",
"a",
"modified",
"version",
"with",
"fc6",
"/",
"fc7",
"layers",
"replaced",
"by",
"conv",
"layers",
"And",
"the",
"network",
"is",
"slightly",
"smaller",
"than",
"original",
"VGG",
"16",
"network",
"This",
"is",
"the",
"detection",
"network"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/symbol/legacy_vgg16_ssd_300.py#L175-L207
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.load
|
def load(prefix, epoch, load_optimizer_states=False, **kwargs):
"""Creates a model from previously saved checkpoint.
Parameters
----------
prefix : str
path prefix of saved model files. You should have
"prefix-symbol.json", "prefix-xxxx.params", and
optionally "prefix-xxxx.states", where xxxx is the
epoch number.
epoch : int
epoch to load.
load_optimizer_states : bool
whether to load optimizer states. Checkpoint needs
to have been made with save_optimizer_states=True.
data_names : list of str
Default is `('data')` for a typical model used in image classification.
label_names : list of str
Default is `('softmax_label')` for a typical model used in image
classification.
logger : Logger
Default is `logging`.
context : Context or list of Context
Default is ``cpu()``.
work_load_list : list of number
Default ``None``, indicating uniform workload.
fixed_param_names: list of str
Default ``None``, indicating no network parameters are fixed.
"""
sym, args, auxs = load_checkpoint(prefix, epoch)
mod = Module(symbol=sym, **kwargs)
mod._arg_params = args
mod._aux_params = auxs
mod.params_initialized = True
if load_optimizer_states:
mod._preload_opt_states = '%s-%04d.states'%(prefix, epoch)
return mod
|
python
|
def load(prefix, epoch, load_optimizer_states=False, **kwargs):
"""Creates a model from previously saved checkpoint.
Parameters
----------
prefix : str
path prefix of saved model files. You should have
"prefix-symbol.json", "prefix-xxxx.params", and
optionally "prefix-xxxx.states", where xxxx is the
epoch number.
epoch : int
epoch to load.
load_optimizer_states : bool
whether to load optimizer states. Checkpoint needs
to have been made with save_optimizer_states=True.
data_names : list of str
Default is `('data')` for a typical model used in image classification.
label_names : list of str
Default is `('softmax_label')` for a typical model used in image
classification.
logger : Logger
Default is `logging`.
context : Context or list of Context
Default is ``cpu()``.
work_load_list : list of number
Default ``None``, indicating uniform workload.
fixed_param_names: list of str
Default ``None``, indicating no network parameters are fixed.
"""
sym, args, auxs = load_checkpoint(prefix, epoch)
mod = Module(symbol=sym, **kwargs)
mod._arg_params = args
mod._aux_params = auxs
mod.params_initialized = True
if load_optimizer_states:
mod._preload_opt_states = '%s-%04d.states'%(prefix, epoch)
return mod
|
[
"def",
"load",
"(",
"prefix",
",",
"epoch",
",",
"load_optimizer_states",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"sym",
",",
"args",
",",
"auxs",
"=",
"load_checkpoint",
"(",
"prefix",
",",
"epoch",
")",
"mod",
"=",
"Module",
"(",
"symbol",
"=",
"sym",
",",
"*",
"*",
"kwargs",
")",
"mod",
".",
"_arg_params",
"=",
"args",
"mod",
".",
"_aux_params",
"=",
"auxs",
"mod",
".",
"params_initialized",
"=",
"True",
"if",
"load_optimizer_states",
":",
"mod",
".",
"_preload_opt_states",
"=",
"'%s-%04d.states'",
"%",
"(",
"prefix",
",",
"epoch",
")",
"return",
"mod"
] |
Creates a model from previously saved checkpoint.
Parameters
----------
prefix : str
path prefix of saved model files. You should have
"prefix-symbol.json", "prefix-xxxx.params", and
optionally "prefix-xxxx.states", where xxxx is the
epoch number.
epoch : int
epoch to load.
load_optimizer_states : bool
whether to load optimizer states. Checkpoint needs
to have been made with save_optimizer_states=True.
data_names : list of str
Default is `('data')` for a typical model used in image classification.
label_names : list of str
Default is `('softmax_label')` for a typical model used in image
classification.
logger : Logger
Default is `logging`.
context : Context or list of Context
Default is ``cpu()``.
work_load_list : list of number
Default ``None``, indicating uniform workload.
fixed_param_names: list of str
Default ``None``, indicating no network parameters are fixed.
|
[
"Creates",
"a",
"model",
"from",
"previously",
"saved",
"checkpoint",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L127-L163
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.save_checkpoint
|
def save_checkpoint(self, prefix, epoch, save_optimizer_states=False):
"""Saves current progress to checkpoint.
Use `mx.callback.module_checkpoint` as `epoch_end_callback` to save during training.
Parameters
----------
prefix : str
The file prefix to checkpoint to.
epoch : int
The current epoch number.
save_optimizer_states : bool
Whether to save optimizer states to continue training.
"""
self._symbol.save('%s-symbol.json'%prefix)
param_name = '%s-%04d.params' % (prefix, epoch)
self.save_params(param_name)
logging.info('Saved checkpoint to \"%s\"', param_name)
if save_optimizer_states:
state_name = '%s-%04d.states' % (prefix, epoch)
self.save_optimizer_states(state_name)
logging.info('Saved optimizer state to \"%s\"', state_name)
|
python
|
def save_checkpoint(self, prefix, epoch, save_optimizer_states=False):
"""Saves current progress to checkpoint.
Use `mx.callback.module_checkpoint` as `epoch_end_callback` to save during training.
Parameters
----------
prefix : str
The file prefix to checkpoint to.
epoch : int
The current epoch number.
save_optimizer_states : bool
Whether to save optimizer states to continue training.
"""
self._symbol.save('%s-symbol.json'%prefix)
param_name = '%s-%04d.params' % (prefix, epoch)
self.save_params(param_name)
logging.info('Saved checkpoint to \"%s\"', param_name)
if save_optimizer_states:
state_name = '%s-%04d.states' % (prefix, epoch)
self.save_optimizer_states(state_name)
logging.info('Saved optimizer state to \"%s\"', state_name)
|
[
"def",
"save_checkpoint",
"(",
"self",
",",
"prefix",
",",
"epoch",
",",
"save_optimizer_states",
"=",
"False",
")",
":",
"self",
".",
"_symbol",
".",
"save",
"(",
"'%s-symbol.json'",
"%",
"prefix",
")",
"param_name",
"=",
"'%s-%04d.params'",
"%",
"(",
"prefix",
",",
"epoch",
")",
"self",
".",
"save_params",
"(",
"param_name",
")",
"logging",
".",
"info",
"(",
"'Saved checkpoint to \\\"%s\\\"'",
",",
"param_name",
")",
"if",
"save_optimizer_states",
":",
"state_name",
"=",
"'%s-%04d.states'",
"%",
"(",
"prefix",
",",
"epoch",
")",
"self",
".",
"save_optimizer_states",
"(",
"state_name",
")",
"logging",
".",
"info",
"(",
"'Saved optimizer state to \\\"%s\\\"'",
",",
"state_name",
")"
] |
Saves current progress to checkpoint.
Use `mx.callback.module_checkpoint` as `epoch_end_callback` to save during training.
Parameters
----------
prefix : str
The file prefix to checkpoint to.
epoch : int
The current epoch number.
save_optimizer_states : bool
Whether to save optimizer states to continue training.
|
[
"Saves",
"current",
"progress",
"to",
"checkpoint",
".",
"Use",
"mx",
".",
"callback",
".",
"module_checkpoint",
"as",
"epoch_end_callback",
"to",
"save",
"during",
"training",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L165-L185
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module._reset_bind
|
def _reset_bind(self):
"""Internal function to reset binded state."""
self.binded = False
self._exec_group = None
self._data_shapes = None
self._label_shapes = None
|
python
|
def _reset_bind(self):
"""Internal function to reset binded state."""
self.binded = False
self._exec_group = None
self._data_shapes = None
self._label_shapes = None
|
[
"def",
"_reset_bind",
"(",
"self",
")",
":",
"self",
".",
"binded",
"=",
"False",
"self",
".",
"_exec_group",
"=",
"None",
"self",
".",
"_data_shapes",
"=",
"None",
"self",
".",
"_label_shapes",
"=",
"None"
] |
Internal function to reset binded state.
|
[
"Internal",
"function",
"to",
"reset",
"binded",
"state",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L187-L192
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.get_params
|
def get_params(self):
"""Gets current parameters.
Returns
-------
`(arg_params, aux_params)`
A pair of dictionaries each mapping parameter names to NDArray values.
"""
assert self.binded and self.params_initialized
if self._params_dirty:
self._sync_params_from_devices()
return (self._arg_params, self._aux_params)
|
python
|
def get_params(self):
"""Gets current parameters.
Returns
-------
`(arg_params, aux_params)`
A pair of dictionaries each mapping parameter names to NDArray values.
"""
assert self.binded and self.params_initialized
if self._params_dirty:
self._sync_params_from_devices()
return (self._arg_params, self._aux_params)
|
[
"def",
"get_params",
"(",
"self",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"if",
"self",
".",
"_params_dirty",
":",
"self",
".",
"_sync_params_from_devices",
"(",
")",
"return",
"(",
"self",
".",
"_arg_params",
",",
"self",
".",
"_aux_params",
")"
] |
Gets current parameters.
Returns
-------
`(arg_params, aux_params)`
A pair of dictionaries each mapping parameter names to NDArray values.
|
[
"Gets",
"current",
"parameters",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L245-L257
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.init_params
|
def init_params(self, initializer=Uniform(0.01), arg_params=None, aux_params=None,
allow_missing=False, force_init=False, allow_extra=False):
"""Initializes the parameters and auxiliary states.
Parameters
----------
initializer : Initializer
Called to initialize parameters if needed.
arg_params : dict
If not ``None``, should be a dictionary of existing arg_params. Initialization
will be copied from that.
aux_params : dict
If not ``None``, should be a dictionary of existing aux_params. Initialization
will be copied from that.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
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.
"""
if self.params_initialized and not force_init:
warnings.warn("Parameters already initialized and force_init=False. "
"init_params call ignored.", stacklevel=2)
return
assert self.binded, 'call bind before initializing the parameters'
def _impl(name, arr, cache):
"""Internal helper for parameter initialization"""
if cache is not None:
if name in cache:
cache_arr = cache[name]
# just in case the cached array is just the target itself
if cache_arr is not arr:
cache_arr.copyto(arr)
else:
if not allow_missing:
raise RuntimeError("%s is not presented" % name)
if initializer is not None:
initializer(name, arr)
else:
initializer(name, arr)
attrs = self._symbol.attr_dict()
for name, arr in sorted(self._arg_params.items()):
desc = InitDesc(name, attrs.get(name, None))
_impl(desc, arr, arg_params)
for name, arr in sorted(self._aux_params.items()):
desc = InitDesc(name, attrs.get(name, None))
_impl(desc, arr, aux_params)
self.params_initialized = True
self._params_dirty = False
# copy the initialized parameters to devices
self._exec_group.set_params(self._arg_params, self._aux_params,
allow_extra=allow_extra)
|
python
|
def init_params(self, initializer=Uniform(0.01), arg_params=None, aux_params=None,
allow_missing=False, force_init=False, allow_extra=False):
"""Initializes the parameters and auxiliary states.
Parameters
----------
initializer : Initializer
Called to initialize parameters if needed.
arg_params : dict
If not ``None``, should be a dictionary of existing arg_params. Initialization
will be copied from that.
aux_params : dict
If not ``None``, should be a dictionary of existing aux_params. Initialization
will be copied from that.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
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.
"""
if self.params_initialized and not force_init:
warnings.warn("Parameters already initialized and force_init=False. "
"init_params call ignored.", stacklevel=2)
return
assert self.binded, 'call bind before initializing the parameters'
def _impl(name, arr, cache):
"""Internal helper for parameter initialization"""
if cache is not None:
if name in cache:
cache_arr = cache[name]
# just in case the cached array is just the target itself
if cache_arr is not arr:
cache_arr.copyto(arr)
else:
if not allow_missing:
raise RuntimeError("%s is not presented" % name)
if initializer is not None:
initializer(name, arr)
else:
initializer(name, arr)
attrs = self._symbol.attr_dict()
for name, arr in sorted(self._arg_params.items()):
desc = InitDesc(name, attrs.get(name, None))
_impl(desc, arr, arg_params)
for name, arr in sorted(self._aux_params.items()):
desc = InitDesc(name, attrs.get(name, None))
_impl(desc, arr, aux_params)
self.params_initialized = True
self._params_dirty = False
# copy the initialized parameters to devices
self._exec_group.set_params(self._arg_params, self._aux_params,
allow_extra=allow_extra)
|
[
"def",
"init_params",
"(",
"self",
",",
"initializer",
"=",
"Uniform",
"(",
"0.01",
")",
",",
"arg_params",
"=",
"None",
",",
"aux_params",
"=",
"None",
",",
"allow_missing",
"=",
"False",
",",
"force_init",
"=",
"False",
",",
"allow_extra",
"=",
"False",
")",
":",
"if",
"self",
".",
"params_initialized",
"and",
"not",
"force_init",
":",
"warnings",
".",
"warn",
"(",
"\"Parameters already initialized and force_init=False. \"",
"\"init_params call ignored.\"",
",",
"stacklevel",
"=",
"2",
")",
"return",
"assert",
"self",
".",
"binded",
",",
"'call bind before initializing the parameters'",
"def",
"_impl",
"(",
"name",
",",
"arr",
",",
"cache",
")",
":",
"\"\"\"Internal helper for parameter initialization\"\"\"",
"if",
"cache",
"is",
"not",
"None",
":",
"if",
"name",
"in",
"cache",
":",
"cache_arr",
"=",
"cache",
"[",
"name",
"]",
"# just in case the cached array is just the target itself",
"if",
"cache_arr",
"is",
"not",
"arr",
":",
"cache_arr",
".",
"copyto",
"(",
"arr",
")",
"else",
":",
"if",
"not",
"allow_missing",
":",
"raise",
"RuntimeError",
"(",
"\"%s is not presented\"",
"%",
"name",
")",
"if",
"initializer",
"is",
"not",
"None",
":",
"initializer",
"(",
"name",
",",
"arr",
")",
"else",
":",
"initializer",
"(",
"name",
",",
"arr",
")",
"attrs",
"=",
"self",
".",
"_symbol",
".",
"attr_dict",
"(",
")",
"for",
"name",
",",
"arr",
"in",
"sorted",
"(",
"self",
".",
"_arg_params",
".",
"items",
"(",
")",
")",
":",
"desc",
"=",
"InitDesc",
"(",
"name",
",",
"attrs",
".",
"get",
"(",
"name",
",",
"None",
")",
")",
"_impl",
"(",
"desc",
",",
"arr",
",",
"arg_params",
")",
"for",
"name",
",",
"arr",
"in",
"sorted",
"(",
"self",
".",
"_aux_params",
".",
"items",
"(",
")",
")",
":",
"desc",
"=",
"InitDesc",
"(",
"name",
",",
"attrs",
".",
"get",
"(",
"name",
",",
"None",
")",
")",
"_impl",
"(",
"desc",
",",
"arr",
",",
"aux_params",
")",
"self",
".",
"params_initialized",
"=",
"True",
"self",
".",
"_params_dirty",
"=",
"False",
"# copy the initialized parameters to devices",
"self",
".",
"_exec_group",
".",
"set_params",
"(",
"self",
".",
"_arg_params",
",",
"self",
".",
"_aux_params",
",",
"allow_extra",
"=",
"allow_extra",
")"
] |
Initializes the parameters and auxiliary states.
Parameters
----------
initializer : Initializer
Called to initialize parameters if needed.
arg_params : dict
If not ``None``, should be a dictionary of existing arg_params. Initialization
will be copied from that.
aux_params : dict
If not ``None``, should be a dictionary of existing aux_params. Initialization
will be copied from that.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
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.
|
[
"Initializes",
"the",
"parameters",
"and",
"auxiliary",
"states",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L259-L320
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.set_params
|
def set_params(self, arg_params, aux_params, allow_missing=False, force_init=True,
allow_extra=False):
"""Assigns parameter and aux state values.
Parameters
----------
arg_params : dict
Dictionary of name to `NDArray`.
aux_params : dict
Dictionary of name to `NDArray`.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
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.
Examples
--------
>>> # An example of setting module parameters.
>>> sym, arg_params, aux_params = mx.model.load_checkpoint(model_prefix, n_epoch_load)
>>> mod.set_params(arg_params=arg_params, aux_params=aux_params)
"""
if not allow_missing:
self.init_params(initializer=None, arg_params=arg_params, aux_params=aux_params,
allow_missing=allow_missing, force_init=force_init,
allow_extra=allow_extra)
return
if self.params_initialized and not force_init:
warnings.warn("Parameters already initialized and force_init=False. "
"set_params call ignored.", stacklevel=2)
return
self._exec_group.set_params(arg_params, aux_params, allow_extra=allow_extra)
# because we didn't update self._arg_params, they are dirty now.
self._params_dirty = True
self.params_initialized = True
|
python
|
def set_params(self, arg_params, aux_params, allow_missing=False, force_init=True,
allow_extra=False):
"""Assigns parameter and aux state values.
Parameters
----------
arg_params : dict
Dictionary of name to `NDArray`.
aux_params : dict
Dictionary of name to `NDArray`.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
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.
Examples
--------
>>> # An example of setting module parameters.
>>> sym, arg_params, aux_params = mx.model.load_checkpoint(model_prefix, n_epoch_load)
>>> mod.set_params(arg_params=arg_params, aux_params=aux_params)
"""
if not allow_missing:
self.init_params(initializer=None, arg_params=arg_params, aux_params=aux_params,
allow_missing=allow_missing, force_init=force_init,
allow_extra=allow_extra)
return
if self.params_initialized and not force_init:
warnings.warn("Parameters already initialized and force_init=False. "
"set_params call ignored.", stacklevel=2)
return
self._exec_group.set_params(arg_params, aux_params, allow_extra=allow_extra)
# because we didn't update self._arg_params, they are dirty now.
self._params_dirty = True
self.params_initialized = True
|
[
"def",
"set_params",
"(",
"self",
",",
"arg_params",
",",
"aux_params",
",",
"allow_missing",
"=",
"False",
",",
"force_init",
"=",
"True",
",",
"allow_extra",
"=",
"False",
")",
":",
"if",
"not",
"allow_missing",
":",
"self",
".",
"init_params",
"(",
"initializer",
"=",
"None",
",",
"arg_params",
"=",
"arg_params",
",",
"aux_params",
"=",
"aux_params",
",",
"allow_missing",
"=",
"allow_missing",
",",
"force_init",
"=",
"force_init",
",",
"allow_extra",
"=",
"allow_extra",
")",
"return",
"if",
"self",
".",
"params_initialized",
"and",
"not",
"force_init",
":",
"warnings",
".",
"warn",
"(",
"\"Parameters already initialized and force_init=False. \"",
"\"set_params call ignored.\"",
",",
"stacklevel",
"=",
"2",
")",
"return",
"self",
".",
"_exec_group",
".",
"set_params",
"(",
"arg_params",
",",
"aux_params",
",",
"allow_extra",
"=",
"allow_extra",
")",
"# because we didn't update self._arg_params, they are dirty now.",
"self",
".",
"_params_dirty",
"=",
"True",
"self",
".",
"params_initialized",
"=",
"True"
] |
Assigns parameter and aux state values.
Parameters
----------
arg_params : dict
Dictionary of name to `NDArray`.
aux_params : dict
Dictionary of name to `NDArray`.
allow_missing : bool
If ``True``, params could contain missing values, and the initializer will be
called to fill those missing params.
force_init : bool
If ``True``, will force re-initialize even if already initialized.
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.
Examples
--------
>>> # An example of setting module parameters.
>>> sym, arg_params, aux_params = mx.model.load_checkpoint(model_prefix, n_epoch_load)
>>> mod.set_params(arg_params=arg_params, aux_params=aux_params)
|
[
"Assigns",
"parameter",
"and",
"aux",
"state",
"values",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L322-L362
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.bind
|
def bind(self, data_shapes, label_shapes=None, for_training=True,
inputs_need_grad=False, force_rebind=False, shared_module=None,
grad_req='write'):
"""Binds the symbols to construct executors. This is necessary before one
can perform computation with the module.
Parameters
----------
data_shapes : list of (str, tuple)
Typically is ``data_iter.provide_data``.
label_shapes : list of (str, tuple)
Typically is ``data_iter.provide_label``.
for_training : bool
Default is ``True``. Whether the executors should be bound for training.
inputs_need_grad : bool
Default is ``False``. Whether the gradients to the input data need to be computed.
Typically this is not needed. But this might be needed when implementing composition
of modules.
force_rebind : bool
Default is ``False``. This function does nothing if the executors are already
bound. But with this ``True``, the executors will be forced to rebind.
shared_module : Module
Default is ``None``. This is used in bucketing. When not ``None``, the shared module
essentially corresponds to a different bucket -- a module with different symbol
but with the same sets of parameters (e.g. unrolled RNNs with different lengths).
"""
# force rebinding is typically used when one want to switch from
# training to prediction phase.
if force_rebind:
self._reset_bind()
if self.binded:
self.logger.warning('Already bound, ignoring bind()')
return
self.for_training = for_training
self.inputs_need_grad = inputs_need_grad
self._grad_req = grad_req
if not for_training:
assert not inputs_need_grad
else:
pass
# this is not True, as some module might not contains a loss function
# that consumes the labels
# assert label_shapes is not None
self._data_shapes, self._label_shapes = _parse_data_desc(
self.data_names, self.label_names, data_shapes, label_shapes)
if shared_module is not None:
assert isinstance(shared_module, Module) and \
shared_module.binded and shared_module.params_initialized
shared_group = shared_module._exec_group
assert len(shared_group.execs) >= len(self._context)
else:
shared_group = None
self._exec_group = DataParallelExecutorGroup(self._symbol, self._context,
self._work_load_list, self._data_shapes,
self._label_shapes, self._param_names,
for_training, inputs_need_grad,
shared_group, logger=self.logger,
fixed_param_names=self._fixed_param_names,
grad_req=grad_req, group2ctxs=self._group2ctxs,
state_names=self._state_names)
self._total_exec_bytes = self._exec_group._total_exec_bytes
if shared_module is not None:
self.params_initialized = True
self._arg_params = shared_module._arg_params
self._aux_params = shared_module._aux_params
elif self.params_initialized:
# if the parameters are already initialized, we are re-binding
# so automatically copy the already initialized params
self._exec_group.set_params(self._arg_params, self._aux_params)
else:
assert self._arg_params is None and self._aux_params is None
param_arrays = [
zeros(shape=x[0].shape, dtype=x[0].dtype, stype=x[0].stype)
for x in self._exec_group.param_arrays
]
self._arg_params = {name:arr for name, arr in zip(self._param_names, param_arrays)}
aux_arrays = [
zeros(x[0].shape, dtype=x[0].dtype)
for x in self._exec_group.aux_arrays
]
self._aux_params = {name:arr for name, arr in zip(self._aux_names, aux_arrays)}
if shared_module is not None and shared_module.optimizer_initialized:
self.borrow_optimizer(shared_module)
self.binded = True
|
python
|
def bind(self, data_shapes, label_shapes=None, for_training=True,
inputs_need_grad=False, force_rebind=False, shared_module=None,
grad_req='write'):
"""Binds the symbols to construct executors. This is necessary before one
can perform computation with the module.
Parameters
----------
data_shapes : list of (str, tuple)
Typically is ``data_iter.provide_data``.
label_shapes : list of (str, tuple)
Typically is ``data_iter.provide_label``.
for_training : bool
Default is ``True``. Whether the executors should be bound for training.
inputs_need_grad : bool
Default is ``False``. Whether the gradients to the input data need to be computed.
Typically this is not needed. But this might be needed when implementing composition
of modules.
force_rebind : bool
Default is ``False``. This function does nothing if the executors are already
bound. But with this ``True``, the executors will be forced to rebind.
shared_module : Module
Default is ``None``. This is used in bucketing. When not ``None``, the shared module
essentially corresponds to a different bucket -- a module with different symbol
but with the same sets of parameters (e.g. unrolled RNNs with different lengths).
"""
# force rebinding is typically used when one want to switch from
# training to prediction phase.
if force_rebind:
self._reset_bind()
if self.binded:
self.logger.warning('Already bound, ignoring bind()')
return
self.for_training = for_training
self.inputs_need_grad = inputs_need_grad
self._grad_req = grad_req
if not for_training:
assert not inputs_need_grad
else:
pass
# this is not True, as some module might not contains a loss function
# that consumes the labels
# assert label_shapes is not None
self._data_shapes, self._label_shapes = _parse_data_desc(
self.data_names, self.label_names, data_shapes, label_shapes)
if shared_module is not None:
assert isinstance(shared_module, Module) and \
shared_module.binded and shared_module.params_initialized
shared_group = shared_module._exec_group
assert len(shared_group.execs) >= len(self._context)
else:
shared_group = None
self._exec_group = DataParallelExecutorGroup(self._symbol, self._context,
self._work_load_list, self._data_shapes,
self._label_shapes, self._param_names,
for_training, inputs_need_grad,
shared_group, logger=self.logger,
fixed_param_names=self._fixed_param_names,
grad_req=grad_req, group2ctxs=self._group2ctxs,
state_names=self._state_names)
self._total_exec_bytes = self._exec_group._total_exec_bytes
if shared_module is not None:
self.params_initialized = True
self._arg_params = shared_module._arg_params
self._aux_params = shared_module._aux_params
elif self.params_initialized:
# if the parameters are already initialized, we are re-binding
# so automatically copy the already initialized params
self._exec_group.set_params(self._arg_params, self._aux_params)
else:
assert self._arg_params is None and self._aux_params is None
param_arrays = [
zeros(shape=x[0].shape, dtype=x[0].dtype, stype=x[0].stype)
for x in self._exec_group.param_arrays
]
self._arg_params = {name:arr for name, arr in zip(self._param_names, param_arrays)}
aux_arrays = [
zeros(x[0].shape, dtype=x[0].dtype)
for x in self._exec_group.aux_arrays
]
self._aux_params = {name:arr for name, arr in zip(self._aux_names, aux_arrays)}
if shared_module is not None and shared_module.optimizer_initialized:
self.borrow_optimizer(shared_module)
self.binded = True
|
[
"def",
"bind",
"(",
"self",
",",
"data_shapes",
",",
"label_shapes",
"=",
"None",
",",
"for_training",
"=",
"True",
",",
"inputs_need_grad",
"=",
"False",
",",
"force_rebind",
"=",
"False",
",",
"shared_module",
"=",
"None",
",",
"grad_req",
"=",
"'write'",
")",
":",
"# force rebinding is typically used when one want to switch from",
"# training to prediction phase.",
"if",
"force_rebind",
":",
"self",
".",
"_reset_bind",
"(",
")",
"if",
"self",
".",
"binded",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"'Already bound, ignoring bind()'",
")",
"return",
"self",
".",
"for_training",
"=",
"for_training",
"self",
".",
"inputs_need_grad",
"=",
"inputs_need_grad",
"self",
".",
"_grad_req",
"=",
"grad_req",
"if",
"not",
"for_training",
":",
"assert",
"not",
"inputs_need_grad",
"else",
":",
"pass",
"# this is not True, as some module might not contains a loss function",
"# that consumes the labels",
"# assert label_shapes is not None",
"self",
".",
"_data_shapes",
",",
"self",
".",
"_label_shapes",
"=",
"_parse_data_desc",
"(",
"self",
".",
"data_names",
",",
"self",
".",
"label_names",
",",
"data_shapes",
",",
"label_shapes",
")",
"if",
"shared_module",
"is",
"not",
"None",
":",
"assert",
"isinstance",
"(",
"shared_module",
",",
"Module",
")",
"and",
"shared_module",
".",
"binded",
"and",
"shared_module",
".",
"params_initialized",
"shared_group",
"=",
"shared_module",
".",
"_exec_group",
"assert",
"len",
"(",
"shared_group",
".",
"execs",
")",
">=",
"len",
"(",
"self",
".",
"_context",
")",
"else",
":",
"shared_group",
"=",
"None",
"self",
".",
"_exec_group",
"=",
"DataParallelExecutorGroup",
"(",
"self",
".",
"_symbol",
",",
"self",
".",
"_context",
",",
"self",
".",
"_work_load_list",
",",
"self",
".",
"_data_shapes",
",",
"self",
".",
"_label_shapes",
",",
"self",
".",
"_param_names",
",",
"for_training",
",",
"inputs_need_grad",
",",
"shared_group",
",",
"logger",
"=",
"self",
".",
"logger",
",",
"fixed_param_names",
"=",
"self",
".",
"_fixed_param_names",
",",
"grad_req",
"=",
"grad_req",
",",
"group2ctxs",
"=",
"self",
".",
"_group2ctxs",
",",
"state_names",
"=",
"self",
".",
"_state_names",
")",
"self",
".",
"_total_exec_bytes",
"=",
"self",
".",
"_exec_group",
".",
"_total_exec_bytes",
"if",
"shared_module",
"is",
"not",
"None",
":",
"self",
".",
"params_initialized",
"=",
"True",
"self",
".",
"_arg_params",
"=",
"shared_module",
".",
"_arg_params",
"self",
".",
"_aux_params",
"=",
"shared_module",
".",
"_aux_params",
"elif",
"self",
".",
"params_initialized",
":",
"# if the parameters are already initialized, we are re-binding",
"# so automatically copy the already initialized params",
"self",
".",
"_exec_group",
".",
"set_params",
"(",
"self",
".",
"_arg_params",
",",
"self",
".",
"_aux_params",
")",
"else",
":",
"assert",
"self",
".",
"_arg_params",
"is",
"None",
"and",
"self",
".",
"_aux_params",
"is",
"None",
"param_arrays",
"=",
"[",
"zeros",
"(",
"shape",
"=",
"x",
"[",
"0",
"]",
".",
"shape",
",",
"dtype",
"=",
"x",
"[",
"0",
"]",
".",
"dtype",
",",
"stype",
"=",
"x",
"[",
"0",
"]",
".",
"stype",
")",
"for",
"x",
"in",
"self",
".",
"_exec_group",
".",
"param_arrays",
"]",
"self",
".",
"_arg_params",
"=",
"{",
"name",
":",
"arr",
"for",
"name",
",",
"arr",
"in",
"zip",
"(",
"self",
".",
"_param_names",
",",
"param_arrays",
")",
"}",
"aux_arrays",
"=",
"[",
"zeros",
"(",
"x",
"[",
"0",
"]",
".",
"shape",
",",
"dtype",
"=",
"x",
"[",
"0",
"]",
".",
"dtype",
")",
"for",
"x",
"in",
"self",
".",
"_exec_group",
".",
"aux_arrays",
"]",
"self",
".",
"_aux_params",
"=",
"{",
"name",
":",
"arr",
"for",
"name",
",",
"arr",
"in",
"zip",
"(",
"self",
".",
"_aux_names",
",",
"aux_arrays",
")",
"}",
"if",
"shared_module",
"is",
"not",
"None",
"and",
"shared_module",
".",
"optimizer_initialized",
":",
"self",
".",
"borrow_optimizer",
"(",
"shared_module",
")",
"self",
".",
"binded",
"=",
"True"
] |
Binds the symbols to construct executors. This is necessary before one
can perform computation with the module.
Parameters
----------
data_shapes : list of (str, tuple)
Typically is ``data_iter.provide_data``.
label_shapes : list of (str, tuple)
Typically is ``data_iter.provide_label``.
for_training : bool
Default is ``True``. Whether the executors should be bound for training.
inputs_need_grad : bool
Default is ``False``. Whether the gradients to the input data need to be computed.
Typically this is not needed. But this might be needed when implementing composition
of modules.
force_rebind : bool
Default is ``False``. This function does nothing if the executors are already
bound. But with this ``True``, the executors will be forced to rebind.
shared_module : Module
Default is ``None``. This is used in bucketing. When not ``None``, the shared module
essentially corresponds to a different bucket -- a module with different symbol
but with the same sets of parameters (e.g. unrolled RNNs with different lengths).
|
[
"Binds",
"the",
"symbols",
"to",
"construct",
"executors",
".",
"This",
"is",
"necessary",
"before",
"one",
"can",
"perform",
"computation",
"with",
"the",
"module",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L364-L456
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.reshape
|
def reshape(self, data_shapes, label_shapes=None):
"""Reshapes the module for new input shapes.
Parameters
----------
data_shapes : list of (str, tuple)
Typically is ``data_iter.provide_data``.
label_shapes : list of (str, tuple)
Typically is ``data_iter.provide_label``.
"""
assert self.binded
self._data_shapes, self._label_shapes = _parse_data_desc(
self.data_names, self.label_names, data_shapes, label_shapes)
self._exec_group.reshape(self._data_shapes, self._label_shapes)
|
python
|
def reshape(self, data_shapes, label_shapes=None):
"""Reshapes the module for new input shapes.
Parameters
----------
data_shapes : list of (str, tuple)
Typically is ``data_iter.provide_data``.
label_shapes : list of (str, tuple)
Typically is ``data_iter.provide_label``.
"""
assert self.binded
self._data_shapes, self._label_shapes = _parse_data_desc(
self.data_names, self.label_names, data_shapes, label_shapes)
self._exec_group.reshape(self._data_shapes, self._label_shapes)
|
[
"def",
"reshape",
"(",
"self",
",",
"data_shapes",
",",
"label_shapes",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"self",
".",
"_data_shapes",
",",
"self",
".",
"_label_shapes",
"=",
"_parse_data_desc",
"(",
"self",
".",
"data_names",
",",
"self",
".",
"label_names",
",",
"data_shapes",
",",
"label_shapes",
")",
"self",
".",
"_exec_group",
".",
"reshape",
"(",
"self",
".",
"_data_shapes",
",",
"self",
".",
"_label_shapes",
")"
] |
Reshapes the module for new input shapes.
Parameters
----------
data_shapes : list of (str, tuple)
Typically is ``data_iter.provide_data``.
label_shapes : list of (str, tuple)
Typically is ``data_iter.provide_label``.
|
[
"Reshapes",
"the",
"module",
"for",
"new",
"input",
"shapes",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L458-L472
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.init_optimizer
|
def init_optimizer(self, kvstore='local', optimizer='sgd',
optimizer_params=(('learning_rate', 0.01),), force_init=False):
"""Installs and initializes optimizers.
Parameters
----------
kvstore : str or KVStore
Default `'local'`.
optimizer : str or Optimizer
Default `'sgd'`
optimizer_params : dict
Default `(('learning_rate', 0.01),)`. The default value is not a dictionary,
just to avoid pylint warning of dangerous default values.
force_init : bool
Default ``False``, indicating whether we should force re-initializing the
optimizer in the case an optimizer is already installed.
"""
assert self.binded and self.params_initialized
if self.optimizer_initialized and not force_init:
self.logger.warning('optimizer already initialized, ignoring...')
return
if self._params_dirty:
self._sync_params_from_devices()
(kvstore, update_on_kvstore) = \
_create_kvstore(kvstore, len(self._context), self._arg_params)
batch_size = self._exec_group.batch_size
if kvstore and 'dist' in kvstore.type and '_sync' in kvstore.type:
batch_size *= kvstore.num_workers
rescale_grad = 1.0/batch_size
idx2name = {}
if update_on_kvstore:
idx2name.update(enumerate(self._exec_group.param_names))
else:
for k in range(len(self._context)):
idx2name.update({i*len(self._context)+k: n
for i, n in enumerate(self._exec_group.param_names)})
if isinstance(optimizer, str):
optimizer_params = dict(optimizer_params)
if 'rescale_grad' not in optimizer_params:
optimizer_params['rescale_grad'] = rescale_grad
optimizer = opt.create(optimizer,
sym=self.symbol, param_idx2name=idx2name,
**optimizer_params)
else:
assert isinstance(optimizer, opt.Optimizer)
if optimizer.rescale_grad != rescale_grad:
#pylint: disable=no-member
warnings.warn(
"Optimizer created manually outside Module but rescale_grad " +
"is not normalized to 1.0/batch_size/num_workers (%s vs. %s). "%(
optimizer.rescale_grad, rescale_grad) +
"Is this intended?", stacklevel=2)
if not optimizer.idx2name:
optimizer.idx2name = idx2name.copy()
self._optimizer = optimizer
self._kvstore = kvstore
self._update_on_kvstore = update_on_kvstore
self._updater = None
if kvstore:
if self._compression_params:
kvstore.set_gradient_compression(self._compression_params)
if update_on_kvstore:
kvstore.set_optimizer(self._optimizer)
# copy initialized local parameters to kvstore
_initialize_kvstore(kvstore=kvstore,
param_arrays=self._exec_group.param_arrays,
arg_params=self._arg_params,
param_names=self._param_names,
update_on_kvstore=update_on_kvstore)
if not update_on_kvstore:
self._updater = opt.get_updater(optimizer)
self.optimizer_initialized = True
if self._preload_opt_states is not None:
self.load_optimizer_states(self._preload_opt_states)
self._preload_opt_states = None
|
python
|
def init_optimizer(self, kvstore='local', optimizer='sgd',
optimizer_params=(('learning_rate', 0.01),), force_init=False):
"""Installs and initializes optimizers.
Parameters
----------
kvstore : str or KVStore
Default `'local'`.
optimizer : str or Optimizer
Default `'sgd'`
optimizer_params : dict
Default `(('learning_rate', 0.01),)`. The default value is not a dictionary,
just to avoid pylint warning of dangerous default values.
force_init : bool
Default ``False``, indicating whether we should force re-initializing the
optimizer in the case an optimizer is already installed.
"""
assert self.binded and self.params_initialized
if self.optimizer_initialized and not force_init:
self.logger.warning('optimizer already initialized, ignoring...')
return
if self._params_dirty:
self._sync_params_from_devices()
(kvstore, update_on_kvstore) = \
_create_kvstore(kvstore, len(self._context), self._arg_params)
batch_size = self._exec_group.batch_size
if kvstore and 'dist' in kvstore.type and '_sync' in kvstore.type:
batch_size *= kvstore.num_workers
rescale_grad = 1.0/batch_size
idx2name = {}
if update_on_kvstore:
idx2name.update(enumerate(self._exec_group.param_names))
else:
for k in range(len(self._context)):
idx2name.update({i*len(self._context)+k: n
for i, n in enumerate(self._exec_group.param_names)})
if isinstance(optimizer, str):
optimizer_params = dict(optimizer_params)
if 'rescale_grad' not in optimizer_params:
optimizer_params['rescale_grad'] = rescale_grad
optimizer = opt.create(optimizer,
sym=self.symbol, param_idx2name=idx2name,
**optimizer_params)
else:
assert isinstance(optimizer, opt.Optimizer)
if optimizer.rescale_grad != rescale_grad:
#pylint: disable=no-member
warnings.warn(
"Optimizer created manually outside Module but rescale_grad " +
"is not normalized to 1.0/batch_size/num_workers (%s vs. %s). "%(
optimizer.rescale_grad, rescale_grad) +
"Is this intended?", stacklevel=2)
if not optimizer.idx2name:
optimizer.idx2name = idx2name.copy()
self._optimizer = optimizer
self._kvstore = kvstore
self._update_on_kvstore = update_on_kvstore
self._updater = None
if kvstore:
if self._compression_params:
kvstore.set_gradient_compression(self._compression_params)
if update_on_kvstore:
kvstore.set_optimizer(self._optimizer)
# copy initialized local parameters to kvstore
_initialize_kvstore(kvstore=kvstore,
param_arrays=self._exec_group.param_arrays,
arg_params=self._arg_params,
param_names=self._param_names,
update_on_kvstore=update_on_kvstore)
if not update_on_kvstore:
self._updater = opt.get_updater(optimizer)
self.optimizer_initialized = True
if self._preload_opt_states is not None:
self.load_optimizer_states(self._preload_opt_states)
self._preload_opt_states = None
|
[
"def",
"init_optimizer",
"(",
"self",
",",
"kvstore",
"=",
"'local'",
",",
"optimizer",
"=",
"'sgd'",
",",
"optimizer_params",
"=",
"(",
"(",
"'learning_rate'",
",",
"0.01",
")",
",",
")",
",",
"force_init",
"=",
"False",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"if",
"self",
".",
"optimizer_initialized",
"and",
"not",
"force_init",
":",
"self",
".",
"logger",
".",
"warning",
"(",
"'optimizer already initialized, ignoring...'",
")",
"return",
"if",
"self",
".",
"_params_dirty",
":",
"self",
".",
"_sync_params_from_devices",
"(",
")",
"(",
"kvstore",
",",
"update_on_kvstore",
")",
"=",
"_create_kvstore",
"(",
"kvstore",
",",
"len",
"(",
"self",
".",
"_context",
")",
",",
"self",
".",
"_arg_params",
")",
"batch_size",
"=",
"self",
".",
"_exec_group",
".",
"batch_size",
"if",
"kvstore",
"and",
"'dist'",
"in",
"kvstore",
".",
"type",
"and",
"'_sync'",
"in",
"kvstore",
".",
"type",
":",
"batch_size",
"*=",
"kvstore",
".",
"num_workers",
"rescale_grad",
"=",
"1.0",
"/",
"batch_size",
"idx2name",
"=",
"{",
"}",
"if",
"update_on_kvstore",
":",
"idx2name",
".",
"update",
"(",
"enumerate",
"(",
"self",
".",
"_exec_group",
".",
"param_names",
")",
")",
"else",
":",
"for",
"k",
"in",
"range",
"(",
"len",
"(",
"self",
".",
"_context",
")",
")",
":",
"idx2name",
".",
"update",
"(",
"{",
"i",
"*",
"len",
"(",
"self",
".",
"_context",
")",
"+",
"k",
":",
"n",
"for",
"i",
",",
"n",
"in",
"enumerate",
"(",
"self",
".",
"_exec_group",
".",
"param_names",
")",
"}",
")",
"if",
"isinstance",
"(",
"optimizer",
",",
"str",
")",
":",
"optimizer_params",
"=",
"dict",
"(",
"optimizer_params",
")",
"if",
"'rescale_grad'",
"not",
"in",
"optimizer_params",
":",
"optimizer_params",
"[",
"'rescale_grad'",
"]",
"=",
"rescale_grad",
"optimizer",
"=",
"opt",
".",
"create",
"(",
"optimizer",
",",
"sym",
"=",
"self",
".",
"symbol",
",",
"param_idx2name",
"=",
"idx2name",
",",
"*",
"*",
"optimizer_params",
")",
"else",
":",
"assert",
"isinstance",
"(",
"optimizer",
",",
"opt",
".",
"Optimizer",
")",
"if",
"optimizer",
".",
"rescale_grad",
"!=",
"rescale_grad",
":",
"#pylint: disable=no-member",
"warnings",
".",
"warn",
"(",
"\"Optimizer created manually outside Module but rescale_grad \"",
"+",
"\"is not normalized to 1.0/batch_size/num_workers (%s vs. %s). \"",
"%",
"(",
"optimizer",
".",
"rescale_grad",
",",
"rescale_grad",
")",
"+",
"\"Is this intended?\"",
",",
"stacklevel",
"=",
"2",
")",
"if",
"not",
"optimizer",
".",
"idx2name",
":",
"optimizer",
".",
"idx2name",
"=",
"idx2name",
".",
"copy",
"(",
")",
"self",
".",
"_optimizer",
"=",
"optimizer",
"self",
".",
"_kvstore",
"=",
"kvstore",
"self",
".",
"_update_on_kvstore",
"=",
"update_on_kvstore",
"self",
".",
"_updater",
"=",
"None",
"if",
"kvstore",
":",
"if",
"self",
".",
"_compression_params",
":",
"kvstore",
".",
"set_gradient_compression",
"(",
"self",
".",
"_compression_params",
")",
"if",
"update_on_kvstore",
":",
"kvstore",
".",
"set_optimizer",
"(",
"self",
".",
"_optimizer",
")",
"# copy initialized local parameters to kvstore",
"_initialize_kvstore",
"(",
"kvstore",
"=",
"kvstore",
",",
"param_arrays",
"=",
"self",
".",
"_exec_group",
".",
"param_arrays",
",",
"arg_params",
"=",
"self",
".",
"_arg_params",
",",
"param_names",
"=",
"self",
".",
"_param_names",
",",
"update_on_kvstore",
"=",
"update_on_kvstore",
")",
"if",
"not",
"update_on_kvstore",
":",
"self",
".",
"_updater",
"=",
"opt",
".",
"get_updater",
"(",
"optimizer",
")",
"self",
".",
"optimizer_initialized",
"=",
"True",
"if",
"self",
".",
"_preload_opt_states",
"is",
"not",
"None",
":",
"self",
".",
"load_optimizer_states",
"(",
"self",
".",
"_preload_opt_states",
")",
"self",
".",
"_preload_opt_states",
"=",
"None"
] |
Installs and initializes optimizers.
Parameters
----------
kvstore : str or KVStore
Default `'local'`.
optimizer : str or Optimizer
Default `'sgd'`
optimizer_params : dict
Default `(('learning_rate', 0.01),)`. The default value is not a dictionary,
just to avoid pylint warning of dangerous default values.
force_init : bool
Default ``False``, indicating whether we should force re-initializing the
optimizer in the case an optimizer is already installed.
|
[
"Installs",
"and",
"initializes",
"optimizers",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L474-L558
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.borrow_optimizer
|
def borrow_optimizer(self, shared_module):
"""Borrows optimizer from a shared module. Used in bucketing, where exactly the same
optimizer (esp. kvstore) is used.
Parameters
----------
shared_module : Module
"""
assert shared_module.optimizer_initialized
self._optimizer = shared_module._optimizer
self._kvstore = shared_module._kvstore
self._update_on_kvstore = shared_module._update_on_kvstore
self._updater = shared_module._updater
self.optimizer_initialized = True
|
python
|
def borrow_optimizer(self, shared_module):
"""Borrows optimizer from a shared module. Used in bucketing, where exactly the same
optimizer (esp. kvstore) is used.
Parameters
----------
shared_module : Module
"""
assert shared_module.optimizer_initialized
self._optimizer = shared_module._optimizer
self._kvstore = shared_module._kvstore
self._update_on_kvstore = shared_module._update_on_kvstore
self._updater = shared_module._updater
self.optimizer_initialized = True
|
[
"def",
"borrow_optimizer",
"(",
"self",
",",
"shared_module",
")",
":",
"assert",
"shared_module",
".",
"optimizer_initialized",
"self",
".",
"_optimizer",
"=",
"shared_module",
".",
"_optimizer",
"self",
".",
"_kvstore",
"=",
"shared_module",
".",
"_kvstore",
"self",
".",
"_update_on_kvstore",
"=",
"shared_module",
".",
"_update_on_kvstore",
"self",
".",
"_updater",
"=",
"shared_module",
".",
"_updater",
"self",
".",
"optimizer_initialized",
"=",
"True"
] |
Borrows optimizer from a shared module. Used in bucketing, where exactly the same
optimizer (esp. kvstore) is used.
Parameters
----------
shared_module : Module
|
[
"Borrows",
"optimizer",
"from",
"a",
"shared",
"module",
".",
"Used",
"in",
"bucketing",
"where",
"exactly",
"the",
"same",
"optimizer",
"(",
"esp",
".",
"kvstore",
")",
"is",
"used",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L560-L573
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.forward
|
def forward(self, data_batch, is_train=None):
"""Forward computation. It supports data batches with different shapes, such as
different batch sizes or different image sizes.
If reshaping of data batch relates to modification of symbol or module, such as
changing image layout ordering or switching from training to predicting, module
rebinding is required.
See Also
----------
:meth:`BaseModule.forward`.
Parameters
----------
data_batch : DataBatch
Could be anything with similar API implemented.
is_train : bool
Default is ``None``, which means ``is_train`` takes the value of ``self.for_training``.
"""
assert self.binded and self.params_initialized
curr_data_shapes = tuple(i.shape for i in self._data_shapes)
if isinstance(data_batch, list):
assert data_batch is not None, "Encountered empty data batch"
new_data_shapes = []
for i in range(len(data_batch[0].data)):
shape = data_batch[0].data[i].shape
for db in data_batch:
assert shape == db.data[i].shape, \
"All data batches in a list need to have the same shape"
new_batch_size = len(data_batch) * shape[0]
new_data_shapes.append((new_batch_size,) + shape[1:])
new_data_shapes = tuple(new_data_shapes)
else:
new_data_shapes = tuple(i.shape for i in data_batch.data)
if curr_data_shapes != new_data_shapes:
if hasattr(data_batch, "provide_data") and data_batch.provide_data:
new_dshape = data_batch.provide_data
else:
new_dshape = [DataDesc(i.name, shape, i.dtype, i.layout) \
for i, shape in zip(self._data_shapes, new_data_shapes)]
if hasattr(data_batch, "provide_label") and data_batch.provide_label:
new_lshape = data_batch.provide_label
elif hasattr(data_batch, "label") and data_batch.label:
new_lshape = [DataDesc(i.name, j.shape, i.dtype, i.layout) \
for i, j in zip(self._label_shapes, data_batch.label)]
else:
new_lshape = None
self.reshape(new_dshape, new_lshape)
self._exec_group.forward(data_batch, is_train)
|
python
|
def forward(self, data_batch, is_train=None):
"""Forward computation. It supports data batches with different shapes, such as
different batch sizes or different image sizes.
If reshaping of data batch relates to modification of symbol or module, such as
changing image layout ordering or switching from training to predicting, module
rebinding is required.
See Also
----------
:meth:`BaseModule.forward`.
Parameters
----------
data_batch : DataBatch
Could be anything with similar API implemented.
is_train : bool
Default is ``None``, which means ``is_train`` takes the value of ``self.for_training``.
"""
assert self.binded and self.params_initialized
curr_data_shapes = tuple(i.shape for i in self._data_shapes)
if isinstance(data_batch, list):
assert data_batch is not None, "Encountered empty data batch"
new_data_shapes = []
for i in range(len(data_batch[0].data)):
shape = data_batch[0].data[i].shape
for db in data_batch:
assert shape == db.data[i].shape, \
"All data batches in a list need to have the same shape"
new_batch_size = len(data_batch) * shape[0]
new_data_shapes.append((new_batch_size,) + shape[1:])
new_data_shapes = tuple(new_data_shapes)
else:
new_data_shapes = tuple(i.shape for i in data_batch.data)
if curr_data_shapes != new_data_shapes:
if hasattr(data_batch, "provide_data") and data_batch.provide_data:
new_dshape = data_batch.provide_data
else:
new_dshape = [DataDesc(i.name, shape, i.dtype, i.layout) \
for i, shape in zip(self._data_shapes, new_data_shapes)]
if hasattr(data_batch, "provide_label") and data_batch.provide_label:
new_lshape = data_batch.provide_label
elif hasattr(data_batch, "label") and data_batch.label:
new_lshape = [DataDesc(i.name, j.shape, i.dtype, i.layout) \
for i, j in zip(self._label_shapes, data_batch.label)]
else:
new_lshape = None
self.reshape(new_dshape, new_lshape)
self._exec_group.forward(data_batch, is_train)
|
[
"def",
"forward",
"(",
"self",
",",
"data_batch",
",",
"is_train",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"curr_data_shapes",
"=",
"tuple",
"(",
"i",
".",
"shape",
"for",
"i",
"in",
"self",
".",
"_data_shapes",
")",
"if",
"isinstance",
"(",
"data_batch",
",",
"list",
")",
":",
"assert",
"data_batch",
"is",
"not",
"None",
",",
"\"Encountered empty data batch\"",
"new_data_shapes",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"data_batch",
"[",
"0",
"]",
".",
"data",
")",
")",
":",
"shape",
"=",
"data_batch",
"[",
"0",
"]",
".",
"data",
"[",
"i",
"]",
".",
"shape",
"for",
"db",
"in",
"data_batch",
":",
"assert",
"shape",
"==",
"db",
".",
"data",
"[",
"i",
"]",
".",
"shape",
",",
"\"All data batches in a list need to have the same shape\"",
"new_batch_size",
"=",
"len",
"(",
"data_batch",
")",
"*",
"shape",
"[",
"0",
"]",
"new_data_shapes",
".",
"append",
"(",
"(",
"new_batch_size",
",",
")",
"+",
"shape",
"[",
"1",
":",
"]",
")",
"new_data_shapes",
"=",
"tuple",
"(",
"new_data_shapes",
")",
"else",
":",
"new_data_shapes",
"=",
"tuple",
"(",
"i",
".",
"shape",
"for",
"i",
"in",
"data_batch",
".",
"data",
")",
"if",
"curr_data_shapes",
"!=",
"new_data_shapes",
":",
"if",
"hasattr",
"(",
"data_batch",
",",
"\"provide_data\"",
")",
"and",
"data_batch",
".",
"provide_data",
":",
"new_dshape",
"=",
"data_batch",
".",
"provide_data",
"else",
":",
"new_dshape",
"=",
"[",
"DataDesc",
"(",
"i",
".",
"name",
",",
"shape",
",",
"i",
".",
"dtype",
",",
"i",
".",
"layout",
")",
"for",
"i",
",",
"shape",
"in",
"zip",
"(",
"self",
".",
"_data_shapes",
",",
"new_data_shapes",
")",
"]",
"if",
"hasattr",
"(",
"data_batch",
",",
"\"provide_label\"",
")",
"and",
"data_batch",
".",
"provide_label",
":",
"new_lshape",
"=",
"data_batch",
".",
"provide_label",
"elif",
"hasattr",
"(",
"data_batch",
",",
"\"label\"",
")",
"and",
"data_batch",
".",
"label",
":",
"new_lshape",
"=",
"[",
"DataDesc",
"(",
"i",
".",
"name",
",",
"j",
".",
"shape",
",",
"i",
".",
"dtype",
",",
"i",
".",
"layout",
")",
"for",
"i",
",",
"j",
"in",
"zip",
"(",
"self",
".",
"_label_shapes",
",",
"data_batch",
".",
"label",
")",
"]",
"else",
":",
"new_lshape",
"=",
"None",
"self",
".",
"reshape",
"(",
"new_dshape",
",",
"new_lshape",
")",
"self",
".",
"_exec_group",
".",
"forward",
"(",
"data_batch",
",",
"is_train",
")"
] |
Forward computation. It supports data batches with different shapes, such as
different batch sizes or different image sizes.
If reshaping of data batch relates to modification of symbol or module, such as
changing image layout ordering or switching from training to predicting, module
rebinding is required.
See Also
----------
:meth:`BaseModule.forward`.
Parameters
----------
data_batch : DataBatch
Could be anything with similar API implemented.
is_train : bool
Default is ``None``, which means ``is_train`` takes the value of ``self.for_training``.
|
[
"Forward",
"computation",
".",
"It",
"supports",
"data",
"batches",
"with",
"different",
"shapes",
"such",
"as",
"different",
"batch",
"sizes",
"or",
"different",
"image",
"sizes",
".",
"If",
"reshaping",
"of",
"data",
"batch",
"relates",
"to",
"modification",
"of",
"symbol",
"or",
"module",
"such",
"as",
"changing",
"image",
"layout",
"ordering",
"or",
"switching",
"from",
"training",
"to",
"predicting",
"module",
"rebinding",
"is",
"required",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L575-L627
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.backward
|
def backward(self, out_grads=None):
"""Backward computation.
See Also
----------
:meth:`BaseModule.backward`.
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.binded and self.params_initialized
self._exec_group.backward(out_grads=out_grads)
|
python
|
def backward(self, out_grads=None):
"""Backward computation.
See Also
----------
:meth:`BaseModule.backward`.
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.binded and self.params_initialized
self._exec_group.backward(out_grads=out_grads)
|
[
"def",
"backward",
"(",
"self",
",",
"out_grads",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"self",
".",
"_exec_group",
".",
"backward",
"(",
"out_grads",
"=",
"out_grads",
")"
] |
Backward computation.
See Also
----------
:meth:`BaseModule.backward`.
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.
|
[
"Backward",
"computation",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L629-L644
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.update
|
def update(self):
"""Updates parameters according to the installed optimizer and the gradients computed
in the previous forward-backward batch.
When KVStore is used to update parameters for multi-device or multi-machine training,
a copy of the parameters are stored in KVStore. Note that for `row_sparse` parameters,
this function does update the copy of parameters in KVStore, but doesn't broadcast the
updated parameters to all devices / machines. Please call `prepare` to broadcast
`row_sparse` parameters with the next batch of data.
See Also
----------
:meth:`BaseModule.update`.
"""
assert self.binded and self.params_initialized and self.optimizer_initialized
self._params_dirty = True
if self._update_on_kvstore:
_update_params_on_kvstore(self._exec_group.param_arrays,
self._exec_group.grad_arrays,
self._kvstore, self._exec_group.param_names)
else:
_update_params(self._exec_group.param_arrays,
self._exec_group.grad_arrays,
updater=self._updater,
num_device=len(self._context),
kvstore=self._kvstore,
param_names=self._exec_group.param_names)
|
python
|
def update(self):
"""Updates parameters according to the installed optimizer and the gradients computed
in the previous forward-backward batch.
When KVStore is used to update parameters for multi-device or multi-machine training,
a copy of the parameters are stored in KVStore. Note that for `row_sparse` parameters,
this function does update the copy of parameters in KVStore, but doesn't broadcast the
updated parameters to all devices / machines. Please call `prepare` to broadcast
`row_sparse` parameters with the next batch of data.
See Also
----------
:meth:`BaseModule.update`.
"""
assert self.binded and self.params_initialized and self.optimizer_initialized
self._params_dirty = True
if self._update_on_kvstore:
_update_params_on_kvstore(self._exec_group.param_arrays,
self._exec_group.grad_arrays,
self._kvstore, self._exec_group.param_names)
else:
_update_params(self._exec_group.param_arrays,
self._exec_group.grad_arrays,
updater=self._updater,
num_device=len(self._context),
kvstore=self._kvstore,
param_names=self._exec_group.param_names)
|
[
"def",
"update",
"(",
"self",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"and",
"self",
".",
"optimizer_initialized",
"self",
".",
"_params_dirty",
"=",
"True",
"if",
"self",
".",
"_update_on_kvstore",
":",
"_update_params_on_kvstore",
"(",
"self",
".",
"_exec_group",
".",
"param_arrays",
",",
"self",
".",
"_exec_group",
".",
"grad_arrays",
",",
"self",
".",
"_kvstore",
",",
"self",
".",
"_exec_group",
".",
"param_names",
")",
"else",
":",
"_update_params",
"(",
"self",
".",
"_exec_group",
".",
"param_arrays",
",",
"self",
".",
"_exec_group",
".",
"grad_arrays",
",",
"updater",
"=",
"self",
".",
"_updater",
",",
"num_device",
"=",
"len",
"(",
"self",
".",
"_context",
")",
",",
"kvstore",
"=",
"self",
".",
"_kvstore",
",",
"param_names",
"=",
"self",
".",
"_exec_group",
".",
"param_names",
")"
] |
Updates parameters according to the installed optimizer and the gradients computed
in the previous forward-backward batch.
When KVStore is used to update parameters for multi-device or multi-machine training,
a copy of the parameters are stored in KVStore. Note that for `row_sparse` parameters,
this function does update the copy of parameters in KVStore, but doesn't broadcast the
updated parameters to all devices / machines. Please call `prepare` to broadcast
`row_sparse` parameters with the next batch of data.
See Also
----------
:meth:`BaseModule.update`.
|
[
"Updates",
"parameters",
"according",
"to",
"the",
"installed",
"optimizer",
"and",
"the",
"gradients",
"computed",
"in",
"the",
"previous",
"forward",
"-",
"backward",
"batch",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L646-L673
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.get_outputs
|
def get_outputs(self, merge_multi_context=True):
"""Gets outputs of the previous forward computation.
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`. When `merge_multi_context` is `False`, those `NDArray`
might live on different devices.
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.
Returns
-------
list of NDArray or list of list of NDArray
Output.
"""
assert self.binded and self.params_initialized
return self._exec_group.get_outputs(merge_multi_context=merge_multi_context)
|
python
|
def get_outputs(self, merge_multi_context=True):
"""Gets outputs of the previous forward computation.
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`. When `merge_multi_context` is `False`, those `NDArray`
might live on different devices.
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.
Returns
-------
list of NDArray or list of list of NDArray
Output.
"""
assert self.binded and self.params_initialized
return self._exec_group.get_outputs(merge_multi_context=merge_multi_context)
|
[
"def",
"get_outputs",
"(",
"self",
",",
"merge_multi_context",
"=",
"True",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"return",
"self",
".",
"_exec_group",
".",
"get_outputs",
"(",
"merge_multi_context",
"=",
"merge_multi_context",
")"
] |
Gets outputs of the previous forward computation.
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`. When `merge_multi_context` is `False`, those `NDArray`
might live on different devices.
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.
Returns
-------
list of NDArray or list of list of NDArray
Output.
|
[
"Gets",
"outputs",
"of",
"the",
"previous",
"forward",
"computation",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L675-L697
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.get_input_grads
|
def get_input_grads(self, merge_multi_context=True):
"""Gets the gradients with respect to the inputs of the module.
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`.
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.
Returns
-------
list of NDArray or list of list of NDArray
Input gradients
"""
assert self.binded and self.params_initialized and self.inputs_need_grad
return self._exec_group.get_input_grads(merge_multi_context=merge_multi_context)
|
python
|
def get_input_grads(self, merge_multi_context=True):
"""Gets the gradients with respect to the inputs of the module.
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`.
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.
Returns
-------
list of NDArray or list of list of NDArray
Input gradients
"""
assert self.binded and self.params_initialized and self.inputs_need_grad
return self._exec_group.get_input_grads(merge_multi_context=merge_multi_context)
|
[
"def",
"get_input_grads",
"(",
"self",
",",
"merge_multi_context",
"=",
"True",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"and",
"self",
".",
"inputs_need_grad",
"return",
"self",
".",
"_exec_group",
".",
"get_input_grads",
"(",
"merge_multi_context",
"=",
"merge_multi_context",
")"
] |
Gets the gradients with respect to the inputs of the module.
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`.
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.
Returns
-------
list of NDArray or list of list of NDArray
Input gradients
|
[
"Gets",
"the",
"gradients",
"with",
"respect",
"to",
"the",
"inputs",
"of",
"the",
"module",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L699-L720
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.get_states
|
def get_states(self, merge_multi_context=True):
"""Gets states from all devices.
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`.
Parameters
----------
merge_multi_context : bool
Default is ``True``. In the case when data-parallelism is used, the states
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
-------
list of NDArray or list of list of NDArray
States
"""
assert self.binded and self.params_initialized
return self._exec_group.get_states(merge_multi_context=merge_multi_context)
|
python
|
def get_states(self, merge_multi_context=True):
"""Gets states from all devices.
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`.
Parameters
----------
merge_multi_context : bool
Default is ``True``. In the case when data-parallelism is used, the states
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
-------
list of NDArray or list of list of NDArray
States
"""
assert self.binded and self.params_initialized
return self._exec_group.get_states(merge_multi_context=merge_multi_context)
|
[
"def",
"get_states",
"(",
"self",
",",
"merge_multi_context",
"=",
"True",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"return",
"self",
".",
"_exec_group",
".",
"get_states",
"(",
"merge_multi_context",
"=",
"merge_multi_context",
")"
] |
Gets states from all devices.
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`.
Parameters
----------
merge_multi_context : bool
Default is ``True``. In the case when data-parallelism is used, the states
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
-------
list of NDArray or list of list of NDArray
States
|
[
"Gets",
"states",
"from",
"all",
"devices",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L722-L743
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.update_metric
|
def update_metric(self, eval_metric, labels, pre_sliced=False):
"""Evaluates and accumulates evaluation metric on outputs of the last forward computation.
See Also
----------
:meth:`BaseModule.update_metric`.
Parameters
----------
eval_metric : EvalMetric
Evaluation metric to use.
labels : list of NDArray if `pre_sliced` parameter is set to `False`,
list of lists of NDArray otherwise. Typically `data_batch.label`.
pre_sliced: bool
Whether the labels are already sliced per device (default: False).
"""
self._exec_group.update_metric(eval_metric, labels, pre_sliced)
|
python
|
def update_metric(self, eval_metric, labels, pre_sliced=False):
"""Evaluates and accumulates evaluation metric on outputs of the last forward computation.
See Also
----------
:meth:`BaseModule.update_metric`.
Parameters
----------
eval_metric : EvalMetric
Evaluation metric to use.
labels : list of NDArray if `pre_sliced` parameter is set to `False`,
list of lists of NDArray otherwise. Typically `data_batch.label`.
pre_sliced: bool
Whether the labels are already sliced per device (default: False).
"""
self._exec_group.update_metric(eval_metric, labels, pre_sliced)
|
[
"def",
"update_metric",
"(",
"self",
",",
"eval_metric",
",",
"labels",
",",
"pre_sliced",
"=",
"False",
")",
":",
"self",
".",
"_exec_group",
".",
"update_metric",
"(",
"eval_metric",
",",
"labels",
",",
"pre_sliced",
")"
] |
Evaluates and accumulates evaluation metric on outputs of the last forward computation.
See Also
----------
:meth:`BaseModule.update_metric`.
Parameters
----------
eval_metric : EvalMetric
Evaluation metric to use.
labels : list of NDArray if `pre_sliced` parameter is set to `False`,
list of lists of NDArray otherwise. Typically `data_batch.label`.
pre_sliced: bool
Whether the labels are already sliced per device (default: False).
|
[
"Evaluates",
"and",
"accumulates",
"evaluation",
"metric",
"on",
"outputs",
"of",
"the",
"last",
"forward",
"computation",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L759-L775
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module._sync_params_from_devices
|
def _sync_params_from_devices(self):
"""Synchronizes parameters from devices to CPU. This function should be called after
calling `update` that updates the parameters on the devices, before one can read the
latest parameters from ``self._arg_params`` and ``self._aux_params``.
For row_sparse parameters on devices, ther are pulled from KVStore with all row ids.
"""
self._exec_group.get_params(self._arg_params, self._aux_params)
if self._kvstore and self._update_on_kvstore:
for param_name, param_val in sorted(self._arg_params.items()):
if param_val.stype == 'row_sparse':
row_ids = nd.arange(0, param_val.shape[0], dtype='int64')
self._kvstore.row_sparse_pull(param_name, param_val, row_ids=row_ids)
self._params_dirty = False
|
python
|
def _sync_params_from_devices(self):
"""Synchronizes parameters from devices to CPU. This function should be called after
calling `update` that updates the parameters on the devices, before one can read the
latest parameters from ``self._arg_params`` and ``self._aux_params``.
For row_sparse parameters on devices, ther are pulled from KVStore with all row ids.
"""
self._exec_group.get_params(self._arg_params, self._aux_params)
if self._kvstore and self._update_on_kvstore:
for param_name, param_val in sorted(self._arg_params.items()):
if param_val.stype == 'row_sparse':
row_ids = nd.arange(0, param_val.shape[0], dtype='int64')
self._kvstore.row_sparse_pull(param_name, param_val, row_ids=row_ids)
self._params_dirty = False
|
[
"def",
"_sync_params_from_devices",
"(",
"self",
")",
":",
"self",
".",
"_exec_group",
".",
"get_params",
"(",
"self",
".",
"_arg_params",
",",
"self",
".",
"_aux_params",
")",
"if",
"self",
".",
"_kvstore",
"and",
"self",
".",
"_update_on_kvstore",
":",
"for",
"param_name",
",",
"param_val",
"in",
"sorted",
"(",
"self",
".",
"_arg_params",
".",
"items",
"(",
")",
")",
":",
"if",
"param_val",
".",
"stype",
"==",
"'row_sparse'",
":",
"row_ids",
"=",
"nd",
".",
"arange",
"(",
"0",
",",
"param_val",
".",
"shape",
"[",
"0",
"]",
",",
"dtype",
"=",
"'int64'",
")",
"self",
".",
"_kvstore",
".",
"row_sparse_pull",
"(",
"param_name",
",",
"param_val",
",",
"row_ids",
"=",
"row_ids",
")",
"self",
".",
"_params_dirty",
"=",
"False"
] |
Synchronizes parameters from devices to CPU. This function should be called after
calling `update` that updates the parameters on the devices, before one can read the
latest parameters from ``self._arg_params`` and ``self._aux_params``.
For row_sparse parameters on devices, ther are pulled from KVStore with all row ids.
|
[
"Synchronizes",
"parameters",
"from",
"devices",
"to",
"CPU",
".",
"This",
"function",
"should",
"be",
"called",
"after",
"calling",
"update",
"that",
"updates",
"the",
"parameters",
"on",
"the",
"devices",
"before",
"one",
"can",
"read",
"the",
"latest",
"parameters",
"from",
"self",
".",
"_arg_params",
"and",
"self",
".",
"_aux_params",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L777-L791
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.save_optimizer_states
|
def save_optimizer_states(self, fname):
"""Saves optimizer (updater) state to a file.
Parameters
----------
fname : str
Path to output states file.
"""
assert self.optimizer_initialized
if self._update_on_kvstore:
self._kvstore.save_optimizer_states(fname)
else:
with open(fname, 'wb') as fout:
fout.write(self._updater.get_states())
|
python
|
def save_optimizer_states(self, fname):
"""Saves optimizer (updater) state to a file.
Parameters
----------
fname : str
Path to output states file.
"""
assert self.optimizer_initialized
if self._update_on_kvstore:
self._kvstore.save_optimizer_states(fname)
else:
with open(fname, 'wb') as fout:
fout.write(self._updater.get_states())
|
[
"def",
"save_optimizer_states",
"(",
"self",
",",
"fname",
")",
":",
"assert",
"self",
".",
"optimizer_initialized",
"if",
"self",
".",
"_update_on_kvstore",
":",
"self",
".",
"_kvstore",
".",
"save_optimizer_states",
"(",
"fname",
")",
"else",
":",
"with",
"open",
"(",
"fname",
",",
"'wb'",
")",
"as",
"fout",
":",
"fout",
".",
"write",
"(",
"self",
".",
"_updater",
".",
"get_states",
"(",
")",
")"
] |
Saves optimizer (updater) state to a file.
Parameters
----------
fname : str
Path to output states file.
|
[
"Saves",
"optimizer",
"(",
"updater",
")",
"state",
"to",
"a",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L793-L807
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.load_optimizer_states
|
def load_optimizer_states(self, fname):
"""Loads optimizer (updater) state from a file.
Parameters
----------
fname : str
Path to input states file.
"""
assert self.optimizer_initialized
if self._update_on_kvstore:
self._kvstore.load_optimizer_states(fname)
else:
self._updater.set_states(open(fname, 'rb').read())
|
python
|
def load_optimizer_states(self, fname):
"""Loads optimizer (updater) state from a file.
Parameters
----------
fname : str
Path to input states file.
"""
assert self.optimizer_initialized
if self._update_on_kvstore:
self._kvstore.load_optimizer_states(fname)
else:
self._updater.set_states(open(fname, 'rb').read())
|
[
"def",
"load_optimizer_states",
"(",
"self",
",",
"fname",
")",
":",
"assert",
"self",
".",
"optimizer_initialized",
"if",
"self",
".",
"_update_on_kvstore",
":",
"self",
".",
"_kvstore",
".",
"load_optimizer_states",
"(",
"fname",
")",
"else",
":",
"self",
".",
"_updater",
".",
"set_states",
"(",
"open",
"(",
"fname",
",",
"'rb'",
")",
".",
"read",
"(",
")",
")"
] |
Loads optimizer (updater) state from a file.
Parameters
----------
fname : str
Path to input states file.
|
[
"Loads",
"optimizer",
"(",
"updater",
")",
"state",
"from",
"a",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L809-L822
|
train
|
apache/incubator-mxnet
|
python/mxnet/module/module.py
|
Module.prepare
|
def prepare(self, data_batch, sparse_row_id_fn=None):
'''Prepares the module for processing a data batch.
Usually involves switching bucket and reshaping.
For modules that contain `row_sparse` parameters in KVStore,
it prepares the `row_sparse` parameters based on the sparse_row_id_fn.
When KVStore is used to update parameters for multi-device or multi-machine training,
a copy of the parameters are stored in KVStore. Note that for `row_sparse` parameters,
the `update()` updates the copy of parameters in KVStore, but doesn't broadcast
the updated parameters to all devices / machines. The `prepare` function is used to
broadcast `row_sparse` parameters with the next batch of data.
Parameters
----------
data_batch : DataBatch
The current batch of data for forward computation.
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
if sparse_row_id_fn is not None:
if not self._kvstore or not self._update_on_kvstore:
warnings.warn(UserWarning("Parameters are not updated in the KVStore. "
"No need to call sparse_row_id_fn."))
else:
row_ids = sparse_row_id_fn(data_batch)
assert(isinstance(row_ids, dict)), "Expected dict output from sparse_row_id_fn"
for param_name, row_id in row_ids.items():
param_idx = self._exec_group.param_names.index(param_name)
param_val = self._exec_group.param_arrays[param_idx]
assert(isinstance(param_val, (tuple, list)))
if param_val[0].stype != 'row_sparse':
warnings.warn(UserWarning("%s.stype is not 'row_sparse'. No need to "
"perform row_sparse_pull." % param_name))
else:
self._kvstore.row_sparse_pull(param_name, param_val, row_ids=row_id,
priority=-param_idx)
|
python
|
def prepare(self, data_batch, sparse_row_id_fn=None):
'''Prepares the module for processing a data batch.
Usually involves switching bucket and reshaping.
For modules that contain `row_sparse` parameters in KVStore,
it prepares the `row_sparse` parameters based on the sparse_row_id_fn.
When KVStore is used to update parameters for multi-device or multi-machine training,
a copy of the parameters are stored in KVStore. Note that for `row_sparse` parameters,
the `update()` updates the copy of parameters in KVStore, but doesn't broadcast
the updated parameters to all devices / machines. The `prepare` function is used to
broadcast `row_sparse` parameters with the next batch of data.
Parameters
----------
data_batch : DataBatch
The current batch of data for forward computation.
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
if sparse_row_id_fn is not None:
if not self._kvstore or not self._update_on_kvstore:
warnings.warn(UserWarning("Parameters are not updated in the KVStore. "
"No need to call sparse_row_id_fn."))
else:
row_ids = sparse_row_id_fn(data_batch)
assert(isinstance(row_ids, dict)), "Expected dict output from sparse_row_id_fn"
for param_name, row_id in row_ids.items():
param_idx = self._exec_group.param_names.index(param_name)
param_val = self._exec_group.param_arrays[param_idx]
assert(isinstance(param_val, (tuple, list)))
if param_val[0].stype != 'row_sparse':
warnings.warn(UserWarning("%s.stype is not 'row_sparse'. No need to "
"perform row_sparse_pull." % param_name))
else:
self._kvstore.row_sparse_pull(param_name, param_val, row_ids=row_id,
priority=-param_idx)
|
[
"def",
"prepare",
"(",
"self",
",",
"data_batch",
",",
"sparse_row_id_fn",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"if",
"sparse_row_id_fn",
"is",
"not",
"None",
":",
"if",
"not",
"self",
".",
"_kvstore",
"or",
"not",
"self",
".",
"_update_on_kvstore",
":",
"warnings",
".",
"warn",
"(",
"UserWarning",
"(",
"\"Parameters are not updated in the KVStore. \"",
"\"No need to call sparse_row_id_fn.\"",
")",
")",
"else",
":",
"row_ids",
"=",
"sparse_row_id_fn",
"(",
"data_batch",
")",
"assert",
"(",
"isinstance",
"(",
"row_ids",
",",
"dict",
")",
")",
",",
"\"Expected dict output from sparse_row_id_fn\"",
"for",
"param_name",
",",
"row_id",
"in",
"row_ids",
".",
"items",
"(",
")",
":",
"param_idx",
"=",
"self",
".",
"_exec_group",
".",
"param_names",
".",
"index",
"(",
"param_name",
")",
"param_val",
"=",
"self",
".",
"_exec_group",
".",
"param_arrays",
"[",
"param_idx",
"]",
"assert",
"(",
"isinstance",
"(",
"param_val",
",",
"(",
"tuple",
",",
"list",
")",
")",
")",
"if",
"param_val",
"[",
"0",
"]",
".",
"stype",
"!=",
"'row_sparse'",
":",
"warnings",
".",
"warn",
"(",
"UserWarning",
"(",
"\"%s.stype is not 'row_sparse'. No need to \"",
"\"perform row_sparse_pull.\"",
"%",
"param_name",
")",
")",
"else",
":",
"self",
".",
"_kvstore",
".",
"row_sparse_pull",
"(",
"param_name",
",",
"param_val",
",",
"row_ids",
"=",
"row_id",
",",
"priority",
"=",
"-",
"param_idx",
")"
] |
Prepares the module for processing a data batch.
Usually involves switching bucket and reshaping.
For modules that contain `row_sparse` parameters in KVStore,
it prepares the `row_sparse` parameters based on the sparse_row_id_fn.
When KVStore is used to update parameters for multi-device or multi-machine training,
a copy of the parameters are stored in KVStore. Note that for `row_sparse` parameters,
the `update()` updates the copy of parameters in KVStore, but doesn't broadcast
the updated parameters to all devices / machines. The `prepare` function is used to
broadcast `row_sparse` parameters with the next batch of data.
Parameters
----------
data_batch : DataBatch
The current batch of data for forward computation.
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.
|
[
"Prepares",
"the",
"module",
"for",
"processing",
"a",
"data",
"batch",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/module/module.py#L829-L870
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
_random_helper
|
def _random_helper(random, sampler, params, shape, dtype, ctx, out, kwargs):
"""Helper function for random generators."""
if isinstance(params[0], NDArray):
for i in params[1:]:
assert isinstance(i, NDArray), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return sampler(*params, shape=shape, dtype=dtype, out=out, **kwargs)
elif isinstance(params[0], numeric_types):
if ctx is None:
ctx = current_context()
if shape is _Null and out is None:
shape = 1
for i in params[1:]:
assert isinstance(i, numeric_types), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return random(*params, shape=shape, dtype=dtype, ctx=ctx, out=out, **kwargs)
raise ValueError("Distribution parameters must be either NDArray or numbers, "
"but got %s."%type(params[0]))
|
python
|
def _random_helper(random, sampler, params, shape, dtype, ctx, out, kwargs):
"""Helper function for random generators."""
if isinstance(params[0], NDArray):
for i in params[1:]:
assert isinstance(i, NDArray), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return sampler(*params, shape=shape, dtype=dtype, out=out, **kwargs)
elif isinstance(params[0], numeric_types):
if ctx is None:
ctx = current_context()
if shape is _Null and out is None:
shape = 1
for i in params[1:]:
assert isinstance(i, numeric_types), \
"Distribution parameters must all have the same type, but got " \
"both %s and %s."%(type(params[0]), type(i))
return random(*params, shape=shape, dtype=dtype, ctx=ctx, out=out, **kwargs)
raise ValueError("Distribution parameters must be either NDArray or numbers, "
"but got %s."%type(params[0]))
|
[
"def",
"_random_helper",
"(",
"random",
",",
"sampler",
",",
"params",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"params",
"[",
"0",
"]",
",",
"NDArray",
")",
":",
"for",
"i",
"in",
"params",
"[",
"1",
":",
"]",
":",
"assert",
"isinstance",
"(",
"i",
",",
"NDArray",
")",
",",
"\"Distribution parameters must all have the same type, but got \"",
"\"both %s and %s.\"",
"%",
"(",
"type",
"(",
"params",
"[",
"0",
"]",
")",
",",
"type",
"(",
"i",
")",
")",
"return",
"sampler",
"(",
"*",
"params",
",",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
",",
"out",
"=",
"out",
",",
"*",
"*",
"kwargs",
")",
"elif",
"isinstance",
"(",
"params",
"[",
"0",
"]",
",",
"numeric_types",
")",
":",
"if",
"ctx",
"is",
"None",
":",
"ctx",
"=",
"current_context",
"(",
")",
"if",
"shape",
"is",
"_Null",
"and",
"out",
"is",
"None",
":",
"shape",
"=",
"1",
"for",
"i",
"in",
"params",
"[",
"1",
":",
"]",
":",
"assert",
"isinstance",
"(",
"i",
",",
"numeric_types",
")",
",",
"\"Distribution parameters must all have the same type, but got \"",
"\"both %s and %s.\"",
"%",
"(",
"type",
"(",
"params",
"[",
"0",
"]",
")",
",",
"type",
"(",
"i",
")",
")",
"return",
"random",
"(",
"*",
"params",
",",
"shape",
"=",
"shape",
",",
"dtype",
"=",
"dtype",
",",
"ctx",
"=",
"ctx",
",",
"out",
"=",
"out",
",",
"*",
"*",
"kwargs",
")",
"raise",
"ValueError",
"(",
"\"Distribution parameters must be either NDArray or numbers, \"",
"\"but got %s.\"",
"%",
"type",
"(",
"params",
"[",
"0",
"]",
")",
")"
] |
Helper function for random generators.
|
[
"Helper",
"function",
"for",
"random",
"generators",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L31-L51
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
uniform
|
def uniform(low=0, high=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a uniform distribution.
Samples are uniformly distributed over the half-open interval *[low, high)*
(includes *low*, but excludes *high*).
Parameters
----------
low : float or NDArray, optional
Lower boundary of the output interval. All values generated will be
greater than or equal to low. The default value is 0.
high : float or NDArray, optional
Upper boundary of the output interval. All values generated will be
less than high. The default value is 1.0.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `low` and
`high` are scalars, output shape will be `(m, n)`. If `low` and `high`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[low, high)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`low.context` when `low` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g.,
`(m, n)` and `low` and `high` are scalars, output shape will be `(m, n)`.
If `low` and `high` are NDArrays with shape, e.g., `(x, y)`, then the
return NDArray will have shape `(x, y, m, n)`, where `m*n` uniformly distributed
samples are drawn for each `[low, high)` pair.
Examples
--------
>>> mx.nd.random.uniform(0, 1)
[ 0.54881352]
<NDArray 1 @cpu(0)
>>> mx.nd.random.uniform(0, 1, ctx=mx.gpu(0))
[ 0.92514056]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.uniform(-1, 1, shape=(2,))
[ 0.71589124 0.08976638]
<NDArray 2 @cpu(0)>
>>> low = mx.nd.array([1,2,3])
>>> high = mx.nd.array([2,3,4])
>>> mx.nd.random.uniform(low, high, shape=2)
[[ 1.78653979 1.93707538]
[ 2.01311183 2.37081361]
[ 3.30491424 3.69977832]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_uniform, _internal._sample_uniform,
[low, high], shape, dtype, ctx, out, kwargs)
|
python
|
def uniform(low=0, high=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a uniform distribution.
Samples are uniformly distributed over the half-open interval *[low, high)*
(includes *low*, but excludes *high*).
Parameters
----------
low : float or NDArray, optional
Lower boundary of the output interval. All values generated will be
greater than or equal to low. The default value is 0.
high : float or NDArray, optional
Upper boundary of the output interval. All values generated will be
less than high. The default value is 1.0.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `low` and
`high` are scalars, output shape will be `(m, n)`. If `low` and `high`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[low, high)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`low.context` when `low` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g.,
`(m, n)` and `low` and `high` are scalars, output shape will be `(m, n)`.
If `low` and `high` are NDArrays with shape, e.g., `(x, y)`, then the
return NDArray will have shape `(x, y, m, n)`, where `m*n` uniformly distributed
samples are drawn for each `[low, high)` pair.
Examples
--------
>>> mx.nd.random.uniform(0, 1)
[ 0.54881352]
<NDArray 1 @cpu(0)
>>> mx.nd.random.uniform(0, 1, ctx=mx.gpu(0))
[ 0.92514056]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.uniform(-1, 1, shape=(2,))
[ 0.71589124 0.08976638]
<NDArray 2 @cpu(0)>
>>> low = mx.nd.array([1,2,3])
>>> high = mx.nd.array([2,3,4])
>>> mx.nd.random.uniform(low, high, shape=2)
[[ 1.78653979 1.93707538]
[ 2.01311183 2.37081361]
[ 3.30491424 3.69977832]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_uniform, _internal._sample_uniform,
[low, high], shape, dtype, ctx, out, kwargs)
|
[
"def",
"uniform",
"(",
"low",
"=",
"0",
",",
"high",
"=",
"1",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"ctx",
"=",
"None",
",",
"out",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_uniform",
",",
"_internal",
".",
"_sample_uniform",
",",
"[",
"low",
",",
"high",
"]",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")"
] |
Draw random samples from a uniform distribution.
Samples are uniformly distributed over the half-open interval *[low, high)*
(includes *low*, but excludes *high*).
Parameters
----------
low : float or NDArray, optional
Lower boundary of the output interval. All values generated will be
greater than or equal to low. The default value is 0.
high : float or NDArray, optional
Upper boundary of the output interval. All values generated will be
less than high. The default value is 1.0.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `low` and
`high` are scalars, output shape will be `(m, n)`. If `low` and `high`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[low, high)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`low.context` when `low` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g.,
`(m, n)` and `low` and `high` are scalars, output shape will be `(m, n)`.
If `low` and `high` are NDArrays with shape, e.g., `(x, y)`, then the
return NDArray will have shape `(x, y, m, n)`, where `m*n` uniformly distributed
samples are drawn for each `[low, high)` pair.
Examples
--------
>>> mx.nd.random.uniform(0, 1)
[ 0.54881352]
<NDArray 1 @cpu(0)
>>> mx.nd.random.uniform(0, 1, ctx=mx.gpu(0))
[ 0.92514056]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.uniform(-1, 1, shape=(2,))
[ 0.71589124 0.08976638]
<NDArray 2 @cpu(0)>
>>> low = mx.nd.array([1,2,3])
>>> high = mx.nd.array([2,3,4])
>>> mx.nd.random.uniform(low, high, shape=2)
[[ 1.78653979 1.93707538]
[ 2.01311183 2.37081361]
[ 3.30491424 3.69977832]]
<NDArray 3x2 @cpu(0)>
|
[
"Draw",
"random",
"samples",
"from",
"a",
"uniform",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L54-L110
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
normal
|
def normal(loc=0, scale=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a normal (Gaussian) distribution.
Samples are distributed according to a normal distribution parametrized
by *loc* (mean) and *scale* (standard deviation).
Parameters
----------
loc : float or NDArray, optional
Mean (centre) of the distribution.
scale : float or NDArray, optional
Standard deviation (spread or width) of the distribution.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `loc` and
`scale` are scalars, output shape will be `(m, n)`. If `loc` and `scale`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`loc.context` when `loc` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g., `(m, n)` and
`loc` and `scale` are scalars, output shape will be `(m, n)`. If `loc` and
`scale` are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
Examples
--------
>>> mx.nd.random.normal(0, 1)
[ 2.21220636]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.normal(0, 1, ctx=mx.gpu(0))
[ 0.29253659]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.normal(-1, 1, shape=(2,))
[-0.2259962 -0.51619542]
<NDArray 2 @cpu(0)>
>>> loc = mx.nd.array([1,2,3])
>>> scale = mx.nd.array([2,3,4])
>>> mx.nd.random.normal(loc, scale, shape=2)
[[ 0.55912292 3.19566321]
[ 1.91728961 2.47706747]
[ 2.79666662 5.44254589]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_normal, _internal._sample_normal,
[loc, scale], shape, dtype, ctx, out, kwargs)
|
python
|
def normal(loc=0, scale=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a normal (Gaussian) distribution.
Samples are distributed according to a normal distribution parametrized
by *loc* (mean) and *scale* (standard deviation).
Parameters
----------
loc : float or NDArray, optional
Mean (centre) of the distribution.
scale : float or NDArray, optional
Standard deviation (spread or width) of the distribution.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `loc` and
`scale` are scalars, output shape will be `(m, n)`. If `loc` and `scale`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`loc.context` when `loc` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g., `(m, n)` and
`loc` and `scale` are scalars, output shape will be `(m, n)`. If `loc` and
`scale` are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
Examples
--------
>>> mx.nd.random.normal(0, 1)
[ 2.21220636]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.normal(0, 1, ctx=mx.gpu(0))
[ 0.29253659]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.normal(-1, 1, shape=(2,))
[-0.2259962 -0.51619542]
<NDArray 2 @cpu(0)>
>>> loc = mx.nd.array([1,2,3])
>>> scale = mx.nd.array([2,3,4])
>>> mx.nd.random.normal(loc, scale, shape=2)
[[ 0.55912292 3.19566321]
[ 1.91728961 2.47706747]
[ 2.79666662 5.44254589]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_normal, _internal._sample_normal,
[loc, scale], shape, dtype, ctx, out, kwargs)
|
[
"def",
"normal",
"(",
"loc",
"=",
"0",
",",
"scale",
"=",
"1",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"ctx",
"=",
"None",
",",
"out",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_normal",
",",
"_internal",
".",
"_sample_normal",
",",
"[",
"loc",
",",
"scale",
"]",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")"
] |
Draw random samples from a normal (Gaussian) distribution.
Samples are distributed according to a normal distribution parametrized
by *loc* (mean) and *scale* (standard deviation).
Parameters
----------
loc : float or NDArray, optional
Mean (centre) of the distribution.
scale : float or NDArray, optional
Standard deviation (spread or width) of the distribution.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `loc` and
`scale` are scalars, output shape will be `(m, n)`. If `loc` and `scale`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`loc.context` when `loc` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g., `(m, n)` and
`loc` and `scale` are scalars, output shape will be `(m, n)`. If `loc` and
`scale` are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
Examples
--------
>>> mx.nd.random.normal(0, 1)
[ 2.21220636]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.normal(0, 1, ctx=mx.gpu(0))
[ 0.29253659]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.normal(-1, 1, shape=(2,))
[-0.2259962 -0.51619542]
<NDArray 2 @cpu(0)>
>>> loc = mx.nd.array([1,2,3])
>>> scale = mx.nd.array([2,3,4])
>>> mx.nd.random.normal(loc, scale, shape=2)
[[ 0.55912292 3.19566321]
[ 1.91728961 2.47706747]
[ 2.79666662 5.44254589]]
<NDArray 3x2 @cpu(0)>
|
[
"Draw",
"random",
"samples",
"from",
"a",
"normal",
"(",
"Gaussian",
")",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L113-L167
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
randn
|
def randn(*shape, **kwargs):
"""Draw random samples from a normal (Gaussian) distribution.
Samples are distributed according to a normal distribution parametrized
by *loc* (mean) and *scale* (standard deviation).
Parameters
----------
loc : float or NDArray
Mean (centre) of the distribution.
scale : float or NDArray
Standard deviation (spread or width) of the distribution.
shape : int or tuple of ints
The number of samples to draw. If shape is, e.g., `(m, n)` and `loc` and
`scale` are scalars, output shape will be `(m, n)`. If `loc` and `scale`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
dtype : {'float16', 'float32', 'float64'}
Data type of output samples. Default is 'float32'
ctx : Context
Device context of output. Default is current context. Overridden by
`loc.context` when `loc` is an NDArray.
out : NDArray
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `loc` and `scale` are scalars, output
shape will be `(m, n)`. If `loc` and `scale` are NDArrays with shape, e.g., `(x, y)`,
then output will have shape `(x, y, m, n)`, where `m*n` samples are drawn for
each `[loc, scale)` pair.
Examples
--------
>>> mx.nd.random.randn()
2.21220636
<NDArray 1 @cpu(0)>
>>> mx.nd.random.randn(2, 2)
[[-1.856082 -1.9768796 ]
[-0.20801921 0.2444218 ]]
<NDArray 2x2 @cpu(0)>
>>> mx.nd.random.randn(2, 3, loc=5, scale=1)
[[4.19962 4.8311777 5.936328 ]
[5.357444 5.7793283 3.9896927]]
<NDArray 2x3 @cpu(0)>
"""
loc = kwargs.pop('loc', 0)
scale = kwargs.pop('scale', 1)
dtype = kwargs.pop('dtype', _Null)
ctx = kwargs.pop('ctx', None)
out = kwargs.pop('out', None)
assert isinstance(loc, (int, float))
assert isinstance(scale, (int, float))
return _random_helper(_internal._random_normal, _internal._sample_normal,
[loc, scale], shape, dtype, ctx, out, kwargs)
|
python
|
def randn(*shape, **kwargs):
"""Draw random samples from a normal (Gaussian) distribution.
Samples are distributed according to a normal distribution parametrized
by *loc* (mean) and *scale* (standard deviation).
Parameters
----------
loc : float or NDArray
Mean (centre) of the distribution.
scale : float or NDArray
Standard deviation (spread or width) of the distribution.
shape : int or tuple of ints
The number of samples to draw. If shape is, e.g., `(m, n)` and `loc` and
`scale` are scalars, output shape will be `(m, n)`. If `loc` and `scale`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
dtype : {'float16', 'float32', 'float64'}
Data type of output samples. Default is 'float32'
ctx : Context
Device context of output. Default is current context. Overridden by
`loc.context` when `loc` is an NDArray.
out : NDArray
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `loc` and `scale` are scalars, output
shape will be `(m, n)`. If `loc` and `scale` are NDArrays with shape, e.g., `(x, y)`,
then output will have shape `(x, y, m, n)`, where `m*n` samples are drawn for
each `[loc, scale)` pair.
Examples
--------
>>> mx.nd.random.randn()
2.21220636
<NDArray 1 @cpu(0)>
>>> mx.nd.random.randn(2, 2)
[[-1.856082 -1.9768796 ]
[-0.20801921 0.2444218 ]]
<NDArray 2x2 @cpu(0)>
>>> mx.nd.random.randn(2, 3, loc=5, scale=1)
[[4.19962 4.8311777 5.936328 ]
[5.357444 5.7793283 3.9896927]]
<NDArray 2x3 @cpu(0)>
"""
loc = kwargs.pop('loc', 0)
scale = kwargs.pop('scale', 1)
dtype = kwargs.pop('dtype', _Null)
ctx = kwargs.pop('ctx', None)
out = kwargs.pop('out', None)
assert isinstance(loc, (int, float))
assert isinstance(scale, (int, float))
return _random_helper(_internal._random_normal, _internal._sample_normal,
[loc, scale], shape, dtype, ctx, out, kwargs)
|
[
"def",
"randn",
"(",
"*",
"shape",
",",
"*",
"*",
"kwargs",
")",
":",
"loc",
"=",
"kwargs",
".",
"pop",
"(",
"'loc'",
",",
"0",
")",
"scale",
"=",
"kwargs",
".",
"pop",
"(",
"'scale'",
",",
"1",
")",
"dtype",
"=",
"kwargs",
".",
"pop",
"(",
"'dtype'",
",",
"_Null",
")",
"ctx",
"=",
"kwargs",
".",
"pop",
"(",
"'ctx'",
",",
"None",
")",
"out",
"=",
"kwargs",
".",
"pop",
"(",
"'out'",
",",
"None",
")",
"assert",
"isinstance",
"(",
"loc",
",",
"(",
"int",
",",
"float",
")",
")",
"assert",
"isinstance",
"(",
"scale",
",",
"(",
"int",
",",
"float",
")",
")",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_normal",
",",
"_internal",
".",
"_sample_normal",
",",
"[",
"loc",
",",
"scale",
"]",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")"
] |
Draw random samples from a normal (Gaussian) distribution.
Samples are distributed according to a normal distribution parametrized
by *loc* (mean) and *scale* (standard deviation).
Parameters
----------
loc : float or NDArray
Mean (centre) of the distribution.
scale : float or NDArray
Standard deviation (spread or width) of the distribution.
shape : int or tuple of ints
The number of samples to draw. If shape is, e.g., `(m, n)` and `loc` and
`scale` are scalars, output shape will be `(m, n)`. If `loc` and `scale`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[loc, scale)` pair.
dtype : {'float16', 'float32', 'float64'}
Data type of output samples. Default is 'float32'
ctx : Context
Device context of output. Default is current context. Overridden by
`loc.context` when `loc` is an NDArray.
out : NDArray
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `loc` and `scale` are scalars, output
shape will be `(m, n)`. If `loc` and `scale` are NDArrays with shape, e.g., `(x, y)`,
then output will have shape `(x, y, m, n)`, where `m*n` samples are drawn for
each `[loc, scale)` pair.
Examples
--------
>>> mx.nd.random.randn()
2.21220636
<NDArray 1 @cpu(0)>
>>> mx.nd.random.randn(2, 2)
[[-1.856082 -1.9768796 ]
[-0.20801921 0.2444218 ]]
<NDArray 2x2 @cpu(0)>
>>> mx.nd.random.randn(2, 3, loc=5, scale=1)
[[4.19962 4.8311777 5.936328 ]
[5.357444 5.7793283 3.9896927]]
<NDArray 2x3 @cpu(0)>
|
[
"Draw",
"random",
"samples",
"from",
"a",
"normal",
"(",
"Gaussian",
")",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L170-L226
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
exponential
|
def exponential(scale=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
r"""Draw samples from an exponential distribution.
Its probability density function is
.. math:: f(x; \frac{1}{\beta}) = \frac{1}{\beta} \exp(-\frac{x}{\beta}),
for x > 0 and 0 elsewhere. \beta is the scale parameter, which is the
inverse of the rate parameter \lambda = 1/\beta.
Parameters
----------
scale : float or NDArray, optional
The scale parameter, \beta = 1/\lambda.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `scale` is
a scalar, output shape will be `(m, n)`. If `scale`
is an NDArray with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `scale`.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`scale.context` when `scale` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `scale` is a scalar, output shape will
be `(m, n)`. If `scale` is an NDArray with shape, e.g., `(x, y)`, then `output`
will have shape `(x, y, m, n)`, where `m*n` samples are drawn for each entry in scale.
Examples
--------
>>> mx.nd.random.exponential(1)
[ 0.79587454]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.exponential(1, shape=(2,))
[ 0.89856035 1.25593066]
<NDArray 2 @cpu(0)>
>>> scale = mx.nd.array([1,2,3])
>>> mx.nd.random.exponential(scale, shape=2)
[[ 0.41063145 0.42140478]
[ 2.59407091 10.12439728]
[ 2.42544937 1.14260709]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_exponential, _internal._sample_exponential,
[1.0/scale], shape, dtype, ctx, out, kwargs)
|
python
|
def exponential(scale=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
r"""Draw samples from an exponential distribution.
Its probability density function is
.. math:: f(x; \frac{1}{\beta}) = \frac{1}{\beta} \exp(-\frac{x}{\beta}),
for x > 0 and 0 elsewhere. \beta is the scale parameter, which is the
inverse of the rate parameter \lambda = 1/\beta.
Parameters
----------
scale : float or NDArray, optional
The scale parameter, \beta = 1/\lambda.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `scale` is
a scalar, output shape will be `(m, n)`. If `scale`
is an NDArray with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `scale`.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`scale.context` when `scale` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `scale` is a scalar, output shape will
be `(m, n)`. If `scale` is an NDArray with shape, e.g., `(x, y)`, then `output`
will have shape `(x, y, m, n)`, where `m*n` samples are drawn for each entry in scale.
Examples
--------
>>> mx.nd.random.exponential(1)
[ 0.79587454]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.exponential(1, shape=(2,))
[ 0.89856035 1.25593066]
<NDArray 2 @cpu(0)>
>>> scale = mx.nd.array([1,2,3])
>>> mx.nd.random.exponential(scale, shape=2)
[[ 0.41063145 0.42140478]
[ 2.59407091 10.12439728]
[ 2.42544937 1.14260709]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_exponential, _internal._sample_exponential,
[1.0/scale], shape, dtype, ctx, out, kwargs)
|
[
"def",
"exponential",
"(",
"scale",
"=",
"1",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"ctx",
"=",
"None",
",",
"out",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_exponential",
",",
"_internal",
".",
"_sample_exponential",
",",
"[",
"1.0",
"/",
"scale",
"]",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")"
] |
r"""Draw samples from an exponential distribution.
Its probability density function is
.. math:: f(x; \frac{1}{\beta}) = \frac{1}{\beta} \exp(-\frac{x}{\beta}),
for x > 0 and 0 elsewhere. \beta is the scale parameter, which is the
inverse of the rate parameter \lambda = 1/\beta.
Parameters
----------
scale : float or NDArray, optional
The scale parameter, \beta = 1/\lambda.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `scale` is
a scalar, output shape will be `(m, n)`. If `scale`
is an NDArray with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each entry in `scale`.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`scale.context` when `scale` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `scale` is a scalar, output shape will
be `(m, n)`. If `scale` is an NDArray with shape, e.g., `(x, y)`, then `output`
will have shape `(x, y, m, n)`, where `m*n` samples are drawn for each entry in scale.
Examples
--------
>>> mx.nd.random.exponential(1)
[ 0.79587454]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.exponential(1, shape=(2,))
[ 0.89856035 1.25593066]
<NDArray 2 @cpu(0)>
>>> scale = mx.nd.array([1,2,3])
>>> mx.nd.random.exponential(scale, shape=2)
[[ 0.41063145 0.42140478]
[ 2.59407091 10.12439728]
[ 2.42544937 1.14260709]]
<NDArray 3x2 @cpu(0)>
|
[
"r",
"Draw",
"samples",
"from",
"an",
"exponential",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L279-L329
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
gamma
|
def gamma(alpha=1, beta=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a gamma distribution.
Samples are distributed according to a gamma distribution parametrized
by *alpha* (shape) and *beta* (scale).
Parameters
----------
alpha : float or NDArray, optional
The shape of the gamma distribution. Should be greater than zero.
beta : float or NDArray, optional
The scale of the gamma distribution. Should be greater than zero.
Default is equal to 1.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `alpha` and
`beta` are scalars, output shape will be `(m, n)`. If `alpha` and `beta`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[alpha, beta)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`alpha.context` when `alpha` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `alpha` and `beta` are scalars, output
shape will be `(m, n)`. If `alpha` and `beta` are NDArrays with shape, e.g.,
`(x, y)`, then output will have shape `(x, y, m, n)`, where `m*n` samples are
drawn for each `[alpha, beta)` pair.
Examples
--------
>>> mx.nd.random.gamma(1, 1)
[ 1.93308783]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.gamma(1, 1, shape=(2,))
[ 0.48216391 2.09890771]
<NDArray 2 @cpu(0)>
>>> alpha = mx.nd.array([1,2,3])
>>> beta = mx.nd.array([2,3,4])
>>> mx.nd.random.gamma(alpha, beta, shape=2)
[[ 3.24343276 0.94137681]
[ 3.52734375 0.45568955]
[ 14.26264095 14.0170126 ]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_gamma, _internal._sample_gamma,
[alpha, beta], shape, dtype, ctx, out, kwargs)
|
python
|
def gamma(alpha=1, beta=1, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a gamma distribution.
Samples are distributed according to a gamma distribution parametrized
by *alpha* (shape) and *beta* (scale).
Parameters
----------
alpha : float or NDArray, optional
The shape of the gamma distribution. Should be greater than zero.
beta : float or NDArray, optional
The scale of the gamma distribution. Should be greater than zero.
Default is equal to 1.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `alpha` and
`beta` are scalars, output shape will be `(m, n)`. If `alpha` and `beta`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[alpha, beta)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`alpha.context` when `alpha` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `alpha` and `beta` are scalars, output
shape will be `(m, n)`. If `alpha` and `beta` are NDArrays with shape, e.g.,
`(x, y)`, then output will have shape `(x, y, m, n)`, where `m*n` samples are
drawn for each `[alpha, beta)` pair.
Examples
--------
>>> mx.nd.random.gamma(1, 1)
[ 1.93308783]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.gamma(1, 1, shape=(2,))
[ 0.48216391 2.09890771]
<NDArray 2 @cpu(0)>
>>> alpha = mx.nd.array([1,2,3])
>>> beta = mx.nd.array([2,3,4])
>>> mx.nd.random.gamma(alpha, beta, shape=2)
[[ 3.24343276 0.94137681]
[ 3.52734375 0.45568955]
[ 14.26264095 14.0170126 ]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_gamma, _internal._sample_gamma,
[alpha, beta], shape, dtype, ctx, out, kwargs)
|
[
"def",
"gamma",
"(",
"alpha",
"=",
"1",
",",
"beta",
"=",
"1",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"ctx",
"=",
"None",
",",
"out",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_gamma",
",",
"_internal",
".",
"_sample_gamma",
",",
"[",
"alpha",
",",
"beta",
"]",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")"
] |
Draw random samples from a gamma distribution.
Samples are distributed according to a gamma distribution parametrized
by *alpha* (shape) and *beta* (scale).
Parameters
----------
alpha : float or NDArray, optional
The shape of the gamma distribution. Should be greater than zero.
beta : float or NDArray, optional
The scale of the gamma distribution. Should be greater than zero.
Default is equal to 1.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `alpha` and
`beta` are scalars, output shape will be `(m, n)`. If `alpha` and `beta`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[alpha, beta)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`alpha.context` when `alpha` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `alpha` and `beta` are scalars, output
shape will be `(m, n)`. If `alpha` and `beta` are NDArrays with shape, e.g.,
`(x, y)`, then output will have shape `(x, y, m, n)`, where `m*n` samples are
drawn for each `[alpha, beta)` pair.
Examples
--------
>>> mx.nd.random.gamma(1, 1)
[ 1.93308783]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.gamma(1, 1, shape=(2,))
[ 0.48216391 2.09890771]
<NDArray 2 @cpu(0)>
>>> alpha = mx.nd.array([1,2,3])
>>> beta = mx.nd.array([2,3,4])
>>> mx.nd.random.gamma(alpha, beta, shape=2)
[[ 3.24343276 0.94137681]
[ 3.52734375 0.45568955]
[ 14.26264095 14.0170126 ]]
<NDArray 3x2 @cpu(0)>
|
[
"Draw",
"random",
"samples",
"from",
"a",
"gamma",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L332-L383
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
negative_binomial
|
def negative_binomial(k=1, p=1, shape=_Null, dtype=_Null, ctx=None,
out=None, **kwargs):
"""Draw random samples from a negative binomial distribution.
Samples are distributed according to a negative binomial distribution
parametrized by *k* (limit of unsuccessful experiments) and *p* (failure
probability in each experiment). Samples will always be returned as a
floating point data type.
Parameters
----------
k : float or NDArray, optional
Limit of unsuccessful experiments, > 0.
p : float or NDArray, optional
Failure probability in each experiment, >= 0 and <=1.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `k` and
`p` are scalars, output shape will be `(m, n)`. If `k` and `p`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[k, p)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`k.context` when `k` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `k` and `p` are scalars, output shape
will be `(m, n)`. If `k` and `p` are NDArrays with shape, e.g., `(x, y)`, then
output will have shape `(x, y, m, n)`, where `m*n` samples are drawn for each `[k, p)` pair.
Examples
--------
>>> mx.nd.random.negative_binomial(10, 0.5)
[ 4.]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.negative_binomial(10, 0.5, shape=(2,))
[ 3. 4.]
<NDArray 2 @cpu(0)>
>>> k = mx.nd.array([1,2,3])
>>> p = mx.nd.array([0.2,0.4,0.6])
>>> mx.nd.random.negative_binomial(k, p, shape=2)
[[ 3. 2.]
[ 4. 4.]
[ 0. 5.]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_negative_binomial,
_internal._sample_negative_binomial,
[k, p], shape, dtype, ctx, out, kwargs)
|
python
|
def negative_binomial(k=1, p=1, shape=_Null, dtype=_Null, ctx=None,
out=None, **kwargs):
"""Draw random samples from a negative binomial distribution.
Samples are distributed according to a negative binomial distribution
parametrized by *k* (limit of unsuccessful experiments) and *p* (failure
probability in each experiment). Samples will always be returned as a
floating point data type.
Parameters
----------
k : float or NDArray, optional
Limit of unsuccessful experiments, > 0.
p : float or NDArray, optional
Failure probability in each experiment, >= 0 and <=1.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `k` and
`p` are scalars, output shape will be `(m, n)`. If `k` and `p`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[k, p)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`k.context` when `k` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `k` and `p` are scalars, output shape
will be `(m, n)`. If `k` and `p` are NDArrays with shape, e.g., `(x, y)`, then
output will have shape `(x, y, m, n)`, where `m*n` samples are drawn for each `[k, p)` pair.
Examples
--------
>>> mx.nd.random.negative_binomial(10, 0.5)
[ 4.]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.negative_binomial(10, 0.5, shape=(2,))
[ 3. 4.]
<NDArray 2 @cpu(0)>
>>> k = mx.nd.array([1,2,3])
>>> p = mx.nd.array([0.2,0.4,0.6])
>>> mx.nd.random.negative_binomial(k, p, shape=2)
[[ 3. 2.]
[ 4. 4.]
[ 0. 5.]]
<NDArray 3x2 @cpu(0)>
"""
return _random_helper(_internal._random_negative_binomial,
_internal._sample_negative_binomial,
[k, p], shape, dtype, ctx, out, kwargs)
|
[
"def",
"negative_binomial",
"(",
"k",
"=",
"1",
",",
"p",
"=",
"1",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"ctx",
"=",
"None",
",",
"out",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_negative_binomial",
",",
"_internal",
".",
"_sample_negative_binomial",
",",
"[",
"k",
",",
"p",
"]",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")"
] |
Draw random samples from a negative binomial distribution.
Samples are distributed according to a negative binomial distribution
parametrized by *k* (limit of unsuccessful experiments) and *p* (failure
probability in each experiment). Samples will always be returned as a
floating point data type.
Parameters
----------
k : float or NDArray, optional
Limit of unsuccessful experiments, > 0.
p : float or NDArray, optional
Failure probability in each experiment, >= 0 and <=1.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `k` and
`p` are scalars, output shape will be `(m, n)`. If `k` and `p`
are NDArrays with shape, e.g., `(x, y)`, then output will have shape
`(x, y, m, n)`, where `m*n` samples are drawn for each `[k, p)` pair.
dtype : {'float16', 'float32', 'float64'}, optional
Data type of output samples. Default is 'float32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`k.context` when `k` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
If input `shape` has shape, e.g., `(m, n)` and `k` and `p` are scalars, output shape
will be `(m, n)`. If `k` and `p` are NDArrays with shape, e.g., `(x, y)`, then
output will have shape `(x, y, m, n)`, where `m*n` samples are drawn for each `[k, p)` pair.
Examples
--------
>>> mx.nd.random.negative_binomial(10, 0.5)
[ 4.]
<NDArray 1 @cpu(0)>
>>> mx.nd.random.negative_binomial(10, 0.5, shape=(2,))
[ 3. 4.]
<NDArray 2 @cpu(0)>
>>> k = mx.nd.array([1,2,3])
>>> p = mx.nd.array([0.2,0.4,0.6])
>>> mx.nd.random.negative_binomial(k, p, shape=2)
[[ 3. 2.]
[ 4. 4.]
[ 0. 5.]]
<NDArray 3x2 @cpu(0)>
|
[
"Draw",
"random",
"samples",
"from",
"a",
"negative",
"binomial",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L386-L439
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
multinomial
|
def multinomial(data, shape=_Null, get_prob=False, out=None, dtype='int32', **kwargs):
"""Concurrent sampling from multiple multinomial distributions.
.. note:: The input distribution must be normalized, i.e. `data` must sum to
1 along its last dimension.
Parameters
----------
data : NDArray
An *n* dimensional array whose last dimension has length `k`, where
`k` is the number of possible outcomes of each multinomial distribution.
For example, data with shape `(m, n, k)` specifies `m*n` multinomial
distributions each with `k` possible outcomes.
shape : int or tuple of ints, optional
The number of samples to draw from each distribution. If shape is empty
one sample will be drawn from each distribution.
get_prob : bool, optional
If true, a second array containing log likelihood of the drawn
samples will also be returned.
This is usually used for reinforcement learning, where you can provide
reward as head gradient w.r.t. this array to estimate gradient.
out : NDArray, optional
Store output to an existing NDArray.
dtype : str or numpy.dtype, optional
Data type of the sample output array. The default is int32.
Note that the data type of the log likelihood array is the same with that of `data`.
Returns
-------
List, or NDArray
For input `data` with `n` dimensions and shape `(d1, d2, ..., dn-1, k)`, and input
`shape` with shape `(s1, s2, ..., sx)`, returns an NDArray with shape
`(d1, d2, ... dn-1, s1, s2, ..., sx)`. The `s1, s2, ... sx` dimensions of the
returned NDArray consist of 0-indexed values sampled from each respective multinomial
distribution provided in the `k` dimension of `data`.
For the case `n`=1, and `x`=1 (one shape dimension), returned NDArray has shape `(s1,)`.
If `get_prob` is set to True, this function returns a list of format:
`[ndarray_output, log_likelihood_output]`, where `log_likelihood_output` is an NDArray of the
same shape as the sampled outputs.
Examples
--------
>>> probs = mx.nd.array([0, 0.1, 0.2, 0.3, 0.4])
>>> mx.nd.random.multinomial(probs)
[3]
<NDArray 1 @cpu(0)>
>>> probs = mx.nd.array([[0, 0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1, 0]])
>>> mx.nd.random.multinomial(probs)
[3 1]
<NDArray 2 @cpu(0)>
>>> mx.nd.random.multinomial(probs, shape=2)
[[4 4]
[1 2]]
<NDArray 2x2 @cpu(0)>
>>> mx.nd.random.multinomial(probs, get_prob=True)
[3 2]
<NDArray 2 @cpu(0)>
[-1.20397282 -1.60943794]
<NDArray 2 @cpu(0)>
"""
return _internal._sample_multinomial(data, shape, get_prob, out=out, dtype=dtype, **kwargs)
|
python
|
def multinomial(data, shape=_Null, get_prob=False, out=None, dtype='int32', **kwargs):
"""Concurrent sampling from multiple multinomial distributions.
.. note:: The input distribution must be normalized, i.e. `data` must sum to
1 along its last dimension.
Parameters
----------
data : NDArray
An *n* dimensional array whose last dimension has length `k`, where
`k` is the number of possible outcomes of each multinomial distribution.
For example, data with shape `(m, n, k)` specifies `m*n` multinomial
distributions each with `k` possible outcomes.
shape : int or tuple of ints, optional
The number of samples to draw from each distribution. If shape is empty
one sample will be drawn from each distribution.
get_prob : bool, optional
If true, a second array containing log likelihood of the drawn
samples will also be returned.
This is usually used for reinforcement learning, where you can provide
reward as head gradient w.r.t. this array to estimate gradient.
out : NDArray, optional
Store output to an existing NDArray.
dtype : str or numpy.dtype, optional
Data type of the sample output array. The default is int32.
Note that the data type of the log likelihood array is the same with that of `data`.
Returns
-------
List, or NDArray
For input `data` with `n` dimensions and shape `(d1, d2, ..., dn-1, k)`, and input
`shape` with shape `(s1, s2, ..., sx)`, returns an NDArray with shape
`(d1, d2, ... dn-1, s1, s2, ..., sx)`. The `s1, s2, ... sx` dimensions of the
returned NDArray consist of 0-indexed values sampled from each respective multinomial
distribution provided in the `k` dimension of `data`.
For the case `n`=1, and `x`=1 (one shape dimension), returned NDArray has shape `(s1,)`.
If `get_prob` is set to True, this function returns a list of format:
`[ndarray_output, log_likelihood_output]`, where `log_likelihood_output` is an NDArray of the
same shape as the sampled outputs.
Examples
--------
>>> probs = mx.nd.array([0, 0.1, 0.2, 0.3, 0.4])
>>> mx.nd.random.multinomial(probs)
[3]
<NDArray 1 @cpu(0)>
>>> probs = mx.nd.array([[0, 0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1, 0]])
>>> mx.nd.random.multinomial(probs)
[3 1]
<NDArray 2 @cpu(0)>
>>> mx.nd.random.multinomial(probs, shape=2)
[[4 4]
[1 2]]
<NDArray 2x2 @cpu(0)>
>>> mx.nd.random.multinomial(probs, get_prob=True)
[3 2]
<NDArray 2 @cpu(0)>
[-1.20397282 -1.60943794]
<NDArray 2 @cpu(0)>
"""
return _internal._sample_multinomial(data, shape, get_prob, out=out, dtype=dtype, **kwargs)
|
[
"def",
"multinomial",
"(",
"data",
",",
"shape",
"=",
"_Null",
",",
"get_prob",
"=",
"False",
",",
"out",
"=",
"None",
",",
"dtype",
"=",
"'int32'",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_internal",
".",
"_sample_multinomial",
"(",
"data",
",",
"shape",
",",
"get_prob",
",",
"out",
"=",
"out",
",",
"dtype",
"=",
"dtype",
",",
"*",
"*",
"kwargs",
")"
] |
Concurrent sampling from multiple multinomial distributions.
.. note:: The input distribution must be normalized, i.e. `data` must sum to
1 along its last dimension.
Parameters
----------
data : NDArray
An *n* dimensional array whose last dimension has length `k`, where
`k` is the number of possible outcomes of each multinomial distribution.
For example, data with shape `(m, n, k)` specifies `m*n` multinomial
distributions each with `k` possible outcomes.
shape : int or tuple of ints, optional
The number of samples to draw from each distribution. If shape is empty
one sample will be drawn from each distribution.
get_prob : bool, optional
If true, a second array containing log likelihood of the drawn
samples will also be returned.
This is usually used for reinforcement learning, where you can provide
reward as head gradient w.r.t. this array to estimate gradient.
out : NDArray, optional
Store output to an existing NDArray.
dtype : str or numpy.dtype, optional
Data type of the sample output array. The default is int32.
Note that the data type of the log likelihood array is the same with that of `data`.
Returns
-------
List, or NDArray
For input `data` with `n` dimensions and shape `(d1, d2, ..., dn-1, k)`, and input
`shape` with shape `(s1, s2, ..., sx)`, returns an NDArray with shape
`(d1, d2, ... dn-1, s1, s2, ..., sx)`. The `s1, s2, ... sx` dimensions of the
returned NDArray consist of 0-indexed values sampled from each respective multinomial
distribution provided in the `k` dimension of `data`.
For the case `n`=1, and `x`=1 (one shape dimension), returned NDArray has shape `(s1,)`.
If `get_prob` is set to True, this function returns a list of format:
`[ndarray_output, log_likelihood_output]`, where `log_likelihood_output` is an NDArray of the
same shape as the sampled outputs.
Examples
--------
>>> probs = mx.nd.array([0, 0.1, 0.2, 0.3, 0.4])
>>> mx.nd.random.multinomial(probs)
[3]
<NDArray 1 @cpu(0)>
>>> probs = mx.nd.array([[0, 0.1, 0.2, 0.3, 0.4], [0.4, 0.3, 0.2, 0.1, 0]])
>>> mx.nd.random.multinomial(probs)
[3 1]
<NDArray 2 @cpu(0)>
>>> mx.nd.random.multinomial(probs, shape=2)
[[4 4]
[1 2]]
<NDArray 2x2 @cpu(0)>
>>> mx.nd.random.multinomial(probs, get_prob=True)
[3 2]
<NDArray 2 @cpu(0)>
[-1.20397282 -1.60943794]
<NDArray 2 @cpu(0)>
|
[
"Concurrent",
"sampling",
"from",
"multiple",
"multinomial",
"distributions",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L500-L562
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/random.py
|
randint
|
def randint(low, high, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a discrete uniform distribution.
Samples are uniformly distributed over the half-open interval *[low, high)*
(includes *low*, but excludes *high*).
Parameters
----------
low : int, required
Lower boundary of the output interval. All values generated will be
greater than or equal to low.
high : int, required
Upper boundary of the output interval. All values generated will be
less than high.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `low` and
`high` are scalars, output shape will be `(m, n)`.
dtype : {'int32', 'int64'}, optional
Data type of output samples. Default is 'int32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`low.context` when `low` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g.,
`(m, n)`, the returned NDArray will shape will be `(m, n)`. Contents
of the returned NDArray will be samples from the interval `[low, high)`.
Examples
--------
>>> mx.nd.random.randint(5, 100)
[ 90]
<NDArray 1 @cpu(0)
>>> mx.nd.random.randint(-10, 2, ctx=mx.gpu(0))
[ -8]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.randint(-10, 10, shape=(2,))
[ -5 4]
<NDArray 2 @cpu(0)>
"""
return _random_helper(_internal._random_randint, None,
[low, high], shape, dtype, ctx, out, kwargs)
|
python
|
def randint(low, high, shape=_Null, dtype=_Null, ctx=None, out=None, **kwargs):
"""Draw random samples from a discrete uniform distribution.
Samples are uniformly distributed over the half-open interval *[low, high)*
(includes *low*, but excludes *high*).
Parameters
----------
low : int, required
Lower boundary of the output interval. All values generated will be
greater than or equal to low.
high : int, required
Upper boundary of the output interval. All values generated will be
less than high.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `low` and
`high` are scalars, output shape will be `(m, n)`.
dtype : {'int32', 'int64'}, optional
Data type of output samples. Default is 'int32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`low.context` when `low` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g.,
`(m, n)`, the returned NDArray will shape will be `(m, n)`. Contents
of the returned NDArray will be samples from the interval `[low, high)`.
Examples
--------
>>> mx.nd.random.randint(5, 100)
[ 90]
<NDArray 1 @cpu(0)
>>> mx.nd.random.randint(-10, 2, ctx=mx.gpu(0))
[ -8]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.randint(-10, 10, shape=(2,))
[ -5 4]
<NDArray 2 @cpu(0)>
"""
return _random_helper(_internal._random_randint, None,
[low, high], shape, dtype, ctx, out, kwargs)
|
[
"def",
"randint",
"(",
"low",
",",
"high",
",",
"shape",
"=",
"_Null",
",",
"dtype",
"=",
"_Null",
",",
"ctx",
"=",
"None",
",",
"out",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"return",
"_random_helper",
"(",
"_internal",
".",
"_random_randint",
",",
"None",
",",
"[",
"low",
",",
"high",
"]",
",",
"shape",
",",
"dtype",
",",
"ctx",
",",
"out",
",",
"kwargs",
")"
] |
Draw random samples from a discrete uniform distribution.
Samples are uniformly distributed over the half-open interval *[low, high)*
(includes *low*, but excludes *high*).
Parameters
----------
low : int, required
Lower boundary of the output interval. All values generated will be
greater than or equal to low.
high : int, required
Upper boundary of the output interval. All values generated will be
less than high.
shape : int or tuple of ints, optional
The number of samples to draw. If shape is, e.g., `(m, n)` and `low` and
`high` are scalars, output shape will be `(m, n)`.
dtype : {'int32', 'int64'}, optional
Data type of output samples. Default is 'int32'
ctx : Context, optional
Device context of output. Default is current context. Overridden by
`low.context` when `low` is an NDArray.
out : NDArray, optional
Store output to an existing NDArray.
Returns
-------
NDArray
An NDArray of type `dtype`. If input `shape` has shape, e.g.,
`(m, n)`, the returned NDArray will shape will be `(m, n)`. Contents
of the returned NDArray will be samples from the interval `[low, high)`.
Examples
--------
>>> mx.nd.random.randint(5, 100)
[ 90]
<NDArray 1 @cpu(0)
>>> mx.nd.random.randint(-10, 2, ctx=mx.gpu(0))
[ -8]
<NDArray 1 @gpu(0)>
>>> mx.nd.random.randint(-10, 10, shape=(2,))
[ -5 4]
<NDArray 2 @cpu(0)>
|
[
"Draw",
"random",
"samples",
"from",
"a",
"discrete",
"uniform",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/random.py#L604-L649
|
train
|
apache/incubator-mxnet
|
example/sparse/wide_deep/data.py
|
preprocess_uci_adult
|
def preprocess_uci_adult(data_name):
"""Some tricks of feature engineering are adapted
from tensorflow's wide and deep tutorial.
"""
csv_columns = [
"age", "workclass", "fnlwgt", "education", "education_num",
"marital_status", "occupation", "relationship", "race", "gender",
"capital_gain", "capital_loss", "hours_per_week", "native_country",
"income_bracket"
]
vocabulary_dict = {
"gender": [
"Female", "Male"
],
"education": [
"Bachelors", "HS-grad", "11th", "Masters", "9th",
"Some-college", "Assoc-acdm", "Assoc-voc", "7th-8th",
"Doctorate", "Prof-school", "5th-6th", "10th", "1st-4th",
"Preschool", "12th"
],
"marital_status": [
"Married-civ-spouse", "Divorced", "Married-spouse-absent",
"Never-married", "Separated", "Married-AF-spouse", "Widowed"
],
"relationship": [
"Husband", "Not-in-family", "Wife", "Own-child", "Unmarried",
"Other-relative"
],
"workclass": [
"Self-emp-not-inc", "Private", "State-gov", "Federal-gov",
"Local-gov", "?", "Self-emp-inc", "Without-pay", "Never-worked"
]
}
# wide columns
crossed_columns = [
["education", "occupation"],
["native_country", "occupation"],
["age_buckets", "education", "occupation"],
]
age_boundaries = [18, 25, 30, 35, 40, 45, 50, 55, 60, 65]
# deep columns
indicator_columns = ['workclass', 'education', 'gender', 'relationship']
embedding_columns = ['native_country', 'occupation']
continuous_columns = ['age', 'education_num', 'capital_gain', 'capital_loss', 'hours_per_week']
# income_bracket column is the label
labels = ["<", ">"]
hash_bucket_size = 1000
csr_ncols = len(crossed_columns) * hash_bucket_size
dns_ncols = len(continuous_columns) + len(embedding_columns)
for col in indicator_columns:
dns_ncols += len(vocabulary_dict[col])
label_list = []
csr_list = []
dns_list = []
with open(data_name) as f:
for row in DictReader(f, fieldnames=csv_columns):
label_list.append(labels.index(row['income_bracket'].strip()[0]))
for i, cols in enumerate(crossed_columns):
if cols[0] == "age_buckets":
age_bucket = np.digitize(float(row["age"]), age_boundaries)
s = '_'.join([row[col].strip() for col in cols[1:]])
s += '_' + str(age_bucket)
csr_list.append((i * hash_bucket_size + hash(s) % hash_bucket_size, 1.0))
else:
s = '_'.join([row[col].strip() for col in cols])
csr_list.append((i * hash_bucket_size + hash(s) % hash_bucket_size, 1.0))
dns_row = [0] * dns_ncols
dns_dim = 0
for col in embedding_columns:
dns_row[dns_dim] = hash(row[col].strip()) % hash_bucket_size
dns_dim += 1
for col in indicator_columns:
dns_row[dns_dim + vocabulary_dict[col].index(row[col].strip())] = 1.0
dns_dim += len(vocabulary_dict[col])
for col in continuous_columns:
dns_row[dns_dim] = float(row[col].strip())
dns_dim += 1
dns_list.append(dns_row)
data_list = [item[1] for item in csr_list]
indices_list = [item[0] for item in csr_list]
indptr_list = range(0, len(indices_list) + 1, len(crossed_columns))
# convert to ndarrays
csr = mx.nd.sparse.csr_matrix((data_list, indices_list, indptr_list),
shape=(len(label_list), hash_bucket_size * len(crossed_columns)))
dns = np.array(dns_list)
label = np.array(label_list)
return csr, dns, label
|
python
|
def preprocess_uci_adult(data_name):
"""Some tricks of feature engineering are adapted
from tensorflow's wide and deep tutorial.
"""
csv_columns = [
"age", "workclass", "fnlwgt", "education", "education_num",
"marital_status", "occupation", "relationship", "race", "gender",
"capital_gain", "capital_loss", "hours_per_week", "native_country",
"income_bracket"
]
vocabulary_dict = {
"gender": [
"Female", "Male"
],
"education": [
"Bachelors", "HS-grad", "11th", "Masters", "9th",
"Some-college", "Assoc-acdm", "Assoc-voc", "7th-8th",
"Doctorate", "Prof-school", "5th-6th", "10th", "1st-4th",
"Preschool", "12th"
],
"marital_status": [
"Married-civ-spouse", "Divorced", "Married-spouse-absent",
"Never-married", "Separated", "Married-AF-spouse", "Widowed"
],
"relationship": [
"Husband", "Not-in-family", "Wife", "Own-child", "Unmarried",
"Other-relative"
],
"workclass": [
"Self-emp-not-inc", "Private", "State-gov", "Federal-gov",
"Local-gov", "?", "Self-emp-inc", "Without-pay", "Never-worked"
]
}
# wide columns
crossed_columns = [
["education", "occupation"],
["native_country", "occupation"],
["age_buckets", "education", "occupation"],
]
age_boundaries = [18, 25, 30, 35, 40, 45, 50, 55, 60, 65]
# deep columns
indicator_columns = ['workclass', 'education', 'gender', 'relationship']
embedding_columns = ['native_country', 'occupation']
continuous_columns = ['age', 'education_num', 'capital_gain', 'capital_loss', 'hours_per_week']
# income_bracket column is the label
labels = ["<", ">"]
hash_bucket_size = 1000
csr_ncols = len(crossed_columns) * hash_bucket_size
dns_ncols = len(continuous_columns) + len(embedding_columns)
for col in indicator_columns:
dns_ncols += len(vocabulary_dict[col])
label_list = []
csr_list = []
dns_list = []
with open(data_name) as f:
for row in DictReader(f, fieldnames=csv_columns):
label_list.append(labels.index(row['income_bracket'].strip()[0]))
for i, cols in enumerate(crossed_columns):
if cols[0] == "age_buckets":
age_bucket = np.digitize(float(row["age"]), age_boundaries)
s = '_'.join([row[col].strip() for col in cols[1:]])
s += '_' + str(age_bucket)
csr_list.append((i * hash_bucket_size + hash(s) % hash_bucket_size, 1.0))
else:
s = '_'.join([row[col].strip() for col in cols])
csr_list.append((i * hash_bucket_size + hash(s) % hash_bucket_size, 1.0))
dns_row = [0] * dns_ncols
dns_dim = 0
for col in embedding_columns:
dns_row[dns_dim] = hash(row[col].strip()) % hash_bucket_size
dns_dim += 1
for col in indicator_columns:
dns_row[dns_dim + vocabulary_dict[col].index(row[col].strip())] = 1.0
dns_dim += len(vocabulary_dict[col])
for col in continuous_columns:
dns_row[dns_dim] = float(row[col].strip())
dns_dim += 1
dns_list.append(dns_row)
data_list = [item[1] for item in csr_list]
indices_list = [item[0] for item in csr_list]
indptr_list = range(0, len(indices_list) + 1, len(crossed_columns))
# convert to ndarrays
csr = mx.nd.sparse.csr_matrix((data_list, indices_list, indptr_list),
shape=(len(label_list), hash_bucket_size * len(crossed_columns)))
dns = np.array(dns_list)
label = np.array(label_list)
return csr, dns, label
|
[
"def",
"preprocess_uci_adult",
"(",
"data_name",
")",
":",
"csv_columns",
"=",
"[",
"\"age\"",
",",
"\"workclass\"",
",",
"\"fnlwgt\"",
",",
"\"education\"",
",",
"\"education_num\"",
",",
"\"marital_status\"",
",",
"\"occupation\"",
",",
"\"relationship\"",
",",
"\"race\"",
",",
"\"gender\"",
",",
"\"capital_gain\"",
",",
"\"capital_loss\"",
",",
"\"hours_per_week\"",
",",
"\"native_country\"",
",",
"\"income_bracket\"",
"]",
"vocabulary_dict",
"=",
"{",
"\"gender\"",
":",
"[",
"\"Female\"",
",",
"\"Male\"",
"]",
",",
"\"education\"",
":",
"[",
"\"Bachelors\"",
",",
"\"HS-grad\"",
",",
"\"11th\"",
",",
"\"Masters\"",
",",
"\"9th\"",
",",
"\"Some-college\"",
",",
"\"Assoc-acdm\"",
",",
"\"Assoc-voc\"",
",",
"\"7th-8th\"",
",",
"\"Doctorate\"",
",",
"\"Prof-school\"",
",",
"\"5th-6th\"",
",",
"\"10th\"",
",",
"\"1st-4th\"",
",",
"\"Preschool\"",
",",
"\"12th\"",
"]",
",",
"\"marital_status\"",
":",
"[",
"\"Married-civ-spouse\"",
",",
"\"Divorced\"",
",",
"\"Married-spouse-absent\"",
",",
"\"Never-married\"",
",",
"\"Separated\"",
",",
"\"Married-AF-spouse\"",
",",
"\"Widowed\"",
"]",
",",
"\"relationship\"",
":",
"[",
"\"Husband\"",
",",
"\"Not-in-family\"",
",",
"\"Wife\"",
",",
"\"Own-child\"",
",",
"\"Unmarried\"",
",",
"\"Other-relative\"",
"]",
",",
"\"workclass\"",
":",
"[",
"\"Self-emp-not-inc\"",
",",
"\"Private\"",
",",
"\"State-gov\"",
",",
"\"Federal-gov\"",
",",
"\"Local-gov\"",
",",
"\"?\"",
",",
"\"Self-emp-inc\"",
",",
"\"Without-pay\"",
",",
"\"Never-worked\"",
"]",
"}",
"# wide columns",
"crossed_columns",
"=",
"[",
"[",
"\"education\"",
",",
"\"occupation\"",
"]",
",",
"[",
"\"native_country\"",
",",
"\"occupation\"",
"]",
",",
"[",
"\"age_buckets\"",
",",
"\"education\"",
",",
"\"occupation\"",
"]",
",",
"]",
"age_boundaries",
"=",
"[",
"18",
",",
"25",
",",
"30",
",",
"35",
",",
"40",
",",
"45",
",",
"50",
",",
"55",
",",
"60",
",",
"65",
"]",
"# deep columns",
"indicator_columns",
"=",
"[",
"'workclass'",
",",
"'education'",
",",
"'gender'",
",",
"'relationship'",
"]",
"embedding_columns",
"=",
"[",
"'native_country'",
",",
"'occupation'",
"]",
"continuous_columns",
"=",
"[",
"'age'",
",",
"'education_num'",
",",
"'capital_gain'",
",",
"'capital_loss'",
",",
"'hours_per_week'",
"]",
"# income_bracket column is the label",
"labels",
"=",
"[",
"\"<\"",
",",
"\">\"",
"]",
"hash_bucket_size",
"=",
"1000",
"csr_ncols",
"=",
"len",
"(",
"crossed_columns",
")",
"*",
"hash_bucket_size",
"dns_ncols",
"=",
"len",
"(",
"continuous_columns",
")",
"+",
"len",
"(",
"embedding_columns",
")",
"for",
"col",
"in",
"indicator_columns",
":",
"dns_ncols",
"+=",
"len",
"(",
"vocabulary_dict",
"[",
"col",
"]",
")",
"label_list",
"=",
"[",
"]",
"csr_list",
"=",
"[",
"]",
"dns_list",
"=",
"[",
"]",
"with",
"open",
"(",
"data_name",
")",
"as",
"f",
":",
"for",
"row",
"in",
"DictReader",
"(",
"f",
",",
"fieldnames",
"=",
"csv_columns",
")",
":",
"label_list",
".",
"append",
"(",
"labels",
".",
"index",
"(",
"row",
"[",
"'income_bracket'",
"]",
".",
"strip",
"(",
")",
"[",
"0",
"]",
")",
")",
"for",
"i",
",",
"cols",
"in",
"enumerate",
"(",
"crossed_columns",
")",
":",
"if",
"cols",
"[",
"0",
"]",
"==",
"\"age_buckets\"",
":",
"age_bucket",
"=",
"np",
".",
"digitize",
"(",
"float",
"(",
"row",
"[",
"\"age\"",
"]",
")",
",",
"age_boundaries",
")",
"s",
"=",
"'_'",
".",
"join",
"(",
"[",
"row",
"[",
"col",
"]",
".",
"strip",
"(",
")",
"for",
"col",
"in",
"cols",
"[",
"1",
":",
"]",
"]",
")",
"s",
"+=",
"'_'",
"+",
"str",
"(",
"age_bucket",
")",
"csr_list",
".",
"append",
"(",
"(",
"i",
"*",
"hash_bucket_size",
"+",
"hash",
"(",
"s",
")",
"%",
"hash_bucket_size",
",",
"1.0",
")",
")",
"else",
":",
"s",
"=",
"'_'",
".",
"join",
"(",
"[",
"row",
"[",
"col",
"]",
".",
"strip",
"(",
")",
"for",
"col",
"in",
"cols",
"]",
")",
"csr_list",
".",
"append",
"(",
"(",
"i",
"*",
"hash_bucket_size",
"+",
"hash",
"(",
"s",
")",
"%",
"hash_bucket_size",
",",
"1.0",
")",
")",
"dns_row",
"=",
"[",
"0",
"]",
"*",
"dns_ncols",
"dns_dim",
"=",
"0",
"for",
"col",
"in",
"embedding_columns",
":",
"dns_row",
"[",
"dns_dim",
"]",
"=",
"hash",
"(",
"row",
"[",
"col",
"]",
".",
"strip",
"(",
")",
")",
"%",
"hash_bucket_size",
"dns_dim",
"+=",
"1",
"for",
"col",
"in",
"indicator_columns",
":",
"dns_row",
"[",
"dns_dim",
"+",
"vocabulary_dict",
"[",
"col",
"]",
".",
"index",
"(",
"row",
"[",
"col",
"]",
".",
"strip",
"(",
")",
")",
"]",
"=",
"1.0",
"dns_dim",
"+=",
"len",
"(",
"vocabulary_dict",
"[",
"col",
"]",
")",
"for",
"col",
"in",
"continuous_columns",
":",
"dns_row",
"[",
"dns_dim",
"]",
"=",
"float",
"(",
"row",
"[",
"col",
"]",
".",
"strip",
"(",
")",
")",
"dns_dim",
"+=",
"1",
"dns_list",
".",
"append",
"(",
"dns_row",
")",
"data_list",
"=",
"[",
"item",
"[",
"1",
"]",
"for",
"item",
"in",
"csr_list",
"]",
"indices_list",
"=",
"[",
"item",
"[",
"0",
"]",
"for",
"item",
"in",
"csr_list",
"]",
"indptr_list",
"=",
"range",
"(",
"0",
",",
"len",
"(",
"indices_list",
")",
"+",
"1",
",",
"len",
"(",
"crossed_columns",
")",
")",
"# convert to ndarrays",
"csr",
"=",
"mx",
".",
"nd",
".",
"sparse",
".",
"csr_matrix",
"(",
"(",
"data_list",
",",
"indices_list",
",",
"indptr_list",
")",
",",
"shape",
"=",
"(",
"len",
"(",
"label_list",
")",
",",
"hash_bucket_size",
"*",
"len",
"(",
"crossed_columns",
")",
")",
")",
"dns",
"=",
"np",
".",
"array",
"(",
"dns_list",
")",
"label",
"=",
"np",
".",
"array",
"(",
"label_list",
")",
"return",
"csr",
",",
"dns",
",",
"label"
] |
Some tricks of feature engineering are adapted
from tensorflow's wide and deep tutorial.
|
[
"Some",
"tricks",
"of",
"feature",
"engineering",
"are",
"adapted",
"from",
"tensorflow",
"s",
"wide",
"and",
"deep",
"tutorial",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/sparse/wide_deep/data.py#L40-L139
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer._init_params
|
def _init_params(self):
"""Initialize parameters in the KVStore.
Parameters with incomplete initialization are ignored.
"""
assert self._kv_initialized, "Cannot initialize parameters in KVStore " \
"when KVStore is not initialized."
params_to_init = []
if self._kvstore:
for param in self._params_to_init:
if param._deferred_init:
params_to_init.append(param)
else:
param_arrays = param._check_and_get(param._data, list)
idx = self._param2idx[param.name]
self._kvstore.init(idx, param_arrays[0])
if param._stype == 'default':
self._kvstore.pull(idx, param_arrays, priority=-idx)
self._params_to_init = params_to_init
|
python
|
def _init_params(self):
"""Initialize parameters in the KVStore.
Parameters with incomplete initialization are ignored.
"""
assert self._kv_initialized, "Cannot initialize parameters in KVStore " \
"when KVStore is not initialized."
params_to_init = []
if self._kvstore:
for param in self._params_to_init:
if param._deferred_init:
params_to_init.append(param)
else:
param_arrays = param._check_and_get(param._data, list)
idx = self._param2idx[param.name]
self._kvstore.init(idx, param_arrays[0])
if param._stype == 'default':
self._kvstore.pull(idx, param_arrays, priority=-idx)
self._params_to_init = params_to_init
|
[
"def",
"_init_params",
"(",
"self",
")",
":",
"assert",
"self",
".",
"_kv_initialized",
",",
"\"Cannot initialize parameters in KVStore \"",
"\"when KVStore is not initialized.\"",
"params_to_init",
"=",
"[",
"]",
"if",
"self",
".",
"_kvstore",
":",
"for",
"param",
"in",
"self",
".",
"_params_to_init",
":",
"if",
"param",
".",
"_deferred_init",
":",
"params_to_init",
".",
"append",
"(",
"param",
")",
"else",
":",
"param_arrays",
"=",
"param",
".",
"_check_and_get",
"(",
"param",
".",
"_data",
",",
"list",
")",
"idx",
"=",
"self",
".",
"_param2idx",
"[",
"param",
".",
"name",
"]",
"self",
".",
"_kvstore",
".",
"init",
"(",
"idx",
",",
"param_arrays",
"[",
"0",
"]",
")",
"if",
"param",
".",
"_stype",
"==",
"'default'",
":",
"self",
".",
"_kvstore",
".",
"pull",
"(",
"idx",
",",
"param_arrays",
",",
"priority",
"=",
"-",
"idx",
")",
"self",
".",
"_params_to_init",
"=",
"params_to_init"
] |
Initialize parameters in the KVStore.
Parameters with incomplete initialization are ignored.
|
[
"Initialize",
"parameters",
"in",
"the",
"KVStore",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L137-L157
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer._reset_kvstore
|
def _reset_kvstore(self):
"""Reset kvstore."""
if self._kvstore and 'dist' in self._kvstore.type:
raise RuntimeError("Cannot reset distributed KVStore.")
self._kv_initialized = False
self._kvstore = None
self._distributed = None
self._update_on_kvstore = None
self._params_to_init = [param for param in self._params]
|
python
|
def _reset_kvstore(self):
"""Reset kvstore."""
if self._kvstore and 'dist' in self._kvstore.type:
raise RuntimeError("Cannot reset distributed KVStore.")
self._kv_initialized = False
self._kvstore = None
self._distributed = None
self._update_on_kvstore = None
self._params_to_init = [param for param in self._params]
|
[
"def",
"_reset_kvstore",
"(",
"self",
")",
":",
"if",
"self",
".",
"_kvstore",
"and",
"'dist'",
"in",
"self",
".",
"_kvstore",
".",
"type",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot reset distributed KVStore.\"",
")",
"self",
".",
"_kv_initialized",
"=",
"False",
"self",
".",
"_kvstore",
"=",
"None",
"self",
".",
"_distributed",
"=",
"None",
"self",
".",
"_update_on_kvstore",
"=",
"None",
"self",
".",
"_params_to_init",
"=",
"[",
"param",
"for",
"param",
"in",
"self",
".",
"_params",
"]"
] |
Reset kvstore.
|
[
"Reset",
"kvstore",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L159-L167
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer._init_kvstore
|
def _init_kvstore(self):
"""Create kvstore."""
config = self._kvstore_params
# configure kvstore, update_on_kvstore and self._distributed on three cases:
if self._contains_sparse_weight:
# If weight is sparse, kvstore must be present and the weight must be updated on kvstore.
# The training loop is the following:
# - row_sparse_pull(sparse_weight)
# - forward()
# - backward()
# - push_and_update(grad)
# - pull(weight)
kvstore, update_on_kvstore = _create_sparse_kvstore(config['kvstore'])
self._distributed = 'dist' in kvstore.type
# raise err if user provides unsupported configs
if config['update_on_kvstore'] is False:
raise ValueError("Cannot set update_on_kvstore=False when sparse weights "
"are present.")
elif self._contains_sparse_grad:
# For single node training with dense weight and sparse grad,
# we prefer update_on_kvstore=False because this is usually faster.
# This means we push and pull sparse gradients, and we do not store weight in kvstore.
# The training loop is the following:
# - forward()
# - backward()
# - push(grad)
# - pull(grad)
# - update(grad, weight)
#
# For multi-node training with dense weight and sparse grad,
# only update_on_kvstore=True is supported, due to the fact that
# kv.row_sparse_pull(grad) is not implemented.
# Therefore, we push sparse gradients and pull dense weights.
# The training loop contains:
# - forward()
# - backward()
# - push_and_update(grad)
# - pull(weight)
arg_arrays = {param.name: param.data(self._contexts[0]) for param in self._params}
kvstore, _ = _create_kvstore(config['kvstore'], len(self._contexts), arg_arrays)
self._distributed = 'dist' in kvstore.type if kvstore else False
update_on_kvstore = self._distributed
# raise err if user provides unsupported configs
if config['update_on_kvstore'] is not None:
if config['update_on_kvstore'] is False and self._distributed:
raise ValueError("Cannot set update_on_kvstore=False on dist kvstore "
"when sparse gradients are present.")
update_on_kvstore = config['update_on_kvstore']
else:
# Training with dense weight and dense gradients.
# The only unsupported mode is async with update_on_kvstore=False
arg_arrays = {param.name: param.data(self._contexts[0]) for param in self._params}
kvstore, update_on_kvstore = _create_kvstore(config['kvstore'], len(self._contexts),
arg_arrays)
self._distributed = 'dist' in kvstore.type if kvstore else False
if self._distributed and 'async' in kvstore.type:
update_on_kvstore = True
# raise err if user provides unsupported configs
if config['update_on_kvstore'] is False:
raise ValueError("Please set update_on_kvstore=True "
"when training in async mode.")
if config['update_on_kvstore'] is not None:
update_on_kvstore = config['update_on_kvstore']
# set grad compression and optimizers
if kvstore:
if self._compression_params:
kvstore.set_gradient_compression(self._compression_params)
if update_on_kvstore:
# optimizer preferably needs to be set before init for multiprecision
kvstore.set_optimizer(self._optimizer)
self._kvstore = kvstore
self._update_on_kvstore = update_on_kvstore
else:
self._kvstore = None
self._update_on_kvstore = None
self._kv_initialized = True
|
python
|
def _init_kvstore(self):
"""Create kvstore."""
config = self._kvstore_params
# configure kvstore, update_on_kvstore and self._distributed on three cases:
if self._contains_sparse_weight:
# If weight is sparse, kvstore must be present and the weight must be updated on kvstore.
# The training loop is the following:
# - row_sparse_pull(sparse_weight)
# - forward()
# - backward()
# - push_and_update(grad)
# - pull(weight)
kvstore, update_on_kvstore = _create_sparse_kvstore(config['kvstore'])
self._distributed = 'dist' in kvstore.type
# raise err if user provides unsupported configs
if config['update_on_kvstore'] is False:
raise ValueError("Cannot set update_on_kvstore=False when sparse weights "
"are present.")
elif self._contains_sparse_grad:
# For single node training with dense weight and sparse grad,
# we prefer update_on_kvstore=False because this is usually faster.
# This means we push and pull sparse gradients, and we do not store weight in kvstore.
# The training loop is the following:
# - forward()
# - backward()
# - push(grad)
# - pull(grad)
# - update(grad, weight)
#
# For multi-node training with dense weight and sparse grad,
# only update_on_kvstore=True is supported, due to the fact that
# kv.row_sparse_pull(grad) is not implemented.
# Therefore, we push sparse gradients and pull dense weights.
# The training loop contains:
# - forward()
# - backward()
# - push_and_update(grad)
# - pull(weight)
arg_arrays = {param.name: param.data(self._contexts[0]) for param in self._params}
kvstore, _ = _create_kvstore(config['kvstore'], len(self._contexts), arg_arrays)
self._distributed = 'dist' in kvstore.type if kvstore else False
update_on_kvstore = self._distributed
# raise err if user provides unsupported configs
if config['update_on_kvstore'] is not None:
if config['update_on_kvstore'] is False and self._distributed:
raise ValueError("Cannot set update_on_kvstore=False on dist kvstore "
"when sparse gradients are present.")
update_on_kvstore = config['update_on_kvstore']
else:
# Training with dense weight and dense gradients.
# The only unsupported mode is async with update_on_kvstore=False
arg_arrays = {param.name: param.data(self._contexts[0]) for param in self._params}
kvstore, update_on_kvstore = _create_kvstore(config['kvstore'], len(self._contexts),
arg_arrays)
self._distributed = 'dist' in kvstore.type if kvstore else False
if self._distributed and 'async' in kvstore.type:
update_on_kvstore = True
# raise err if user provides unsupported configs
if config['update_on_kvstore'] is False:
raise ValueError("Please set update_on_kvstore=True "
"when training in async mode.")
if config['update_on_kvstore'] is not None:
update_on_kvstore = config['update_on_kvstore']
# set grad compression and optimizers
if kvstore:
if self._compression_params:
kvstore.set_gradient_compression(self._compression_params)
if update_on_kvstore:
# optimizer preferably needs to be set before init for multiprecision
kvstore.set_optimizer(self._optimizer)
self._kvstore = kvstore
self._update_on_kvstore = update_on_kvstore
else:
self._kvstore = None
self._update_on_kvstore = None
self._kv_initialized = True
|
[
"def",
"_init_kvstore",
"(",
"self",
")",
":",
"config",
"=",
"self",
".",
"_kvstore_params",
"# configure kvstore, update_on_kvstore and self._distributed on three cases:",
"if",
"self",
".",
"_contains_sparse_weight",
":",
"# If weight is sparse, kvstore must be present and the weight must be updated on kvstore.",
"# The training loop is the following:",
"# - row_sparse_pull(sparse_weight)",
"# - forward()",
"# - backward()",
"# - push_and_update(grad)",
"# - pull(weight)",
"kvstore",
",",
"update_on_kvstore",
"=",
"_create_sparse_kvstore",
"(",
"config",
"[",
"'kvstore'",
"]",
")",
"self",
".",
"_distributed",
"=",
"'dist'",
"in",
"kvstore",
".",
"type",
"# raise err if user provides unsupported configs",
"if",
"config",
"[",
"'update_on_kvstore'",
"]",
"is",
"False",
":",
"raise",
"ValueError",
"(",
"\"Cannot set update_on_kvstore=False when sparse weights \"",
"\"are present.\"",
")",
"elif",
"self",
".",
"_contains_sparse_grad",
":",
"# For single node training with dense weight and sparse grad,",
"# we prefer update_on_kvstore=False because this is usually faster.",
"# This means we push and pull sparse gradients, and we do not store weight in kvstore.",
"# The training loop is the following:",
"# - forward()",
"# - backward()",
"# - push(grad)",
"# - pull(grad)",
"# - update(grad, weight)",
"#",
"# For multi-node training with dense weight and sparse grad,",
"# only update_on_kvstore=True is supported, due to the fact that",
"# kv.row_sparse_pull(grad) is not implemented.",
"# Therefore, we push sparse gradients and pull dense weights.",
"# The training loop contains:",
"# - forward()",
"# - backward()",
"# - push_and_update(grad)",
"# - pull(weight)",
"arg_arrays",
"=",
"{",
"param",
".",
"name",
":",
"param",
".",
"data",
"(",
"self",
".",
"_contexts",
"[",
"0",
"]",
")",
"for",
"param",
"in",
"self",
".",
"_params",
"}",
"kvstore",
",",
"_",
"=",
"_create_kvstore",
"(",
"config",
"[",
"'kvstore'",
"]",
",",
"len",
"(",
"self",
".",
"_contexts",
")",
",",
"arg_arrays",
")",
"self",
".",
"_distributed",
"=",
"'dist'",
"in",
"kvstore",
".",
"type",
"if",
"kvstore",
"else",
"False",
"update_on_kvstore",
"=",
"self",
".",
"_distributed",
"# raise err if user provides unsupported configs",
"if",
"config",
"[",
"'update_on_kvstore'",
"]",
"is",
"not",
"None",
":",
"if",
"config",
"[",
"'update_on_kvstore'",
"]",
"is",
"False",
"and",
"self",
".",
"_distributed",
":",
"raise",
"ValueError",
"(",
"\"Cannot set update_on_kvstore=False on dist kvstore \"",
"\"when sparse gradients are present.\"",
")",
"update_on_kvstore",
"=",
"config",
"[",
"'update_on_kvstore'",
"]",
"else",
":",
"# Training with dense weight and dense gradients.",
"# The only unsupported mode is async with update_on_kvstore=False",
"arg_arrays",
"=",
"{",
"param",
".",
"name",
":",
"param",
".",
"data",
"(",
"self",
".",
"_contexts",
"[",
"0",
"]",
")",
"for",
"param",
"in",
"self",
".",
"_params",
"}",
"kvstore",
",",
"update_on_kvstore",
"=",
"_create_kvstore",
"(",
"config",
"[",
"'kvstore'",
"]",
",",
"len",
"(",
"self",
".",
"_contexts",
")",
",",
"arg_arrays",
")",
"self",
".",
"_distributed",
"=",
"'dist'",
"in",
"kvstore",
".",
"type",
"if",
"kvstore",
"else",
"False",
"if",
"self",
".",
"_distributed",
"and",
"'async'",
"in",
"kvstore",
".",
"type",
":",
"update_on_kvstore",
"=",
"True",
"# raise err if user provides unsupported configs",
"if",
"config",
"[",
"'update_on_kvstore'",
"]",
"is",
"False",
":",
"raise",
"ValueError",
"(",
"\"Please set update_on_kvstore=True \"",
"\"when training in async mode.\"",
")",
"if",
"config",
"[",
"'update_on_kvstore'",
"]",
"is",
"not",
"None",
":",
"update_on_kvstore",
"=",
"config",
"[",
"'update_on_kvstore'",
"]",
"# set grad compression and optimizers",
"if",
"kvstore",
":",
"if",
"self",
".",
"_compression_params",
":",
"kvstore",
".",
"set_gradient_compression",
"(",
"self",
".",
"_compression_params",
")",
"if",
"update_on_kvstore",
":",
"# optimizer preferably needs to be set before init for multiprecision",
"kvstore",
".",
"set_optimizer",
"(",
"self",
".",
"_optimizer",
")",
"self",
".",
"_kvstore",
"=",
"kvstore",
"self",
".",
"_update_on_kvstore",
"=",
"update_on_kvstore",
"else",
":",
"self",
".",
"_kvstore",
"=",
"None",
"self",
".",
"_update_on_kvstore",
"=",
"None",
"self",
".",
"_kv_initialized",
"=",
"True"
] |
Create kvstore.
|
[
"Create",
"kvstore",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L169-L248
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer.set_learning_rate
|
def set_learning_rate(self, lr):
"""Sets a new learning rate of the optimizer.
Parameters
----------
lr : float
The new learning rate of the optimizer.
"""
if not isinstance(self._optimizer, opt.Optimizer):
raise UserWarning("Optimizer has to be defined before its learning "
"rate is mutated.")
else:
self._optimizer.set_learning_rate(lr)
|
python
|
def set_learning_rate(self, lr):
"""Sets a new learning rate of the optimizer.
Parameters
----------
lr : float
The new learning rate of the optimizer.
"""
if not isinstance(self._optimizer, opt.Optimizer):
raise UserWarning("Optimizer has to be defined before its learning "
"rate is mutated.")
else:
self._optimizer.set_learning_rate(lr)
|
[
"def",
"set_learning_rate",
"(",
"self",
",",
"lr",
")",
":",
"if",
"not",
"isinstance",
"(",
"self",
".",
"_optimizer",
",",
"opt",
".",
"Optimizer",
")",
":",
"raise",
"UserWarning",
"(",
"\"Optimizer has to be defined before its learning \"",
"\"rate is mutated.\"",
")",
"else",
":",
"self",
".",
"_optimizer",
".",
"set_learning_rate",
"(",
"lr",
")"
] |
Sets a new learning rate of the optimizer.
Parameters
----------
lr : float
The new learning rate of the optimizer.
|
[
"Sets",
"a",
"new",
"learning",
"rate",
"of",
"the",
"optimizer",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L258-L270
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer._row_sparse_pull
|
def _row_sparse_pull(self, parameter, out, row_id, full_idx=False):
"""Internal method to invoke pull operations on KVStore. If `full_idx` is set to True,
`kv.pull` is preferred instead of `kv.row_sparse_pull`.
"""
# initialize kv and params if not already
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
idx = self._param2idx[parameter.name]
if full_idx and 'dist' not in self._kvstore.type:
assert row_id.size == out.shape[0]
self._kvstore.pull(idx, out=out, priority=-idx, ignore_sparse=False)
else:
self._kvstore.row_sparse_pull(idx, out=out, row_ids=row_id, priority=-idx)
|
python
|
def _row_sparse_pull(self, parameter, out, row_id, full_idx=False):
"""Internal method to invoke pull operations on KVStore. If `full_idx` is set to True,
`kv.pull` is preferred instead of `kv.row_sparse_pull`.
"""
# initialize kv and params if not already
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
idx = self._param2idx[parameter.name]
if full_idx and 'dist' not in self._kvstore.type:
assert row_id.size == out.shape[0]
self._kvstore.pull(idx, out=out, priority=-idx, ignore_sparse=False)
else:
self._kvstore.row_sparse_pull(idx, out=out, row_ids=row_id, priority=-idx)
|
[
"def",
"_row_sparse_pull",
"(",
"self",
",",
"parameter",
",",
"out",
",",
"row_id",
",",
"full_idx",
"=",
"False",
")",
":",
"# initialize kv and params if not already",
"if",
"not",
"self",
".",
"_kv_initialized",
":",
"self",
".",
"_init_kvstore",
"(",
")",
"if",
"self",
".",
"_params_to_init",
":",
"self",
".",
"_init_params",
"(",
")",
"idx",
"=",
"self",
".",
"_param2idx",
"[",
"parameter",
".",
"name",
"]",
"if",
"full_idx",
"and",
"'dist'",
"not",
"in",
"self",
".",
"_kvstore",
".",
"type",
":",
"assert",
"row_id",
".",
"size",
"==",
"out",
".",
"shape",
"[",
"0",
"]",
"self",
".",
"_kvstore",
".",
"pull",
"(",
"idx",
",",
"out",
"=",
"out",
",",
"priority",
"=",
"-",
"idx",
",",
"ignore_sparse",
"=",
"False",
")",
"else",
":",
"self",
".",
"_kvstore",
".",
"row_sparse_pull",
"(",
"idx",
",",
"out",
"=",
"out",
",",
"row_ids",
"=",
"row_id",
",",
"priority",
"=",
"-",
"idx",
")"
] |
Internal method to invoke pull operations on KVStore. If `full_idx` is set to True,
`kv.pull` is preferred instead of `kv.row_sparse_pull`.
|
[
"Internal",
"method",
"to",
"invoke",
"pull",
"operations",
"on",
"KVStore",
".",
"If",
"full_idx",
"is",
"set",
"to",
"True",
"kv",
".",
"pull",
"is",
"preferred",
"instead",
"of",
"kv",
".",
"row_sparse_pull",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L272-L286
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer.step
|
def step(self, batch_size, ignore_stale_grad=False):
"""Makes one step of parameter update. Should be called after
`autograd.backward()` and outside of `record()` scope.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
Parameters
----------
batch_size : int
Batch size of data processed. Gradient will be normalized by `1/batch_size`.
Set this to 1 if you normalized loss manually with `loss = mean(loss)`.
ignore_stale_grad : bool, optional, default=False
If true, ignores Parameters with stale gradient (gradient that has not
been updated by `backward` after last step) and skip update.
"""
rescale_grad = self._scale / batch_size
self._check_and_rescale_grad(rescale_grad)
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
self._allreduce_grads()
self._update(ignore_stale_grad)
|
python
|
def step(self, batch_size, ignore_stale_grad=False):
"""Makes one step of parameter update. Should be called after
`autograd.backward()` and outside of `record()` scope.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
Parameters
----------
batch_size : int
Batch size of data processed. Gradient will be normalized by `1/batch_size`.
Set this to 1 if you normalized loss manually with `loss = mean(loss)`.
ignore_stale_grad : bool, optional, default=False
If true, ignores Parameters with stale gradient (gradient that has not
been updated by `backward` after last step) and skip update.
"""
rescale_grad = self._scale / batch_size
self._check_and_rescale_grad(rescale_grad)
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
self._allreduce_grads()
self._update(ignore_stale_grad)
|
[
"def",
"step",
"(",
"self",
",",
"batch_size",
",",
"ignore_stale_grad",
"=",
"False",
")",
":",
"rescale_grad",
"=",
"self",
".",
"_scale",
"/",
"batch_size",
"self",
".",
"_check_and_rescale_grad",
"(",
"rescale_grad",
")",
"if",
"not",
"self",
".",
"_kv_initialized",
":",
"self",
".",
"_init_kvstore",
"(",
")",
"if",
"self",
".",
"_params_to_init",
":",
"self",
".",
"_init_params",
"(",
")",
"self",
".",
"_allreduce_grads",
"(",
")",
"self",
".",
"_update",
"(",
"ignore_stale_grad",
")"
] |
Makes one step of parameter update. Should be called after
`autograd.backward()` and outside of `record()` scope.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
Parameters
----------
batch_size : int
Batch size of data processed. Gradient will be normalized by `1/batch_size`.
Set this to 1 if you normalized loss manually with `loss = mean(loss)`.
ignore_stale_grad : bool, optional, default=False
If true, ignores Parameters with stale gradient (gradient that has not
been updated by `backward` after last step) and skip update.
|
[
"Makes",
"one",
"step",
"of",
"parameter",
"update",
".",
"Should",
"be",
"called",
"after",
"autograd",
".",
"backward",
"()",
"and",
"outside",
"of",
"record",
"()",
"scope",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L298-L325
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer.allreduce_grads
|
def allreduce_grads(self):
"""For each parameter, reduce the gradients from different contexts.
Should be called after `autograd.backward()`, outside of `record()` scope,
and before `trainer.update()`.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
"""
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
assert not (self._kvstore and self._update_on_kvstore), \
'allreduce_grads() when parameters are updated on kvstore ' \
'is not supported. Try setting `update_on_kvstore` ' \
'to False when creating trainer.'
self._allreduce_grads()
|
python
|
def allreduce_grads(self):
"""For each parameter, reduce the gradients from different contexts.
Should be called after `autograd.backward()`, outside of `record()` scope,
and before `trainer.update()`.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
"""
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
assert not (self._kvstore and self._update_on_kvstore), \
'allreduce_grads() when parameters are updated on kvstore ' \
'is not supported. Try setting `update_on_kvstore` ' \
'to False when creating trainer.'
self._allreduce_grads()
|
[
"def",
"allreduce_grads",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"_kv_initialized",
":",
"self",
".",
"_init_kvstore",
"(",
")",
"if",
"self",
".",
"_params_to_init",
":",
"self",
".",
"_init_params",
"(",
")",
"assert",
"not",
"(",
"self",
".",
"_kvstore",
"and",
"self",
".",
"_update_on_kvstore",
")",
",",
"'allreduce_grads() when parameters are updated on kvstore '",
"'is not supported. Try setting `update_on_kvstore` '",
"'to False when creating trainer.'",
"self",
".",
"_allreduce_grads",
"(",
")"
] |
For each parameter, reduce the gradients from different contexts.
Should be called after `autograd.backward()`, outside of `record()` scope,
and before `trainer.update()`.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
|
[
"For",
"each",
"parameter",
"reduce",
"the",
"gradients",
"from",
"different",
"contexts",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L327-L347
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer.update
|
def update(self, batch_size, ignore_stale_grad=False):
"""Makes one step of parameter update.
Should be called after `autograd.backward()` and outside of `record()` scope,
and after `trainer.update()`.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
Parameters
----------
batch_size : int
Batch size of data processed. Gradient will be normalized by `1/batch_size`.
Set this to 1 if you normalized loss manually with `loss = mean(loss)`.
ignore_stale_grad : bool, optional, default=False
If true, ignores Parameters with stale gradient (gradient that has not
been updated by `backward` after last step) and skip update.
"""
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
assert not (self._kvstore and self._update_on_kvstore), \
'update() when parameters are updated on kvstore ' \
'is not supported. Try setting `update_on_kvstore` ' \
'to False when creating trainer.'
self._check_and_rescale_grad(self._scale / batch_size)
self._update(ignore_stale_grad)
|
python
|
def update(self, batch_size, ignore_stale_grad=False):
"""Makes one step of parameter update.
Should be called after `autograd.backward()` and outside of `record()` scope,
and after `trainer.update()`.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
Parameters
----------
batch_size : int
Batch size of data processed. Gradient will be normalized by `1/batch_size`.
Set this to 1 if you normalized loss manually with `loss = mean(loss)`.
ignore_stale_grad : bool, optional, default=False
If true, ignores Parameters with stale gradient (gradient that has not
been updated by `backward` after last step) and skip update.
"""
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
assert not (self._kvstore and self._update_on_kvstore), \
'update() when parameters are updated on kvstore ' \
'is not supported. Try setting `update_on_kvstore` ' \
'to False when creating trainer.'
self._check_and_rescale_grad(self._scale / batch_size)
self._update(ignore_stale_grad)
|
[
"def",
"update",
"(",
"self",
",",
"batch_size",
",",
"ignore_stale_grad",
"=",
"False",
")",
":",
"if",
"not",
"self",
".",
"_kv_initialized",
":",
"self",
".",
"_init_kvstore",
"(",
")",
"if",
"self",
".",
"_params_to_init",
":",
"self",
".",
"_init_params",
"(",
")",
"assert",
"not",
"(",
"self",
".",
"_kvstore",
"and",
"self",
".",
"_update_on_kvstore",
")",
",",
"'update() when parameters are updated on kvstore '",
"'is not supported. Try setting `update_on_kvstore` '",
"'to False when creating trainer.'",
"self",
".",
"_check_and_rescale_grad",
"(",
"self",
".",
"_scale",
"/",
"batch_size",
")",
"self",
".",
"_update",
"(",
"ignore_stale_grad",
")"
] |
Makes one step of parameter update.
Should be called after `autograd.backward()` and outside of `record()` scope,
and after `trainer.update()`.
For normal parameter updates, `step()` should be used, which internally calls
`allreduce_grads()` and then `update()`. However, if you need to get the reduced
gradients to perform certain transformation, such as in gradient clipping, then
you may want to manually call `allreduce_grads()` and `update()` separately.
Parameters
----------
batch_size : int
Batch size of data processed. Gradient will be normalized by `1/batch_size`.
Set this to 1 if you normalized loss manually with `loss = mean(loss)`.
ignore_stale_grad : bool, optional, default=False
If true, ignores Parameters with stale gradient (gradient that has not
been updated by `backward` after last step) and skip update.
|
[
"Makes",
"one",
"step",
"of",
"parameter",
"update",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L359-L390
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer.save_states
|
def save_states(self, fname):
"""Saves trainer states (e.g. optimizer, momentum) to a file.
Parameters
----------
fname : str
Path to output states file.
Note
----
`optimizer.param_dict`, which contains Parameter information (such as
`lr_mult` and `wd_mult`) will not be saved.
"""
assert self._optimizer is not None
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
if self._update_on_kvstore:
assert not self._params_to_init, "Cannot save trainer states when some " \
"parameters are not yet initialized in kvstore."
self._kvstore.save_optimizer_states(fname, dump_optimizer=True)
else:
with open(fname, 'wb') as fout:
fout.write(self._updaters[0].get_states(dump_optimizer=True))
|
python
|
def save_states(self, fname):
"""Saves trainer states (e.g. optimizer, momentum) to a file.
Parameters
----------
fname : str
Path to output states file.
Note
----
`optimizer.param_dict`, which contains Parameter information (such as
`lr_mult` and `wd_mult`) will not be saved.
"""
assert self._optimizer is not None
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
if self._update_on_kvstore:
assert not self._params_to_init, "Cannot save trainer states when some " \
"parameters are not yet initialized in kvstore."
self._kvstore.save_optimizer_states(fname, dump_optimizer=True)
else:
with open(fname, 'wb') as fout:
fout.write(self._updaters[0].get_states(dump_optimizer=True))
|
[
"def",
"save_states",
"(",
"self",
",",
"fname",
")",
":",
"assert",
"self",
".",
"_optimizer",
"is",
"not",
"None",
"if",
"not",
"self",
".",
"_kv_initialized",
":",
"self",
".",
"_init_kvstore",
"(",
")",
"if",
"self",
".",
"_params_to_init",
":",
"self",
".",
"_init_params",
"(",
")",
"if",
"self",
".",
"_update_on_kvstore",
":",
"assert",
"not",
"self",
".",
"_params_to_init",
",",
"\"Cannot save trainer states when some \"",
"\"parameters are not yet initialized in kvstore.\"",
"self",
".",
"_kvstore",
".",
"save_optimizer_states",
"(",
"fname",
",",
"dump_optimizer",
"=",
"True",
")",
"else",
":",
"with",
"open",
"(",
"fname",
",",
"'wb'",
")",
"as",
"fout",
":",
"fout",
".",
"write",
"(",
"self",
".",
"_updaters",
"[",
"0",
"]",
".",
"get_states",
"(",
"dump_optimizer",
"=",
"True",
")",
")"
] |
Saves trainer states (e.g. optimizer, momentum) to a file.
Parameters
----------
fname : str
Path to output states file.
Note
----
`optimizer.param_dict`, which contains Parameter information (such as
`lr_mult` and `wd_mult`) will not be saved.
|
[
"Saves",
"trainer",
"states",
"(",
"e",
".",
"g",
".",
"optimizer",
"momentum",
")",
"to",
"a",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L429-L456
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/trainer.py
|
Trainer.load_states
|
def load_states(self, fname):
"""Loads trainer states (e.g. optimizer, momentum) from a file.
Parameters
----------
fname : str
Path to input states file.
Note
----
`optimizer.param_dict`, which contains Parameter information (such as
`lr_mult` and `wd_mult`) will not be loaded from the file, but rather set
based on current Trainer's parameters.
"""
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
if self._update_on_kvstore:
self._kvstore.load_optimizer_states(fname)
self._optimizer = self._kvstore._updater.optimizer
else:
with open(fname, 'rb') as f:
states = f.read()
for updater in self._updaters:
updater.set_states(states)
updater.optimizer = self._updaters[0].optimizer
self._optimizer = self._updaters[0].optimizer
param_dict = {i: param for i, param in enumerate(self._params)}
self._optimizer.param_dict = param_dict
|
python
|
def load_states(self, fname):
"""Loads trainer states (e.g. optimizer, momentum) from a file.
Parameters
----------
fname : str
Path to input states file.
Note
----
`optimizer.param_dict`, which contains Parameter information (such as
`lr_mult` and `wd_mult`) will not be loaded from the file, but rather set
based on current Trainer's parameters.
"""
if not self._kv_initialized:
self._init_kvstore()
if self._params_to_init:
self._init_params()
if self._update_on_kvstore:
self._kvstore.load_optimizer_states(fname)
self._optimizer = self._kvstore._updater.optimizer
else:
with open(fname, 'rb') as f:
states = f.read()
for updater in self._updaters:
updater.set_states(states)
updater.optimizer = self._updaters[0].optimizer
self._optimizer = self._updaters[0].optimizer
param_dict = {i: param for i, param in enumerate(self._params)}
self._optimizer.param_dict = param_dict
|
[
"def",
"load_states",
"(",
"self",
",",
"fname",
")",
":",
"if",
"not",
"self",
".",
"_kv_initialized",
":",
"self",
".",
"_init_kvstore",
"(",
")",
"if",
"self",
".",
"_params_to_init",
":",
"self",
".",
"_init_params",
"(",
")",
"if",
"self",
".",
"_update_on_kvstore",
":",
"self",
".",
"_kvstore",
".",
"load_optimizer_states",
"(",
"fname",
")",
"self",
".",
"_optimizer",
"=",
"self",
".",
"_kvstore",
".",
"_updater",
".",
"optimizer",
"else",
":",
"with",
"open",
"(",
"fname",
",",
"'rb'",
")",
"as",
"f",
":",
"states",
"=",
"f",
".",
"read",
"(",
")",
"for",
"updater",
"in",
"self",
".",
"_updaters",
":",
"updater",
".",
"set_states",
"(",
"states",
")",
"updater",
".",
"optimizer",
"=",
"self",
".",
"_updaters",
"[",
"0",
"]",
".",
"optimizer",
"self",
".",
"_optimizer",
"=",
"self",
".",
"_updaters",
"[",
"0",
"]",
".",
"optimizer",
"param_dict",
"=",
"{",
"i",
":",
"param",
"for",
"i",
",",
"param",
"in",
"enumerate",
"(",
"self",
".",
"_params",
")",
"}",
"self",
".",
"_optimizer",
".",
"param_dict",
"=",
"param_dict"
] |
Loads trainer states (e.g. optimizer, momentum) from a file.
Parameters
----------
fname : str
Path to input states file.
Note
----
`optimizer.param_dict`, which contains Parameter information (such as
`lr_mult` and `wd_mult`) will not be loaded from the file, but rather set
based on current Trainer's parameters.
|
[
"Loads",
"trainer",
"states",
"(",
"e",
".",
"g",
".",
"optimizer",
"momentum",
")",
"from",
"a",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/trainer.py#L458-L488
|
train
|
apache/incubator-mxnet
|
benchmark/python/sparse/util.py
|
estimate_density
|
def estimate_density(DATA_PATH, feature_size):
"""sample 10 times of a size of 1000 for estimating the density of the sparse dataset"""
if not os.path.exists(DATA_PATH):
raise Exception("Data is not there!")
density = []
P = 0.01
for _ in range(10):
num_non_zero = 0
num_sample = 0
with open(DATA_PATH) as f:
for line in f:
if (random.random() < P):
num_non_zero += len(line.split(" ")) - 1
num_sample += 1
density.append(num_non_zero * 1.0 / (feature_size * num_sample))
return sum(density) / len(density)
|
python
|
def estimate_density(DATA_PATH, feature_size):
"""sample 10 times of a size of 1000 for estimating the density of the sparse dataset"""
if not os.path.exists(DATA_PATH):
raise Exception("Data is not there!")
density = []
P = 0.01
for _ in range(10):
num_non_zero = 0
num_sample = 0
with open(DATA_PATH) as f:
for line in f:
if (random.random() < P):
num_non_zero += len(line.split(" ")) - 1
num_sample += 1
density.append(num_non_zero * 1.0 / (feature_size * num_sample))
return sum(density) / len(density)
|
[
"def",
"estimate_density",
"(",
"DATA_PATH",
",",
"feature_size",
")",
":",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"DATA_PATH",
")",
":",
"raise",
"Exception",
"(",
"\"Data is not there!\"",
")",
"density",
"=",
"[",
"]",
"P",
"=",
"0.01",
"for",
"_",
"in",
"range",
"(",
"10",
")",
":",
"num_non_zero",
"=",
"0",
"num_sample",
"=",
"0",
"with",
"open",
"(",
"DATA_PATH",
")",
"as",
"f",
":",
"for",
"line",
"in",
"f",
":",
"if",
"(",
"random",
".",
"random",
"(",
")",
"<",
"P",
")",
":",
"num_non_zero",
"+=",
"len",
"(",
"line",
".",
"split",
"(",
"\" \"",
")",
")",
"-",
"1",
"num_sample",
"+=",
"1",
"density",
".",
"append",
"(",
"num_non_zero",
"*",
"1.0",
"/",
"(",
"feature_size",
"*",
"num_sample",
")",
")",
"return",
"sum",
"(",
"density",
")",
"/",
"len",
"(",
"density",
")"
] |
sample 10 times of a size of 1000 for estimating the density of the sparse dataset
|
[
"sample",
"10",
"times",
"of",
"a",
"size",
"of",
"1000",
"for",
"estimating",
"the",
"density",
"of",
"the",
"sparse",
"dataset"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/benchmark/python/sparse/util.py#L21-L36
|
train
|
apache/incubator-mxnet
|
example/reinforcement-learning/a3c/launcher.py
|
exec_cmd
|
def exec_cmd(cmd, role, taskid, pass_env):
"""Execute the command line command."""
if cmd[0].find('/') == -1 and os.path.exists(cmd[0]) and os.name != 'nt':
cmd[0] = './' + cmd[0]
cmd = ' '.join(cmd)
env = os.environ.copy()
for k, v in pass_env.items():
env[k] = str(v)
env['DMLC_TASK_ID'] = str(taskid)
env['DMLC_ROLE'] = role
env['DMLC_JOB_CLUSTER'] = 'local'
ntrial = 0
while True:
if os.name == 'nt':
env['DMLC_NUM_ATTEMPT'] = str(ntrial)
ret = subprocess.call(cmd, shell=True, env=env)
if ret != 0:
ntrial += 1
continue
else:
bash = cmd
ret = subprocess.call(bash, shell=True, executable='bash', env=env)
if ret == 0:
logging.debug('Thread %d exit with 0', taskid)
return
else:
if os.name == 'nt':
sys.exit(-1)
else:
raise RuntimeError('Get nonzero return code=%d' % ret)
|
python
|
def exec_cmd(cmd, role, taskid, pass_env):
"""Execute the command line command."""
if cmd[0].find('/') == -1 and os.path.exists(cmd[0]) and os.name != 'nt':
cmd[0] = './' + cmd[0]
cmd = ' '.join(cmd)
env = os.environ.copy()
for k, v in pass_env.items():
env[k] = str(v)
env['DMLC_TASK_ID'] = str(taskid)
env['DMLC_ROLE'] = role
env['DMLC_JOB_CLUSTER'] = 'local'
ntrial = 0
while True:
if os.name == 'nt':
env['DMLC_NUM_ATTEMPT'] = str(ntrial)
ret = subprocess.call(cmd, shell=True, env=env)
if ret != 0:
ntrial += 1
continue
else:
bash = cmd
ret = subprocess.call(bash, shell=True, executable='bash', env=env)
if ret == 0:
logging.debug('Thread %d exit with 0', taskid)
return
else:
if os.name == 'nt':
sys.exit(-1)
else:
raise RuntimeError('Get nonzero return code=%d' % ret)
|
[
"def",
"exec_cmd",
"(",
"cmd",
",",
"role",
",",
"taskid",
",",
"pass_env",
")",
":",
"if",
"cmd",
"[",
"0",
"]",
".",
"find",
"(",
"'/'",
")",
"==",
"-",
"1",
"and",
"os",
".",
"path",
".",
"exists",
"(",
"cmd",
"[",
"0",
"]",
")",
"and",
"os",
".",
"name",
"!=",
"'nt'",
":",
"cmd",
"[",
"0",
"]",
"=",
"'./'",
"+",
"cmd",
"[",
"0",
"]",
"cmd",
"=",
"' '",
".",
"join",
"(",
"cmd",
")",
"env",
"=",
"os",
".",
"environ",
".",
"copy",
"(",
")",
"for",
"k",
",",
"v",
"in",
"pass_env",
".",
"items",
"(",
")",
":",
"env",
"[",
"k",
"]",
"=",
"str",
"(",
"v",
")",
"env",
"[",
"'DMLC_TASK_ID'",
"]",
"=",
"str",
"(",
"taskid",
")",
"env",
"[",
"'DMLC_ROLE'",
"]",
"=",
"role",
"env",
"[",
"'DMLC_JOB_CLUSTER'",
"]",
"=",
"'local'",
"ntrial",
"=",
"0",
"while",
"True",
":",
"if",
"os",
".",
"name",
"==",
"'nt'",
":",
"env",
"[",
"'DMLC_NUM_ATTEMPT'",
"]",
"=",
"str",
"(",
"ntrial",
")",
"ret",
"=",
"subprocess",
".",
"call",
"(",
"cmd",
",",
"shell",
"=",
"True",
",",
"env",
"=",
"env",
")",
"if",
"ret",
"!=",
"0",
":",
"ntrial",
"+=",
"1",
"continue",
"else",
":",
"bash",
"=",
"cmd",
"ret",
"=",
"subprocess",
".",
"call",
"(",
"bash",
",",
"shell",
"=",
"True",
",",
"executable",
"=",
"'bash'",
",",
"env",
"=",
"env",
")",
"if",
"ret",
"==",
"0",
":",
"logging",
".",
"debug",
"(",
"'Thread %d exit with 0'",
",",
"taskid",
")",
"return",
"else",
":",
"if",
"os",
".",
"name",
"==",
"'nt'",
":",
"sys",
".",
"exit",
"(",
"-",
"1",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Get nonzero return code=%d'",
"%",
"ret",
")"
] |
Execute the command line command.
|
[
"Execute",
"the",
"command",
"line",
"command",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/reinforcement-learning/a3c/launcher.py#L46-L77
|
train
|
apache/incubator-mxnet
|
example/reinforcement-learning/a3c/launcher.py
|
submit
|
def submit(args):
gpus = args.gpus.strip().split(',')
"""Submit function of local jobs."""
def mthread_submit(nworker, nserver, envs):
"""
customized submit script, that submit nslave jobs, each must contain args as parameter
note this can be a lambda function containing additional parameters in input
Parameters
----------
nworker: number of slave process to start up
nserver: number of server nodes to start up
envs: enviroment variables to be added to the starting programs
"""
procs = {}
for i, gpu in enumerate(gpus):
for j in range(args.num_threads):
procs[i] = Thread(target=exec_cmd, args=(args.command + ['--gpus=%s'%gpu], 'worker', i*args.num_threads+j, envs))
procs[i].setDaemon(True)
procs[i].start()
for i in range(len(gpus)*args.num_threads, len(gpus)*args.num_threads + nserver):
procs[i] = Thread(target=exec_cmd, args=(args.command, 'server', i, envs))
procs[i].setDaemon(True)
procs[i].start()
# call submit, with nslave, the commands to run each job and submit function
tracker.submit(args.num_threads*len(gpus), args.num_servers, fun_submit=mthread_submit,
pscmd=(' '.join(args.command)))
|
python
|
def submit(args):
gpus = args.gpus.strip().split(',')
"""Submit function of local jobs."""
def mthread_submit(nworker, nserver, envs):
"""
customized submit script, that submit nslave jobs, each must contain args as parameter
note this can be a lambda function containing additional parameters in input
Parameters
----------
nworker: number of slave process to start up
nserver: number of server nodes to start up
envs: enviroment variables to be added to the starting programs
"""
procs = {}
for i, gpu in enumerate(gpus):
for j in range(args.num_threads):
procs[i] = Thread(target=exec_cmd, args=(args.command + ['--gpus=%s'%gpu], 'worker', i*args.num_threads+j, envs))
procs[i].setDaemon(True)
procs[i].start()
for i in range(len(gpus)*args.num_threads, len(gpus)*args.num_threads + nserver):
procs[i] = Thread(target=exec_cmd, args=(args.command, 'server', i, envs))
procs[i].setDaemon(True)
procs[i].start()
# call submit, with nslave, the commands to run each job and submit function
tracker.submit(args.num_threads*len(gpus), args.num_servers, fun_submit=mthread_submit,
pscmd=(' '.join(args.command)))
|
[
"def",
"submit",
"(",
"args",
")",
":",
"gpus",
"=",
"args",
".",
"gpus",
".",
"strip",
"(",
")",
".",
"split",
"(",
"','",
")",
"def",
"mthread_submit",
"(",
"nworker",
",",
"nserver",
",",
"envs",
")",
":",
"\"\"\"\n customized submit script, that submit nslave jobs, each must contain args as parameter\n note this can be a lambda function containing additional parameters in input\n\n Parameters\n ----------\n nworker: number of slave process to start up\n nserver: number of server nodes to start up\n envs: enviroment variables to be added to the starting programs\n \"\"\"",
"procs",
"=",
"{",
"}",
"for",
"i",
",",
"gpu",
"in",
"enumerate",
"(",
"gpus",
")",
":",
"for",
"j",
"in",
"range",
"(",
"args",
".",
"num_threads",
")",
":",
"procs",
"[",
"i",
"]",
"=",
"Thread",
"(",
"target",
"=",
"exec_cmd",
",",
"args",
"=",
"(",
"args",
".",
"command",
"+",
"[",
"'--gpus=%s'",
"%",
"gpu",
"]",
",",
"'worker'",
",",
"i",
"*",
"args",
".",
"num_threads",
"+",
"j",
",",
"envs",
")",
")",
"procs",
"[",
"i",
"]",
".",
"setDaemon",
"(",
"True",
")",
"procs",
"[",
"i",
"]",
".",
"start",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"gpus",
")",
"*",
"args",
".",
"num_threads",
",",
"len",
"(",
"gpus",
")",
"*",
"args",
".",
"num_threads",
"+",
"nserver",
")",
":",
"procs",
"[",
"i",
"]",
"=",
"Thread",
"(",
"target",
"=",
"exec_cmd",
",",
"args",
"=",
"(",
"args",
".",
"command",
",",
"'server'",
",",
"i",
",",
"envs",
")",
")",
"procs",
"[",
"i",
"]",
".",
"setDaemon",
"(",
"True",
")",
"procs",
"[",
"i",
"]",
".",
"start",
"(",
")",
"# call submit, with nslave, the commands to run each job and submit function",
"tracker",
".",
"submit",
"(",
"args",
".",
"num_threads",
"*",
"len",
"(",
"gpus",
")",
",",
"args",
".",
"num_servers",
",",
"fun_submit",
"=",
"mthread_submit",
",",
"pscmd",
"=",
"(",
"' '",
".",
"join",
"(",
"args",
".",
"command",
")",
")",
")"
] |
Submit function of local jobs.
|
[
"Submit",
"function",
"of",
"local",
"jobs",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/reinforcement-learning/a3c/launcher.py#L79-L106
|
train
|
apache/incubator-mxnet
|
example/ctc/ctc_metrics.py
|
CtcMetrics.ctc_label
|
def ctc_label(p):
"""Iterates through p, identifying non-zero and non-repeating values, and returns them in a list Parameters
----------
p: list of int
Returns
-------
list of int
"""
ret = []
p1 = [0] + p
for i, _ in enumerate(p):
c1 = p1[i]
c2 = p1[i+1]
if c2 in (0, c1):
continue
ret.append(c2)
return ret
|
python
|
def ctc_label(p):
"""Iterates through p, identifying non-zero and non-repeating values, and returns them in a list Parameters
----------
p: list of int
Returns
-------
list of int
"""
ret = []
p1 = [0] + p
for i, _ in enumerate(p):
c1 = p1[i]
c2 = p1[i+1]
if c2 in (0, c1):
continue
ret.append(c2)
return ret
|
[
"def",
"ctc_label",
"(",
"p",
")",
":",
"ret",
"=",
"[",
"]",
"p1",
"=",
"[",
"0",
"]",
"+",
"p",
"for",
"i",
",",
"_",
"in",
"enumerate",
"(",
"p",
")",
":",
"c1",
"=",
"p1",
"[",
"i",
"]",
"c2",
"=",
"p1",
"[",
"i",
"+",
"1",
"]",
"if",
"c2",
"in",
"(",
"0",
",",
"c1",
")",
":",
"continue",
"ret",
".",
"append",
"(",
"c2",
")",
"return",
"ret"
] |
Iterates through p, identifying non-zero and non-repeating values, and returns them in a list Parameters
----------
p: list of int
Returns
-------
list of int
|
[
"Iterates",
"through",
"p",
"identifying",
"non",
"-",
"zero",
"and",
"non",
"-",
"repeating",
"values",
"and",
"returns",
"them",
"in",
"a",
"list",
"Parameters",
"----------",
"p",
":",
"list",
"of",
"int"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/ctc_metrics.py#L34-L51
|
train
|
apache/incubator-mxnet
|
example/ctc/ctc_metrics.py
|
CtcMetrics._remove_blank
|
def _remove_blank(l):
""" Removes trailing zeros in the list of integers and returns a new list of integers"""
ret = []
for i, _ in enumerate(l):
if l[i] == 0:
break
ret.append(l[i])
return ret
|
python
|
def _remove_blank(l):
""" Removes trailing zeros in the list of integers and returns a new list of integers"""
ret = []
for i, _ in enumerate(l):
if l[i] == 0:
break
ret.append(l[i])
return ret
|
[
"def",
"_remove_blank",
"(",
"l",
")",
":",
"ret",
"=",
"[",
"]",
"for",
"i",
",",
"_",
"in",
"enumerate",
"(",
"l",
")",
":",
"if",
"l",
"[",
"i",
"]",
"==",
"0",
":",
"break",
"ret",
".",
"append",
"(",
"l",
"[",
"i",
"]",
")",
"return",
"ret"
] |
Removes trailing zeros in the list of integers and returns a new list of integers
|
[
"Removes",
"trailing",
"zeros",
"in",
"the",
"list",
"of",
"integers",
"and",
"returns",
"a",
"new",
"list",
"of",
"integers"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/ctc_metrics.py#L54-L61
|
train
|
apache/incubator-mxnet
|
example/ctc/ctc_metrics.py
|
CtcMetrics._lcs
|
def _lcs(p, l):
""" Calculates the Longest Common Subsequence between p and l (both list of int) and returns its length"""
# Dynamic Programming Finding LCS
if len(p) == 0:
return 0
P = np.array(list(p)).reshape((1, len(p)))
L = np.array(list(l)).reshape((len(l), 1))
M = np.ndarray(shape=(len(P), len(L)), dtype=np.int32)
for i in range(M.shape[0]):
for j in range(M.shape[1]):
up = 0 if i == 0 else M[i-1, j]
left = 0 if j == 0 else M[i, j-1]
if i == 0 or j == 0:
M[i, j] = max(up, left, M[i, j])
else:
M[i, j] = M[i, j] + M[i - 1, j - 1]
return M.max()
|
python
|
def _lcs(p, l):
""" Calculates the Longest Common Subsequence between p and l (both list of int) and returns its length"""
# Dynamic Programming Finding LCS
if len(p) == 0:
return 0
P = np.array(list(p)).reshape((1, len(p)))
L = np.array(list(l)).reshape((len(l), 1))
M = np.ndarray(shape=(len(P), len(L)), dtype=np.int32)
for i in range(M.shape[0]):
for j in range(M.shape[1]):
up = 0 if i == 0 else M[i-1, j]
left = 0 if j == 0 else M[i, j-1]
if i == 0 or j == 0:
M[i, j] = max(up, left, M[i, j])
else:
M[i, j] = M[i, j] + M[i - 1, j - 1]
return M.max()
|
[
"def",
"_lcs",
"(",
"p",
",",
"l",
")",
":",
"# Dynamic Programming Finding LCS",
"if",
"len",
"(",
"p",
")",
"==",
"0",
":",
"return",
"0",
"P",
"=",
"np",
".",
"array",
"(",
"list",
"(",
"p",
")",
")",
".",
"reshape",
"(",
"(",
"1",
",",
"len",
"(",
"p",
")",
")",
")",
"L",
"=",
"np",
".",
"array",
"(",
"list",
"(",
"l",
")",
")",
".",
"reshape",
"(",
"(",
"len",
"(",
"l",
")",
",",
"1",
")",
")",
"M",
"=",
"np",
".",
"ndarray",
"(",
"shape",
"=",
"(",
"len",
"(",
"P",
")",
",",
"len",
"(",
"L",
")",
")",
",",
"dtype",
"=",
"np",
".",
"int32",
")",
"for",
"i",
"in",
"range",
"(",
"M",
".",
"shape",
"[",
"0",
"]",
")",
":",
"for",
"j",
"in",
"range",
"(",
"M",
".",
"shape",
"[",
"1",
"]",
")",
":",
"up",
"=",
"0",
"if",
"i",
"==",
"0",
"else",
"M",
"[",
"i",
"-",
"1",
",",
"j",
"]",
"left",
"=",
"0",
"if",
"j",
"==",
"0",
"else",
"M",
"[",
"i",
",",
"j",
"-",
"1",
"]",
"if",
"i",
"==",
"0",
"or",
"j",
"==",
"0",
":",
"M",
"[",
"i",
",",
"j",
"]",
"=",
"max",
"(",
"up",
",",
"left",
",",
"M",
"[",
"i",
",",
"j",
"]",
")",
"else",
":",
"M",
"[",
"i",
",",
"j",
"]",
"=",
"M",
"[",
"i",
",",
"j",
"]",
"+",
"M",
"[",
"i",
"-",
"1",
",",
"j",
"-",
"1",
"]",
"return",
"M",
".",
"max",
"(",
")"
] |
Calculates the Longest Common Subsequence between p and l (both list of int) and returns its length
|
[
"Calculates",
"the",
"Longest",
"Common",
"Subsequence",
"between",
"p",
"and",
"l",
"(",
"both",
"list",
"of",
"int",
")",
"and",
"returns",
"its",
"length"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/ctc_metrics.py#L64-L81
|
train
|
apache/incubator-mxnet
|
example/ctc/ctc_metrics.py
|
CtcMetrics.accuracy
|
def accuracy(self, label, pred):
""" Simple accuracy measure: number of 100% accurate predictions divided by total number """
hit = 0.
total = 0.
batch_size = label.shape[0]
for i in range(batch_size):
l = self._remove_blank(label[i])
p = []
for k in range(self.seq_len):
p.append(np.argmax(pred[k * batch_size + i]))
p = self.ctc_label(p)
if len(p) == len(l):
match = True
for k, _ in enumerate(p):
if p[k] != int(l[k]):
match = False
break
if match:
hit += 1.0
total += 1.0
assert total == batch_size
return hit / total
|
python
|
def accuracy(self, label, pred):
""" Simple accuracy measure: number of 100% accurate predictions divided by total number """
hit = 0.
total = 0.
batch_size = label.shape[0]
for i in range(batch_size):
l = self._remove_blank(label[i])
p = []
for k in range(self.seq_len):
p.append(np.argmax(pred[k * batch_size + i]))
p = self.ctc_label(p)
if len(p) == len(l):
match = True
for k, _ in enumerate(p):
if p[k] != int(l[k]):
match = False
break
if match:
hit += 1.0
total += 1.0
assert total == batch_size
return hit / total
|
[
"def",
"accuracy",
"(",
"self",
",",
"label",
",",
"pred",
")",
":",
"hit",
"=",
"0.",
"total",
"=",
"0.",
"batch_size",
"=",
"label",
".",
"shape",
"[",
"0",
"]",
"for",
"i",
"in",
"range",
"(",
"batch_size",
")",
":",
"l",
"=",
"self",
".",
"_remove_blank",
"(",
"label",
"[",
"i",
"]",
")",
"p",
"=",
"[",
"]",
"for",
"k",
"in",
"range",
"(",
"self",
".",
"seq_len",
")",
":",
"p",
".",
"append",
"(",
"np",
".",
"argmax",
"(",
"pred",
"[",
"k",
"*",
"batch_size",
"+",
"i",
"]",
")",
")",
"p",
"=",
"self",
".",
"ctc_label",
"(",
"p",
")",
"if",
"len",
"(",
"p",
")",
"==",
"len",
"(",
"l",
")",
":",
"match",
"=",
"True",
"for",
"k",
",",
"_",
"in",
"enumerate",
"(",
"p",
")",
":",
"if",
"p",
"[",
"k",
"]",
"!=",
"int",
"(",
"l",
"[",
"k",
"]",
")",
":",
"match",
"=",
"False",
"break",
"if",
"match",
":",
"hit",
"+=",
"1.0",
"total",
"+=",
"1.0",
"assert",
"total",
"==",
"batch_size",
"return",
"hit",
"/",
"total"
] |
Simple accuracy measure: number of 100% accurate predictions divided by total number
|
[
"Simple",
"accuracy",
"measure",
":",
"number",
"of",
"100%",
"accurate",
"predictions",
"divided",
"by",
"total",
"number"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/ctc_metrics.py#L83-L104
|
train
|
apache/incubator-mxnet
|
example/ctc/ctc_metrics.py
|
CtcMetrics.accuracy_lcs
|
def accuracy_lcs(self, label, pred):
""" Longest Common Subsequence accuracy measure: calculate accuracy of each prediction as LCS/length"""
hit = 0.
total = 0.
batch_size = label.shape[0]
for i in range(batch_size):
l = self._remove_blank(label[i])
p = []
for k in range(self.seq_len):
p.append(np.argmax(pred[k * batch_size + i]))
p = self.ctc_label(p)
hit += self._lcs(p, l) * 1.0 / len(l)
total += 1.0
assert total == batch_size
return hit / total
|
python
|
def accuracy_lcs(self, label, pred):
""" Longest Common Subsequence accuracy measure: calculate accuracy of each prediction as LCS/length"""
hit = 0.
total = 0.
batch_size = label.shape[0]
for i in range(batch_size):
l = self._remove_blank(label[i])
p = []
for k in range(self.seq_len):
p.append(np.argmax(pred[k * batch_size + i]))
p = self.ctc_label(p)
hit += self._lcs(p, l) * 1.0 / len(l)
total += 1.0
assert total == batch_size
return hit / total
|
[
"def",
"accuracy_lcs",
"(",
"self",
",",
"label",
",",
"pred",
")",
":",
"hit",
"=",
"0.",
"total",
"=",
"0.",
"batch_size",
"=",
"label",
".",
"shape",
"[",
"0",
"]",
"for",
"i",
"in",
"range",
"(",
"batch_size",
")",
":",
"l",
"=",
"self",
".",
"_remove_blank",
"(",
"label",
"[",
"i",
"]",
")",
"p",
"=",
"[",
"]",
"for",
"k",
"in",
"range",
"(",
"self",
".",
"seq_len",
")",
":",
"p",
".",
"append",
"(",
"np",
".",
"argmax",
"(",
"pred",
"[",
"k",
"*",
"batch_size",
"+",
"i",
"]",
")",
")",
"p",
"=",
"self",
".",
"ctc_label",
"(",
"p",
")",
"hit",
"+=",
"self",
".",
"_lcs",
"(",
"p",
",",
"l",
")",
"*",
"1.0",
"/",
"len",
"(",
"l",
")",
"total",
"+=",
"1.0",
"assert",
"total",
"==",
"batch_size",
"return",
"hit",
"/",
"total"
] |
Longest Common Subsequence accuracy measure: calculate accuracy of each prediction as LCS/length
|
[
"Longest",
"Common",
"Subsequence",
"accuracy",
"measure",
":",
"calculate",
"accuracy",
"of",
"each",
"prediction",
"as",
"LCS",
"/",
"length"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ctc/ctc_metrics.py#L106-L120
|
train
|
apache/incubator-mxnet
|
example/sparse/matrix_factorization/data.py
|
get_movielens_iter
|
def get_movielens_iter(filename, batch_size):
"""Not particularly fast code to parse the text file and load into NDArrays.
return two data iters, one for train, the other for validation.
"""
logging.info("Preparing data iterators for " + filename + " ... ")
user = []
item = []
score = []
with open(filename, 'r') as f:
num_samples = 0
for line in f:
tks = line.strip().split('::')
if len(tks) != 4:
continue
num_samples += 1
user.append((tks[0]))
item.append((tks[1]))
score.append((tks[2]))
# convert to ndarrays
user = mx.nd.array(user, dtype='int32')
item = mx.nd.array(item)
score = mx.nd.array(score)
# prepare data iters
data_train = {'user': user, 'item': item}
label_train = {'score': score}
iter_train = mx.io.NDArrayIter(data=data_train,label=label_train,
batch_size=batch_size, shuffle=True)
return mx.io.PrefetchingIter(iter_train)
|
python
|
def get_movielens_iter(filename, batch_size):
"""Not particularly fast code to parse the text file and load into NDArrays.
return two data iters, one for train, the other for validation.
"""
logging.info("Preparing data iterators for " + filename + " ... ")
user = []
item = []
score = []
with open(filename, 'r') as f:
num_samples = 0
for line in f:
tks = line.strip().split('::')
if len(tks) != 4:
continue
num_samples += 1
user.append((tks[0]))
item.append((tks[1]))
score.append((tks[2]))
# convert to ndarrays
user = mx.nd.array(user, dtype='int32')
item = mx.nd.array(item)
score = mx.nd.array(score)
# prepare data iters
data_train = {'user': user, 'item': item}
label_train = {'score': score}
iter_train = mx.io.NDArrayIter(data=data_train,label=label_train,
batch_size=batch_size, shuffle=True)
return mx.io.PrefetchingIter(iter_train)
|
[
"def",
"get_movielens_iter",
"(",
"filename",
",",
"batch_size",
")",
":",
"logging",
".",
"info",
"(",
"\"Preparing data iterators for \"",
"+",
"filename",
"+",
"\" ... \"",
")",
"user",
"=",
"[",
"]",
"item",
"=",
"[",
"]",
"score",
"=",
"[",
"]",
"with",
"open",
"(",
"filename",
",",
"'r'",
")",
"as",
"f",
":",
"num_samples",
"=",
"0",
"for",
"line",
"in",
"f",
":",
"tks",
"=",
"line",
".",
"strip",
"(",
")",
".",
"split",
"(",
"'::'",
")",
"if",
"len",
"(",
"tks",
")",
"!=",
"4",
":",
"continue",
"num_samples",
"+=",
"1",
"user",
".",
"append",
"(",
"(",
"tks",
"[",
"0",
"]",
")",
")",
"item",
".",
"append",
"(",
"(",
"tks",
"[",
"1",
"]",
")",
")",
"score",
".",
"append",
"(",
"(",
"tks",
"[",
"2",
"]",
")",
")",
"# convert to ndarrays",
"user",
"=",
"mx",
".",
"nd",
".",
"array",
"(",
"user",
",",
"dtype",
"=",
"'int32'",
")",
"item",
"=",
"mx",
".",
"nd",
".",
"array",
"(",
"item",
")",
"score",
"=",
"mx",
".",
"nd",
".",
"array",
"(",
"score",
")",
"# prepare data iters",
"data_train",
"=",
"{",
"'user'",
":",
"user",
",",
"'item'",
":",
"item",
"}",
"label_train",
"=",
"{",
"'score'",
":",
"score",
"}",
"iter_train",
"=",
"mx",
".",
"io",
".",
"NDArrayIter",
"(",
"data",
"=",
"data_train",
",",
"label",
"=",
"label_train",
",",
"batch_size",
"=",
"batch_size",
",",
"shuffle",
"=",
"True",
")",
"return",
"mx",
".",
"io",
".",
"PrefetchingIter",
"(",
"iter_train",
")"
] |
Not particularly fast code to parse the text file and load into NDArrays.
return two data iters, one for train, the other for validation.
|
[
"Not",
"particularly",
"fast",
"code",
"to",
"parse",
"the",
"text",
"file",
"and",
"load",
"into",
"NDArrays",
".",
"return",
"two",
"data",
"iters",
"one",
"for",
"train",
"the",
"other",
"for",
"validation",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/sparse/matrix_factorization/data.py#L29-L56
|
train
|
apache/incubator-mxnet
|
plugin/opencv/opencv.py
|
imdecode
|
def imdecode(str_img, flag=1):
"""Decode image from str buffer.
Wrapper for cv2.imdecode that uses mx.nd.NDArray
Parameters
----------
str_img : str
str buffer read from image file
flag : int
same as flag for cv2.imdecode
Returns
-------
img : NDArray
decoded image in (width, height, channels)
with BGR color channel order
"""
hdl = NDArrayHandle()
check_call(_LIB.MXCVImdecode(ctypes.c_char_p(str_img),
mx_uint(len(str_img)),
flag, ctypes.byref(hdl)))
return mx.nd.NDArray(hdl)
|
python
|
def imdecode(str_img, flag=1):
"""Decode image from str buffer.
Wrapper for cv2.imdecode that uses mx.nd.NDArray
Parameters
----------
str_img : str
str buffer read from image file
flag : int
same as flag for cv2.imdecode
Returns
-------
img : NDArray
decoded image in (width, height, channels)
with BGR color channel order
"""
hdl = NDArrayHandle()
check_call(_LIB.MXCVImdecode(ctypes.c_char_p(str_img),
mx_uint(len(str_img)),
flag, ctypes.byref(hdl)))
return mx.nd.NDArray(hdl)
|
[
"def",
"imdecode",
"(",
"str_img",
",",
"flag",
"=",
"1",
")",
":",
"hdl",
"=",
"NDArrayHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXCVImdecode",
"(",
"ctypes",
".",
"c_char_p",
"(",
"str_img",
")",
",",
"mx_uint",
"(",
"len",
"(",
"str_img",
")",
")",
",",
"flag",
",",
"ctypes",
".",
"byref",
"(",
"hdl",
")",
")",
")",
"return",
"mx",
".",
"nd",
".",
"NDArray",
"(",
"hdl",
")"
] |
Decode image from str buffer.
Wrapper for cv2.imdecode that uses mx.nd.NDArray
Parameters
----------
str_img : str
str buffer read from image file
flag : int
same as flag for cv2.imdecode
Returns
-------
img : NDArray
decoded image in (width, height, channels)
with BGR color channel order
|
[
"Decode",
"image",
"from",
"str",
"buffer",
".",
"Wrapper",
"for",
"cv2",
".",
"imdecode",
"that",
"uses",
"mx",
".",
"nd",
".",
"NDArray"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/plugin/opencv/opencv.py#L29-L49
|
train
|
apache/incubator-mxnet
|
plugin/opencv/opencv.py
|
resize
|
def resize(src, size, interpolation=cv2.INTER_LINEAR):
"""Decode image from str buffer.
Wrapper for cv2.imresize that uses mx.nd.NDArray
Parameters
----------
src : NDArray
image in (width, height, channels)
size : tuple
target size in (width, height)
interpolation : int
same as interpolation for cv2.imresize
Returns
-------
img : NDArray
resized image
"""
hdl = NDArrayHandle()
check_call(_LIB.MXCVResize(src.handle, mx_uint(size[0]), mx_uint(size[1]),
interpolation, ctypes.byref(hdl)))
return mx.nd.NDArray(hdl)
|
python
|
def resize(src, size, interpolation=cv2.INTER_LINEAR):
"""Decode image from str buffer.
Wrapper for cv2.imresize that uses mx.nd.NDArray
Parameters
----------
src : NDArray
image in (width, height, channels)
size : tuple
target size in (width, height)
interpolation : int
same as interpolation for cv2.imresize
Returns
-------
img : NDArray
resized image
"""
hdl = NDArrayHandle()
check_call(_LIB.MXCVResize(src.handle, mx_uint(size[0]), mx_uint(size[1]),
interpolation, ctypes.byref(hdl)))
return mx.nd.NDArray(hdl)
|
[
"def",
"resize",
"(",
"src",
",",
"size",
",",
"interpolation",
"=",
"cv2",
".",
"INTER_LINEAR",
")",
":",
"hdl",
"=",
"NDArrayHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXCVResize",
"(",
"src",
".",
"handle",
",",
"mx_uint",
"(",
"size",
"[",
"0",
"]",
")",
",",
"mx_uint",
"(",
"size",
"[",
"1",
"]",
")",
",",
"interpolation",
",",
"ctypes",
".",
"byref",
"(",
"hdl",
")",
")",
")",
"return",
"mx",
".",
"nd",
".",
"NDArray",
"(",
"hdl",
")"
] |
Decode image from str buffer.
Wrapper for cv2.imresize that uses mx.nd.NDArray
Parameters
----------
src : NDArray
image in (width, height, channels)
size : tuple
target size in (width, height)
interpolation : int
same as interpolation for cv2.imresize
Returns
-------
img : NDArray
resized image
|
[
"Decode",
"image",
"from",
"str",
"buffer",
".",
"Wrapper",
"for",
"cv2",
".",
"imresize",
"that",
"uses",
"mx",
".",
"nd",
".",
"NDArray"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/plugin/opencv/opencv.py#L51-L72
|
train
|
apache/incubator-mxnet
|
plugin/opencv/opencv.py
|
copyMakeBorder
|
def copyMakeBorder(src, top, bot, left, right, border_type=cv2.BORDER_CONSTANT, value=0):
"""Pad image border
Wrapper for cv2.copyMakeBorder that uses mx.nd.NDArray
Parameters
----------
src : NDArray
Image in (width, height, channels).
Others are the same with cv2.copyMakeBorder
Returns
-------
img : NDArray
padded image
"""
hdl = NDArrayHandle()
check_call(_LIB.MXCVcopyMakeBorder(src.handle, ctypes.c_int(top), ctypes.c_int(bot),
ctypes.c_int(left), ctypes.c_int(right),
ctypes.c_int(border_type), ctypes.c_double(value),
ctypes.byref(hdl)))
return mx.nd.NDArray(hdl)
|
python
|
def copyMakeBorder(src, top, bot, left, right, border_type=cv2.BORDER_CONSTANT, value=0):
"""Pad image border
Wrapper for cv2.copyMakeBorder that uses mx.nd.NDArray
Parameters
----------
src : NDArray
Image in (width, height, channels).
Others are the same with cv2.copyMakeBorder
Returns
-------
img : NDArray
padded image
"""
hdl = NDArrayHandle()
check_call(_LIB.MXCVcopyMakeBorder(src.handle, ctypes.c_int(top), ctypes.c_int(bot),
ctypes.c_int(left), ctypes.c_int(right),
ctypes.c_int(border_type), ctypes.c_double(value),
ctypes.byref(hdl)))
return mx.nd.NDArray(hdl)
|
[
"def",
"copyMakeBorder",
"(",
"src",
",",
"top",
",",
"bot",
",",
"left",
",",
"right",
",",
"border_type",
"=",
"cv2",
".",
"BORDER_CONSTANT",
",",
"value",
"=",
"0",
")",
":",
"hdl",
"=",
"NDArrayHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXCVcopyMakeBorder",
"(",
"src",
".",
"handle",
",",
"ctypes",
".",
"c_int",
"(",
"top",
")",
",",
"ctypes",
".",
"c_int",
"(",
"bot",
")",
",",
"ctypes",
".",
"c_int",
"(",
"left",
")",
",",
"ctypes",
".",
"c_int",
"(",
"right",
")",
",",
"ctypes",
".",
"c_int",
"(",
"border_type",
")",
",",
"ctypes",
".",
"c_double",
"(",
"value",
")",
",",
"ctypes",
".",
"byref",
"(",
"hdl",
")",
")",
")",
"return",
"mx",
".",
"nd",
".",
"NDArray",
"(",
"hdl",
")"
] |
Pad image border
Wrapper for cv2.copyMakeBorder that uses mx.nd.NDArray
Parameters
----------
src : NDArray
Image in (width, height, channels).
Others are the same with cv2.copyMakeBorder
Returns
-------
img : NDArray
padded image
|
[
"Pad",
"image",
"border",
"Wrapper",
"for",
"cv2",
".",
"copyMakeBorder",
"that",
"uses",
"mx",
".",
"nd",
".",
"NDArray"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/plugin/opencv/opencv.py#L74-L94
|
train
|
apache/incubator-mxnet
|
plugin/opencv/opencv.py
|
fixed_crop
|
def fixed_crop(src, x0, y0, w, h, size=None, interpolation=cv2.INTER_CUBIC):
"""Crop src at fixed location, and (optionally) resize it to size"""
out = mx.nd.crop(src, begin=(y0, x0, 0), end=(y0+h, x0+w, int(src.shape[2])))
if size is not None and (w, h) != size:
out = resize(out, size, interpolation=interpolation)
return out
|
python
|
def fixed_crop(src, x0, y0, w, h, size=None, interpolation=cv2.INTER_CUBIC):
"""Crop src at fixed location, and (optionally) resize it to size"""
out = mx.nd.crop(src, begin=(y0, x0, 0), end=(y0+h, x0+w, int(src.shape[2])))
if size is not None and (w, h) != size:
out = resize(out, size, interpolation=interpolation)
return out
|
[
"def",
"fixed_crop",
"(",
"src",
",",
"x0",
",",
"y0",
",",
"w",
",",
"h",
",",
"size",
"=",
"None",
",",
"interpolation",
"=",
"cv2",
".",
"INTER_CUBIC",
")",
":",
"out",
"=",
"mx",
".",
"nd",
".",
"crop",
"(",
"src",
",",
"begin",
"=",
"(",
"y0",
",",
"x0",
",",
"0",
")",
",",
"end",
"=",
"(",
"y0",
"+",
"h",
",",
"x0",
"+",
"w",
",",
"int",
"(",
"src",
".",
"shape",
"[",
"2",
"]",
")",
")",
")",
"if",
"size",
"is",
"not",
"None",
"and",
"(",
"w",
",",
"h",
")",
"!=",
"size",
":",
"out",
"=",
"resize",
"(",
"out",
",",
"size",
",",
"interpolation",
"=",
"interpolation",
")",
"return",
"out"
] |
Crop src at fixed location, and (optionally) resize it to size
|
[
"Crop",
"src",
"at",
"fixed",
"location",
"and",
"(",
"optionally",
")",
"resize",
"it",
"to",
"size"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/plugin/opencv/opencv.py#L107-L112
|
train
|
apache/incubator-mxnet
|
plugin/opencv/opencv.py
|
random_crop
|
def random_crop(src, size):
"""Randomly crop src with size. Upsample result if src is smaller than size"""
h, w, _ = src.shape
new_w, new_h = scale_down((w, h), size)
x0 = random.randint(0, w - new_w)
y0 = random.randint(0, h - new_h)
out = fixed_crop(src, x0, y0, new_w, new_h, size)
return out, (x0, y0, new_w, new_h)
|
python
|
def random_crop(src, size):
"""Randomly crop src with size. Upsample result if src is smaller than size"""
h, w, _ = src.shape
new_w, new_h = scale_down((w, h), size)
x0 = random.randint(0, w - new_w)
y0 = random.randint(0, h - new_h)
out = fixed_crop(src, x0, y0, new_w, new_h, size)
return out, (x0, y0, new_w, new_h)
|
[
"def",
"random_crop",
"(",
"src",
",",
"size",
")",
":",
"h",
",",
"w",
",",
"_",
"=",
"src",
".",
"shape",
"new_w",
",",
"new_h",
"=",
"scale_down",
"(",
"(",
"w",
",",
"h",
")",
",",
"size",
")",
"x0",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"w",
"-",
"new_w",
")",
"y0",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"h",
"-",
"new_h",
")",
"out",
"=",
"fixed_crop",
"(",
"src",
",",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
",",
"size",
")",
"return",
"out",
",",
"(",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
")"
] |
Randomly crop src with size. Upsample result if src is smaller than size
|
[
"Randomly",
"crop",
"src",
"with",
"size",
".",
"Upsample",
"result",
"if",
"src",
"is",
"smaller",
"than",
"size"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/plugin/opencv/opencv.py#L114-L123
|
train
|
apache/incubator-mxnet
|
plugin/opencv/opencv.py
|
random_size_crop
|
def random_size_crop(src, size, min_area=0.25, ratio=(3.0/4.0, 4.0/3.0)):
"""Randomly crop src with size. Randomize area and aspect ratio"""
h, w, _ = src.shape
area = w*h
for _ in range(10):
new_area = random.uniform(min_area, 1.0) * area
new_ratio = random.uniform(*ratio)
new_w = int(new_area*new_ratio)
new_h = int(new_area/new_ratio)
if random.uniform(0., 1.) < 0.5:
new_w, new_h = new_h, new_w
if new_w > w or new_h > h:
continue
x0 = random.randint(0, w - new_w)
y0 = random.randint(0, h - new_h)
out = fixed_crop(src, x0, y0, new_w, new_h, size)
return out, (x0, y0, new_w, new_h)
return random_crop(src, size)
|
python
|
def random_size_crop(src, size, min_area=0.25, ratio=(3.0/4.0, 4.0/3.0)):
"""Randomly crop src with size. Randomize area and aspect ratio"""
h, w, _ = src.shape
area = w*h
for _ in range(10):
new_area = random.uniform(min_area, 1.0) * area
new_ratio = random.uniform(*ratio)
new_w = int(new_area*new_ratio)
new_h = int(new_area/new_ratio)
if random.uniform(0., 1.) < 0.5:
new_w, new_h = new_h, new_w
if new_w > w or new_h > h:
continue
x0 = random.randint(0, w - new_w)
y0 = random.randint(0, h - new_h)
out = fixed_crop(src, x0, y0, new_w, new_h, size)
return out, (x0, y0, new_w, new_h)
return random_crop(src, size)
|
[
"def",
"random_size_crop",
"(",
"src",
",",
"size",
",",
"min_area",
"=",
"0.25",
",",
"ratio",
"=",
"(",
"3.0",
"/",
"4.0",
",",
"4.0",
"/",
"3.0",
")",
")",
":",
"h",
",",
"w",
",",
"_",
"=",
"src",
".",
"shape",
"area",
"=",
"w",
"*",
"h",
"for",
"_",
"in",
"range",
"(",
"10",
")",
":",
"new_area",
"=",
"random",
".",
"uniform",
"(",
"min_area",
",",
"1.0",
")",
"*",
"area",
"new_ratio",
"=",
"random",
".",
"uniform",
"(",
"*",
"ratio",
")",
"new_w",
"=",
"int",
"(",
"new_area",
"*",
"new_ratio",
")",
"new_h",
"=",
"int",
"(",
"new_area",
"/",
"new_ratio",
")",
"if",
"random",
".",
"uniform",
"(",
"0.",
",",
"1.",
")",
"<",
"0.5",
":",
"new_w",
",",
"new_h",
"=",
"new_h",
",",
"new_w",
"if",
"new_w",
">",
"w",
"or",
"new_h",
">",
"h",
":",
"continue",
"x0",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"w",
"-",
"new_w",
")",
"y0",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"h",
"-",
"new_h",
")",
"out",
"=",
"fixed_crop",
"(",
"src",
",",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
",",
"size",
")",
"return",
"out",
",",
"(",
"x0",
",",
"y0",
",",
"new_w",
",",
"new_h",
")",
"return",
"random_crop",
"(",
"src",
",",
"size",
")"
] |
Randomly crop src with size. Randomize area and aspect ratio
|
[
"Randomly",
"crop",
"src",
"with",
"size",
".",
"Randomize",
"area",
"and",
"aspect",
"ratio"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/plugin/opencv/opencv.py#L131-L153
|
train
|
apache/incubator-mxnet
|
plugin/opencv/opencv.py
|
ImageListIter.next
|
def next(self):
"""Move iterator position forward"""
batch = mx.nd.zeros((self.batch_size, self.size[1], self.size[0], 3))
i = self.cur
for i in range(self.cur, min(len(self.list), self.cur+self.batch_size)):
str_img = open(self.root+self.list[i]+'.jpg').read()
img = imdecode(str_img, 1)
img, _ = random_crop(img, self.size)
batch[i - self.cur] = img
batch = mx.nd.transpose(batch, axes=(0, 3, 1, 2))
ret = mx.io.DataBatch(data=[batch],
label=[],
pad=self.batch_size-(i-self.cur),
index=None)
self.cur = i
return ret
|
python
|
def next(self):
"""Move iterator position forward"""
batch = mx.nd.zeros((self.batch_size, self.size[1], self.size[0], 3))
i = self.cur
for i in range(self.cur, min(len(self.list), self.cur+self.batch_size)):
str_img = open(self.root+self.list[i]+'.jpg').read()
img = imdecode(str_img, 1)
img, _ = random_crop(img, self.size)
batch[i - self.cur] = img
batch = mx.nd.transpose(batch, axes=(0, 3, 1, 2))
ret = mx.io.DataBatch(data=[batch],
label=[],
pad=self.batch_size-(i-self.cur),
index=None)
self.cur = i
return ret
|
[
"def",
"next",
"(",
"self",
")",
":",
"batch",
"=",
"mx",
".",
"nd",
".",
"zeros",
"(",
"(",
"self",
".",
"batch_size",
",",
"self",
".",
"size",
"[",
"1",
"]",
",",
"self",
".",
"size",
"[",
"0",
"]",
",",
"3",
")",
")",
"i",
"=",
"self",
".",
"cur",
"for",
"i",
"in",
"range",
"(",
"self",
".",
"cur",
",",
"min",
"(",
"len",
"(",
"self",
".",
"list",
")",
",",
"self",
".",
"cur",
"+",
"self",
".",
"batch_size",
")",
")",
":",
"str_img",
"=",
"open",
"(",
"self",
".",
"root",
"+",
"self",
".",
"list",
"[",
"i",
"]",
"+",
"'.jpg'",
")",
".",
"read",
"(",
")",
"img",
"=",
"imdecode",
"(",
"str_img",
",",
"1",
")",
"img",
",",
"_",
"=",
"random_crop",
"(",
"img",
",",
"self",
".",
"size",
")",
"batch",
"[",
"i",
"-",
"self",
".",
"cur",
"]",
"=",
"img",
"batch",
"=",
"mx",
".",
"nd",
".",
"transpose",
"(",
"batch",
",",
"axes",
"=",
"(",
"0",
",",
"3",
",",
"1",
",",
"2",
")",
")",
"ret",
"=",
"mx",
".",
"io",
".",
"DataBatch",
"(",
"data",
"=",
"[",
"batch",
"]",
",",
"label",
"=",
"[",
"]",
",",
"pad",
"=",
"self",
".",
"batch_size",
"-",
"(",
"i",
"-",
"self",
".",
"cur",
")",
",",
"index",
"=",
"None",
")",
"self",
".",
"cur",
"=",
"i",
"return",
"ret"
] |
Move iterator position forward
|
[
"Move",
"iterator",
"position",
"forward"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/plugin/opencv/opencv.py#L173-L188
|
train
|
apache/incubator-mxnet
|
example/speech_recognition/stt_metric.py
|
check_label_shapes
|
def check_label_shapes(labels, preds, shape=0):
"""Check to see if the two arrays are the same size."""
if shape == 0:
label_shape, pred_shape = len(labels), len(preds)
else:
label_shape, pred_shape = labels.shape, preds.shape
if label_shape != pred_shape:
raise ValueError("Shape of labels {} does not match shape of "
"predictions {}".format(label_shape, pred_shape))
|
python
|
def check_label_shapes(labels, preds, shape=0):
"""Check to see if the two arrays are the same size."""
if shape == 0:
label_shape, pred_shape = len(labels), len(preds)
else:
label_shape, pred_shape = labels.shape, preds.shape
if label_shape != pred_shape:
raise ValueError("Shape of labels {} does not match shape of "
"predictions {}".format(label_shape, pred_shape))
|
[
"def",
"check_label_shapes",
"(",
"labels",
",",
"preds",
",",
"shape",
"=",
"0",
")",
":",
"if",
"shape",
"==",
"0",
":",
"label_shape",
",",
"pred_shape",
"=",
"len",
"(",
"labels",
")",
",",
"len",
"(",
"preds",
")",
"else",
":",
"label_shape",
",",
"pred_shape",
"=",
"labels",
".",
"shape",
",",
"preds",
".",
"shape",
"if",
"label_shape",
"!=",
"pred_shape",
":",
"raise",
"ValueError",
"(",
"\"Shape of labels {} does not match shape of \"",
"\"predictions {}\"",
".",
"format",
"(",
"label_shape",
",",
"pred_shape",
")",
")"
] |
Check to see if the two arrays are the same size.
|
[
"Check",
"to",
"see",
"if",
"the",
"two",
"arrays",
"are",
"the",
"same",
"size",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/speech_recognition/stt_metric.py#L25-L35
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/import_to_gluon.py
|
import_to_gluon
|
def import_to_gluon(model_file, ctx):
"""
Imports the ONNX model files, passed as a parameter, into Gluon SymbolBlock object.
Parameters
----------
model_file : str
ONNX model file name
ctx : Context or list of Context
Loads the model into one or many context(s).
Returns
-------
sym_block : :class:`~mxnet.gluon.SymbolBlock`
A SymbolBlock object representing the given model file.
Notes
-----
This method is available when you ``import mxnet.contrib.onnx``
"""
graph = GraphProto()
try:
import onnx
except ImportError:
raise ImportError("Onnx and protobuf need to be installed. Instructions to"
+ " install - https://github.com/onnx/onnx#installation")
model_proto = onnx.load_model(model_file)
net = graph.graph_to_gluon(model_proto.graph, ctx)
return net
|
python
|
def import_to_gluon(model_file, ctx):
"""
Imports the ONNX model files, passed as a parameter, into Gluon SymbolBlock object.
Parameters
----------
model_file : str
ONNX model file name
ctx : Context or list of Context
Loads the model into one or many context(s).
Returns
-------
sym_block : :class:`~mxnet.gluon.SymbolBlock`
A SymbolBlock object representing the given model file.
Notes
-----
This method is available when you ``import mxnet.contrib.onnx``
"""
graph = GraphProto()
try:
import onnx
except ImportError:
raise ImportError("Onnx and protobuf need to be installed. Instructions to"
+ " install - https://github.com/onnx/onnx#installation")
model_proto = onnx.load_model(model_file)
net = graph.graph_to_gluon(model_proto.graph, ctx)
return net
|
[
"def",
"import_to_gluon",
"(",
"model_file",
",",
"ctx",
")",
":",
"graph",
"=",
"GraphProto",
"(",
")",
"try",
":",
"import",
"onnx",
"except",
"ImportError",
":",
"raise",
"ImportError",
"(",
"\"Onnx and protobuf need to be installed. Instructions to\"",
"+",
"\" install - https://github.com/onnx/onnx#installation\"",
")",
"model_proto",
"=",
"onnx",
".",
"load_model",
"(",
"model_file",
")",
"net",
"=",
"graph",
".",
"graph_to_gluon",
"(",
"model_proto",
".",
"graph",
",",
"ctx",
")",
"return",
"net"
] |
Imports the ONNX model files, passed as a parameter, into Gluon SymbolBlock object.
Parameters
----------
model_file : str
ONNX model file name
ctx : Context or list of Context
Loads the model into one or many context(s).
Returns
-------
sym_block : :class:`~mxnet.gluon.SymbolBlock`
A SymbolBlock object representing the given model file.
Notes
-----
This method is available when you ``import mxnet.contrib.onnx``
|
[
"Imports",
"the",
"ONNX",
"model",
"files",
"passed",
"as",
"a",
"parameter",
"into",
"Gluon",
"SymbolBlock",
"object",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/import_to_gluon.py#L24-L53
|
train
|
apache/incubator-mxnet
|
example/gluon/image_classification.py
|
get_model
|
def get_model(model, ctx, opt):
"""Model initialization."""
kwargs = {'ctx': ctx, 'pretrained': opt.use_pretrained, 'classes': classes}
if model.startswith('resnet'):
kwargs['thumbnail'] = opt.use_thumbnail
elif model.startswith('vgg'):
kwargs['batch_norm'] = opt.batch_norm
net = models.get_model(model, **kwargs)
if opt.resume:
net.load_parameters(opt.resume)
elif not opt.use_pretrained:
if model in ['alexnet']:
net.initialize(mx.init.Normal())
else:
net.initialize(mx.init.Xavier(magnitude=2))
net.cast(opt.dtype)
return net
|
python
|
def get_model(model, ctx, opt):
"""Model initialization."""
kwargs = {'ctx': ctx, 'pretrained': opt.use_pretrained, 'classes': classes}
if model.startswith('resnet'):
kwargs['thumbnail'] = opt.use_thumbnail
elif model.startswith('vgg'):
kwargs['batch_norm'] = opt.batch_norm
net = models.get_model(model, **kwargs)
if opt.resume:
net.load_parameters(opt.resume)
elif not opt.use_pretrained:
if model in ['alexnet']:
net.initialize(mx.init.Normal())
else:
net.initialize(mx.init.Xavier(magnitude=2))
net.cast(opt.dtype)
return net
|
[
"def",
"get_model",
"(",
"model",
",",
"ctx",
",",
"opt",
")",
":",
"kwargs",
"=",
"{",
"'ctx'",
":",
"ctx",
",",
"'pretrained'",
":",
"opt",
".",
"use_pretrained",
",",
"'classes'",
":",
"classes",
"}",
"if",
"model",
".",
"startswith",
"(",
"'resnet'",
")",
":",
"kwargs",
"[",
"'thumbnail'",
"]",
"=",
"opt",
".",
"use_thumbnail",
"elif",
"model",
".",
"startswith",
"(",
"'vgg'",
")",
":",
"kwargs",
"[",
"'batch_norm'",
"]",
"=",
"opt",
".",
"batch_norm",
"net",
"=",
"models",
".",
"get_model",
"(",
"model",
",",
"*",
"*",
"kwargs",
")",
"if",
"opt",
".",
"resume",
":",
"net",
".",
"load_parameters",
"(",
"opt",
".",
"resume",
")",
"elif",
"not",
"opt",
".",
"use_pretrained",
":",
"if",
"model",
"in",
"[",
"'alexnet'",
"]",
":",
"net",
".",
"initialize",
"(",
"mx",
".",
"init",
".",
"Normal",
"(",
")",
")",
"else",
":",
"net",
".",
"initialize",
"(",
"mx",
".",
"init",
".",
"Xavier",
"(",
"magnitude",
"=",
"2",
")",
")",
"net",
".",
"cast",
"(",
"opt",
".",
"dtype",
")",
"return",
"net"
] |
Model initialization.
|
[
"Model",
"initialization",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/image_classification.py#L117-L134
|
train
|
apache/incubator-mxnet
|
example/gluon/image_classification.py
|
get_data_iters
|
def get_data_iters(dataset, batch_size, opt):
"""get dataset iterators"""
if dataset == 'mnist':
train_data, val_data = get_mnist_iterator(batch_size, (1, 28, 28),
num_parts=kv.num_workers, part_index=kv.rank)
elif dataset == 'cifar10':
train_data, val_data = get_cifar10_iterator(batch_size, (3, 32, 32),
num_parts=kv.num_workers, part_index=kv.rank)
elif dataset == 'imagenet':
shape_dim = 299 if model_name == 'inceptionv3' else 224
if not opt.data_dir:
raise ValueError('Dir containing raw images in train/val is required for imagenet.'
'Please specify "--data-dir"')
train_data, val_data = get_imagenet_iterator(opt.data_dir, batch_size,
opt.num_workers, shape_dim, opt.dtype)
elif dataset == 'caltech101':
train_data, val_data = get_caltech101_iterator(batch_size, opt.num_workers, opt.dtype)
elif dataset == 'dummy':
shape_dim = 299 if model_name == 'inceptionv3' else 224
train_data, val_data = dummy_iterator(batch_size, (3, shape_dim, shape_dim))
return train_data, val_data
|
python
|
def get_data_iters(dataset, batch_size, opt):
"""get dataset iterators"""
if dataset == 'mnist':
train_data, val_data = get_mnist_iterator(batch_size, (1, 28, 28),
num_parts=kv.num_workers, part_index=kv.rank)
elif dataset == 'cifar10':
train_data, val_data = get_cifar10_iterator(batch_size, (3, 32, 32),
num_parts=kv.num_workers, part_index=kv.rank)
elif dataset == 'imagenet':
shape_dim = 299 if model_name == 'inceptionv3' else 224
if not opt.data_dir:
raise ValueError('Dir containing raw images in train/val is required for imagenet.'
'Please specify "--data-dir"')
train_data, val_data = get_imagenet_iterator(opt.data_dir, batch_size,
opt.num_workers, shape_dim, opt.dtype)
elif dataset == 'caltech101':
train_data, val_data = get_caltech101_iterator(batch_size, opt.num_workers, opt.dtype)
elif dataset == 'dummy':
shape_dim = 299 if model_name == 'inceptionv3' else 224
train_data, val_data = dummy_iterator(batch_size, (3, shape_dim, shape_dim))
return train_data, val_data
|
[
"def",
"get_data_iters",
"(",
"dataset",
",",
"batch_size",
",",
"opt",
")",
":",
"if",
"dataset",
"==",
"'mnist'",
":",
"train_data",
",",
"val_data",
"=",
"get_mnist_iterator",
"(",
"batch_size",
",",
"(",
"1",
",",
"28",
",",
"28",
")",
",",
"num_parts",
"=",
"kv",
".",
"num_workers",
",",
"part_index",
"=",
"kv",
".",
"rank",
")",
"elif",
"dataset",
"==",
"'cifar10'",
":",
"train_data",
",",
"val_data",
"=",
"get_cifar10_iterator",
"(",
"batch_size",
",",
"(",
"3",
",",
"32",
",",
"32",
")",
",",
"num_parts",
"=",
"kv",
".",
"num_workers",
",",
"part_index",
"=",
"kv",
".",
"rank",
")",
"elif",
"dataset",
"==",
"'imagenet'",
":",
"shape_dim",
"=",
"299",
"if",
"model_name",
"==",
"'inceptionv3'",
"else",
"224",
"if",
"not",
"opt",
".",
"data_dir",
":",
"raise",
"ValueError",
"(",
"'Dir containing raw images in train/val is required for imagenet.'",
"'Please specify \"--data-dir\"'",
")",
"train_data",
",",
"val_data",
"=",
"get_imagenet_iterator",
"(",
"opt",
".",
"data_dir",
",",
"batch_size",
",",
"opt",
".",
"num_workers",
",",
"shape_dim",
",",
"opt",
".",
"dtype",
")",
"elif",
"dataset",
"==",
"'caltech101'",
":",
"train_data",
",",
"val_data",
"=",
"get_caltech101_iterator",
"(",
"batch_size",
",",
"opt",
".",
"num_workers",
",",
"opt",
".",
"dtype",
")",
"elif",
"dataset",
"==",
"'dummy'",
":",
"shape_dim",
"=",
"299",
"if",
"model_name",
"==",
"'inceptionv3'",
"else",
"224",
"train_data",
",",
"val_data",
"=",
"dummy_iterator",
"(",
"batch_size",
",",
"(",
"3",
",",
"shape_dim",
",",
"shape_dim",
")",
")",
"return",
"train_data",
",",
"val_data"
] |
get dataset iterators
|
[
"get",
"dataset",
"iterators"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/image_classification.py#L138-L160
|
train
|
apache/incubator-mxnet
|
example/gluon/image_classification.py
|
update_learning_rate
|
def update_learning_rate(lr, trainer, epoch, ratio, steps):
"""Set the learning rate to the initial value decayed by ratio every N epochs."""
new_lr = lr * (ratio ** int(np.sum(np.array(steps) < epoch)))
trainer.set_learning_rate(new_lr)
return trainer
|
python
|
def update_learning_rate(lr, trainer, epoch, ratio, steps):
"""Set the learning rate to the initial value decayed by ratio every N epochs."""
new_lr = lr * (ratio ** int(np.sum(np.array(steps) < epoch)))
trainer.set_learning_rate(new_lr)
return trainer
|
[
"def",
"update_learning_rate",
"(",
"lr",
",",
"trainer",
",",
"epoch",
",",
"ratio",
",",
"steps",
")",
":",
"new_lr",
"=",
"lr",
"*",
"(",
"ratio",
"**",
"int",
"(",
"np",
".",
"sum",
"(",
"np",
".",
"array",
"(",
"steps",
")",
"<",
"epoch",
")",
")",
")",
"trainer",
".",
"set_learning_rate",
"(",
"new_lr",
")",
"return",
"trainer"
] |
Set the learning rate to the initial value decayed by ratio every N epochs.
|
[
"Set",
"the",
"learning",
"rate",
"to",
"the",
"initial",
"value",
"decayed",
"by",
"ratio",
"every",
"N",
"epochs",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/image_classification.py#L174-L178
|
train
|
apache/incubator-mxnet
|
python/mxnet/random.py
|
seed
|
def seed(seed_state, ctx="all"):
"""Seeds the random number generators in MXNet.
This affects the behavior of modules in MXNet that uses random number generators,
like the dropout operator and `NDArray`'s random sampling operators.
Parameters
----------
seed_state : int
The random number seed.
ctx : Context
The device context of the generator. The default is "all" which means seeding random
number generators of all devices.
Notes
-----
Random number generators in MXNet are device specific.
`mx.random.seed(seed_state)` sets the state of each generator using `seed_state` and the
device id. Therefore, random numbers generated from different devices can be different
even if they are seeded using the same seed.
To produce identical random number sequences independent of the device id,
set optional `ctx` argument. This produces the same sequence of random numbers independent
of the device id, but the sequence can be different on different kind of devices as MXNet's
random number generators for CPU and GPU use different algorithms.
Example
-------
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 1.36481571 -0.62203991]
[-1.4962182 -0.08511394]]
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 1.09544981 -0.20014545]
[-0.20808885 0.2527658 ]]
# Same results on the same device with the same seed
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 0.47400656 -0.75213492]
[ 0.20251541 0.95352972]]
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 0.47400656 -0.75213492]
[ 0.20251541 0.95352972]]
# Different results on gpu(0) and gpu(1) with the same seed
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(0)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(1)).asnumpy())
[[ 0.24336822 -1.664805 ]
[-1.0223296 1.253198 ]]
# Seeding with `ctx` argument produces identical results on gpu(0) and gpu(1)
>>> mx.random.seed(128, ctx=mx.gpu(0))
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(0)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
>>> mx.random.seed(128, ctx=mx.gpu(1))
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(1)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
"""
if not isinstance(seed_state, integer_types):
raise ValueError('seed_state must be int')
seed_state = ctypes.c_int(int(seed_state))
if ctx == "all":
check_call(_LIB.MXRandomSeed(seed_state))
else:
ctx = Context(ctx)
check_call(_LIB.MXRandomSeedContext(seed_state, ctx.device_typeid, ctx.device_id))
|
python
|
def seed(seed_state, ctx="all"):
"""Seeds the random number generators in MXNet.
This affects the behavior of modules in MXNet that uses random number generators,
like the dropout operator and `NDArray`'s random sampling operators.
Parameters
----------
seed_state : int
The random number seed.
ctx : Context
The device context of the generator. The default is "all" which means seeding random
number generators of all devices.
Notes
-----
Random number generators in MXNet are device specific.
`mx.random.seed(seed_state)` sets the state of each generator using `seed_state` and the
device id. Therefore, random numbers generated from different devices can be different
even if they are seeded using the same seed.
To produce identical random number sequences independent of the device id,
set optional `ctx` argument. This produces the same sequence of random numbers independent
of the device id, but the sequence can be different on different kind of devices as MXNet's
random number generators for CPU and GPU use different algorithms.
Example
-------
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 1.36481571 -0.62203991]
[-1.4962182 -0.08511394]]
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 1.09544981 -0.20014545]
[-0.20808885 0.2527658 ]]
# Same results on the same device with the same seed
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 0.47400656 -0.75213492]
[ 0.20251541 0.95352972]]
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 0.47400656 -0.75213492]
[ 0.20251541 0.95352972]]
# Different results on gpu(0) and gpu(1) with the same seed
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(0)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(1)).asnumpy())
[[ 0.24336822 -1.664805 ]
[-1.0223296 1.253198 ]]
# Seeding with `ctx` argument produces identical results on gpu(0) and gpu(1)
>>> mx.random.seed(128, ctx=mx.gpu(0))
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(0)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
>>> mx.random.seed(128, ctx=mx.gpu(1))
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(1)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
"""
if not isinstance(seed_state, integer_types):
raise ValueError('seed_state must be int')
seed_state = ctypes.c_int(int(seed_state))
if ctx == "all":
check_call(_LIB.MXRandomSeed(seed_state))
else:
ctx = Context(ctx)
check_call(_LIB.MXRandomSeedContext(seed_state, ctx.device_typeid, ctx.device_id))
|
[
"def",
"seed",
"(",
"seed_state",
",",
"ctx",
"=",
"\"all\"",
")",
":",
"if",
"not",
"isinstance",
"(",
"seed_state",
",",
"integer_types",
")",
":",
"raise",
"ValueError",
"(",
"'seed_state must be int'",
")",
"seed_state",
"=",
"ctypes",
".",
"c_int",
"(",
"int",
"(",
"seed_state",
")",
")",
"if",
"ctx",
"==",
"\"all\"",
":",
"check_call",
"(",
"_LIB",
".",
"MXRandomSeed",
"(",
"seed_state",
")",
")",
"else",
":",
"ctx",
"=",
"Context",
"(",
"ctx",
")",
"check_call",
"(",
"_LIB",
".",
"MXRandomSeedContext",
"(",
"seed_state",
",",
"ctx",
".",
"device_typeid",
",",
"ctx",
".",
"device_id",
")",
")"
] |
Seeds the random number generators in MXNet.
This affects the behavior of modules in MXNet that uses random number generators,
like the dropout operator and `NDArray`'s random sampling operators.
Parameters
----------
seed_state : int
The random number seed.
ctx : Context
The device context of the generator. The default is "all" which means seeding random
number generators of all devices.
Notes
-----
Random number generators in MXNet are device specific.
`mx.random.seed(seed_state)` sets the state of each generator using `seed_state` and the
device id. Therefore, random numbers generated from different devices can be different
even if they are seeded using the same seed.
To produce identical random number sequences independent of the device id,
set optional `ctx` argument. This produces the same sequence of random numbers independent
of the device id, but the sequence can be different on different kind of devices as MXNet's
random number generators for CPU and GPU use different algorithms.
Example
-------
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 1.36481571 -0.62203991]
[-1.4962182 -0.08511394]]
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 1.09544981 -0.20014545]
[-0.20808885 0.2527658 ]]
# Same results on the same device with the same seed
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 0.47400656 -0.75213492]
[ 0.20251541 0.95352972]]
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2)).asnumpy())
[[ 0.47400656 -0.75213492]
[ 0.20251541 0.95352972]]
# Different results on gpu(0) and gpu(1) with the same seed
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(0)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
>>> mx.random.seed(128)
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(1)).asnumpy())
[[ 0.24336822 -1.664805 ]
[-1.0223296 1.253198 ]]
# Seeding with `ctx` argument produces identical results on gpu(0) and gpu(1)
>>> mx.random.seed(128, ctx=mx.gpu(0))
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(0)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
>>> mx.random.seed(128, ctx=mx.gpu(1))
>>> print(mx.nd.random.normal(shape=(2,2), ctx=mx.gpu(1)).asnumpy())
[[ 2.5020072 -1.6884501]
[-0.7931333 -1.4218881]]
|
[
"Seeds",
"the",
"random",
"number",
"generators",
"in",
"MXNet",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/random.py#L30-L100
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
random_uniform
|
def random_uniform(attrs, inputs, proto_obj):
"""Draw random samples from a uniform distribtuion."""
try:
from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE
except ImportError:
raise ImportError("Onnx and protobuf need to be installed. "
"Instructions to install - https://github.com/onnx/onnx")
new_attrs = translation_utils._remove_attributes(attrs, ['seed'])
new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attrs.get('dtype', 1))]
return 'random_uniform', new_attrs, inputs
|
python
|
def random_uniform(attrs, inputs, proto_obj):
"""Draw random samples from a uniform distribtuion."""
try:
from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE
except ImportError:
raise ImportError("Onnx and protobuf need to be installed. "
"Instructions to install - https://github.com/onnx/onnx")
new_attrs = translation_utils._remove_attributes(attrs, ['seed'])
new_attrs['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attrs.get('dtype', 1))]
return 'random_uniform', new_attrs, inputs
|
[
"def",
"random_uniform",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"try",
":",
"from",
"onnx",
".",
"mapping",
"import",
"TENSOR_TYPE_TO_NP_TYPE",
"except",
"ImportError",
":",
"raise",
"ImportError",
"(",
"\"Onnx and protobuf need to be installed. \"",
"\"Instructions to install - https://github.com/onnx/onnx\"",
")",
"new_attrs",
"=",
"translation_utils",
".",
"_remove_attributes",
"(",
"attrs",
",",
"[",
"'seed'",
"]",
")",
"new_attrs",
"[",
"'dtype'",
"]",
"=",
"TENSOR_TYPE_TO_NP_TYPE",
"[",
"int",
"(",
"new_attrs",
".",
"get",
"(",
"'dtype'",
",",
"1",
")",
")",
"]",
"return",
"'random_uniform'",
",",
"new_attrs",
",",
"inputs"
] |
Draw random samples from a uniform distribtuion.
|
[
"Draw",
"random",
"samples",
"from",
"a",
"uniform",
"distribtuion",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L30-L39
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
random_normal
|
def random_normal(attrs, inputs, proto_obj):
"""Draw random samples from a Gaussian distribution."""
try:
from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE
except ImportError:
raise ImportError("Onnx and protobuf need to be installed. "
"Instructions to install - https://github.com/onnx/onnx")
new_attr = translation_utils._remove_attributes(attrs, ['seed'])
new_attr = translation_utils._fix_attribute_names(new_attr, {'mean': 'loc'})
new_attr['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attr.get('dtype', 1))]
return 'random_normal', new_attr, inputs
|
python
|
def random_normal(attrs, inputs, proto_obj):
"""Draw random samples from a Gaussian distribution."""
try:
from onnx.mapping import TENSOR_TYPE_TO_NP_TYPE
except ImportError:
raise ImportError("Onnx and protobuf need to be installed. "
"Instructions to install - https://github.com/onnx/onnx")
new_attr = translation_utils._remove_attributes(attrs, ['seed'])
new_attr = translation_utils._fix_attribute_names(new_attr, {'mean': 'loc'})
new_attr['dtype'] = TENSOR_TYPE_TO_NP_TYPE[int(new_attr.get('dtype', 1))]
return 'random_normal', new_attr, inputs
|
[
"def",
"random_normal",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"try",
":",
"from",
"onnx",
".",
"mapping",
"import",
"TENSOR_TYPE_TO_NP_TYPE",
"except",
"ImportError",
":",
"raise",
"ImportError",
"(",
"\"Onnx and protobuf need to be installed. \"",
"\"Instructions to install - https://github.com/onnx/onnx\"",
")",
"new_attr",
"=",
"translation_utils",
".",
"_remove_attributes",
"(",
"attrs",
",",
"[",
"'seed'",
"]",
")",
"new_attr",
"=",
"translation_utils",
".",
"_fix_attribute_names",
"(",
"new_attr",
",",
"{",
"'mean'",
":",
"'loc'",
"}",
")",
"new_attr",
"[",
"'dtype'",
"]",
"=",
"TENSOR_TYPE_TO_NP_TYPE",
"[",
"int",
"(",
"new_attr",
".",
"get",
"(",
"'dtype'",
",",
"1",
")",
")",
"]",
"return",
"'random_normal'",
",",
"new_attr",
",",
"inputs"
] |
Draw random samples from a Gaussian distribution.
|
[
"Draw",
"random",
"samples",
"from",
"a",
"Gaussian",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L41-L51
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
add
|
def add(attrs, inputs, proto_obj):
"""Adding two tensors"""
new_attr = {}
if 'broadcast' in attrs and attrs['broadcast'] == 1:
broadcast_axis = attrs['axis']
op_value = translation_utils._fix_broadcast('broadcast_add', inputs,
broadcast_axis, proto_obj)
return op_value, new_attr, inputs
return 'broadcast_add', new_attr, inputs
|
python
|
def add(attrs, inputs, proto_obj):
"""Adding two tensors"""
new_attr = {}
if 'broadcast' in attrs and attrs['broadcast'] == 1:
broadcast_axis = attrs['axis']
op_value = translation_utils._fix_broadcast('broadcast_add', inputs,
broadcast_axis, proto_obj)
return op_value, new_attr, inputs
return 'broadcast_add', new_attr, inputs
|
[
"def",
"add",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"new_attr",
"=",
"{",
"}",
"if",
"'broadcast'",
"in",
"attrs",
"and",
"attrs",
"[",
"'broadcast'",
"]",
"==",
"1",
":",
"broadcast_axis",
"=",
"attrs",
"[",
"'axis'",
"]",
"op_value",
"=",
"translation_utils",
".",
"_fix_broadcast",
"(",
"'broadcast_add'",
",",
"inputs",
",",
"broadcast_axis",
",",
"proto_obj",
")",
"return",
"op_value",
",",
"new_attr",
",",
"inputs",
"return",
"'broadcast_add'",
",",
"new_attr",
",",
"inputs"
] |
Adding two tensors
|
[
"Adding",
"two",
"tensors"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L66-L75
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
mean
|
def mean(attrs, inputs, proto_obj):
"""Mean of all the input tensors."""
concat_input = [symbol.expand_dims(op_input, axis=0) for op_input in inputs]
concat_sym = symbol.concat(*concat_input, dim=0)
mean_sym = symbol.mean(concat_sym, axis=0)
return mean_sym, attrs, inputs
|
python
|
def mean(attrs, inputs, proto_obj):
"""Mean of all the input tensors."""
concat_input = [symbol.expand_dims(op_input, axis=0) for op_input in inputs]
concat_sym = symbol.concat(*concat_input, dim=0)
mean_sym = symbol.mean(concat_sym, axis=0)
return mean_sym, attrs, inputs
|
[
"def",
"mean",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"concat_input",
"=",
"[",
"symbol",
".",
"expand_dims",
"(",
"op_input",
",",
"axis",
"=",
"0",
")",
"for",
"op_input",
"in",
"inputs",
"]",
"concat_sym",
"=",
"symbol",
".",
"concat",
"(",
"*",
"concat_input",
",",
"dim",
"=",
"0",
")",
"mean_sym",
"=",
"symbol",
".",
"mean",
"(",
"concat_sym",
",",
"axis",
"=",
"0",
")",
"return",
"mean_sym",
",",
"attrs",
",",
"inputs"
] |
Mean of all the input tensors.
|
[
"Mean",
"of",
"all",
"the",
"input",
"tensors",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L110-L115
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
argmax
|
def argmax(attrs, inputs, proto_obj):
"""Returns indices of the maximum values along an axis"""
axis = attrs.get('axis', 0)
keepdims = attrs.get('keepdims', 1)
argmax_op = symbol.argmax(inputs[0], axis=axis, keepdims=keepdims)
# onnx argmax operator always expects int64 as output type
cast_attrs = {'dtype': 'int64'}
return 'cast', cast_attrs, argmax_op
|
python
|
def argmax(attrs, inputs, proto_obj):
"""Returns indices of the maximum values along an axis"""
axis = attrs.get('axis', 0)
keepdims = attrs.get('keepdims', 1)
argmax_op = symbol.argmax(inputs[0], axis=axis, keepdims=keepdims)
# onnx argmax operator always expects int64 as output type
cast_attrs = {'dtype': 'int64'}
return 'cast', cast_attrs, argmax_op
|
[
"def",
"argmax",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"axis",
"=",
"attrs",
".",
"get",
"(",
"'axis'",
",",
"0",
")",
"keepdims",
"=",
"attrs",
".",
"get",
"(",
"'keepdims'",
",",
"1",
")",
"argmax_op",
"=",
"symbol",
".",
"argmax",
"(",
"inputs",
"[",
"0",
"]",
",",
"axis",
"=",
"axis",
",",
"keepdims",
"=",
"keepdims",
")",
"# onnx argmax operator always expects int64 as output type",
"cast_attrs",
"=",
"{",
"'dtype'",
":",
"'int64'",
"}",
"return",
"'cast'",
",",
"cast_attrs",
",",
"argmax_op"
] |
Returns indices of the maximum values along an axis
|
[
"Returns",
"indices",
"of",
"the",
"maximum",
"values",
"along",
"an",
"axis"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L146-L153
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
argmin
|
def argmin(attrs, inputs, proto_obj):
"""Returns indices of the minimum values along an axis."""
axis = attrs.get('axis', 0)
keepdims = attrs.get('keepdims', 1)
argmin_op = symbol.argmin(inputs[0], axis=axis, keepdims=keepdims)
# onnx argmax operator always expects int64 as output type
cast_attrs = {'dtype': 'int64'}
return 'cast', cast_attrs, argmin_op
|
python
|
def argmin(attrs, inputs, proto_obj):
"""Returns indices of the minimum values along an axis."""
axis = attrs.get('axis', 0)
keepdims = attrs.get('keepdims', 1)
argmin_op = symbol.argmin(inputs[0], axis=axis, keepdims=keepdims)
# onnx argmax operator always expects int64 as output type
cast_attrs = {'dtype': 'int64'}
return 'cast', cast_attrs, argmin_op
|
[
"def",
"argmin",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"axis",
"=",
"attrs",
".",
"get",
"(",
"'axis'",
",",
"0",
")",
"keepdims",
"=",
"attrs",
".",
"get",
"(",
"'keepdims'",
",",
"1",
")",
"argmin_op",
"=",
"symbol",
".",
"argmin",
"(",
"inputs",
"[",
"0",
"]",
",",
"axis",
"=",
"axis",
",",
"keepdims",
"=",
"keepdims",
")",
"# onnx argmax operator always expects int64 as output type",
"cast_attrs",
"=",
"{",
"'dtype'",
":",
"'int64'",
"}",
"return",
"'cast'",
",",
"cast_attrs",
",",
"argmin_op"
] |
Returns indices of the minimum values along an axis.
|
[
"Returns",
"indices",
"of",
"the",
"minimum",
"values",
"along",
"an",
"axis",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L155-L162
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
maximum
|
def maximum(attrs, inputs, proto_obj):
"""
Elementwise maximum of arrays.
MXNet maximum compares only two symbols at a time.
ONNX can send more than two to compare.
Breaking into multiple mxnet ops to compare two symbols at a time
"""
if len(inputs) > 1:
mxnet_op = symbol.maximum(inputs[0], inputs[1])
for op_input in inputs[2:]:
mxnet_op = symbol.maximum(mxnet_op, op_input)
else:
mxnet_op = symbol.maximum(inputs[0], inputs[0])
return mxnet_op, attrs, inputs
|
python
|
def maximum(attrs, inputs, proto_obj):
"""
Elementwise maximum of arrays.
MXNet maximum compares only two symbols at a time.
ONNX can send more than two to compare.
Breaking into multiple mxnet ops to compare two symbols at a time
"""
if len(inputs) > 1:
mxnet_op = symbol.maximum(inputs[0], inputs[1])
for op_input in inputs[2:]:
mxnet_op = symbol.maximum(mxnet_op, op_input)
else:
mxnet_op = symbol.maximum(inputs[0], inputs[0])
return mxnet_op, attrs, inputs
|
[
"def",
"maximum",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"if",
"len",
"(",
"inputs",
")",
">",
"1",
":",
"mxnet_op",
"=",
"symbol",
".",
"maximum",
"(",
"inputs",
"[",
"0",
"]",
",",
"inputs",
"[",
"1",
"]",
")",
"for",
"op_input",
"in",
"inputs",
"[",
"2",
":",
"]",
":",
"mxnet_op",
"=",
"symbol",
".",
"maximum",
"(",
"mxnet_op",
",",
"op_input",
")",
"else",
":",
"mxnet_op",
"=",
"symbol",
".",
"maximum",
"(",
"inputs",
"[",
"0",
"]",
",",
"inputs",
"[",
"0",
"]",
")",
"return",
"mxnet_op",
",",
"attrs",
",",
"inputs"
] |
Elementwise maximum of arrays.
MXNet maximum compares only two symbols at a time.
ONNX can send more than two to compare.
Breaking into multiple mxnet ops to compare two symbols at a time
|
[
"Elementwise",
"maximum",
"of",
"arrays",
".",
"MXNet",
"maximum",
"compares",
"only",
"two",
"symbols",
"at",
"a",
"time",
".",
"ONNX",
"can",
"send",
"more",
"than",
"two",
"to",
"compare",
".",
"Breaking",
"into",
"multiple",
"mxnet",
"ops",
"to",
"compare",
"two",
"symbols",
"at",
"a",
"time"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L164-L177
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
minimum
|
def minimum(attrs, inputs, proto_obj):
"""Elementwise minimum of arrays."""
# MXNet minimum compares only two symbols at a time.
# ONNX can send more than two to compare.
# Breaking into multiple mxnet ops to compare two symbols at a time
if len(inputs) > 1:
mxnet_op = symbol.minimum(inputs[0], inputs[1])
for op_input in inputs[2:]:
mxnet_op = symbol.minimum(mxnet_op, op_input)
else:
mxnet_op = symbol.minimum(inputs[0], inputs[0])
return mxnet_op, attrs, inputs
|
python
|
def minimum(attrs, inputs, proto_obj):
"""Elementwise minimum of arrays."""
# MXNet minimum compares only two symbols at a time.
# ONNX can send more than two to compare.
# Breaking into multiple mxnet ops to compare two symbols at a time
if len(inputs) > 1:
mxnet_op = symbol.minimum(inputs[0], inputs[1])
for op_input in inputs[2:]:
mxnet_op = symbol.minimum(mxnet_op, op_input)
else:
mxnet_op = symbol.minimum(inputs[0], inputs[0])
return mxnet_op, attrs, inputs
|
[
"def",
"minimum",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"# MXNet minimum compares only two symbols at a time.",
"# ONNX can send more than two to compare.",
"# Breaking into multiple mxnet ops to compare two symbols at a time",
"if",
"len",
"(",
"inputs",
")",
">",
"1",
":",
"mxnet_op",
"=",
"symbol",
".",
"minimum",
"(",
"inputs",
"[",
"0",
"]",
",",
"inputs",
"[",
"1",
"]",
")",
"for",
"op_input",
"in",
"inputs",
"[",
"2",
":",
"]",
":",
"mxnet_op",
"=",
"symbol",
".",
"minimum",
"(",
"mxnet_op",
",",
"op_input",
")",
"else",
":",
"mxnet_op",
"=",
"symbol",
".",
"minimum",
"(",
"inputs",
"[",
"0",
"]",
",",
"inputs",
"[",
"0",
"]",
")",
"return",
"mxnet_op",
",",
"attrs",
",",
"inputs"
] |
Elementwise minimum of arrays.
|
[
"Elementwise",
"minimum",
"of",
"arrays",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L179-L190
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
concat
|
def concat(attrs, inputs, proto_obj):
""" Joins input arrays along a given axis. """
new_attrs = translation_utils._fix_attribute_names(attrs, {'axis': 'dim'})
return 'concat', new_attrs, inputs
|
python
|
def concat(attrs, inputs, proto_obj):
""" Joins input arrays along a given axis. """
new_attrs = translation_utils._fix_attribute_names(attrs, {'axis': 'dim'})
return 'concat', new_attrs, inputs
|
[
"def",
"concat",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_fix_attribute_names",
"(",
"attrs",
",",
"{",
"'axis'",
":",
"'dim'",
"}",
")",
"return",
"'concat'",
",",
"new_attrs",
",",
"inputs"
] |
Joins input arrays along a given axis.
|
[
"Joins",
"input",
"arrays",
"along",
"a",
"given",
"axis",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L219-L222
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
pad
|
def pad(attrs, inputs, proto_obj):
""" Add padding to input tensor"""
new_attrs = translation_utils._fix_attribute_names(attrs, {'pads' : 'pad_width',
'value' : 'constant_value'
})
new_attrs['pad_width'] = translation_utils._pad_sequence_fix(new_attrs.get('pad_width'))
return 'pad', new_attrs, inputs
|
python
|
def pad(attrs, inputs, proto_obj):
""" Add padding to input tensor"""
new_attrs = translation_utils._fix_attribute_names(attrs, {'pads' : 'pad_width',
'value' : 'constant_value'
})
new_attrs['pad_width'] = translation_utils._pad_sequence_fix(new_attrs.get('pad_width'))
return 'pad', new_attrs, inputs
|
[
"def",
"pad",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_fix_attribute_names",
"(",
"attrs",
",",
"{",
"'pads'",
":",
"'pad_width'",
",",
"'value'",
":",
"'constant_value'",
"}",
")",
"new_attrs",
"[",
"'pad_width'",
"]",
"=",
"translation_utils",
".",
"_pad_sequence_fix",
"(",
"new_attrs",
".",
"get",
"(",
"'pad_width'",
")",
")",
"return",
"'pad'",
",",
"new_attrs",
",",
"inputs"
] |
Add padding to input tensor
|
[
"Add",
"padding",
"to",
"input",
"tensor"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L241-L247
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
batch_norm
|
def batch_norm(attrs, inputs, proto_obj):
"""Batch normalization."""
new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon': 'eps',
'is_test': 'fix_gamma'})
new_attrs = translation_utils._remove_attributes(new_attrs,
['spatial', 'consumed_inputs'])
# Disable cuDNN BN only if epsilon from model is < than minimum cuDNN eps (1e-5)
cudnn_min_eps = 1e-5
cudnn_off = 0 if attrs.get('epsilon', cudnn_min_eps) >= cudnn_min_eps else 1
new_attrs = translation_utils._add_extra_attributes(new_attrs, {'cudnn_off': cudnn_off})
# in test mode "fix_gamma" should be unset.
new_attrs['fix_gamma'] = not attrs.get('is_test', 1)
return 'BatchNorm', new_attrs, inputs
|
python
|
def batch_norm(attrs, inputs, proto_obj):
"""Batch normalization."""
new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon': 'eps',
'is_test': 'fix_gamma'})
new_attrs = translation_utils._remove_attributes(new_attrs,
['spatial', 'consumed_inputs'])
# Disable cuDNN BN only if epsilon from model is < than minimum cuDNN eps (1e-5)
cudnn_min_eps = 1e-5
cudnn_off = 0 if attrs.get('epsilon', cudnn_min_eps) >= cudnn_min_eps else 1
new_attrs = translation_utils._add_extra_attributes(new_attrs, {'cudnn_off': cudnn_off})
# in test mode "fix_gamma" should be unset.
new_attrs['fix_gamma'] = not attrs.get('is_test', 1)
return 'BatchNorm', new_attrs, inputs
|
[
"def",
"batch_norm",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_fix_attribute_names",
"(",
"attrs",
",",
"{",
"'epsilon'",
":",
"'eps'",
",",
"'is_test'",
":",
"'fix_gamma'",
"}",
")",
"new_attrs",
"=",
"translation_utils",
".",
"_remove_attributes",
"(",
"new_attrs",
",",
"[",
"'spatial'",
",",
"'consumed_inputs'",
"]",
")",
"# Disable cuDNN BN only if epsilon from model is < than minimum cuDNN eps (1e-5)",
"cudnn_min_eps",
"=",
"1e-5",
"cudnn_off",
"=",
"0",
"if",
"attrs",
".",
"get",
"(",
"'epsilon'",
",",
"cudnn_min_eps",
")",
">=",
"cudnn_min_eps",
"else",
"1",
"new_attrs",
"=",
"translation_utils",
".",
"_add_extra_attributes",
"(",
"new_attrs",
",",
"{",
"'cudnn_off'",
":",
"cudnn_off",
"}",
")",
"# in test mode \"fix_gamma\" should be unset.",
"new_attrs",
"[",
"'fix_gamma'",
"]",
"=",
"not",
"attrs",
".",
"get",
"(",
"'is_test'",
",",
"1",
")",
"return",
"'BatchNorm'",
",",
"new_attrs",
",",
"inputs"
] |
Batch normalization.
|
[
"Batch",
"normalization",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L253-L266
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
instance_norm
|
def instance_norm(attrs, inputs, proto_obj):
"""Instance Normalization."""
new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon' : 'eps'})
new_attrs['eps'] = attrs.get('epsilon', 1e-5)
return 'InstanceNorm', new_attrs, inputs
|
python
|
def instance_norm(attrs, inputs, proto_obj):
"""Instance Normalization."""
new_attrs = translation_utils._fix_attribute_names(attrs, {'epsilon' : 'eps'})
new_attrs['eps'] = attrs.get('epsilon', 1e-5)
return 'InstanceNorm', new_attrs, inputs
|
[
"def",
"instance_norm",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_fix_attribute_names",
"(",
"attrs",
",",
"{",
"'epsilon'",
":",
"'eps'",
"}",
")",
"new_attrs",
"[",
"'eps'",
"]",
"=",
"attrs",
".",
"get",
"(",
"'epsilon'",
",",
"1e-5",
")",
"return",
"'InstanceNorm'",
",",
"new_attrs",
",",
"inputs"
] |
Instance Normalization.
|
[
"Instance",
"Normalization",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L268-L272
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
leaky_relu
|
def leaky_relu(attrs, inputs, proto_obj):
"""Leaky Relu function"""
if 'alpha' in attrs:
new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})
else:
new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 0.01})
return 'LeakyReLU', new_attrs, inputs
|
python
|
def leaky_relu(attrs, inputs, proto_obj):
"""Leaky Relu function"""
if 'alpha' in attrs:
new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})
else:
new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 0.01})
return 'LeakyReLU', new_attrs, inputs
|
[
"def",
"leaky_relu",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"if",
"'alpha'",
"in",
"attrs",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_fix_attribute_names",
"(",
"attrs",
",",
"{",
"'alpha'",
":",
"'slope'",
"}",
")",
"else",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_add_extra_attributes",
"(",
"attrs",
",",
"{",
"'slope'",
":",
"0.01",
"}",
")",
"return",
"'LeakyReLU'",
",",
"new_attrs",
",",
"inputs"
] |
Leaky Relu function
|
[
"Leaky",
"Relu",
"function"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L274-L280
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/onnx/onnx2mx/_op_translations.py
|
_elu
|
def _elu(attrs, inputs, proto_obj):
"""Elu function"""
if 'alpha' in attrs:
new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})
else:
new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 1.0})
new_attrs = translation_utils._add_extra_attributes(new_attrs, {'act_type': 'elu'})
return 'LeakyReLU', new_attrs, inputs
|
python
|
def _elu(attrs, inputs, proto_obj):
"""Elu function"""
if 'alpha' in attrs:
new_attrs = translation_utils._fix_attribute_names(attrs, {'alpha' : 'slope'})
else:
new_attrs = translation_utils._add_extra_attributes(attrs, {'slope': 1.0})
new_attrs = translation_utils._add_extra_attributes(new_attrs, {'act_type': 'elu'})
return 'LeakyReLU', new_attrs, inputs
|
[
"def",
"_elu",
"(",
"attrs",
",",
"inputs",
",",
"proto_obj",
")",
":",
"if",
"'alpha'",
"in",
"attrs",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_fix_attribute_names",
"(",
"attrs",
",",
"{",
"'alpha'",
":",
"'slope'",
"}",
")",
"else",
":",
"new_attrs",
"=",
"translation_utils",
".",
"_add_extra_attributes",
"(",
"attrs",
",",
"{",
"'slope'",
":",
"1.0",
"}",
")",
"new_attrs",
"=",
"translation_utils",
".",
"_add_extra_attributes",
"(",
"new_attrs",
",",
"{",
"'act_type'",
":",
"'elu'",
"}",
")",
"return",
"'LeakyReLU'",
",",
"new_attrs",
",",
"inputs"
] |
Elu function
|
[
"Elu",
"function"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/onnx/onnx2mx/_op_translations.py#L282-L289
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.