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
|
python/mxnet/ndarray/ndarray.py
|
NDArray.dtype
|
def dtype(self):
"""Data-type of the array's elements.
Returns
-------
numpy.dtype
This NDArray's data type.
Examples
--------
>>> x = mx.nd.zeros((2,3))
>>> x.dtype
<type 'numpy.float32'>
>>> y = mx.nd.zeros((2,3), dtype='int32')
>>> y.dtype
<type 'numpy.int32'>
"""
mx_dtype = ctypes.c_int()
check_call(_LIB.MXNDArrayGetDType(
self.handle, ctypes.byref(mx_dtype)))
return _DTYPE_MX_TO_NP[mx_dtype.value]
|
python
|
def dtype(self):
"""Data-type of the array's elements.
Returns
-------
numpy.dtype
This NDArray's data type.
Examples
--------
>>> x = mx.nd.zeros((2,3))
>>> x.dtype
<type 'numpy.float32'>
>>> y = mx.nd.zeros((2,3), dtype='int32')
>>> y.dtype
<type 'numpy.int32'>
"""
mx_dtype = ctypes.c_int()
check_call(_LIB.MXNDArrayGetDType(
self.handle, ctypes.byref(mx_dtype)))
return _DTYPE_MX_TO_NP[mx_dtype.value]
|
[
"def",
"dtype",
"(",
"self",
")",
":",
"mx_dtype",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXNDArrayGetDType",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"mx_dtype",
")",
")",
")",
"return",
"_DTYPE_MX_TO_NP",
"[",
"mx_dtype",
".",
"value",
"]"
] |
Data-type of the array's elements.
Returns
-------
numpy.dtype
This NDArray's data type.
Examples
--------
>>> x = mx.nd.zeros((2,3))
>>> x.dtype
<type 'numpy.float32'>
>>> y = mx.nd.zeros((2,3), dtype='int32')
>>> y.dtype
<type 'numpy.int32'>
|
[
"Data",
"-",
"type",
"of",
"the",
"array",
"s",
"elements",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L1900-L1920
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray._fresh_grad
|
def _fresh_grad(self):
"""Whether this array's corresponding gradient array
(registered via `autograd.mark_variables`) has been
updated by `autograd.backward` since last reset.
`_fresh_grad` need to be manually set to False
after consuming gradient (usually after updating this
array).
"""
out = ctypes.c_int()
check_call(_LIB.MXNDArrayGetGradState(self.handle, ctypes.byref(out)))
return out.value
|
python
|
def _fresh_grad(self):
"""Whether this array's corresponding gradient array
(registered via `autograd.mark_variables`) has been
updated by `autograd.backward` since last reset.
`_fresh_grad` need to be manually set to False
after consuming gradient (usually after updating this
array).
"""
out = ctypes.c_int()
check_call(_LIB.MXNDArrayGetGradState(self.handle, ctypes.byref(out)))
return out.value
|
[
"def",
"_fresh_grad",
"(",
"self",
")",
":",
"out",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXNDArrayGetGradState",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"out",
")",
")",
")",
"return",
"out",
".",
"value"
] |
Whether this array's corresponding gradient array
(registered via `autograd.mark_variables`) has been
updated by `autograd.backward` since last reset.
`_fresh_grad` need to be manually set to False
after consuming gradient (usually after updating this
array).
|
[
"Whether",
"this",
"array",
"s",
"corresponding",
"gradient",
"array",
"(",
"registered",
"via",
"autograd",
".",
"mark_variables",
")",
"has",
"been",
"updated",
"by",
"autograd",
".",
"backward",
"since",
"last",
"reset",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L1957-L1968
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.asnumpy
|
def asnumpy(self):
"""Returns a ``numpy.ndarray`` object with value copied from this array.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = x.asnumpy()
>>> type(y)
<type 'numpy.ndarray'>
>>> y
array([[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=float32)
>>> z = mx.nd.ones((2,3), dtype='int32')
>>> z.asnumpy()
array([[1, 1, 1],
[1, 1, 1]], dtype=int32)
"""
data = np.empty(self.shape, dtype=self.dtype)
check_call(_LIB.MXNDArraySyncCopyToCPU(
self.handle,
data.ctypes.data_as(ctypes.c_void_p),
ctypes.c_size_t(data.size)))
return data
|
python
|
def asnumpy(self):
"""Returns a ``numpy.ndarray`` object with value copied from this array.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = x.asnumpy()
>>> type(y)
<type 'numpy.ndarray'>
>>> y
array([[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=float32)
>>> z = mx.nd.ones((2,3), dtype='int32')
>>> z.asnumpy()
array([[1, 1, 1],
[1, 1, 1]], dtype=int32)
"""
data = np.empty(self.shape, dtype=self.dtype)
check_call(_LIB.MXNDArraySyncCopyToCPU(
self.handle,
data.ctypes.data_as(ctypes.c_void_p),
ctypes.c_size_t(data.size)))
return data
|
[
"def",
"asnumpy",
"(",
"self",
")",
":",
"data",
"=",
"np",
".",
"empty",
"(",
"self",
".",
"shape",
",",
"dtype",
"=",
"self",
".",
"dtype",
")",
"check_call",
"(",
"_LIB",
".",
"MXNDArraySyncCopyToCPU",
"(",
"self",
".",
"handle",
",",
"data",
".",
"ctypes",
".",
"data_as",
"(",
"ctypes",
".",
"c_void_p",
")",
",",
"ctypes",
".",
"c_size_t",
"(",
"data",
".",
"size",
")",
")",
")",
"return",
"data"
] |
Returns a ``numpy.ndarray`` object with value copied from this array.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = x.asnumpy()
>>> type(y)
<type 'numpy.ndarray'>
>>> y
array([[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=float32)
>>> z = mx.nd.ones((2,3), dtype='int32')
>>> z.asnumpy()
array([[1, 1, 1],
[1, 1, 1]], dtype=int32)
|
[
"Returns",
"a",
"numpy",
".",
"ndarray",
"object",
"with",
"value",
"copied",
"from",
"this",
"array",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L1974-L1996
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.astype
|
def astype(self, dtype, copy=True):
"""Returns a copy of the array after casting to a specified type.
Parameters
----------
dtype : numpy.dtype or str
The type of the returned array.
copy : bool
Default `True`. By default, astype always returns a newly
allocated ndarray on the same context. If this is set to
`False`, and the dtype requested is the same as the ndarray's
dtype, the ndarray is returned instead of a copy.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The copied array after casting to the specified type, or
the same array if copy=False and dtype is the same as the input
array.
Examples
--------
>>> x = mx.nd.zeros((2,3), dtype='float32')
>>> y = x.astype('int32')
>>> y.dtype
<type 'numpy.int32'>
"""
if not copy and np.dtype(dtype) == self.dtype:
return self
res = empty(self.shape, ctx=self.context, dtype=dtype)
self.copyto(res)
return res
|
python
|
def astype(self, dtype, copy=True):
"""Returns a copy of the array after casting to a specified type.
Parameters
----------
dtype : numpy.dtype or str
The type of the returned array.
copy : bool
Default `True`. By default, astype always returns a newly
allocated ndarray on the same context. If this is set to
`False`, and the dtype requested is the same as the ndarray's
dtype, the ndarray is returned instead of a copy.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The copied array after casting to the specified type, or
the same array if copy=False and dtype is the same as the input
array.
Examples
--------
>>> x = mx.nd.zeros((2,3), dtype='float32')
>>> y = x.astype('int32')
>>> y.dtype
<type 'numpy.int32'>
"""
if not copy and np.dtype(dtype) == self.dtype:
return self
res = empty(self.shape, ctx=self.context, dtype=dtype)
self.copyto(res)
return res
|
[
"def",
"astype",
"(",
"self",
",",
"dtype",
",",
"copy",
"=",
"True",
")",
":",
"if",
"not",
"copy",
"and",
"np",
".",
"dtype",
"(",
"dtype",
")",
"==",
"self",
".",
"dtype",
":",
"return",
"self",
"res",
"=",
"empty",
"(",
"self",
".",
"shape",
",",
"ctx",
"=",
"self",
".",
"context",
",",
"dtype",
"=",
"dtype",
")",
"self",
".",
"copyto",
"(",
"res",
")",
"return",
"res"
] |
Returns a copy of the array after casting to a specified type.
Parameters
----------
dtype : numpy.dtype or str
The type of the returned array.
copy : bool
Default `True`. By default, astype always returns a newly
allocated ndarray on the same context. If this is set to
`False`, and the dtype requested is the same as the ndarray's
dtype, the ndarray is returned instead of a copy.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The copied array after casting to the specified type, or
the same array if copy=False and dtype is the same as the input
array.
Examples
--------
>>> x = mx.nd.zeros((2,3), dtype='float32')
>>> y = x.astype('int32')
>>> y.dtype
<type 'numpy.int32'>
|
[
"Returns",
"a",
"copy",
"of",
"the",
"array",
"after",
"casting",
"to",
"a",
"specified",
"type",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L2015-L2048
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.copyto
|
def copyto(self, other):
"""Copies the value of this array to another array.
If ``other`` is a ``NDArray`` object, then ``other.shape`` and
``self.shape`` should be the same. This function copies the value from
``self`` to ``other``.
If ``other`` is a context, a new ``NDArray`` will be first created on
the target context, and the value of ``self`` is copied.
Parameters
----------
other : NDArray or Context
The destination array or context.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The copied array. If ``other`` is an ``NDArray``, then the return value
and ``other`` will point to the same ``NDArray``.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = mx.nd.zeros((2,3), mx.gpu(0))
>>> z = x.copyto(y)
>>> z is y
True
>>> y.asnumpy()
array([[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=float32)
>>> y.copyto(mx.gpu(0))
<NDArray 2x3 @gpu(0)>
"""
if isinstance(other, NDArray):
if other.handle is self.handle:
warnings.warn('You are attempting to copy an array to itself', RuntimeWarning)
return False
return _internal._copyto(self, out=other)
elif isinstance(other, Context):
hret = NDArray(_new_alloc_handle(self.shape, other, True, self.dtype))
return _internal._copyto(self, out=hret)
else:
raise TypeError('copyto does not support type ' + str(type(other)))
|
python
|
def copyto(self, other):
"""Copies the value of this array to another array.
If ``other`` is a ``NDArray`` object, then ``other.shape`` and
``self.shape`` should be the same. This function copies the value from
``self`` to ``other``.
If ``other`` is a context, a new ``NDArray`` will be first created on
the target context, and the value of ``self`` is copied.
Parameters
----------
other : NDArray or Context
The destination array or context.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The copied array. If ``other`` is an ``NDArray``, then the return value
and ``other`` will point to the same ``NDArray``.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = mx.nd.zeros((2,3), mx.gpu(0))
>>> z = x.copyto(y)
>>> z is y
True
>>> y.asnumpy()
array([[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=float32)
>>> y.copyto(mx.gpu(0))
<NDArray 2x3 @gpu(0)>
"""
if isinstance(other, NDArray):
if other.handle is self.handle:
warnings.warn('You are attempting to copy an array to itself', RuntimeWarning)
return False
return _internal._copyto(self, out=other)
elif isinstance(other, Context):
hret = NDArray(_new_alloc_handle(self.shape, other, True, self.dtype))
return _internal._copyto(self, out=hret)
else:
raise TypeError('copyto does not support type ' + str(type(other)))
|
[
"def",
"copyto",
"(",
"self",
",",
"other",
")",
":",
"if",
"isinstance",
"(",
"other",
",",
"NDArray",
")",
":",
"if",
"other",
".",
"handle",
"is",
"self",
".",
"handle",
":",
"warnings",
".",
"warn",
"(",
"'You are attempting to copy an array to itself'",
",",
"RuntimeWarning",
")",
"return",
"False",
"return",
"_internal",
".",
"_copyto",
"(",
"self",
",",
"out",
"=",
"other",
")",
"elif",
"isinstance",
"(",
"other",
",",
"Context",
")",
":",
"hret",
"=",
"NDArray",
"(",
"_new_alloc_handle",
"(",
"self",
".",
"shape",
",",
"other",
",",
"True",
",",
"self",
".",
"dtype",
")",
")",
"return",
"_internal",
".",
"_copyto",
"(",
"self",
",",
"out",
"=",
"hret",
")",
"else",
":",
"raise",
"TypeError",
"(",
"'copyto does not support type '",
"+",
"str",
"(",
"type",
"(",
"other",
")",
")",
")"
] |
Copies the value of this array to another array.
If ``other`` is a ``NDArray`` object, then ``other.shape`` and
``self.shape`` should be the same. This function copies the value from
``self`` to ``other``.
If ``other`` is a context, a new ``NDArray`` will be first created on
the target context, and the value of ``self`` is copied.
Parameters
----------
other : NDArray or Context
The destination array or context.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The copied array. If ``other`` is an ``NDArray``, then the return value
and ``other`` will point to the same ``NDArray``.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = mx.nd.zeros((2,3), mx.gpu(0))
>>> z = x.copyto(y)
>>> z is y
True
>>> y.asnumpy()
array([[ 1., 1., 1.],
[ 1., 1., 1.]], dtype=float32)
>>> y.copyto(mx.gpu(0))
<NDArray 2x3 @gpu(0)>
|
[
"Copies",
"the",
"value",
"of",
"this",
"array",
"to",
"another",
"array",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L2050-L2094
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.as_in_context
|
def as_in_context(self, context):
"""Returns an array on the target device with the same value as this array.
If the target context is the same as ``self.context``, then ``self`` is
returned. Otherwise, a copy is made.
Parameters
----------
context : Context
The target context.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The target array.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = x.as_in_context(mx.cpu())
>>> y is x
True
>>> z = x.as_in_context(mx.gpu(0))
>>> z is x
False
"""
if self.context == context:
return self
return self.copyto(context)
|
python
|
def as_in_context(self, context):
"""Returns an array on the target device with the same value as this array.
If the target context is the same as ``self.context``, then ``self`` is
returned. Otherwise, a copy is made.
Parameters
----------
context : Context
The target context.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The target array.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = x.as_in_context(mx.cpu())
>>> y is x
True
>>> z = x.as_in_context(mx.gpu(0))
>>> z is x
False
"""
if self.context == context:
return self
return self.copyto(context)
|
[
"def",
"as_in_context",
"(",
"self",
",",
"context",
")",
":",
"if",
"self",
".",
"context",
"==",
"context",
":",
"return",
"self",
"return",
"self",
".",
"copyto",
"(",
"context",
")"
] |
Returns an array on the target device with the same value as this array.
If the target context is the same as ``self.context``, then ``self`` is
returned. Otherwise, a copy is made.
Parameters
----------
context : Context
The target context.
Returns
-------
NDArray, CSRNDArray or RowSparseNDArray
The target array.
Examples
--------
>>> x = mx.nd.ones((2,3))
>>> y = x.as_in_context(mx.cpu())
>>> y is x
True
>>> z = x.as_in_context(mx.gpu(0))
>>> z is x
False
|
[
"Returns",
"an",
"array",
"on",
"the",
"target",
"device",
"with",
"the",
"same",
"value",
"as",
"this",
"array",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L2114-L2143
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.attach_grad
|
def attach_grad(self, grad_req='write', stype=None):
"""Attach a gradient buffer to this NDArray, so that `backward`
can compute gradient with respect to it.
Parameters
----------
grad_req : {'write', 'add', 'null'}
How gradient will be accumulated.
- 'write': gradient will be overwritten on every backward.
- 'add': gradient will be added to existing value on every backward.
- 'null': do not compute gradient for this NDArray.
stype : str, optional
The storage type of the gradient array. Defaults to the same stype of this NDArray.
"""
from . import zeros as _zeros
if stype is not None:
grad = _zeros(self.shape, stype=stype)
else:
grad = op.zeros_like(self) # pylint: disable=undefined-variable
grad_req = _GRAD_REQ_MAP[grad_req]
check_call(_LIB.MXAutogradMarkVariables(
1, ctypes.pointer(self.handle),
ctypes.pointer(mx_uint(grad_req)),
ctypes.pointer(grad.handle)))
|
python
|
def attach_grad(self, grad_req='write', stype=None):
"""Attach a gradient buffer to this NDArray, so that `backward`
can compute gradient with respect to it.
Parameters
----------
grad_req : {'write', 'add', 'null'}
How gradient will be accumulated.
- 'write': gradient will be overwritten on every backward.
- 'add': gradient will be added to existing value on every backward.
- 'null': do not compute gradient for this NDArray.
stype : str, optional
The storage type of the gradient array. Defaults to the same stype of this NDArray.
"""
from . import zeros as _zeros
if stype is not None:
grad = _zeros(self.shape, stype=stype)
else:
grad = op.zeros_like(self) # pylint: disable=undefined-variable
grad_req = _GRAD_REQ_MAP[grad_req]
check_call(_LIB.MXAutogradMarkVariables(
1, ctypes.pointer(self.handle),
ctypes.pointer(mx_uint(grad_req)),
ctypes.pointer(grad.handle)))
|
[
"def",
"attach_grad",
"(",
"self",
",",
"grad_req",
"=",
"'write'",
",",
"stype",
"=",
"None",
")",
":",
"from",
".",
"import",
"zeros",
"as",
"_zeros",
"if",
"stype",
"is",
"not",
"None",
":",
"grad",
"=",
"_zeros",
"(",
"self",
".",
"shape",
",",
"stype",
"=",
"stype",
")",
"else",
":",
"grad",
"=",
"op",
".",
"zeros_like",
"(",
"self",
")",
"# pylint: disable=undefined-variable",
"grad_req",
"=",
"_GRAD_REQ_MAP",
"[",
"grad_req",
"]",
"check_call",
"(",
"_LIB",
".",
"MXAutogradMarkVariables",
"(",
"1",
",",
"ctypes",
".",
"pointer",
"(",
"self",
".",
"handle",
")",
",",
"ctypes",
".",
"pointer",
"(",
"mx_uint",
"(",
"grad_req",
")",
")",
",",
"ctypes",
".",
"pointer",
"(",
"grad",
".",
"handle",
")",
")",
")"
] |
Attach a gradient buffer to this NDArray, so that `backward`
can compute gradient with respect to it.
Parameters
----------
grad_req : {'write', 'add', 'null'}
How gradient will be accumulated.
- 'write': gradient will be overwritten on every backward.
- 'add': gradient will be added to existing value on every backward.
- 'null': do not compute gradient for this NDArray.
stype : str, optional
The storage type of the gradient array. Defaults to the same stype of this NDArray.
|
[
"Attach",
"a",
"gradient",
"buffer",
"to",
"this",
"NDArray",
"so",
"that",
"backward",
"can",
"compute",
"gradient",
"with",
"respect",
"to",
"it",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L2145-L2168
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.grad
|
def grad(self):
"""Returns gradient buffer attached to this NDArray."""
from . import _ndarray_cls
hdl = NDArrayHandle()
check_call(_LIB.MXNDArrayGetGrad(self.handle, ctypes.byref(hdl)))
if hdl.value is None:
return None
return _ndarray_cls(hdl)
|
python
|
def grad(self):
"""Returns gradient buffer attached to this NDArray."""
from . import _ndarray_cls
hdl = NDArrayHandle()
check_call(_LIB.MXNDArrayGetGrad(self.handle, ctypes.byref(hdl)))
if hdl.value is None:
return None
return _ndarray_cls(hdl)
|
[
"def",
"grad",
"(",
"self",
")",
":",
"from",
".",
"import",
"_ndarray_cls",
"hdl",
"=",
"NDArrayHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXNDArrayGetGrad",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"hdl",
")",
")",
")",
"if",
"hdl",
".",
"value",
"is",
"None",
":",
"return",
"None",
"return",
"_ndarray_cls",
"(",
"hdl",
")"
] |
Returns gradient buffer attached to this NDArray.
|
[
"Returns",
"gradient",
"buffer",
"attached",
"to",
"this",
"NDArray",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L2171-L2178
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.detach
|
def detach(self):
"""Returns a new NDArray, detached from the current graph."""
from . import _ndarray_cls
hdl = NDArrayHandle()
check_call(_LIB.MXNDArrayDetach(self.handle, ctypes.byref(hdl)))
return _ndarray_cls(hdl)
|
python
|
def detach(self):
"""Returns a new NDArray, detached from the current graph."""
from . import _ndarray_cls
hdl = NDArrayHandle()
check_call(_LIB.MXNDArrayDetach(self.handle, ctypes.byref(hdl)))
return _ndarray_cls(hdl)
|
[
"def",
"detach",
"(",
"self",
")",
":",
"from",
".",
"import",
"_ndarray_cls",
"hdl",
"=",
"NDArrayHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXNDArrayDetach",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"hdl",
")",
")",
")",
"return",
"_ndarray_cls",
"(",
"hdl",
")"
] |
Returns a new NDArray, detached from the current graph.
|
[
"Returns",
"a",
"new",
"NDArray",
"detached",
"from",
"the",
"current",
"graph",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L2180-L2185
|
train
|
apache/incubator-mxnet
|
python/mxnet/ndarray/ndarray.py
|
NDArray.backward
|
def backward(self, out_grad=None, retain_graph=False, train_mode=True):
"""Compute the gradients of this NDArray w.r.t variables.
Parameters
----------
out_grad : NDArray, optional
Gradient with respect to head.
retain_graph : bool, optional
Whether to retain the computaion graph for another backward
pass on the same graph. By default the computaion history
is cleared.
train_mode : bool, optional
Whether to compute gradient for training or inference.
"""
if out_grad is None:
ograd_handles = [NDArrayHandle(0)]
else:
ograd_handles = [out_grad.handle]
check_call(_LIB.MXAutogradBackwardEx(
1, c_handle_array([self]),
c_array(NDArrayHandle, ograd_handles),
0,
ctypes.c_void_p(0),
ctypes.c_int(retain_graph),
ctypes.c_int(0),
ctypes.c_int(train_mode),
ctypes.c_void_p(0),
ctypes.c_void_p(0)))
|
python
|
def backward(self, out_grad=None, retain_graph=False, train_mode=True):
"""Compute the gradients of this NDArray w.r.t variables.
Parameters
----------
out_grad : NDArray, optional
Gradient with respect to head.
retain_graph : bool, optional
Whether to retain the computaion graph for another backward
pass on the same graph. By default the computaion history
is cleared.
train_mode : bool, optional
Whether to compute gradient for training or inference.
"""
if out_grad is None:
ograd_handles = [NDArrayHandle(0)]
else:
ograd_handles = [out_grad.handle]
check_call(_LIB.MXAutogradBackwardEx(
1, c_handle_array([self]),
c_array(NDArrayHandle, ograd_handles),
0,
ctypes.c_void_p(0),
ctypes.c_int(retain_graph),
ctypes.c_int(0),
ctypes.c_int(train_mode),
ctypes.c_void_p(0),
ctypes.c_void_p(0)))
|
[
"def",
"backward",
"(",
"self",
",",
"out_grad",
"=",
"None",
",",
"retain_graph",
"=",
"False",
",",
"train_mode",
"=",
"True",
")",
":",
"if",
"out_grad",
"is",
"None",
":",
"ograd_handles",
"=",
"[",
"NDArrayHandle",
"(",
"0",
")",
"]",
"else",
":",
"ograd_handles",
"=",
"[",
"out_grad",
".",
"handle",
"]",
"check_call",
"(",
"_LIB",
".",
"MXAutogradBackwardEx",
"(",
"1",
",",
"c_handle_array",
"(",
"[",
"self",
"]",
")",
",",
"c_array",
"(",
"NDArrayHandle",
",",
"ograd_handles",
")",
",",
"0",
",",
"ctypes",
".",
"c_void_p",
"(",
"0",
")",
",",
"ctypes",
".",
"c_int",
"(",
"retain_graph",
")",
",",
"ctypes",
".",
"c_int",
"(",
"0",
")",
",",
"ctypes",
".",
"c_int",
"(",
"train_mode",
")",
",",
"ctypes",
".",
"c_void_p",
"(",
"0",
")",
",",
"ctypes",
".",
"c_void_p",
"(",
"0",
")",
")",
")"
] |
Compute the gradients of this NDArray w.r.t variables.
Parameters
----------
out_grad : NDArray, optional
Gradient with respect to head.
retain_graph : bool, optional
Whether to retain the computaion graph for another backward
pass on the same graph. By default the computaion history
is cleared.
train_mode : bool, optional
Whether to compute gradient for training or inference.
|
[
"Compute",
"the",
"gradients",
"of",
"this",
"NDArray",
"w",
".",
"r",
".",
"t",
"variables",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/ndarray/ndarray.py#L2187-L2215
|
train
|
apache/incubator-mxnet
|
example/gluon/lipnet/utils/align.py
|
Align.build
|
def build(self, align_path):
"""
Build the align array
"""
file = open(align_path, 'r')
lines = file.readlines()
file.close()
# words: list([op, ed, word])
words = []
for line in lines:
_op, _ed, word = line.strip().split(' ')
if word not in Align.skip_list:
words.append((int(_op), int(_ed), word))
self.words = words
self.n_words = len(words)
self.sentence_str = " ".join([w[2] for w in self.words])
self.sentence_length = len(self.sentence_str)
|
python
|
def build(self, align_path):
"""
Build the align array
"""
file = open(align_path, 'r')
lines = file.readlines()
file.close()
# words: list([op, ed, word])
words = []
for line in lines:
_op, _ed, word = line.strip().split(' ')
if word not in Align.skip_list:
words.append((int(_op), int(_ed), word))
self.words = words
self.n_words = len(words)
self.sentence_str = " ".join([w[2] for w in self.words])
self.sentence_length = len(self.sentence_str)
|
[
"def",
"build",
"(",
"self",
",",
"align_path",
")",
":",
"file",
"=",
"open",
"(",
"align_path",
",",
"'r'",
")",
"lines",
"=",
"file",
".",
"readlines",
"(",
")",
"file",
".",
"close",
"(",
")",
"# words: list([op, ed, word])",
"words",
"=",
"[",
"]",
"for",
"line",
"in",
"lines",
":",
"_op",
",",
"_ed",
",",
"word",
"=",
"line",
".",
"strip",
"(",
")",
".",
"split",
"(",
"' '",
")",
"if",
"word",
"not",
"in",
"Align",
".",
"skip_list",
":",
"words",
".",
"append",
"(",
"(",
"int",
"(",
"_op",
")",
",",
"int",
"(",
"_ed",
")",
",",
"word",
")",
")",
"self",
".",
"words",
"=",
"words",
"self",
".",
"n_words",
"=",
"len",
"(",
"words",
")",
"self",
".",
"sentence_str",
"=",
"\" \"",
".",
"join",
"(",
"[",
"w",
"[",
"2",
"]",
"for",
"w",
"in",
"self",
".",
"words",
"]",
")",
"self",
".",
"sentence_length",
"=",
"len",
"(",
"self",
".",
"sentence_str",
")"
] |
Build the align array
|
[
"Build",
"the",
"align",
"array"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/align.py#L36-L52
|
train
|
apache/incubator-mxnet
|
example/gluon/lipnet/utils/align.py
|
Align.sentence
|
def sentence(self, padding=75):
"""
Get sentence
"""
vec = word_to_vector(self.sentence_str)
vec += [-1] * (padding - self.sentence_length)
return np.array(vec, dtype=np.int32)
|
python
|
def sentence(self, padding=75):
"""
Get sentence
"""
vec = word_to_vector(self.sentence_str)
vec += [-1] * (padding - self.sentence_length)
return np.array(vec, dtype=np.int32)
|
[
"def",
"sentence",
"(",
"self",
",",
"padding",
"=",
"75",
")",
":",
"vec",
"=",
"word_to_vector",
"(",
"self",
".",
"sentence_str",
")",
"vec",
"+=",
"[",
"-",
"1",
"]",
"*",
"(",
"padding",
"-",
"self",
".",
"sentence_length",
")",
"return",
"np",
".",
"array",
"(",
"vec",
",",
"dtype",
"=",
"np",
".",
"int32",
")"
] |
Get sentence
|
[
"Get",
"sentence"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/align.py#L54-L60
|
train
|
apache/incubator-mxnet
|
example/gluon/lipnet/utils/align.py
|
Align.word
|
def word(self, _id, padding=75):
"""
Get words
"""
word = self.words[_id][2]
vec = word_to_vector(word)
vec += [-1] * (padding - len(vec))
return np.array(vec, dtype=np.int32)
|
python
|
def word(self, _id, padding=75):
"""
Get words
"""
word = self.words[_id][2]
vec = word_to_vector(word)
vec += [-1] * (padding - len(vec))
return np.array(vec, dtype=np.int32)
|
[
"def",
"word",
"(",
"self",
",",
"_id",
",",
"padding",
"=",
"75",
")",
":",
"word",
"=",
"self",
".",
"words",
"[",
"_id",
"]",
"[",
"2",
"]",
"vec",
"=",
"word_to_vector",
"(",
"word",
")",
"vec",
"+=",
"[",
"-",
"1",
"]",
"*",
"(",
"padding",
"-",
"len",
"(",
"vec",
")",
")",
"return",
"np",
".",
"array",
"(",
"vec",
",",
"dtype",
"=",
"np",
".",
"int32",
")"
] |
Get words
|
[
"Get",
"words"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/align.py#L62-L69
|
train
|
apache/incubator-mxnet
|
example/gluon/lipnet/utils/align.py
|
Align.word_frame_pos
|
def word_frame_pos(self, _id):
"""
Get the position of words
"""
left = int(self.words[_id][0]/1000)
right = max(left+1, int(self.words[_id][1]/1000))
return (left, right)
|
python
|
def word_frame_pos(self, _id):
"""
Get the position of words
"""
left = int(self.words[_id][0]/1000)
right = max(left+1, int(self.words[_id][1]/1000))
return (left, right)
|
[
"def",
"word_frame_pos",
"(",
"self",
",",
"_id",
")",
":",
"left",
"=",
"int",
"(",
"self",
".",
"words",
"[",
"_id",
"]",
"[",
"0",
"]",
"/",
"1000",
")",
"right",
"=",
"max",
"(",
"left",
"+",
"1",
",",
"int",
"(",
"self",
".",
"words",
"[",
"_id",
"]",
"[",
"1",
"]",
"/",
"1000",
")",
")",
"return",
"(",
"left",
",",
"right",
")"
] |
Get the position of words
|
[
"Get",
"the",
"position",
"of",
"words"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/lipnet/utils/align.py#L77-L83
|
train
|
apache/incubator-mxnet
|
example/rnn/large_word_lm/custom_module.py
|
CustomModule.prepare_sparse_params
|
def prepare_sparse_params(self, param_rowids):
'''Prepares the module for processing a data batch by pulling row_sparse
parameters from kvstore to all devices based on rowids.
Parameters
----------
param_rowids : dict of str to NDArray of list of NDArrays
'''
if not self._kvstore:
return
assert(isinstance(param_rowids, dict))
for param_name, rowids in param_rowids.items():
if isinstance(rowids, (tuple, list)):
rowids_1d = []
for r in rowids:
rowids_1d.append(r.reshape((-1,)).astype(np.int64))
rowid = mx.nd.concat(*rowids_1d, dim=0)
else:
rowid = rowids
param_idx = self._exec_group.param_names.index(param_name)
param_val = self._exec_group.param_arrays[param_idx]
self._kvstore.row_sparse_pull(param_name, param_val, row_ids=rowid,
priority=-param_idx)
|
python
|
def prepare_sparse_params(self, param_rowids):
'''Prepares the module for processing a data batch by pulling row_sparse
parameters from kvstore to all devices based on rowids.
Parameters
----------
param_rowids : dict of str to NDArray of list of NDArrays
'''
if not self._kvstore:
return
assert(isinstance(param_rowids, dict))
for param_name, rowids in param_rowids.items():
if isinstance(rowids, (tuple, list)):
rowids_1d = []
for r in rowids:
rowids_1d.append(r.reshape((-1,)).astype(np.int64))
rowid = mx.nd.concat(*rowids_1d, dim=0)
else:
rowid = rowids
param_idx = self._exec_group.param_names.index(param_name)
param_val = self._exec_group.param_arrays[param_idx]
self._kvstore.row_sparse_pull(param_name, param_val, row_ids=rowid,
priority=-param_idx)
|
[
"def",
"prepare_sparse_params",
"(",
"self",
",",
"param_rowids",
")",
":",
"if",
"not",
"self",
".",
"_kvstore",
":",
"return",
"assert",
"(",
"isinstance",
"(",
"param_rowids",
",",
"dict",
")",
")",
"for",
"param_name",
",",
"rowids",
"in",
"param_rowids",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"rowids",
",",
"(",
"tuple",
",",
"list",
")",
")",
":",
"rowids_1d",
"=",
"[",
"]",
"for",
"r",
"in",
"rowids",
":",
"rowids_1d",
".",
"append",
"(",
"r",
".",
"reshape",
"(",
"(",
"-",
"1",
",",
")",
")",
".",
"astype",
"(",
"np",
".",
"int64",
")",
")",
"rowid",
"=",
"mx",
".",
"nd",
".",
"concat",
"(",
"*",
"rowids_1d",
",",
"dim",
"=",
"0",
")",
"else",
":",
"rowid",
"=",
"rowids",
"param_idx",
"=",
"self",
".",
"_exec_group",
".",
"param_names",
".",
"index",
"(",
"param_name",
")",
"param_val",
"=",
"self",
".",
"_exec_group",
".",
"param_arrays",
"[",
"param_idx",
"]",
"self",
".",
"_kvstore",
".",
"row_sparse_pull",
"(",
"param_name",
",",
"param_val",
",",
"row_ids",
"=",
"rowid",
",",
"priority",
"=",
"-",
"param_idx",
")"
] |
Prepares the module for processing a data batch by pulling row_sparse
parameters from kvstore to all devices based on rowids.
Parameters
----------
param_rowids : dict of str to NDArray of list of NDArrays
|
[
"Prepares",
"the",
"module",
"for",
"processing",
"a",
"data",
"batch",
"by",
"pulling",
"row_sparse",
"parameters",
"from",
"kvstore",
"to",
"all",
"devices",
"based",
"on",
"rowids",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/large_word_lm/custom_module.py#L38-L60
|
train
|
apache/incubator-mxnet
|
example/rnn/large_word_lm/custom_module.py
|
CustomModule.save_params
|
def save_params(self, fname):
"""Saves model parameters to file.
Parameters
----------
fname : str
Path to output param file.
Examples
--------
>>> # An example of saving module parameters.
>>> mod.save_params('myfile')
"""
arg_params, aux_params = self.get_params_from_kv(self._arg_params, self._aux_params)
save_dict = {('arg:%s' % k) : v.as_in_context(mx.cpu()) for k, v in arg_params.items()}
save_dict.update({('aux:%s' % k) : v.as_in_context(mx.cpu()) for k, v in aux_params.items()})
mx.nd.save(fname, save_dict)
|
python
|
def save_params(self, fname):
"""Saves model parameters to file.
Parameters
----------
fname : str
Path to output param file.
Examples
--------
>>> # An example of saving module parameters.
>>> mod.save_params('myfile')
"""
arg_params, aux_params = self.get_params_from_kv(self._arg_params, self._aux_params)
save_dict = {('arg:%s' % k) : v.as_in_context(mx.cpu()) for k, v in arg_params.items()}
save_dict.update({('aux:%s' % k) : v.as_in_context(mx.cpu()) for k, v in aux_params.items()})
mx.nd.save(fname, save_dict)
|
[
"def",
"save_params",
"(",
"self",
",",
"fname",
")",
":",
"arg_params",
",",
"aux_params",
"=",
"self",
".",
"get_params_from_kv",
"(",
"self",
".",
"_arg_params",
",",
"self",
".",
"_aux_params",
")",
"save_dict",
"=",
"{",
"(",
"'arg:%s'",
"%",
"k",
")",
":",
"v",
".",
"as_in_context",
"(",
"mx",
".",
"cpu",
"(",
")",
")",
"for",
"k",
",",
"v",
"in",
"arg_params",
".",
"items",
"(",
")",
"}",
"save_dict",
".",
"update",
"(",
"{",
"(",
"'aux:%s'",
"%",
"k",
")",
":",
"v",
".",
"as_in_context",
"(",
"mx",
".",
"cpu",
"(",
")",
")",
"for",
"k",
",",
"v",
"in",
"aux_params",
".",
"items",
"(",
")",
"}",
")",
"mx",
".",
"nd",
".",
"save",
"(",
"fname",
",",
"save_dict",
")"
] |
Saves model parameters to file.
Parameters
----------
fname : str
Path to output param file.
Examples
--------
>>> # An example of saving module parameters.
>>> mod.save_params('myfile')
|
[
"Saves",
"model",
"parameters",
"to",
"file",
".",
"Parameters",
"----------",
"fname",
":",
"str",
"Path",
"to",
"output",
"param",
"file",
".",
"Examples",
"--------",
">>>",
"#",
"An",
"example",
"of",
"saving",
"module",
"parameters",
".",
">>>",
"mod",
".",
"save_params",
"(",
"myfile",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/large_word_lm/custom_module.py#L102-L116
|
train
|
apache/incubator-mxnet
|
example/rnn/large_word_lm/custom_module.py
|
CustomModule.get_params_from_kv
|
def get_params_from_kv(self, arg_params, aux_params):
""" Copy data from kvstore to `arg_params` and `aux_params`.
Parameters
----------
arg_params : list of NDArray
Target parameter arrays.
aux_params : list of NDArray
Target aux arrays.
Notes
-----
- This function will inplace update the NDArrays in arg_params and aux_params.
"""
assert(self._kvstore is not None)
for name, block in zip(self._exec_group.param_names, self._exec_group.param_arrays):
assert(isinstance(block, list))
if block[0].stype == 'row_sparse':
row_ids = mx.nd.arange(start=0, stop=block[0].shape[0], dtype='int64')
self._kvstore.row_sparse_pull(name, arg_params[name], row_ids=row_ids)
else:
assert(block[0].stype == 'default')
self._kvstore.pull(name, out=arg_params[name])
if len(aux_params) > 0:
raise NotImplementedError()
return arg_params, aux_params
|
python
|
def get_params_from_kv(self, arg_params, aux_params):
""" Copy data from kvstore to `arg_params` and `aux_params`.
Parameters
----------
arg_params : list of NDArray
Target parameter arrays.
aux_params : list of NDArray
Target aux arrays.
Notes
-----
- This function will inplace update the NDArrays in arg_params and aux_params.
"""
assert(self._kvstore is not None)
for name, block in zip(self._exec_group.param_names, self._exec_group.param_arrays):
assert(isinstance(block, list))
if block[0].stype == 'row_sparse':
row_ids = mx.nd.arange(start=0, stop=block[0].shape[0], dtype='int64')
self._kvstore.row_sparse_pull(name, arg_params[name], row_ids=row_ids)
else:
assert(block[0].stype == 'default')
self._kvstore.pull(name, out=arg_params[name])
if len(aux_params) > 0:
raise NotImplementedError()
return arg_params, aux_params
|
[
"def",
"get_params_from_kv",
"(",
"self",
",",
"arg_params",
",",
"aux_params",
")",
":",
"assert",
"(",
"self",
".",
"_kvstore",
"is",
"not",
"None",
")",
"for",
"name",
",",
"block",
"in",
"zip",
"(",
"self",
".",
"_exec_group",
".",
"param_names",
",",
"self",
".",
"_exec_group",
".",
"param_arrays",
")",
":",
"assert",
"(",
"isinstance",
"(",
"block",
",",
"list",
")",
")",
"if",
"block",
"[",
"0",
"]",
".",
"stype",
"==",
"'row_sparse'",
":",
"row_ids",
"=",
"mx",
".",
"nd",
".",
"arange",
"(",
"start",
"=",
"0",
",",
"stop",
"=",
"block",
"[",
"0",
"]",
".",
"shape",
"[",
"0",
"]",
",",
"dtype",
"=",
"'int64'",
")",
"self",
".",
"_kvstore",
".",
"row_sparse_pull",
"(",
"name",
",",
"arg_params",
"[",
"name",
"]",
",",
"row_ids",
"=",
"row_ids",
")",
"else",
":",
"assert",
"(",
"block",
"[",
"0",
"]",
".",
"stype",
"==",
"'default'",
")",
"self",
".",
"_kvstore",
".",
"pull",
"(",
"name",
",",
"out",
"=",
"arg_params",
"[",
"name",
"]",
")",
"if",
"len",
"(",
"aux_params",
")",
">",
"0",
":",
"raise",
"NotImplementedError",
"(",
")",
"return",
"arg_params",
",",
"aux_params"
] |
Copy data from kvstore to `arg_params` and `aux_params`.
Parameters
----------
arg_params : list of NDArray
Target parameter arrays.
aux_params : list of NDArray
Target aux arrays.
Notes
-----
- This function will inplace update the NDArrays in arg_params and aux_params.
|
[
"Copy",
"data",
"from",
"kvstore",
"to",
"arg_params",
"and",
"aux_params",
".",
"Parameters",
"----------",
"arg_params",
":",
"list",
"of",
"NDArray",
"Target",
"parameter",
"arrays",
".",
"aux_params",
":",
"list",
"of",
"NDArray",
"Target",
"aux",
"arrays",
".",
"Notes",
"-----",
"-",
"This",
"function",
"will",
"inplace",
"update",
"the",
"NDArrays",
"in",
"arg_params",
"and",
"aux_params",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/large_word_lm/custom_module.py#L118-L141
|
train
|
apache/incubator-mxnet
|
example/rnn/large_word_lm/custom_module.py
|
CustomModule.clip_by_global_norm_per_ctx
|
def clip_by_global_norm_per_ctx(self, max_norm=1.0, param_names=None):
"""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`
Note that the gradients are concatenated per context in this implementation.
Examples
--------
An example of using clip_grad_norm to clip the gradient before updating the parameters::
>>> #Get the gradient via back-propagation
>>> net.forward_backward(data_batch=data_batch)
>>> norm_val = net.clip_by_global_norm(max_norm=2.0, param_names='w0')
>>> net.update()
"""
assert self.binded and self.params_initialized and self.optimizer_initialized
num_ctx = len(self._exec_group.grad_arrays[0])
grad_array_per_ctx = [[] for i in range(num_ctx)]
assert(param_names is not None)
for param_name in param_names:
param_idx = self._exec_group.param_names.index(param_name)
grad_val = self._exec_group.grad_arrays[param_idx]
assert(len(grad_val) == num_ctx)
for i in range(num_ctx):
grad_array_per_ctx[i].append(grad_val[i])
norm_vals = []
for i in range(num_ctx):
mx.gluon.utils.clip_global_norm(grad_array_per_ctx[i], max_norm)
|
python
|
def clip_by_global_norm_per_ctx(self, max_norm=1.0, param_names=None):
"""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`
Note that the gradients are concatenated per context in this implementation.
Examples
--------
An example of using clip_grad_norm to clip the gradient before updating the parameters::
>>> #Get the gradient via back-propagation
>>> net.forward_backward(data_batch=data_batch)
>>> norm_val = net.clip_by_global_norm(max_norm=2.0, param_names='w0')
>>> net.update()
"""
assert self.binded and self.params_initialized and self.optimizer_initialized
num_ctx = len(self._exec_group.grad_arrays[0])
grad_array_per_ctx = [[] for i in range(num_ctx)]
assert(param_names is not None)
for param_name in param_names:
param_idx = self._exec_group.param_names.index(param_name)
grad_val = self._exec_group.grad_arrays[param_idx]
assert(len(grad_val) == num_ctx)
for i in range(num_ctx):
grad_array_per_ctx[i].append(grad_val[i])
norm_vals = []
for i in range(num_ctx):
mx.gluon.utils.clip_global_norm(grad_array_per_ctx[i], max_norm)
|
[
"def",
"clip_by_global_norm_per_ctx",
"(",
"self",
",",
"max_norm",
"=",
"1.0",
",",
"param_names",
"=",
"None",
")",
":",
"assert",
"self",
".",
"binded",
"and",
"self",
".",
"params_initialized",
"and",
"self",
".",
"optimizer_initialized",
"num_ctx",
"=",
"len",
"(",
"self",
".",
"_exec_group",
".",
"grad_arrays",
"[",
"0",
"]",
")",
"grad_array_per_ctx",
"=",
"[",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"num_ctx",
")",
"]",
"assert",
"(",
"param_names",
"is",
"not",
"None",
")",
"for",
"param_name",
"in",
"param_names",
":",
"param_idx",
"=",
"self",
".",
"_exec_group",
".",
"param_names",
".",
"index",
"(",
"param_name",
")",
"grad_val",
"=",
"self",
".",
"_exec_group",
".",
"grad_arrays",
"[",
"param_idx",
"]",
"assert",
"(",
"len",
"(",
"grad_val",
")",
"==",
"num_ctx",
")",
"for",
"i",
"in",
"range",
"(",
"num_ctx",
")",
":",
"grad_array_per_ctx",
"[",
"i",
"]",
".",
"append",
"(",
"grad_val",
"[",
"i",
"]",
")",
"norm_vals",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"num_ctx",
")",
":",
"mx",
".",
"gluon",
".",
"utils",
".",
"clip_global_norm",
"(",
"grad_array_per_ctx",
"[",
"i",
"]",
",",
"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`
Note that the gradients are concatenated per context in this implementation.
Examples
--------
An example of using clip_grad_norm to clip the gradient before updating the parameters::
>>> #Get the gradient via back-propagation
>>> net.forward_backward(data_batch=data_batch)
>>> norm_val = net.clip_by_global_norm(max_norm=2.0, param_names='w0')
>>> net.update()
|
[
"Clips",
"gradient",
"norm",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/large_word_lm/custom_module.py#L143-L174
|
train
|
apache/incubator-mxnet
|
example/rnn/large_word_lm/custom_module.py
|
CustomModule.rescale_grad
|
def rescale_grad(self, scale=None, param_name=None):
""" Rescale the gradient of provided parameters by a certain scale """
if scale is None or param_name is None:
return
param_idx = self._exec_group.param_names.index(param_name)
grad_vals = self._exec_group.grad_arrays[param_idx]
for grad in grad_vals:
grad[:] *= scale
|
python
|
def rescale_grad(self, scale=None, param_name=None):
""" Rescale the gradient of provided parameters by a certain scale """
if scale is None or param_name is None:
return
param_idx = self._exec_group.param_names.index(param_name)
grad_vals = self._exec_group.grad_arrays[param_idx]
for grad in grad_vals:
grad[:] *= scale
|
[
"def",
"rescale_grad",
"(",
"self",
",",
"scale",
"=",
"None",
",",
"param_name",
"=",
"None",
")",
":",
"if",
"scale",
"is",
"None",
"or",
"param_name",
"is",
"None",
":",
"return",
"param_idx",
"=",
"self",
".",
"_exec_group",
".",
"param_names",
".",
"index",
"(",
"param_name",
")",
"grad_vals",
"=",
"self",
".",
"_exec_group",
".",
"grad_arrays",
"[",
"param_idx",
"]",
"for",
"grad",
"in",
"grad_vals",
":",
"grad",
"[",
":",
"]",
"*=",
"scale"
] |
Rescale the gradient of provided parameters by a certain scale
|
[
"Rescale",
"the",
"gradient",
"of",
"provided",
"parameters",
"by",
"a",
"certain",
"scale"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/large_word_lm/custom_module.py#L176-L183
|
train
|
apache/incubator-mxnet
|
example/sparse/factorization_machine/model.py
|
factorization_machine_model
|
def factorization_machine_model(factor_size, num_features,
lr_mult_config, wd_mult_config, init_config):
""" builds factorization machine network with proper formulation:
y = w_0 \sum(x_i w_i) + 0.5(\sum\sum<v_i,v_j>x_ix_j - \sum<v_iv_i>x_i^2)
"""
x = mx.symbol.Variable("data", stype='csr')
# factor, linear and bias terms
v = mx.symbol.Variable("v", shape=(num_features, factor_size), stype='row_sparse',
init=init_config['v'], lr_mult=lr_mult_config['v'],
wd_mult=wd_mult_config['v'])
w = mx.symbol.Variable('w', shape=(num_features, 1), stype='row_sparse',
init=init_config['w'], lr_mult=lr_mult_config['w'],
wd_mult=wd_mult_config['w'])
w0 = mx.symbol.Variable('w0', shape=(1,), init=init_config['w0'],
lr_mult=lr_mult_config['w0'], wd_mult=wd_mult_config['w0'])
w1 = mx.symbol.broadcast_add(mx.symbol.dot(x, w), w0)
# squared terms for subtracting self interactions
v_s = mx.symbol._internal._square_sum(data=v, axis=1, keepdims=True)
x_s = x.square()
bd_sum = mx.sym.dot(x_s, v_s)
# interactions
w2 = mx.symbol.dot(x, v)
w2_squared = 0.5 * mx.symbol.square(data=w2)
# putting everything together
w_all = mx.symbol.Concat(w1, w2_squared, dim=1)
sum1 = w_all.sum(axis=1, keepdims=True)
sum2 = -0.5 * bd_sum
model = sum1 + sum2
y = mx.symbol.Variable("softmax_label")
model = mx.symbol.LogisticRegressionOutput(data=model, label=y)
return model
|
python
|
def factorization_machine_model(factor_size, num_features,
lr_mult_config, wd_mult_config, init_config):
""" builds factorization machine network with proper formulation:
y = w_0 \sum(x_i w_i) + 0.5(\sum\sum<v_i,v_j>x_ix_j - \sum<v_iv_i>x_i^2)
"""
x = mx.symbol.Variable("data", stype='csr')
# factor, linear and bias terms
v = mx.symbol.Variable("v", shape=(num_features, factor_size), stype='row_sparse',
init=init_config['v'], lr_mult=lr_mult_config['v'],
wd_mult=wd_mult_config['v'])
w = mx.symbol.Variable('w', shape=(num_features, 1), stype='row_sparse',
init=init_config['w'], lr_mult=lr_mult_config['w'],
wd_mult=wd_mult_config['w'])
w0 = mx.symbol.Variable('w0', shape=(1,), init=init_config['w0'],
lr_mult=lr_mult_config['w0'], wd_mult=wd_mult_config['w0'])
w1 = mx.symbol.broadcast_add(mx.symbol.dot(x, w), w0)
# squared terms for subtracting self interactions
v_s = mx.symbol._internal._square_sum(data=v, axis=1, keepdims=True)
x_s = x.square()
bd_sum = mx.sym.dot(x_s, v_s)
# interactions
w2 = mx.symbol.dot(x, v)
w2_squared = 0.5 * mx.symbol.square(data=w2)
# putting everything together
w_all = mx.symbol.Concat(w1, w2_squared, dim=1)
sum1 = w_all.sum(axis=1, keepdims=True)
sum2 = -0.5 * bd_sum
model = sum1 + sum2
y = mx.symbol.Variable("softmax_label")
model = mx.symbol.LogisticRegressionOutput(data=model, label=y)
return model
|
[
"def",
"factorization_machine_model",
"(",
"factor_size",
",",
"num_features",
",",
"lr_mult_config",
",",
"wd_mult_config",
",",
"init_config",
")",
":",
"x",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"\"data\"",
",",
"stype",
"=",
"'csr'",
")",
"# factor, linear and bias terms",
"v",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"\"v\"",
",",
"shape",
"=",
"(",
"num_features",
",",
"factor_size",
")",
",",
"stype",
"=",
"'row_sparse'",
",",
"init",
"=",
"init_config",
"[",
"'v'",
"]",
",",
"lr_mult",
"=",
"lr_mult_config",
"[",
"'v'",
"]",
",",
"wd_mult",
"=",
"wd_mult_config",
"[",
"'v'",
"]",
")",
"w",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"'w'",
",",
"shape",
"=",
"(",
"num_features",
",",
"1",
")",
",",
"stype",
"=",
"'row_sparse'",
",",
"init",
"=",
"init_config",
"[",
"'w'",
"]",
",",
"lr_mult",
"=",
"lr_mult_config",
"[",
"'w'",
"]",
",",
"wd_mult",
"=",
"wd_mult_config",
"[",
"'w'",
"]",
")",
"w0",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"'w0'",
",",
"shape",
"=",
"(",
"1",
",",
")",
",",
"init",
"=",
"init_config",
"[",
"'w0'",
"]",
",",
"lr_mult",
"=",
"lr_mult_config",
"[",
"'w0'",
"]",
",",
"wd_mult",
"=",
"wd_mult_config",
"[",
"'w0'",
"]",
")",
"w1",
"=",
"mx",
".",
"symbol",
".",
"broadcast_add",
"(",
"mx",
".",
"symbol",
".",
"dot",
"(",
"x",
",",
"w",
")",
",",
"w0",
")",
"# squared terms for subtracting self interactions",
"v_s",
"=",
"mx",
".",
"symbol",
".",
"_internal",
".",
"_square_sum",
"(",
"data",
"=",
"v",
",",
"axis",
"=",
"1",
",",
"keepdims",
"=",
"True",
")",
"x_s",
"=",
"x",
".",
"square",
"(",
")",
"bd_sum",
"=",
"mx",
".",
"sym",
".",
"dot",
"(",
"x_s",
",",
"v_s",
")",
"# interactions",
"w2",
"=",
"mx",
".",
"symbol",
".",
"dot",
"(",
"x",
",",
"v",
")",
"w2_squared",
"=",
"0.5",
"*",
"mx",
".",
"symbol",
".",
"square",
"(",
"data",
"=",
"w2",
")",
"# putting everything together",
"w_all",
"=",
"mx",
".",
"symbol",
".",
"Concat",
"(",
"w1",
",",
"w2_squared",
",",
"dim",
"=",
"1",
")",
"sum1",
"=",
"w_all",
".",
"sum",
"(",
"axis",
"=",
"1",
",",
"keepdims",
"=",
"True",
")",
"sum2",
"=",
"-",
"0.5",
"*",
"bd_sum",
"model",
"=",
"sum1",
"+",
"sum2",
"y",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"\"softmax_label\"",
")",
"model",
"=",
"mx",
".",
"symbol",
".",
"LogisticRegressionOutput",
"(",
"data",
"=",
"model",
",",
"label",
"=",
"y",
")",
"return",
"model"
] |
builds factorization machine network with proper formulation:
y = w_0 \sum(x_i w_i) + 0.5(\sum\sum<v_i,v_j>x_ix_j - \sum<v_iv_i>x_i^2)
|
[
"builds",
"factorization",
"machine",
"network",
"with",
"proper",
"formulation",
":",
"y",
"=",
"w_0",
"\\",
"sum",
"(",
"x_i",
"w_i",
")",
"+",
"0",
".",
"5",
"(",
"\\",
"sum",
"\\",
"sum<v_i",
"v_j",
">",
"x_ix_j",
"-",
"\\",
"sum<v_iv_i",
">",
"x_i^2",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/sparse/factorization_machine/model.py#L20-L54
|
train
|
apache/incubator-mxnet
|
example/rnn/word_lm/data.py
|
batchify
|
def batchify(data, batch_size):
"""Reshape data into (num_example, batch_size)"""
nbatch = data.shape[0] // batch_size
data = data[:nbatch * batch_size]
data = data.reshape((batch_size, nbatch)).T
return data
|
python
|
def batchify(data, batch_size):
"""Reshape data into (num_example, batch_size)"""
nbatch = data.shape[0] // batch_size
data = data[:nbatch * batch_size]
data = data.reshape((batch_size, nbatch)).T
return data
|
[
"def",
"batchify",
"(",
"data",
",",
"batch_size",
")",
":",
"nbatch",
"=",
"data",
".",
"shape",
"[",
"0",
"]",
"//",
"batch_size",
"data",
"=",
"data",
"[",
":",
"nbatch",
"*",
"batch_size",
"]",
"data",
"=",
"data",
".",
"reshape",
"(",
"(",
"batch_size",
",",
"nbatch",
")",
")",
".",
"T",
"return",
"data"
] |
Reshape data into (num_example, batch_size)
|
[
"Reshape",
"data",
"into",
"(",
"num_example",
"batch_size",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/word_lm/data.py#L72-L77
|
train
|
apache/incubator-mxnet
|
example/rnn/word_lm/data.py
|
Corpus.tokenize
|
def tokenize(self, path):
"""Tokenizes a text file."""
assert os.path.exists(path)
# Add words to the dictionary
with open(path, 'r') as f:
tokens = 0
for line in f:
words = line.split() + ['<eos>']
tokens += len(words)
for word in words:
self.dictionary.add_word(word)
# Tokenize file content
with open(path, 'r') as f:
ids = np.zeros((tokens,), dtype='int32')
token = 0
for line in f:
words = line.split() + ['<eos>']
for word in words:
ids[token] = self.dictionary.word2idx[word]
token += 1
return mx.nd.array(ids, dtype='int32')
|
python
|
def tokenize(self, path):
"""Tokenizes a text file."""
assert os.path.exists(path)
# Add words to the dictionary
with open(path, 'r') as f:
tokens = 0
for line in f:
words = line.split() + ['<eos>']
tokens += len(words)
for word in words:
self.dictionary.add_word(word)
# Tokenize file content
with open(path, 'r') as f:
ids = np.zeros((tokens,), dtype='int32')
token = 0
for line in f:
words = line.split() + ['<eos>']
for word in words:
ids[token] = self.dictionary.word2idx[word]
token += 1
return mx.nd.array(ids, dtype='int32')
|
[
"def",
"tokenize",
"(",
"self",
",",
"path",
")",
":",
"assert",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
"# Add words to the dictionary",
"with",
"open",
"(",
"path",
",",
"'r'",
")",
"as",
"f",
":",
"tokens",
"=",
"0",
"for",
"line",
"in",
"f",
":",
"words",
"=",
"line",
".",
"split",
"(",
")",
"+",
"[",
"'<eos>'",
"]",
"tokens",
"+=",
"len",
"(",
"words",
")",
"for",
"word",
"in",
"words",
":",
"self",
".",
"dictionary",
".",
"add_word",
"(",
"word",
")",
"# Tokenize file content",
"with",
"open",
"(",
"path",
",",
"'r'",
")",
"as",
"f",
":",
"ids",
"=",
"np",
".",
"zeros",
"(",
"(",
"tokens",
",",
")",
",",
"dtype",
"=",
"'int32'",
")",
"token",
"=",
"0",
"for",
"line",
"in",
"f",
":",
"words",
"=",
"line",
".",
"split",
"(",
")",
"+",
"[",
"'<eos>'",
"]",
"for",
"word",
"in",
"words",
":",
"ids",
"[",
"token",
"]",
"=",
"self",
".",
"dictionary",
".",
"word2idx",
"[",
"word",
"]",
"token",
"+=",
"1",
"return",
"mx",
".",
"nd",
".",
"array",
"(",
"ids",
",",
"dtype",
"=",
"'int32'",
")"
] |
Tokenizes a text file.
|
[
"Tokenizes",
"a",
"text",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/rnn/word_lm/data.py#L48-L70
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol_doc.py
|
_build_doc
|
def _build_doc(func_name,
desc,
arg_names,
arg_types,
arg_desc,
key_var_num_args=None,
ret_type=None):
"""Build docstring for symbolic functions."""
param_str = _build_param_doc(arg_names, arg_types, arg_desc)
if key_var_num_args:
desc += '\nThis function support variable length of positional input.'
doc_str = ('%s\n\n' +
'%s\n' +
'name : string, optional.\n' +
' Name of the resulting symbol.\n\n' +
'Returns\n' +
'-------\n' +
'Symbol\n' +
' The result symbol.')
doc_str = doc_str % (desc, param_str)
extra_doc = "\n" + '\n'.join([x.__doc__ for x in type.__subclasses__(SymbolDoc)
if x.__name__ == '%sDoc' % func_name])
doc_str += _re.sub(_re.compile(" "), "", extra_doc)
doc_str = _re.sub('NDArray-or-Symbol', 'Symbol', doc_str)
return doc_str
|
python
|
def _build_doc(func_name,
desc,
arg_names,
arg_types,
arg_desc,
key_var_num_args=None,
ret_type=None):
"""Build docstring for symbolic functions."""
param_str = _build_param_doc(arg_names, arg_types, arg_desc)
if key_var_num_args:
desc += '\nThis function support variable length of positional input.'
doc_str = ('%s\n\n' +
'%s\n' +
'name : string, optional.\n' +
' Name of the resulting symbol.\n\n' +
'Returns\n' +
'-------\n' +
'Symbol\n' +
' The result symbol.')
doc_str = doc_str % (desc, param_str)
extra_doc = "\n" + '\n'.join([x.__doc__ for x in type.__subclasses__(SymbolDoc)
if x.__name__ == '%sDoc' % func_name])
doc_str += _re.sub(_re.compile(" "), "", extra_doc)
doc_str = _re.sub('NDArray-or-Symbol', 'Symbol', doc_str)
return doc_str
|
[
"def",
"_build_doc",
"(",
"func_name",
",",
"desc",
",",
"arg_names",
",",
"arg_types",
",",
"arg_desc",
",",
"key_var_num_args",
"=",
"None",
",",
"ret_type",
"=",
"None",
")",
":",
"param_str",
"=",
"_build_param_doc",
"(",
"arg_names",
",",
"arg_types",
",",
"arg_desc",
")",
"if",
"key_var_num_args",
":",
"desc",
"+=",
"'\\nThis function support variable length of positional input.'",
"doc_str",
"=",
"(",
"'%s\\n\\n'",
"+",
"'%s\\n'",
"+",
"'name : string, optional.\\n'",
"+",
"' Name of the resulting symbol.\\n\\n'",
"+",
"'Returns\\n'",
"+",
"'-------\\n'",
"+",
"'Symbol\\n'",
"+",
"' The result symbol.'",
")",
"doc_str",
"=",
"doc_str",
"%",
"(",
"desc",
",",
"param_str",
")",
"extra_doc",
"=",
"\"\\n\"",
"+",
"'\\n'",
".",
"join",
"(",
"[",
"x",
".",
"__doc__",
"for",
"x",
"in",
"type",
".",
"__subclasses__",
"(",
"SymbolDoc",
")",
"if",
"x",
".",
"__name__",
"==",
"'%sDoc'",
"%",
"func_name",
"]",
")",
"doc_str",
"+=",
"_re",
".",
"sub",
"(",
"_re",
".",
"compile",
"(",
"\" \"",
")",
",",
"\"\"",
",",
"extra_doc",
")",
"doc_str",
"=",
"_re",
".",
"sub",
"(",
"'NDArray-or-Symbol'",
",",
"'Symbol'",
",",
"doc_str",
")",
"return",
"doc_str"
] |
Build docstring for symbolic functions.
|
[
"Build",
"docstring",
"for",
"symbolic",
"functions",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol_doc.py#L212-L236
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol_doc.py
|
SymbolDoc.get_output_shape
|
def get_output_shape(sym, **input_shapes):
"""Get user friendly information of the output shapes."""
_, s_outputs, _ = sym.infer_shape(**input_shapes)
return dict(zip(sym.list_outputs(), s_outputs))
|
python
|
def get_output_shape(sym, **input_shapes):
"""Get user friendly information of the output shapes."""
_, s_outputs, _ = sym.infer_shape(**input_shapes)
return dict(zip(sym.list_outputs(), s_outputs))
|
[
"def",
"get_output_shape",
"(",
"sym",
",",
"*",
"*",
"input_shapes",
")",
":",
"_",
",",
"s_outputs",
",",
"_",
"=",
"sym",
".",
"infer_shape",
"(",
"*",
"*",
"input_shapes",
")",
"return",
"dict",
"(",
"zip",
"(",
"sym",
".",
"list_outputs",
"(",
")",
",",
"s_outputs",
")",
")"
] |
Get user friendly information of the output shapes.
|
[
"Get",
"user",
"friendly",
"information",
"of",
"the",
"output",
"shapes",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol_doc.py#L56-L59
|
train
|
apache/incubator-mxnet
|
python/mxnet/context.py
|
num_gpus
|
def num_gpus():
"""Query CUDA for the number of GPUs present.
Raises
------
Will raise an exception on any CUDA error.
Returns
-------
count : int
The number of GPUs.
"""
count = ctypes.c_int()
check_call(_LIB.MXGetGPUCount(ctypes.byref(count)))
return count.value
|
python
|
def num_gpus():
"""Query CUDA for the number of GPUs present.
Raises
------
Will raise an exception on any CUDA error.
Returns
-------
count : int
The number of GPUs.
"""
count = ctypes.c_int()
check_call(_LIB.MXGetGPUCount(ctypes.byref(count)))
return count.value
|
[
"def",
"num_gpus",
"(",
")",
":",
"count",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXGetGPUCount",
"(",
"ctypes",
".",
"byref",
"(",
"count",
")",
")",
")",
"return",
"count",
".",
"value"
] |
Query CUDA for the number of GPUs present.
Raises
------
Will raise an exception on any CUDA error.
Returns
-------
count : int
The number of GPUs.
|
[
"Query",
"CUDA",
"for",
"the",
"number",
"of",
"GPUs",
"present",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/context.py#L244-L259
|
train
|
apache/incubator-mxnet
|
python/mxnet/context.py
|
gpu_memory_info
|
def gpu_memory_info(device_id=0):
"""Query CUDA for the free and total bytes of GPU global memory.
Parameters
----------
device_id : int, optional
The device id of the GPU device.
Raises
------
Will raise an exception on any CUDA error.
Returns
-------
(free, total) : (int, int)
The number of GPUs.
"""
free = ctypes.c_uint64()
total = ctypes.c_uint64()
dev_id = ctypes.c_int(device_id)
check_call(_LIB.MXGetGPUMemoryInformation64(dev_id, ctypes.byref(free), ctypes.byref(total)))
return (free.value, total.value)
|
python
|
def gpu_memory_info(device_id=0):
"""Query CUDA for the free and total bytes of GPU global memory.
Parameters
----------
device_id : int, optional
The device id of the GPU device.
Raises
------
Will raise an exception on any CUDA error.
Returns
-------
(free, total) : (int, int)
The number of GPUs.
"""
free = ctypes.c_uint64()
total = ctypes.c_uint64()
dev_id = ctypes.c_int(device_id)
check_call(_LIB.MXGetGPUMemoryInformation64(dev_id, ctypes.byref(free), ctypes.byref(total)))
return (free.value, total.value)
|
[
"def",
"gpu_memory_info",
"(",
"device_id",
"=",
"0",
")",
":",
"free",
"=",
"ctypes",
".",
"c_uint64",
"(",
")",
"total",
"=",
"ctypes",
".",
"c_uint64",
"(",
")",
"dev_id",
"=",
"ctypes",
".",
"c_int",
"(",
"device_id",
")",
"check_call",
"(",
"_LIB",
".",
"MXGetGPUMemoryInformation64",
"(",
"dev_id",
",",
"ctypes",
".",
"byref",
"(",
"free",
")",
",",
"ctypes",
".",
"byref",
"(",
"total",
")",
")",
")",
"return",
"(",
"free",
".",
"value",
",",
"total",
".",
"value",
")"
] |
Query CUDA for the free and total bytes of GPU global memory.
Parameters
----------
device_id : int, optional
The device id of the GPU device.
Raises
------
Will raise an exception on any CUDA error.
Returns
-------
(free, total) : (int, int)
The number of GPUs.
|
[
"Query",
"CUDA",
"for",
"the",
"free",
"and",
"total",
"bytes",
"of",
"GPU",
"global",
"memory",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/context.py#L261-L283
|
train
|
apache/incubator-mxnet
|
python/mxnet/context.py
|
current_context
|
def current_context():
"""Returns the current context.
By default, `mx.cpu()` is used for all the computations
and it can be overridden by using `with mx.Context(x)` statement where
x can be cpu(device_id) or gpu(device_id).
Examples
-------
>>> mx.current_context()
cpu(0)
>>> with mx.Context('gpu', 1): # Context changed in `with` block.
... mx.current_context() # Computation done here will be on gpu(1).
...
gpu(1)
>>> mx.current_context() # Back to default context.
cpu(0)
Returns
-------
default_ctx : Context
"""
if not hasattr(Context._default_ctx, "value"):
Context._default_ctx.value = Context('cpu', 0)
return Context._default_ctx.value
|
python
|
def current_context():
"""Returns the current context.
By default, `mx.cpu()` is used for all the computations
and it can be overridden by using `with mx.Context(x)` statement where
x can be cpu(device_id) or gpu(device_id).
Examples
-------
>>> mx.current_context()
cpu(0)
>>> with mx.Context('gpu', 1): # Context changed in `with` block.
... mx.current_context() # Computation done here will be on gpu(1).
...
gpu(1)
>>> mx.current_context() # Back to default context.
cpu(0)
Returns
-------
default_ctx : Context
"""
if not hasattr(Context._default_ctx, "value"):
Context._default_ctx.value = Context('cpu', 0)
return Context._default_ctx.value
|
[
"def",
"current_context",
"(",
")",
":",
"if",
"not",
"hasattr",
"(",
"Context",
".",
"_default_ctx",
",",
"\"value\"",
")",
":",
"Context",
".",
"_default_ctx",
".",
"value",
"=",
"Context",
"(",
"'cpu'",
",",
"0",
")",
"return",
"Context",
".",
"_default_ctx",
".",
"value"
] |
Returns the current context.
By default, `mx.cpu()` is used for all the computations
and it can be overridden by using `with mx.Context(x)` statement where
x can be cpu(device_id) or gpu(device_id).
Examples
-------
>>> mx.current_context()
cpu(0)
>>> with mx.Context('gpu', 1): # Context changed in `with` block.
... mx.current_context() # Computation done here will be on gpu(1).
...
gpu(1)
>>> mx.current_context() # Back to default context.
cpu(0)
Returns
-------
default_ctx : Context
|
[
"Returns",
"the",
"current",
"context",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/context.py#L285-L309
|
train
|
apache/incubator-mxnet
|
example/gluon/audio/urban_sounds/datasets.py
|
AudioFolderDataset._list_audio_files
|
def _list_audio_files(self, root, skip_rows=0):
"""Populates synsets - a map of index to label for the data items.
Populates the data in the dataset, making tuples of (data, label)
"""
self.synsets = []
self.items = []
if not self._train_csv:
# The audio files are organized in folder structure with
# directory name as label and audios in them
self._folder_structure(root)
else:
# train_csv contains mapping between filename and label
self._csv_labelled_dataset(root, skip_rows=skip_rows)
# Generating the synset.txt file now
if not os.path.exists("./synset.txt"):
with open("./synset.txt", "w") as synsets_file:
for item in self.synsets:
synsets_file.write(item+os.linesep)
print("Synsets is generated as synset.txt")
else:
warnings.warn("Synset file already exists in the current directory! Not generating synset.txt.")
|
python
|
def _list_audio_files(self, root, skip_rows=0):
"""Populates synsets - a map of index to label for the data items.
Populates the data in the dataset, making tuples of (data, label)
"""
self.synsets = []
self.items = []
if not self._train_csv:
# The audio files are organized in folder structure with
# directory name as label and audios in them
self._folder_structure(root)
else:
# train_csv contains mapping between filename and label
self._csv_labelled_dataset(root, skip_rows=skip_rows)
# Generating the synset.txt file now
if not os.path.exists("./synset.txt"):
with open("./synset.txt", "w") as synsets_file:
for item in self.synsets:
synsets_file.write(item+os.linesep)
print("Synsets is generated as synset.txt")
else:
warnings.warn("Synset file already exists in the current directory! Not generating synset.txt.")
|
[
"def",
"_list_audio_files",
"(",
"self",
",",
"root",
",",
"skip_rows",
"=",
"0",
")",
":",
"self",
".",
"synsets",
"=",
"[",
"]",
"self",
".",
"items",
"=",
"[",
"]",
"if",
"not",
"self",
".",
"_train_csv",
":",
"# The audio files are organized in folder structure with",
"# directory name as label and audios in them",
"self",
".",
"_folder_structure",
"(",
"root",
")",
"else",
":",
"# train_csv contains mapping between filename and label",
"self",
".",
"_csv_labelled_dataset",
"(",
"root",
",",
"skip_rows",
"=",
"skip_rows",
")",
"# Generating the synset.txt file now",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"\"./synset.txt\"",
")",
":",
"with",
"open",
"(",
"\"./synset.txt\"",
",",
"\"w\"",
")",
"as",
"synsets_file",
":",
"for",
"item",
"in",
"self",
".",
"synsets",
":",
"synsets_file",
".",
"write",
"(",
"item",
"+",
"os",
".",
"linesep",
")",
"print",
"(",
"\"Synsets is generated as synset.txt\"",
")",
"else",
":",
"warnings",
".",
"warn",
"(",
"\"Synset file already exists in the current directory! Not generating synset.txt.\"",
")"
] |
Populates synsets - a map of index to label for the data items.
Populates the data in the dataset, making tuples of (data, label)
|
[
"Populates",
"synsets",
"-",
"a",
"map",
"of",
"index",
"to",
"label",
"for",
"the",
"data",
"items",
".",
"Populates",
"the",
"data",
"in",
"the",
"dataset",
"making",
"tuples",
"of",
"(",
"data",
"label",
")"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/audio/urban_sounds/datasets.py#L86-L107
|
train
|
apache/incubator-mxnet
|
example/gluon/audio/urban_sounds/datasets.py
|
AudioFolderDataset.transform_first
|
def transform_first(self, fn, lazy=False):
"""Returns a new dataset with the first element of each sample
transformed by the transformer function `fn`.
This is useful, for example, when you only want to transform data
while keeping label as is.
lazy=False is passed to transform_first for dataset so that all tramsforms could be performed in
one shot and not during training. This is a performance consideration.
Parameters
----------
fn : callable
A transformer function that takes the first element of a sample
as input and returns the transformed element.
lazy : bool, default False
If False, transforms all samples at once. Otherwise,
transforms each sample on demand. Note that if `fn`
is stochastic, you must set lazy to True or you will
get the same result on all epochs.
Returns
-------
Dataset
The transformed dataset.
"""
return super(AudioFolderDataset, self).transform_first(fn, lazy=lazy)
|
python
|
def transform_first(self, fn, lazy=False):
"""Returns a new dataset with the first element of each sample
transformed by the transformer function `fn`.
This is useful, for example, when you only want to transform data
while keeping label as is.
lazy=False is passed to transform_first for dataset so that all tramsforms could be performed in
one shot and not during training. This is a performance consideration.
Parameters
----------
fn : callable
A transformer function that takes the first element of a sample
as input and returns the transformed element.
lazy : bool, default False
If False, transforms all samples at once. Otherwise,
transforms each sample on demand. Note that if `fn`
is stochastic, you must set lazy to True or you will
get the same result on all epochs.
Returns
-------
Dataset
The transformed dataset.
"""
return super(AudioFolderDataset, self).transform_first(fn, lazy=lazy)
|
[
"def",
"transform_first",
"(",
"self",
",",
"fn",
",",
"lazy",
"=",
"False",
")",
":",
"return",
"super",
"(",
"AudioFolderDataset",
",",
"self",
")",
".",
"transform_first",
"(",
"fn",
",",
"lazy",
"=",
"lazy",
")"
] |
Returns a new dataset with the first element of each sample
transformed by the transformer function `fn`.
This is useful, for example, when you only want to transform data
while keeping label as is.
lazy=False is passed to transform_first for dataset so that all tramsforms could be performed in
one shot and not during training. This is a performance consideration.
Parameters
----------
fn : callable
A transformer function that takes the first element of a sample
as input and returns the transformed element.
lazy : bool, default False
If False, transforms all samples at once. Otherwise,
transforms each sample on demand. Note that if `fn`
is stochastic, you must set lazy to True or you will
get the same result on all epochs.
Returns
-------
Dataset
The transformed dataset.
|
[
"Returns",
"a",
"new",
"dataset",
"with",
"the",
"first",
"element",
"of",
"each",
"sample",
"transformed",
"by",
"the",
"transformer",
"function",
"fn",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/gluon/audio/urban_sounds/datasets.py#L153-L179
|
train
|
apache/incubator-mxnet
|
python/setup.py
|
config_cython
|
def config_cython():
"""Try to configure cython and return cython configuration"""
if not with_cython:
return []
# pylint: disable=unreachable
if os.name == 'nt':
print("WARNING: Cython is not supported on Windows, will compile without cython module")
return []
try:
from Cython.Build import cythonize
# from setuptools.extension import Extension
if sys.version_info >= (3, 0):
subdir = "_cy3"
else:
subdir = "_cy2"
ret = []
path = "mxnet/cython"
if os.name == 'nt':
library_dirs = ['mxnet', '../build/Release', '../build']
libraries = ['libmxnet']
else:
library_dirs = None
libraries = None
for fn in os.listdir(path):
if not fn.endswith(".pyx"):
continue
ret.append(Extension(
"mxnet/%s/.%s" % (subdir, fn[:-4]),
["mxnet/cython/%s" % fn],
include_dirs=["../include/", "../3rdparty/tvm/nnvm/include"],
library_dirs=library_dirs,
libraries=libraries,
language="c++"))
return cythonize(ret)
except ImportError:
print("WARNING: Cython is not installed, will compile without cython module")
return []
|
python
|
def config_cython():
"""Try to configure cython and return cython configuration"""
if not with_cython:
return []
# pylint: disable=unreachable
if os.name == 'nt':
print("WARNING: Cython is not supported on Windows, will compile without cython module")
return []
try:
from Cython.Build import cythonize
# from setuptools.extension import Extension
if sys.version_info >= (3, 0):
subdir = "_cy3"
else:
subdir = "_cy2"
ret = []
path = "mxnet/cython"
if os.name == 'nt':
library_dirs = ['mxnet', '../build/Release', '../build']
libraries = ['libmxnet']
else:
library_dirs = None
libraries = None
for fn in os.listdir(path):
if not fn.endswith(".pyx"):
continue
ret.append(Extension(
"mxnet/%s/.%s" % (subdir, fn[:-4]),
["mxnet/cython/%s" % fn],
include_dirs=["../include/", "../3rdparty/tvm/nnvm/include"],
library_dirs=library_dirs,
libraries=libraries,
language="c++"))
return cythonize(ret)
except ImportError:
print("WARNING: Cython is not installed, will compile without cython module")
return []
|
[
"def",
"config_cython",
"(",
")",
":",
"if",
"not",
"with_cython",
":",
"return",
"[",
"]",
"# pylint: disable=unreachable",
"if",
"os",
".",
"name",
"==",
"'nt'",
":",
"print",
"(",
"\"WARNING: Cython is not supported on Windows, will compile without cython module\"",
")",
"return",
"[",
"]",
"try",
":",
"from",
"Cython",
".",
"Build",
"import",
"cythonize",
"# from setuptools.extension import Extension",
"if",
"sys",
".",
"version_info",
">=",
"(",
"3",
",",
"0",
")",
":",
"subdir",
"=",
"\"_cy3\"",
"else",
":",
"subdir",
"=",
"\"_cy2\"",
"ret",
"=",
"[",
"]",
"path",
"=",
"\"mxnet/cython\"",
"if",
"os",
".",
"name",
"==",
"'nt'",
":",
"library_dirs",
"=",
"[",
"'mxnet'",
",",
"'../build/Release'",
",",
"'../build'",
"]",
"libraries",
"=",
"[",
"'libmxnet'",
"]",
"else",
":",
"library_dirs",
"=",
"None",
"libraries",
"=",
"None",
"for",
"fn",
"in",
"os",
".",
"listdir",
"(",
"path",
")",
":",
"if",
"not",
"fn",
".",
"endswith",
"(",
"\".pyx\"",
")",
":",
"continue",
"ret",
".",
"append",
"(",
"Extension",
"(",
"\"mxnet/%s/.%s\"",
"%",
"(",
"subdir",
",",
"fn",
"[",
":",
"-",
"4",
"]",
")",
",",
"[",
"\"mxnet/cython/%s\"",
"%",
"fn",
"]",
",",
"include_dirs",
"=",
"[",
"\"../include/\"",
",",
"\"../3rdparty/tvm/nnvm/include\"",
"]",
",",
"library_dirs",
"=",
"library_dirs",
",",
"libraries",
"=",
"libraries",
",",
"language",
"=",
"\"c++\"",
")",
")",
"return",
"cythonize",
"(",
"ret",
")",
"except",
"ImportError",
":",
"print",
"(",
"\"WARNING: Cython is not installed, will compile without cython module\"",
")",
"return",
"[",
"]"
] |
Try to configure cython and return cython configuration
|
[
"Try",
"to",
"configure",
"cython",
"and",
"return",
"cython",
"configuration"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/setup.py#L62-L100
|
train
|
apache/incubator-mxnet
|
python/mxnet/_ctypes/symbol.py
|
SymbolBase._compose
|
def _compose(self, *args, **kwargs):
"""Compose symbol on inputs.
This call mutates the current symbol.
Parameters
----------
args:
provide positional arguments
kwargs:
provide keyword arguments
Returns
-------
the resulting symbol
"""
name = kwargs.pop('name', None)
if name:
name = c_str(name)
if len(args) != 0 and len(kwargs) != 0:
raise TypeError('compose only accept input Symbols \
either as positional or keyword arguments, not both')
for arg in args:
if not isinstance(arg, SymbolBase):
raise TypeError('Compose expect `Symbol` as arguments')
for val in kwargs.values():
if not isinstance(val, SymbolBase):
raise TypeError('Compose expect `Symbol` as arguments')
num_args = len(args) + len(kwargs)
if len(kwargs) != 0:
keys = c_str_array(kwargs.keys())
args = c_handle_array(kwargs.values())
else:
keys = None
args = c_handle_array(kwargs.values())
check_call(_LIB.NNSymbolCompose(
self.handle, name, num_args, keys, args))
|
python
|
def _compose(self, *args, **kwargs):
"""Compose symbol on inputs.
This call mutates the current symbol.
Parameters
----------
args:
provide positional arguments
kwargs:
provide keyword arguments
Returns
-------
the resulting symbol
"""
name = kwargs.pop('name', None)
if name:
name = c_str(name)
if len(args) != 0 and len(kwargs) != 0:
raise TypeError('compose only accept input Symbols \
either as positional or keyword arguments, not both')
for arg in args:
if not isinstance(arg, SymbolBase):
raise TypeError('Compose expect `Symbol` as arguments')
for val in kwargs.values():
if not isinstance(val, SymbolBase):
raise TypeError('Compose expect `Symbol` as arguments')
num_args = len(args) + len(kwargs)
if len(kwargs) != 0:
keys = c_str_array(kwargs.keys())
args = c_handle_array(kwargs.values())
else:
keys = None
args = c_handle_array(kwargs.values())
check_call(_LIB.NNSymbolCompose(
self.handle, name, num_args, keys, args))
|
[
"def",
"_compose",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
"=",
"kwargs",
".",
"pop",
"(",
"'name'",
",",
"None",
")",
"if",
"name",
":",
"name",
"=",
"c_str",
"(",
"name",
")",
"if",
"len",
"(",
"args",
")",
"!=",
"0",
"and",
"len",
"(",
"kwargs",
")",
"!=",
"0",
":",
"raise",
"TypeError",
"(",
"'compose only accept input Symbols \\\n either as positional or keyword arguments, not both'",
")",
"for",
"arg",
"in",
"args",
":",
"if",
"not",
"isinstance",
"(",
"arg",
",",
"SymbolBase",
")",
":",
"raise",
"TypeError",
"(",
"'Compose expect `Symbol` as arguments'",
")",
"for",
"val",
"in",
"kwargs",
".",
"values",
"(",
")",
":",
"if",
"not",
"isinstance",
"(",
"val",
",",
"SymbolBase",
")",
":",
"raise",
"TypeError",
"(",
"'Compose expect `Symbol` as arguments'",
")",
"num_args",
"=",
"len",
"(",
"args",
")",
"+",
"len",
"(",
"kwargs",
")",
"if",
"len",
"(",
"kwargs",
")",
"!=",
"0",
":",
"keys",
"=",
"c_str_array",
"(",
"kwargs",
".",
"keys",
"(",
")",
")",
"args",
"=",
"c_handle_array",
"(",
"kwargs",
".",
"values",
"(",
")",
")",
"else",
":",
"keys",
"=",
"None",
"args",
"=",
"c_handle_array",
"(",
"kwargs",
".",
"values",
"(",
")",
")",
"check_call",
"(",
"_LIB",
".",
"NNSymbolCompose",
"(",
"self",
".",
"handle",
",",
"name",
",",
"num_args",
",",
"keys",
",",
"args",
")",
")"
] |
Compose symbol on inputs.
This call mutates the current symbol.
Parameters
----------
args:
provide positional arguments
kwargs:
provide keyword arguments
Returns
-------
the resulting symbol
|
[
"Compose",
"symbol",
"on",
"inputs",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/_ctypes/symbol.py#L48-L88
|
train
|
apache/incubator-mxnet
|
python/mxnet/_ctypes/symbol.py
|
SymbolBase._set_attr
|
def _set_attr(self, **kwargs):
"""Set the attribute of the symbol.
Parameters
----------
**kwargs
The attributes to set
"""
keys = c_str_array(kwargs.keys())
vals = c_str_array([str(s) for s in kwargs.values()])
num_args = mx_uint(len(kwargs))
check_call(_LIB.MXSymbolSetAttrs(
self.handle, num_args, keys, vals))
|
python
|
def _set_attr(self, **kwargs):
"""Set the attribute of the symbol.
Parameters
----------
**kwargs
The attributes to set
"""
keys = c_str_array(kwargs.keys())
vals = c_str_array([str(s) for s in kwargs.values()])
num_args = mx_uint(len(kwargs))
check_call(_LIB.MXSymbolSetAttrs(
self.handle, num_args, keys, vals))
|
[
"def",
"_set_attr",
"(",
"self",
",",
"*",
"*",
"kwargs",
")",
":",
"keys",
"=",
"c_str_array",
"(",
"kwargs",
".",
"keys",
"(",
")",
")",
"vals",
"=",
"c_str_array",
"(",
"[",
"str",
"(",
"s",
")",
"for",
"s",
"in",
"kwargs",
".",
"values",
"(",
")",
"]",
")",
"num_args",
"=",
"mx_uint",
"(",
"len",
"(",
"kwargs",
")",
")",
"check_call",
"(",
"_LIB",
".",
"MXSymbolSetAttrs",
"(",
"self",
".",
"handle",
",",
"num_args",
",",
"keys",
",",
"vals",
")",
")"
] |
Set the attribute of the symbol.
Parameters
----------
**kwargs
The attributes to set
|
[
"Set",
"the",
"attribute",
"of",
"the",
"symbol",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/_ctypes/symbol.py#L90-L102
|
train
|
apache/incubator-mxnet
|
example/ssd/symbol/symbol_factory.py
|
get_config
|
def get_config(network, data_shape, **kwargs):
"""Configuration factory for various networks
Parameters
----------
network : str
base network name, such as vgg_reduced, inceptionv3, resnet...
data_shape : int
input data dimension
kwargs : dict
extra arguments
"""
if network == 'vgg16_reduced':
if data_shape >= 448:
from_layers = ['relu4_3', 'relu7', '', '', '', '', '']
num_filters = [512, -1, 512, 256, 256, 256, 256]
strides = [-1, -1, 2, 2, 2, 2, 1]
pads = [-1, -1, 1, 1, 1, 1, 1]
sizes = [[.07, .1025], [.15,.2121], [.3, .3674], [.45, .5196], [.6, .6708], \
[.75, .8216], [.9, .9721]]
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,3,1./3], [1,2,.5], [1,2,.5]]
normalizations = [20, -1, -1, -1, -1, -1, -1]
steps = [] if data_shape != 512 else [x / 512.0 for x in
[8, 16, 32, 64, 128, 256, 512]]
else:
from_layers = ['relu4_3', 'relu7', '', '', '', '']
num_filters = [512, -1, 512, 256, 256, 256]
strides = [-1, -1, 2, 2, 1, 1]
pads = [-1, -1, 1, 1, 0, 0]
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 = [] if data_shape != 300 else [x / 300.0 for x in [8, 16, 32, 64, 100, 300]]
if not (data_shape == 300 or data_shape == 512):
logging.warn('data_shape %d was not tested, use with caucious.' % data_shape)
return locals()
elif network == 'inceptionv3':
from_layers = ['ch_concat_mixed_7_chconcat', 'ch_concat_mixed_10_chconcat', '', '', '', '']
num_filters = [-1, -1, 512, 256, 256, 128]
strides = [-1, -1, 2, 2, 2, 2]
pads = [-1, -1, 1, 1, 1, 1]
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 = -1
steps = []
return locals()
elif network == 'resnet50':
num_layers = 50
image_shape = '3,224,224' # resnet require it as shape check
network = 'resnet'
from_layers = ['_plus12', '_plus15', '', '', '', '']
num_filters = [-1, -1, 512, 256, 256, 128]
strides = [-1, -1, 2, 2, 2, 2]
pads = [-1, -1, 1, 1, 1, 1]
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 = -1
steps = []
return locals()
elif network == 'resnet101':
num_layers = 101
image_shape = '3,224,224'
network = 'resnet'
from_layers = ['_plus29', '_plus32', '', '', '', '']
num_filters = [-1, -1, 512, 256, 256, 128]
strides = [-1, -1, 2, 2, 2, 2]
pads = [-1, -1, 1, 1, 1, 1]
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 = -1
steps = []
return locals()
else:
msg = 'No configuration found for %s with data_shape %d' % (network, data_shape)
raise NotImplementedError(msg)
|
python
|
def get_config(network, data_shape, **kwargs):
"""Configuration factory for various networks
Parameters
----------
network : str
base network name, such as vgg_reduced, inceptionv3, resnet...
data_shape : int
input data dimension
kwargs : dict
extra arguments
"""
if network == 'vgg16_reduced':
if data_shape >= 448:
from_layers = ['relu4_3', 'relu7', '', '', '', '', '']
num_filters = [512, -1, 512, 256, 256, 256, 256]
strides = [-1, -1, 2, 2, 2, 2, 1]
pads = [-1, -1, 1, 1, 1, 1, 1]
sizes = [[.07, .1025], [.15,.2121], [.3, .3674], [.45, .5196], [.6, .6708], \
[.75, .8216], [.9, .9721]]
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,3,1./3], [1,2,.5], [1,2,.5]]
normalizations = [20, -1, -1, -1, -1, -1, -1]
steps = [] if data_shape != 512 else [x / 512.0 for x in
[8, 16, 32, 64, 128, 256, 512]]
else:
from_layers = ['relu4_3', 'relu7', '', '', '', '']
num_filters = [512, -1, 512, 256, 256, 256]
strides = [-1, -1, 2, 2, 1, 1]
pads = [-1, -1, 1, 1, 0, 0]
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 = [] if data_shape != 300 else [x / 300.0 for x in [8, 16, 32, 64, 100, 300]]
if not (data_shape == 300 or data_shape == 512):
logging.warn('data_shape %d was not tested, use with caucious.' % data_shape)
return locals()
elif network == 'inceptionv3':
from_layers = ['ch_concat_mixed_7_chconcat', 'ch_concat_mixed_10_chconcat', '', '', '', '']
num_filters = [-1, -1, 512, 256, 256, 128]
strides = [-1, -1, 2, 2, 2, 2]
pads = [-1, -1, 1, 1, 1, 1]
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 = -1
steps = []
return locals()
elif network == 'resnet50':
num_layers = 50
image_shape = '3,224,224' # resnet require it as shape check
network = 'resnet'
from_layers = ['_plus12', '_plus15', '', '', '', '']
num_filters = [-1, -1, 512, 256, 256, 128]
strides = [-1, -1, 2, 2, 2, 2]
pads = [-1, -1, 1, 1, 1, 1]
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 = -1
steps = []
return locals()
elif network == 'resnet101':
num_layers = 101
image_shape = '3,224,224'
network = 'resnet'
from_layers = ['_plus29', '_plus32', '', '', '', '']
num_filters = [-1, -1, 512, 256, 256, 128]
strides = [-1, -1, 2, 2, 2, 2]
pads = [-1, -1, 1, 1, 1, 1]
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 = -1
steps = []
return locals()
else:
msg = 'No configuration found for %s with data_shape %d' % (network, data_shape)
raise NotImplementedError(msg)
|
[
"def",
"get_config",
"(",
"network",
",",
"data_shape",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"network",
"==",
"'vgg16_reduced'",
":",
"if",
"data_shape",
">=",
"448",
":",
"from_layers",
"=",
"[",
"'relu4_3'",
",",
"'relu7'",
",",
"''",
",",
"''",
",",
"''",
",",
"''",
",",
"''",
"]",
"num_filters",
"=",
"[",
"512",
",",
"-",
"1",
",",
"512",
",",
"256",
",",
"256",
",",
"256",
",",
"256",
"]",
"strides",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"2",
",",
"2",
",",
"2",
",",
"2",
",",
"1",
"]",
"pads",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"1",
",",
"1",
",",
"1",
",",
"1",
",",
"1",
"]",
"sizes",
"=",
"[",
"[",
".07",
",",
".1025",
"]",
",",
"[",
".15",
",",
".2121",
"]",
",",
"[",
".3",
",",
".3674",
"]",
",",
"[",
".45",
",",
".5196",
"]",
",",
"[",
".6",
",",
".6708",
"]",
",",
"[",
".75",
",",
".8216",
"]",
",",
"[",
".9",
",",
".9721",
"]",
"]",
"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",
",",
"3",
",",
"1.",
"/",
"3",
"]",
",",
"[",
"1",
",",
"2",
",",
".5",
"]",
",",
"[",
"1",
",",
"2",
",",
".5",
"]",
"]",
"normalizations",
"=",
"[",
"20",
",",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
",",
"-",
"1",
"]",
"steps",
"=",
"[",
"]",
"if",
"data_shape",
"!=",
"512",
"else",
"[",
"x",
"/",
"512.0",
"for",
"x",
"in",
"[",
"8",
",",
"16",
",",
"32",
",",
"64",
",",
"128",
",",
"256",
",",
"512",
"]",
"]",
"else",
":",
"from_layers",
"=",
"[",
"'relu4_3'",
",",
"'relu7'",
",",
"''",
",",
"''",
",",
"''",
",",
"''",
"]",
"num_filters",
"=",
"[",
"512",
",",
"-",
"1",
",",
"512",
",",
"256",
",",
"256",
",",
"256",
"]",
"strides",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"2",
",",
"2",
",",
"1",
",",
"1",
"]",
"pads",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"1",
",",
"1",
",",
"0",
",",
"0",
"]",
"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",
"=",
"[",
"]",
"if",
"data_shape",
"!=",
"300",
"else",
"[",
"x",
"/",
"300.0",
"for",
"x",
"in",
"[",
"8",
",",
"16",
",",
"32",
",",
"64",
",",
"100",
",",
"300",
"]",
"]",
"if",
"not",
"(",
"data_shape",
"==",
"300",
"or",
"data_shape",
"==",
"512",
")",
":",
"logging",
".",
"warn",
"(",
"'data_shape %d was not tested, use with caucious.'",
"%",
"data_shape",
")",
"return",
"locals",
"(",
")",
"elif",
"network",
"==",
"'inceptionv3'",
":",
"from_layers",
"=",
"[",
"'ch_concat_mixed_7_chconcat'",
",",
"'ch_concat_mixed_10_chconcat'",
",",
"''",
",",
"''",
",",
"''",
",",
"''",
"]",
"num_filters",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"512",
",",
"256",
",",
"256",
",",
"128",
"]",
"strides",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"2",
",",
"2",
",",
"2",
",",
"2",
"]",
"pads",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"1",
",",
"1",
",",
"1",
",",
"1",
"]",
"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",
"=",
"-",
"1",
"steps",
"=",
"[",
"]",
"return",
"locals",
"(",
")",
"elif",
"network",
"==",
"'resnet50'",
":",
"num_layers",
"=",
"50",
"image_shape",
"=",
"'3,224,224'",
"# resnet require it as shape check",
"network",
"=",
"'resnet'",
"from_layers",
"=",
"[",
"'_plus12'",
",",
"'_plus15'",
",",
"''",
",",
"''",
",",
"''",
",",
"''",
"]",
"num_filters",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"512",
",",
"256",
",",
"256",
",",
"128",
"]",
"strides",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"2",
",",
"2",
",",
"2",
",",
"2",
"]",
"pads",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"1",
",",
"1",
",",
"1",
",",
"1",
"]",
"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",
"=",
"-",
"1",
"steps",
"=",
"[",
"]",
"return",
"locals",
"(",
")",
"elif",
"network",
"==",
"'resnet101'",
":",
"num_layers",
"=",
"101",
"image_shape",
"=",
"'3,224,224'",
"network",
"=",
"'resnet'",
"from_layers",
"=",
"[",
"'_plus29'",
",",
"'_plus32'",
",",
"''",
",",
"''",
",",
"''",
",",
"''",
"]",
"num_filters",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"512",
",",
"256",
",",
"256",
",",
"128",
"]",
"strides",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"2",
",",
"2",
",",
"2",
",",
"2",
"]",
"pads",
"=",
"[",
"-",
"1",
",",
"-",
"1",
",",
"1",
",",
"1",
",",
"1",
",",
"1",
"]",
"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",
"=",
"-",
"1",
"steps",
"=",
"[",
"]",
"return",
"locals",
"(",
")",
"else",
":",
"msg",
"=",
"'No configuration found for %s with data_shape %d'",
"%",
"(",
"network",
",",
"data_shape",
")",
"raise",
"NotImplementedError",
"(",
"msg",
")"
] |
Configuration factory for various networks
Parameters
----------
network : str
base network name, such as vgg_reduced, inceptionv3, resnet...
data_shape : int
input data dimension
kwargs : dict
extra arguments
|
[
"Configuration",
"factory",
"for",
"various",
"networks"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/symbol/symbol_factory.py#L22-L101
|
train
|
apache/incubator-mxnet
|
example/ssd/symbol/symbol_factory.py
|
get_symbol_train
|
def get_symbol_train(network, data_shape, **kwargs):
"""Wrapper for get symbol for train
Parameters
----------
network : str
name for the base network symbol
data_shape : int
input shape
kwargs : dict
see symbol_builder.get_symbol_train for more details
"""
if network.startswith('legacy'):
logging.warn('Using legacy model.')
return symbol_builder.import_module(network).get_symbol_train(**kwargs)
config = get_config(network, data_shape, **kwargs).copy()
config.update(kwargs)
return symbol_builder.get_symbol_train(**config)
|
python
|
def get_symbol_train(network, data_shape, **kwargs):
"""Wrapper for get symbol for train
Parameters
----------
network : str
name for the base network symbol
data_shape : int
input shape
kwargs : dict
see symbol_builder.get_symbol_train for more details
"""
if network.startswith('legacy'):
logging.warn('Using legacy model.')
return symbol_builder.import_module(network).get_symbol_train(**kwargs)
config = get_config(network, data_shape, **kwargs).copy()
config.update(kwargs)
return symbol_builder.get_symbol_train(**config)
|
[
"def",
"get_symbol_train",
"(",
"network",
",",
"data_shape",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"network",
".",
"startswith",
"(",
"'legacy'",
")",
":",
"logging",
".",
"warn",
"(",
"'Using legacy model.'",
")",
"return",
"symbol_builder",
".",
"import_module",
"(",
"network",
")",
".",
"get_symbol_train",
"(",
"*",
"*",
"kwargs",
")",
"config",
"=",
"get_config",
"(",
"network",
",",
"data_shape",
",",
"*",
"*",
"kwargs",
")",
".",
"copy",
"(",
")",
"config",
".",
"update",
"(",
"kwargs",
")",
"return",
"symbol_builder",
".",
"get_symbol_train",
"(",
"*",
"*",
"config",
")"
] |
Wrapper for get symbol for train
Parameters
----------
network : str
name for the base network symbol
data_shape : int
input shape
kwargs : dict
see symbol_builder.get_symbol_train for more details
|
[
"Wrapper",
"for",
"get",
"symbol",
"for",
"train"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/ssd/symbol/symbol_factory.py#L103-L120
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter._set_trainer
|
def _set_trainer(self, trainer):
""" Set the trainer this parameter is associated with. """
# trainer cannot be replaced for sparse params
if self._stype != 'default' and self._trainer and trainer and self._trainer is not trainer:
raise RuntimeError(
"Failed to set the trainer for Parameter '%s' because it was already set. " \
"More than one trainers for a %s Parameter is not supported." \
%(self.name, self._stype))
self._trainer = trainer
|
python
|
def _set_trainer(self, trainer):
""" Set the trainer this parameter is associated with. """
# trainer cannot be replaced for sparse params
if self._stype != 'default' and self._trainer and trainer and self._trainer is not trainer:
raise RuntimeError(
"Failed to set the trainer for Parameter '%s' because it was already set. " \
"More than one trainers for a %s Parameter is not supported." \
%(self.name, self._stype))
self._trainer = trainer
|
[
"def",
"_set_trainer",
"(",
"self",
",",
"trainer",
")",
":",
"# trainer cannot be replaced for sparse params",
"if",
"self",
".",
"_stype",
"!=",
"'default'",
"and",
"self",
".",
"_trainer",
"and",
"trainer",
"and",
"self",
".",
"_trainer",
"is",
"not",
"trainer",
":",
"raise",
"RuntimeError",
"(",
"\"Failed to set the trainer for Parameter '%s' because it was already set. \"",
"\"More than one trainers for a %s Parameter is not supported.\"",
"%",
"(",
"self",
".",
"name",
",",
"self",
".",
"_stype",
")",
")",
"self",
".",
"_trainer",
"=",
"trainer"
] |
Set the trainer this parameter is associated with.
|
[
"Set",
"the",
"trainer",
"this",
"parameter",
"is",
"associated",
"with",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L174-L182
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter._get_row_sparse
|
def _get_row_sparse(self, arr_list, ctx, row_id):
""" Get row_sparse data from row_sparse parameters based on row_id. """
# get row sparse params based on row ids
if not isinstance(row_id, ndarray.NDArray):
raise TypeError("row_id must have NDArray type, but %s is given"%(type(row_id)))
if not self._trainer:
raise RuntimeError("Cannot get row_sparse data for Parameter '%s' when no " \
"Trainer is created with it."%self.name)
results = self._check_and_get(arr_list, ctx)
# fetch row sparse params from the trainer
self._trainer._row_sparse_pull(self, results, row_id)
return results
|
python
|
def _get_row_sparse(self, arr_list, ctx, row_id):
""" Get row_sparse data from row_sparse parameters based on row_id. """
# get row sparse params based on row ids
if not isinstance(row_id, ndarray.NDArray):
raise TypeError("row_id must have NDArray type, but %s is given"%(type(row_id)))
if not self._trainer:
raise RuntimeError("Cannot get row_sparse data for Parameter '%s' when no " \
"Trainer is created with it."%self.name)
results = self._check_and_get(arr_list, ctx)
# fetch row sparse params from the trainer
self._trainer._row_sparse_pull(self, results, row_id)
return results
|
[
"def",
"_get_row_sparse",
"(",
"self",
",",
"arr_list",
",",
"ctx",
",",
"row_id",
")",
":",
"# get row sparse params based on row ids",
"if",
"not",
"isinstance",
"(",
"row_id",
",",
"ndarray",
".",
"NDArray",
")",
":",
"raise",
"TypeError",
"(",
"\"row_id must have NDArray type, but %s is given\"",
"%",
"(",
"type",
"(",
"row_id",
")",
")",
")",
"if",
"not",
"self",
".",
"_trainer",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot get row_sparse data for Parameter '%s' when no \"",
"\"Trainer is created with it.\"",
"%",
"self",
".",
"name",
")",
"results",
"=",
"self",
".",
"_check_and_get",
"(",
"arr_list",
",",
"ctx",
")",
"# fetch row sparse params from the trainer",
"self",
".",
"_trainer",
".",
"_row_sparse_pull",
"(",
"self",
",",
"results",
",",
"row_id",
")",
"return",
"results"
] |
Get row_sparse data from row_sparse parameters based on row_id.
|
[
"Get",
"row_sparse",
"data",
"from",
"row_sparse",
"parameters",
"based",
"on",
"row_id",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L216-L228
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter._load_init
|
def _load_init(self, data, ctx):
"""(Re)initializes by loading from data."""
if self.shape:
for self_dim, data_dim in zip(self.shape, data.shape):
assert self_dim in (0, data_dim), \
"Failed loading Parameter '%s' from saved params: " \
"shape incompatible expected %s vs saved %s"%(
self.name, str(self.shape), str(data.shape))
self.shape = tuple(i if i != 0 else j for i, j in zip(self.shape, data.shape))
if self.dtype:
assert np.dtype(self.dtype).type == data.dtype, \
"Failed loading Parameter '%s' from saved params: " \
"dtype incompatible expected %s vs saved %s"%(
self.name, str(self.dtype), str(data.dtype))
if self._stype != data.stype:
data = data.tostype(self._stype)
if isinstance(ctx, Context):
ctx = [ctx]
if self._data is None:
if self._deferred_init:
assert ctx is None or set(ctx) == set(self._deferred_init[1]), \
"Failed to load Parameter '%s' on %s because it was " \
"previous initialized on %s."%(
self.name, str(ctx), str(self.list_ctx()))
ctx = self._deferred_init[1]
elif ctx is None:
ctx = [cpu()]
self._init_impl(data, ctx)
else:
assert ctx is None or set(ctx) == set(self.list_ctx()), \
"Failed to load Parameter '%s' on %s because it was " \
"previous initialized on %s."%(
self.name, str(ctx), str(self.list_ctx()))
self.set_data(data)
self._deferred_init = ()
|
python
|
def _load_init(self, data, ctx):
"""(Re)initializes by loading from data."""
if self.shape:
for self_dim, data_dim in zip(self.shape, data.shape):
assert self_dim in (0, data_dim), \
"Failed loading Parameter '%s' from saved params: " \
"shape incompatible expected %s vs saved %s"%(
self.name, str(self.shape), str(data.shape))
self.shape = tuple(i if i != 0 else j for i, j in zip(self.shape, data.shape))
if self.dtype:
assert np.dtype(self.dtype).type == data.dtype, \
"Failed loading Parameter '%s' from saved params: " \
"dtype incompatible expected %s vs saved %s"%(
self.name, str(self.dtype), str(data.dtype))
if self._stype != data.stype:
data = data.tostype(self._stype)
if isinstance(ctx, Context):
ctx = [ctx]
if self._data is None:
if self._deferred_init:
assert ctx is None or set(ctx) == set(self._deferred_init[1]), \
"Failed to load Parameter '%s' on %s because it was " \
"previous initialized on %s."%(
self.name, str(ctx), str(self.list_ctx()))
ctx = self._deferred_init[1]
elif ctx is None:
ctx = [cpu()]
self._init_impl(data, ctx)
else:
assert ctx is None or set(ctx) == set(self.list_ctx()), \
"Failed to load Parameter '%s' on %s because it was " \
"previous initialized on %s."%(
self.name, str(ctx), str(self.list_ctx()))
self.set_data(data)
self._deferred_init = ()
|
[
"def",
"_load_init",
"(",
"self",
",",
"data",
",",
"ctx",
")",
":",
"if",
"self",
".",
"shape",
":",
"for",
"self_dim",
",",
"data_dim",
"in",
"zip",
"(",
"self",
".",
"shape",
",",
"data",
".",
"shape",
")",
":",
"assert",
"self_dim",
"in",
"(",
"0",
",",
"data_dim",
")",
",",
"\"Failed loading Parameter '%s' from saved params: \"",
"\"shape incompatible expected %s vs saved %s\"",
"%",
"(",
"self",
".",
"name",
",",
"str",
"(",
"self",
".",
"shape",
")",
",",
"str",
"(",
"data",
".",
"shape",
")",
")",
"self",
".",
"shape",
"=",
"tuple",
"(",
"i",
"if",
"i",
"!=",
"0",
"else",
"j",
"for",
"i",
",",
"j",
"in",
"zip",
"(",
"self",
".",
"shape",
",",
"data",
".",
"shape",
")",
")",
"if",
"self",
".",
"dtype",
":",
"assert",
"np",
".",
"dtype",
"(",
"self",
".",
"dtype",
")",
".",
"type",
"==",
"data",
".",
"dtype",
",",
"\"Failed loading Parameter '%s' from saved params: \"",
"\"dtype incompatible expected %s vs saved %s\"",
"%",
"(",
"self",
".",
"name",
",",
"str",
"(",
"self",
".",
"dtype",
")",
",",
"str",
"(",
"data",
".",
"dtype",
")",
")",
"if",
"self",
".",
"_stype",
"!=",
"data",
".",
"stype",
":",
"data",
"=",
"data",
".",
"tostype",
"(",
"self",
".",
"_stype",
")",
"if",
"isinstance",
"(",
"ctx",
",",
"Context",
")",
":",
"ctx",
"=",
"[",
"ctx",
"]",
"if",
"self",
".",
"_data",
"is",
"None",
":",
"if",
"self",
".",
"_deferred_init",
":",
"assert",
"ctx",
"is",
"None",
"or",
"set",
"(",
"ctx",
")",
"==",
"set",
"(",
"self",
".",
"_deferred_init",
"[",
"1",
"]",
")",
",",
"\"Failed to load Parameter '%s' on %s because it was \"",
"\"previous initialized on %s.\"",
"%",
"(",
"self",
".",
"name",
",",
"str",
"(",
"ctx",
")",
",",
"str",
"(",
"self",
".",
"list_ctx",
"(",
")",
")",
")",
"ctx",
"=",
"self",
".",
"_deferred_init",
"[",
"1",
"]",
"elif",
"ctx",
"is",
"None",
":",
"ctx",
"=",
"[",
"cpu",
"(",
")",
"]",
"self",
".",
"_init_impl",
"(",
"data",
",",
"ctx",
")",
"else",
":",
"assert",
"ctx",
"is",
"None",
"or",
"set",
"(",
"ctx",
")",
"==",
"set",
"(",
"self",
".",
"list_ctx",
"(",
")",
")",
",",
"\"Failed to load Parameter '%s' on %s because it was \"",
"\"previous initialized on %s.\"",
"%",
"(",
"self",
".",
"name",
",",
"str",
"(",
"ctx",
")",
",",
"str",
"(",
"self",
".",
"list_ctx",
"(",
")",
")",
")",
"self",
".",
"set_data",
"(",
"data",
")",
"self",
".",
"_deferred_init",
"=",
"(",
")"
] |
(Re)initializes by loading from data.
|
[
"(",
"Re",
")",
"initializes",
"by",
"loading",
"from",
"data",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L230-L264
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter._finish_deferred_init
|
def _finish_deferred_init(self):
"""Finishes deferred initialization."""
if not self._deferred_init:
return
init, ctx, default_init, data = self._deferred_init
self._deferred_init = ()
assert self.shape is not None and np.prod(self.shape) > 0, \
"Cannot initialize Parameter '%s' because it has " \
"invalid shape: %s. Please specify in_units, " \
"in_channels, etc for `Block`s."%(
self.name, str(self.shape))
with autograd.pause():
if data is None:
data = ndarray.zeros(shape=self.shape, dtype=self.dtype,
ctx=context.cpu(), stype=self._stype)
initializer.create(default_init)(
initializer.InitDesc(self.name, {'__init__': init}), data)
self._init_impl(data, ctx)
|
python
|
def _finish_deferred_init(self):
"""Finishes deferred initialization."""
if not self._deferred_init:
return
init, ctx, default_init, data = self._deferred_init
self._deferred_init = ()
assert self.shape is not None and np.prod(self.shape) > 0, \
"Cannot initialize Parameter '%s' because it has " \
"invalid shape: %s. Please specify in_units, " \
"in_channels, etc for `Block`s."%(
self.name, str(self.shape))
with autograd.pause():
if data is None:
data = ndarray.zeros(shape=self.shape, dtype=self.dtype,
ctx=context.cpu(), stype=self._stype)
initializer.create(default_init)(
initializer.InitDesc(self.name, {'__init__': init}), data)
self._init_impl(data, ctx)
|
[
"def",
"_finish_deferred_init",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"_deferred_init",
":",
"return",
"init",
",",
"ctx",
",",
"default_init",
",",
"data",
"=",
"self",
".",
"_deferred_init",
"self",
".",
"_deferred_init",
"=",
"(",
")",
"assert",
"self",
".",
"shape",
"is",
"not",
"None",
"and",
"np",
".",
"prod",
"(",
"self",
".",
"shape",
")",
">",
"0",
",",
"\"Cannot initialize Parameter '%s' because it has \"",
"\"invalid shape: %s. Please specify in_units, \"",
"\"in_channels, etc for `Block`s.\"",
"%",
"(",
"self",
".",
"name",
",",
"str",
"(",
"self",
".",
"shape",
")",
")",
"with",
"autograd",
".",
"pause",
"(",
")",
":",
"if",
"data",
"is",
"None",
":",
"data",
"=",
"ndarray",
".",
"zeros",
"(",
"shape",
"=",
"self",
".",
"shape",
",",
"dtype",
"=",
"self",
".",
"dtype",
",",
"ctx",
"=",
"context",
".",
"cpu",
"(",
")",
",",
"stype",
"=",
"self",
".",
"_stype",
")",
"initializer",
".",
"create",
"(",
"default_init",
")",
"(",
"initializer",
".",
"InitDesc",
"(",
"self",
".",
"name",
",",
"{",
"'__init__'",
":",
"init",
"}",
")",
",",
"data",
")",
"self",
".",
"_init_impl",
"(",
"data",
",",
"ctx",
")"
] |
Finishes deferred initialization.
|
[
"Finishes",
"deferred",
"initialization",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L266-L285
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter._init_impl
|
def _init_impl(self, data, ctx_list):
"""Sets data and grad."""
self._ctx_list = list(ctx_list)
self._ctx_map = [[], []]
for i, ctx in enumerate(self._ctx_list):
dev_list = self._ctx_map[ctx.device_typeid&1]
while len(dev_list) <= ctx.device_id:
dev_list.append(None)
dev_list[ctx.device_id] = i
self._data = [data.copyto(ctx) for ctx in self._ctx_list]
self._init_grad()
|
python
|
def _init_impl(self, data, ctx_list):
"""Sets data and grad."""
self._ctx_list = list(ctx_list)
self._ctx_map = [[], []]
for i, ctx in enumerate(self._ctx_list):
dev_list = self._ctx_map[ctx.device_typeid&1]
while len(dev_list) <= ctx.device_id:
dev_list.append(None)
dev_list[ctx.device_id] = i
self._data = [data.copyto(ctx) for ctx in self._ctx_list]
self._init_grad()
|
[
"def",
"_init_impl",
"(",
"self",
",",
"data",
",",
"ctx_list",
")",
":",
"self",
".",
"_ctx_list",
"=",
"list",
"(",
"ctx_list",
")",
"self",
".",
"_ctx_map",
"=",
"[",
"[",
"]",
",",
"[",
"]",
"]",
"for",
"i",
",",
"ctx",
"in",
"enumerate",
"(",
"self",
".",
"_ctx_list",
")",
":",
"dev_list",
"=",
"self",
".",
"_ctx_map",
"[",
"ctx",
".",
"device_typeid",
"&",
"1",
"]",
"while",
"len",
"(",
"dev_list",
")",
"<=",
"ctx",
".",
"device_id",
":",
"dev_list",
".",
"append",
"(",
"None",
")",
"dev_list",
"[",
"ctx",
".",
"device_id",
"]",
"=",
"i",
"self",
".",
"_data",
"=",
"[",
"data",
".",
"copyto",
"(",
"ctx",
")",
"for",
"ctx",
"in",
"self",
".",
"_ctx_list",
"]",
"self",
".",
"_init_grad",
"(",
")"
] |
Sets data and grad.
|
[
"Sets",
"data",
"and",
"grad",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L287-L298
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter._init_grad
|
def _init_grad(self):
"""Initialize grad buffers."""
if self.grad_req == 'null':
self._grad = None
return
self._grad = [ndarray.zeros(shape=i.shape, dtype=i.dtype, ctx=i.context,
stype=self._grad_stype) for i in self._data]
autograd.mark_variables(self._check_and_get(self._data, list),
self._grad, self.grad_req)
|
python
|
def _init_grad(self):
"""Initialize grad buffers."""
if self.grad_req == 'null':
self._grad = None
return
self._grad = [ndarray.zeros(shape=i.shape, dtype=i.dtype, ctx=i.context,
stype=self._grad_stype) for i in self._data]
autograd.mark_variables(self._check_and_get(self._data, list),
self._grad, self.grad_req)
|
[
"def",
"_init_grad",
"(",
"self",
")",
":",
"if",
"self",
".",
"grad_req",
"==",
"'null'",
":",
"self",
".",
"_grad",
"=",
"None",
"return",
"self",
".",
"_grad",
"=",
"[",
"ndarray",
".",
"zeros",
"(",
"shape",
"=",
"i",
".",
"shape",
",",
"dtype",
"=",
"i",
".",
"dtype",
",",
"ctx",
"=",
"i",
".",
"context",
",",
"stype",
"=",
"self",
".",
"_grad_stype",
")",
"for",
"i",
"in",
"self",
".",
"_data",
"]",
"autograd",
".",
"mark_variables",
"(",
"self",
".",
"_check_and_get",
"(",
"self",
".",
"_data",
",",
"list",
")",
",",
"self",
".",
"_grad",
",",
"self",
".",
"grad_req",
")"
] |
Initialize grad buffers.
|
[
"Initialize",
"grad",
"buffers",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L300-L310
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter._reduce
|
def _reduce(self):
"""Reduce data from multiple context to cpu."""
ctx = context.cpu()
if self._stype == 'default':
block = self.list_data()
data = ndarray.add_n(*(w.copyto(ctx) for w in block)) / len(block)
else:
# fetch all rows for 'row_sparse' param
all_row_ids = ndarray.arange(0, self.shape[0], dtype='int64', ctx=ctx)
data = ndarray.zeros(self.shape, stype='row_sparse', ctx=ctx)
self._trainer._row_sparse_pull(self, data, all_row_ids, full_idx=True)
return data
|
python
|
def _reduce(self):
"""Reduce data from multiple context to cpu."""
ctx = context.cpu()
if self._stype == 'default':
block = self.list_data()
data = ndarray.add_n(*(w.copyto(ctx) for w in block)) / len(block)
else:
# fetch all rows for 'row_sparse' param
all_row_ids = ndarray.arange(0, self.shape[0], dtype='int64', ctx=ctx)
data = ndarray.zeros(self.shape, stype='row_sparse', ctx=ctx)
self._trainer._row_sparse_pull(self, data, all_row_ids, full_idx=True)
return data
|
[
"def",
"_reduce",
"(",
"self",
")",
":",
"ctx",
"=",
"context",
".",
"cpu",
"(",
")",
"if",
"self",
".",
"_stype",
"==",
"'default'",
":",
"block",
"=",
"self",
".",
"list_data",
"(",
")",
"data",
"=",
"ndarray",
".",
"add_n",
"(",
"*",
"(",
"w",
".",
"copyto",
"(",
"ctx",
")",
"for",
"w",
"in",
"block",
")",
")",
"/",
"len",
"(",
"block",
")",
"else",
":",
"# fetch all rows for 'row_sparse' param",
"all_row_ids",
"=",
"ndarray",
".",
"arange",
"(",
"0",
",",
"self",
".",
"shape",
"[",
"0",
"]",
",",
"dtype",
"=",
"'int64'",
",",
"ctx",
"=",
"ctx",
")",
"data",
"=",
"ndarray",
".",
"zeros",
"(",
"self",
".",
"shape",
",",
"stype",
"=",
"'row_sparse'",
",",
"ctx",
"=",
"ctx",
")",
"self",
".",
"_trainer",
".",
"_row_sparse_pull",
"(",
"self",
",",
"data",
",",
"all_row_ids",
",",
"full_idx",
"=",
"True",
")",
"return",
"data"
] |
Reduce data from multiple context to cpu.
|
[
"Reduce",
"data",
"from",
"multiple",
"context",
"to",
"cpu",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L312-L323
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.initialize
|
def initialize(self, init=None, ctx=None, default_init=initializer.Uniform(),
force_reinit=False):
"""Initializes parameter and gradient arrays. Only used for :py:class:`NDArray` API.
Parameters
----------
init : Initializer
The initializer to use. Overrides :py:meth:`Parameter.init` and default_init.
ctx : Context or list of Context, defaults to :py:meth:`context.current_context()`.
Initialize Parameter on given context. If ctx is a list of Context, a
copy will be made for each context.
.. note::
Copies are independent arrays. User is responsible for keeping
their values consistent when updating.
Normally :py:class:`gluon.Trainer` does this for you.
default_init : Initializer
Default initializer is used when both :py:func:`init`
and :py:meth:`Parameter.init` are ``None``.
force_reinit : bool, default False
Whether to force re-initialization if parameter is already initialized.
Examples
--------
>>> weight = mx.gluon.Parameter('weight', shape=(2, 2))
>>> weight.initialize(ctx=mx.cpu(0))
>>> weight.data()
[[-0.01068833 0.01729892]
[ 0.02042518 -0.01618656]]
<NDArray 2x2 @cpu(0)>
>>> weight.grad()
[[ 0. 0.]
[ 0. 0.]]
<NDArray 2x2 @cpu(0)>
>>> weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
>>> weight.data(mx.gpu(0))
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>
>>> weight.data(mx.gpu(1))
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>
"""
if self._data is not None and not force_reinit:
warnings.warn("Parameter '%s' is already initialized, ignoring. " \
"Set force_reinit=True to re-initialize."%self.name,
stacklevel=2)
return
self._data = self._grad = None
if ctx is None:
ctx = [context.current_context()]
if isinstance(ctx, Context):
ctx = [ctx]
if init is None:
init = default_init if self.init is None else self.init
if not self.shape or np.prod(self.shape) <= 0:
if self._allow_deferred_init:
self._deferred_init = (init, ctx, default_init, None)
return
raise ValueError("Cannot initialize Parameter '%s' because it has " \
"invalid shape: %s."%(self.name, str(self.shape)))
self._deferred_init = (init, ctx, default_init, None)
self._finish_deferred_init()
|
python
|
def initialize(self, init=None, ctx=None, default_init=initializer.Uniform(),
force_reinit=False):
"""Initializes parameter and gradient arrays. Only used for :py:class:`NDArray` API.
Parameters
----------
init : Initializer
The initializer to use. Overrides :py:meth:`Parameter.init` and default_init.
ctx : Context or list of Context, defaults to :py:meth:`context.current_context()`.
Initialize Parameter on given context. If ctx is a list of Context, a
copy will be made for each context.
.. note::
Copies are independent arrays. User is responsible for keeping
their values consistent when updating.
Normally :py:class:`gluon.Trainer` does this for you.
default_init : Initializer
Default initializer is used when both :py:func:`init`
and :py:meth:`Parameter.init` are ``None``.
force_reinit : bool, default False
Whether to force re-initialization if parameter is already initialized.
Examples
--------
>>> weight = mx.gluon.Parameter('weight', shape=(2, 2))
>>> weight.initialize(ctx=mx.cpu(0))
>>> weight.data()
[[-0.01068833 0.01729892]
[ 0.02042518 -0.01618656]]
<NDArray 2x2 @cpu(0)>
>>> weight.grad()
[[ 0. 0.]
[ 0. 0.]]
<NDArray 2x2 @cpu(0)>
>>> weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
>>> weight.data(mx.gpu(0))
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>
>>> weight.data(mx.gpu(1))
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>
"""
if self._data is not None and not force_reinit:
warnings.warn("Parameter '%s' is already initialized, ignoring. " \
"Set force_reinit=True to re-initialize."%self.name,
stacklevel=2)
return
self._data = self._grad = None
if ctx is None:
ctx = [context.current_context()]
if isinstance(ctx, Context):
ctx = [ctx]
if init is None:
init = default_init if self.init is None else self.init
if not self.shape or np.prod(self.shape) <= 0:
if self._allow_deferred_init:
self._deferred_init = (init, ctx, default_init, None)
return
raise ValueError("Cannot initialize Parameter '%s' because it has " \
"invalid shape: %s."%(self.name, str(self.shape)))
self._deferred_init = (init, ctx, default_init, None)
self._finish_deferred_init()
|
[
"def",
"initialize",
"(",
"self",
",",
"init",
"=",
"None",
",",
"ctx",
"=",
"None",
",",
"default_init",
"=",
"initializer",
".",
"Uniform",
"(",
")",
",",
"force_reinit",
"=",
"False",
")",
":",
"if",
"self",
".",
"_data",
"is",
"not",
"None",
"and",
"not",
"force_reinit",
":",
"warnings",
".",
"warn",
"(",
"\"Parameter '%s' is already initialized, ignoring. \"",
"\"Set force_reinit=True to re-initialize.\"",
"%",
"self",
".",
"name",
",",
"stacklevel",
"=",
"2",
")",
"return",
"self",
".",
"_data",
"=",
"self",
".",
"_grad",
"=",
"None",
"if",
"ctx",
"is",
"None",
":",
"ctx",
"=",
"[",
"context",
".",
"current_context",
"(",
")",
"]",
"if",
"isinstance",
"(",
"ctx",
",",
"Context",
")",
":",
"ctx",
"=",
"[",
"ctx",
"]",
"if",
"init",
"is",
"None",
":",
"init",
"=",
"default_init",
"if",
"self",
".",
"init",
"is",
"None",
"else",
"self",
".",
"init",
"if",
"not",
"self",
".",
"shape",
"or",
"np",
".",
"prod",
"(",
"self",
".",
"shape",
")",
"<=",
"0",
":",
"if",
"self",
".",
"_allow_deferred_init",
":",
"self",
".",
"_deferred_init",
"=",
"(",
"init",
",",
"ctx",
",",
"default_init",
",",
"None",
")",
"return",
"raise",
"ValueError",
"(",
"\"Cannot initialize Parameter '%s' because it has \"",
"\"invalid shape: %s.\"",
"%",
"(",
"self",
".",
"name",
",",
"str",
"(",
"self",
".",
"shape",
")",
")",
")",
"self",
".",
"_deferred_init",
"=",
"(",
"init",
",",
"ctx",
",",
"default_init",
",",
"None",
")",
"self",
".",
"_finish_deferred_init",
"(",
")"
] |
Initializes parameter and gradient arrays. Only used for :py:class:`NDArray` API.
Parameters
----------
init : Initializer
The initializer to use. Overrides :py:meth:`Parameter.init` and default_init.
ctx : Context or list of Context, defaults to :py:meth:`context.current_context()`.
Initialize Parameter on given context. If ctx is a list of Context, a
copy will be made for each context.
.. note::
Copies are independent arrays. User is responsible for keeping
their values consistent when updating.
Normally :py:class:`gluon.Trainer` does this for you.
default_init : Initializer
Default initializer is used when both :py:func:`init`
and :py:meth:`Parameter.init` are ``None``.
force_reinit : bool, default False
Whether to force re-initialization if parameter is already initialized.
Examples
--------
>>> weight = mx.gluon.Parameter('weight', shape=(2, 2))
>>> weight.initialize(ctx=mx.cpu(0))
>>> weight.data()
[[-0.01068833 0.01729892]
[ 0.02042518 -0.01618656]]
<NDArray 2x2 @cpu(0)>
>>> weight.grad()
[[ 0. 0.]
[ 0. 0.]]
<NDArray 2x2 @cpu(0)>
>>> weight.initialize(ctx=[mx.gpu(0), mx.gpu(1)])
>>> weight.data(mx.gpu(0))
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(0)>
>>> weight.data(mx.gpu(1))
[[-0.00873779 -0.02834515]
[ 0.05484822 -0.06206018]]
<NDArray 2x2 @gpu(1)>
|
[
"Initializes",
"parameter",
"and",
"gradient",
"arrays",
".",
"Only",
"used",
"for",
":",
"py",
":",
"class",
":",
"NDArray",
"API",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L325-L391
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.reset_ctx
|
def reset_ctx(self, ctx):
"""Re-assign Parameter to other contexts.
Parameters
----------
ctx : Context or list of Context, default ``context.current_context()``.
Assign Parameter to given context. If ctx is a list of Context, a
copy will be made for each context.
"""
if ctx is None:
ctx = [context.current_context()]
if isinstance(ctx, Context):
ctx = [ctx]
if self._data:
data = self._reduce()
with autograd.pause():
self._init_impl(data, ctx)
elif self._deferred_init:
init, _, default_init, data = self._deferred_init
self._deferred_init = (init, ctx, default_init, data)
else:
raise ValueError("Cannot reset context for Parameter '%s' because it "
"has not been initialized."%self.name)
|
python
|
def reset_ctx(self, ctx):
"""Re-assign Parameter to other contexts.
Parameters
----------
ctx : Context or list of Context, default ``context.current_context()``.
Assign Parameter to given context. If ctx is a list of Context, a
copy will be made for each context.
"""
if ctx is None:
ctx = [context.current_context()]
if isinstance(ctx, Context):
ctx = [ctx]
if self._data:
data = self._reduce()
with autograd.pause():
self._init_impl(data, ctx)
elif self._deferred_init:
init, _, default_init, data = self._deferred_init
self._deferred_init = (init, ctx, default_init, data)
else:
raise ValueError("Cannot reset context for Parameter '%s' because it "
"has not been initialized."%self.name)
|
[
"def",
"reset_ctx",
"(",
"self",
",",
"ctx",
")",
":",
"if",
"ctx",
"is",
"None",
":",
"ctx",
"=",
"[",
"context",
".",
"current_context",
"(",
")",
"]",
"if",
"isinstance",
"(",
"ctx",
",",
"Context",
")",
":",
"ctx",
"=",
"[",
"ctx",
"]",
"if",
"self",
".",
"_data",
":",
"data",
"=",
"self",
".",
"_reduce",
"(",
")",
"with",
"autograd",
".",
"pause",
"(",
")",
":",
"self",
".",
"_init_impl",
"(",
"data",
",",
"ctx",
")",
"elif",
"self",
".",
"_deferred_init",
":",
"init",
",",
"_",
",",
"default_init",
",",
"data",
"=",
"self",
".",
"_deferred_init",
"self",
".",
"_deferred_init",
"=",
"(",
"init",
",",
"ctx",
",",
"default_init",
",",
"data",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Cannot reset context for Parameter '%s' because it \"",
"\"has not been initialized.\"",
"%",
"self",
".",
"name",
")"
] |
Re-assign Parameter to other contexts.
Parameters
----------
ctx : Context or list of Context, default ``context.current_context()``.
Assign Parameter to given context. If ctx is a list of Context, a
copy will be made for each context.
|
[
"Re",
"-",
"assign",
"Parameter",
"to",
"other",
"contexts",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L393-L415
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.set_data
|
def set_data(self, data):
"""Sets this parameter's value on all contexts."""
self.shape = data.shape
if self._data is None:
assert self._deferred_init, \
"Parameter '%s' has not been initialized"%self.name
self._deferred_init = self._deferred_init[:3] + (data,)
return
# if update_on_kvstore, we need to make sure the copy stored in kvstore is in sync
if self._trainer and self._trainer._kv_initialized and self._trainer._update_on_kvstore:
if self not in self._trainer._params_to_init:
self._trainer._reset_kvstore()
for arr in self._check_and_get(self._data, list):
arr[:] = data
|
python
|
def set_data(self, data):
"""Sets this parameter's value on all contexts."""
self.shape = data.shape
if self._data is None:
assert self._deferred_init, \
"Parameter '%s' has not been initialized"%self.name
self._deferred_init = self._deferred_init[:3] + (data,)
return
# if update_on_kvstore, we need to make sure the copy stored in kvstore is in sync
if self._trainer and self._trainer._kv_initialized and self._trainer._update_on_kvstore:
if self not in self._trainer._params_to_init:
self._trainer._reset_kvstore()
for arr in self._check_and_get(self._data, list):
arr[:] = data
|
[
"def",
"set_data",
"(",
"self",
",",
"data",
")",
":",
"self",
".",
"shape",
"=",
"data",
".",
"shape",
"if",
"self",
".",
"_data",
"is",
"None",
":",
"assert",
"self",
".",
"_deferred_init",
",",
"\"Parameter '%s' has not been initialized\"",
"%",
"self",
".",
"name",
"self",
".",
"_deferred_init",
"=",
"self",
".",
"_deferred_init",
"[",
":",
"3",
"]",
"+",
"(",
"data",
",",
")",
"return",
"# if update_on_kvstore, we need to make sure the copy stored in kvstore is in sync",
"if",
"self",
".",
"_trainer",
"and",
"self",
".",
"_trainer",
".",
"_kv_initialized",
"and",
"self",
".",
"_trainer",
".",
"_update_on_kvstore",
":",
"if",
"self",
"not",
"in",
"self",
".",
"_trainer",
".",
"_params_to_init",
":",
"self",
".",
"_trainer",
".",
"_reset_kvstore",
"(",
")",
"for",
"arr",
"in",
"self",
".",
"_check_and_get",
"(",
"self",
".",
"_data",
",",
"list",
")",
":",
"arr",
"[",
":",
"]",
"=",
"data"
] |
Sets this parameter's value on all contexts.
|
[
"Sets",
"this",
"parameter",
"s",
"value",
"on",
"all",
"contexts",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L418-L434
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.row_sparse_data
|
def row_sparse_data(self, row_id):
"""Returns a copy of the 'row_sparse' parameter on the same context as row_id's.
The copy only retains rows whose ids occur in provided row ids.
The parameter must have been initialized on this context before.
Parameters
----------
row_id: NDArray
Row ids to retain for the 'row_sparse' parameter.
Returns
-------
NDArray on row_id's context
"""
if self._stype != 'row_sparse':
raise RuntimeError("Cannot return a copy of Parameter %s via row_sparse_data() " \
"because its storage type is %s. Please use data() instead." \
%(self.name, self._stype))
return self._get_row_sparse(self._data, row_id.context, row_id)
|
python
|
def row_sparse_data(self, row_id):
"""Returns a copy of the 'row_sparse' parameter on the same context as row_id's.
The copy only retains rows whose ids occur in provided row ids.
The parameter must have been initialized on this context before.
Parameters
----------
row_id: NDArray
Row ids to retain for the 'row_sparse' parameter.
Returns
-------
NDArray on row_id's context
"""
if self._stype != 'row_sparse':
raise RuntimeError("Cannot return a copy of Parameter %s via row_sparse_data() " \
"because its storage type is %s. Please use data() instead." \
%(self.name, self._stype))
return self._get_row_sparse(self._data, row_id.context, row_id)
|
[
"def",
"row_sparse_data",
"(",
"self",
",",
"row_id",
")",
":",
"if",
"self",
".",
"_stype",
"!=",
"'row_sparse'",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot return a copy of Parameter %s via row_sparse_data() \"",
"\"because its storage type is %s. Please use data() instead.\"",
"%",
"(",
"self",
".",
"name",
",",
"self",
".",
"_stype",
")",
")",
"return",
"self",
".",
"_get_row_sparse",
"(",
"self",
".",
"_data",
",",
"row_id",
".",
"context",
",",
"row_id",
")"
] |
Returns a copy of the 'row_sparse' parameter on the same context as row_id's.
The copy only retains rows whose ids occur in provided row ids.
The parameter must have been initialized on this context before.
Parameters
----------
row_id: NDArray
Row ids to retain for the 'row_sparse' parameter.
Returns
-------
NDArray on row_id's context
|
[
"Returns",
"a",
"copy",
"of",
"the",
"row_sparse",
"parameter",
"on",
"the",
"same",
"context",
"as",
"row_id",
"s",
".",
"The",
"copy",
"only",
"retains",
"rows",
"whose",
"ids",
"occur",
"in",
"provided",
"row",
"ids",
".",
"The",
"parameter",
"must",
"have",
"been",
"initialized",
"on",
"this",
"context",
"before",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L436-L454
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.list_row_sparse_data
|
def list_row_sparse_data(self, row_id):
"""Returns copies of the 'row_sparse' parameter on all contexts, in the same order
as creation. The copy only retains rows whose ids occur in provided row ids.
The parameter must have been initialized before.
Parameters
----------
row_id: NDArray
Row ids to retain for the 'row_sparse' parameter.
Returns
-------
list of NDArrays
"""
if self._stype != 'row_sparse':
raise RuntimeError("Cannot return copies of Parameter '%s' on all contexts via " \
"list_row_sparse_data() because its storage type is %s. Please " \
"use data() instead." % (self.name, self._stype))
return self._get_row_sparse(self._data, list, row_id)
|
python
|
def list_row_sparse_data(self, row_id):
"""Returns copies of the 'row_sparse' parameter on all contexts, in the same order
as creation. The copy only retains rows whose ids occur in provided row ids.
The parameter must have been initialized before.
Parameters
----------
row_id: NDArray
Row ids to retain for the 'row_sparse' parameter.
Returns
-------
list of NDArrays
"""
if self._stype != 'row_sparse':
raise RuntimeError("Cannot return copies of Parameter '%s' on all contexts via " \
"list_row_sparse_data() because its storage type is %s. Please " \
"use data() instead." % (self.name, self._stype))
return self._get_row_sparse(self._data, list, row_id)
|
[
"def",
"list_row_sparse_data",
"(",
"self",
",",
"row_id",
")",
":",
"if",
"self",
".",
"_stype",
"!=",
"'row_sparse'",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot return copies of Parameter '%s' on all contexts via \"",
"\"list_row_sparse_data() because its storage type is %s. Please \"",
"\"use data() instead.\"",
"%",
"(",
"self",
".",
"name",
",",
"self",
".",
"_stype",
")",
")",
"return",
"self",
".",
"_get_row_sparse",
"(",
"self",
".",
"_data",
",",
"list",
",",
"row_id",
")"
] |
Returns copies of the 'row_sparse' parameter on all contexts, in the same order
as creation. The copy only retains rows whose ids occur in provided row ids.
The parameter must have been initialized before.
Parameters
----------
row_id: NDArray
Row ids to retain for the 'row_sparse' parameter.
Returns
-------
list of NDArrays
|
[
"Returns",
"copies",
"of",
"the",
"row_sparse",
"parameter",
"on",
"all",
"contexts",
"in",
"the",
"same",
"order",
"as",
"creation",
".",
"The",
"copy",
"only",
"retains",
"rows",
"whose",
"ids",
"occur",
"in",
"provided",
"row",
"ids",
".",
"The",
"parameter",
"must",
"have",
"been",
"initialized",
"before",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L456-L474
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.data
|
def data(self, ctx=None):
"""Returns a copy of this parameter on one context. Must have been
initialized on this context before. For sparse parameters, use
:py:meth:`Parameter.row_sparse_data` instead.
Parameters
----------
ctx : Context
Desired context.
Returns
-------
NDArray on ctx
"""
if self._stype != 'default':
raise RuntimeError("Cannot return a copy of Parameter '%s' on ctx %s via data() " \
"because its storage type is %s. Please use row_sparse_data() " \
"instead." % (self.name, str(ctx), self._stype))
return self._check_and_get(self._data, ctx)
|
python
|
def data(self, ctx=None):
"""Returns a copy of this parameter on one context. Must have been
initialized on this context before. For sparse parameters, use
:py:meth:`Parameter.row_sparse_data` instead.
Parameters
----------
ctx : Context
Desired context.
Returns
-------
NDArray on ctx
"""
if self._stype != 'default':
raise RuntimeError("Cannot return a copy of Parameter '%s' on ctx %s via data() " \
"because its storage type is %s. Please use row_sparse_data() " \
"instead." % (self.name, str(ctx), self._stype))
return self._check_and_get(self._data, ctx)
|
[
"def",
"data",
"(",
"self",
",",
"ctx",
"=",
"None",
")",
":",
"if",
"self",
".",
"_stype",
"!=",
"'default'",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot return a copy of Parameter '%s' on ctx %s via data() \"",
"\"because its storage type is %s. Please use row_sparse_data() \"",
"\"instead.\"",
"%",
"(",
"self",
".",
"name",
",",
"str",
"(",
"ctx",
")",
",",
"self",
".",
"_stype",
")",
")",
"return",
"self",
".",
"_check_and_get",
"(",
"self",
".",
"_data",
",",
"ctx",
")"
] |
Returns a copy of this parameter on one context. Must have been
initialized on this context before. For sparse parameters, use
:py:meth:`Parameter.row_sparse_data` instead.
Parameters
----------
ctx : Context
Desired context.
Returns
-------
NDArray on ctx
|
[
"Returns",
"a",
"copy",
"of",
"this",
"parameter",
"on",
"one",
"context",
".",
"Must",
"have",
"been",
"initialized",
"on",
"this",
"context",
"before",
".",
"For",
"sparse",
"parameters",
"use",
":",
"py",
":",
"meth",
":",
"Parameter",
".",
"row_sparse_data",
"instead",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L476-L494
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.list_data
|
def list_data(self):
"""Returns copies of this parameter on all contexts, in the same order
as creation. For sparse parameters, use :py:meth:`Parameter.list_row_sparse_data`
instead.
Returns
-------
list of NDArrays
"""
if self._stype != 'default':
raise RuntimeError("Cannot return copies of Parameter '%s' on all contexts via " \
"list_data() because its storage type is %s. Please use " \
"row_sparse_data() instead." % (self.name, self._stype))
return self._check_and_get(self._data, list)
|
python
|
def list_data(self):
"""Returns copies of this parameter on all contexts, in the same order
as creation. For sparse parameters, use :py:meth:`Parameter.list_row_sparse_data`
instead.
Returns
-------
list of NDArrays
"""
if self._stype != 'default':
raise RuntimeError("Cannot return copies of Parameter '%s' on all contexts via " \
"list_data() because its storage type is %s. Please use " \
"row_sparse_data() instead." % (self.name, self._stype))
return self._check_and_get(self._data, list)
|
[
"def",
"list_data",
"(",
"self",
")",
":",
"if",
"self",
".",
"_stype",
"!=",
"'default'",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot return copies of Parameter '%s' on all contexts via \"",
"\"list_data() because its storage type is %s. Please use \"",
"\"row_sparse_data() instead.\"",
"%",
"(",
"self",
".",
"name",
",",
"self",
".",
"_stype",
")",
")",
"return",
"self",
".",
"_check_and_get",
"(",
"self",
".",
"_data",
",",
"list",
")"
] |
Returns copies of this parameter on all contexts, in the same order
as creation. For sparse parameters, use :py:meth:`Parameter.list_row_sparse_data`
instead.
Returns
-------
list of NDArrays
|
[
"Returns",
"copies",
"of",
"this",
"parameter",
"on",
"all",
"contexts",
"in",
"the",
"same",
"order",
"as",
"creation",
".",
"For",
"sparse",
"parameters",
"use",
":",
"py",
":",
"meth",
":",
"Parameter",
".",
"list_row_sparse_data",
"instead",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L496-L509
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.grad
|
def grad(self, ctx=None):
"""Returns a gradient buffer for this parameter on one context.
Parameters
----------
ctx : Context
Desired context.
"""
if self._data is not None and self._grad is None:
raise RuntimeError(
"Cannot get gradient array for Parameter '%s' " \
"because grad_req='null'"%(self.name))
return self._check_and_get(self._grad, ctx)
|
python
|
def grad(self, ctx=None):
"""Returns a gradient buffer for this parameter on one context.
Parameters
----------
ctx : Context
Desired context.
"""
if self._data is not None and self._grad is None:
raise RuntimeError(
"Cannot get gradient array for Parameter '%s' " \
"because grad_req='null'"%(self.name))
return self._check_and_get(self._grad, ctx)
|
[
"def",
"grad",
"(",
"self",
",",
"ctx",
"=",
"None",
")",
":",
"if",
"self",
".",
"_data",
"is",
"not",
"None",
"and",
"self",
".",
"_grad",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot get gradient array for Parameter '%s' \"",
"\"because grad_req='null'\"",
"%",
"(",
"self",
".",
"name",
")",
")",
"return",
"self",
".",
"_check_and_get",
"(",
"self",
".",
"_grad",
",",
"ctx",
")"
] |
Returns a gradient buffer for this parameter on one context.
Parameters
----------
ctx : Context
Desired context.
|
[
"Returns",
"a",
"gradient",
"buffer",
"for",
"this",
"parameter",
"on",
"one",
"context",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L511-L523
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.list_grad
|
def list_grad(self):
"""Returns gradient buffers on all contexts, in the same order
as :py:meth:`values`."""
if self._data is not None and self._grad is None:
raise RuntimeError(
"Cannot get gradient array for Parameter '%s' " \
"because grad_req='null'"%(self.name))
return self._check_and_get(self._grad, list)
|
python
|
def list_grad(self):
"""Returns gradient buffers on all contexts, in the same order
as :py:meth:`values`."""
if self._data is not None and self._grad is None:
raise RuntimeError(
"Cannot get gradient array for Parameter '%s' " \
"because grad_req='null'"%(self.name))
return self._check_and_get(self._grad, list)
|
[
"def",
"list_grad",
"(",
"self",
")",
":",
"if",
"self",
".",
"_data",
"is",
"not",
"None",
"and",
"self",
".",
"_grad",
"is",
"None",
":",
"raise",
"RuntimeError",
"(",
"\"Cannot get gradient array for Parameter '%s' \"",
"\"because grad_req='null'\"",
"%",
"(",
"self",
".",
"name",
")",
")",
"return",
"self",
".",
"_check_and_get",
"(",
"self",
".",
"_grad",
",",
"list",
")"
] |
Returns gradient buffers on all contexts, in the same order
as :py:meth:`values`.
|
[
"Returns",
"gradient",
"buffers",
"on",
"all",
"contexts",
"in",
"the",
"same",
"order",
"as",
":",
"py",
":",
"meth",
":",
"values",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L525-L532
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.list_ctx
|
def list_ctx(self):
"""Returns a list of contexts this parameter is initialized on."""
if self._data is None:
if self._deferred_init:
return self._deferred_init[1]
raise RuntimeError("Parameter '%s' has not been initialized"%self.name)
return self._ctx_list
|
python
|
def list_ctx(self):
"""Returns a list of contexts this parameter is initialized on."""
if self._data is None:
if self._deferred_init:
return self._deferred_init[1]
raise RuntimeError("Parameter '%s' has not been initialized"%self.name)
return self._ctx_list
|
[
"def",
"list_ctx",
"(",
"self",
")",
":",
"if",
"self",
".",
"_data",
"is",
"None",
":",
"if",
"self",
".",
"_deferred_init",
":",
"return",
"self",
".",
"_deferred_init",
"[",
"1",
"]",
"raise",
"RuntimeError",
"(",
"\"Parameter '%s' has not been initialized\"",
"%",
"self",
".",
"name",
")",
"return",
"self",
".",
"_ctx_list"
] |
Returns a list of contexts this parameter is initialized on.
|
[
"Returns",
"a",
"list",
"of",
"contexts",
"this",
"parameter",
"is",
"initialized",
"on",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L534-L540
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.zero_grad
|
def zero_grad(self):
"""Sets gradient buffer on all contexts to 0. No action is taken if
parameter is uninitialized or doesn't require gradient."""
if self._grad is None:
return
for i in self._grad:
ndarray.zeros_like(i, out=i)
|
python
|
def zero_grad(self):
"""Sets gradient buffer on all contexts to 0. No action is taken if
parameter is uninitialized or doesn't require gradient."""
if self._grad is None:
return
for i in self._grad:
ndarray.zeros_like(i, out=i)
|
[
"def",
"zero_grad",
"(",
"self",
")",
":",
"if",
"self",
".",
"_grad",
"is",
"None",
":",
"return",
"for",
"i",
"in",
"self",
".",
"_grad",
":",
"ndarray",
".",
"zeros_like",
"(",
"i",
",",
"out",
"=",
"i",
")"
] |
Sets gradient buffer on all contexts to 0. No action is taken if
parameter is uninitialized or doesn't require gradient.
|
[
"Sets",
"gradient",
"buffer",
"on",
"all",
"contexts",
"to",
"0",
".",
"No",
"action",
"is",
"taken",
"if",
"parameter",
"is",
"uninitialized",
"or",
"doesn",
"t",
"require",
"gradient",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L542-L548
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.var
|
def var(self):
"""Returns a symbol representing this parameter."""
if self._var is None:
self._var = symbol.var(self.name, shape=self.shape, dtype=self.dtype,
lr_mult=self.lr_mult, wd_mult=self.wd_mult,
init=self.init, stype=self._stype)
return self._var
|
python
|
def var(self):
"""Returns a symbol representing this parameter."""
if self._var is None:
self._var = symbol.var(self.name, shape=self.shape, dtype=self.dtype,
lr_mult=self.lr_mult, wd_mult=self.wd_mult,
init=self.init, stype=self._stype)
return self._var
|
[
"def",
"var",
"(",
"self",
")",
":",
"if",
"self",
".",
"_var",
"is",
"None",
":",
"self",
".",
"_var",
"=",
"symbol",
".",
"var",
"(",
"self",
".",
"name",
",",
"shape",
"=",
"self",
".",
"shape",
",",
"dtype",
"=",
"self",
".",
"dtype",
",",
"lr_mult",
"=",
"self",
".",
"lr_mult",
",",
"wd_mult",
"=",
"self",
".",
"wd_mult",
",",
"init",
"=",
"self",
".",
"init",
",",
"stype",
"=",
"self",
".",
"_stype",
")",
"return",
"self",
".",
"_var"
] |
Returns a symbol representing this parameter.
|
[
"Returns",
"a",
"symbol",
"representing",
"this",
"parameter",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L550-L556
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
Parameter.cast
|
def cast(self, dtype):
"""Cast data and gradient of this Parameter to a new data type.
Parameters
----------
dtype : str or numpy.dtype
The new data type.
"""
self.dtype = dtype
if self._data is None:
return
with autograd.pause():
self._data = [i.astype(dtype) for i in self._data]
if self._grad is None:
return
self._grad = [i.astype(dtype) for i in self._grad]
autograd.mark_variables(self._data, self._grad, self.grad_req)
|
python
|
def cast(self, dtype):
"""Cast data and gradient of this Parameter to a new data type.
Parameters
----------
dtype : str or numpy.dtype
The new data type.
"""
self.dtype = dtype
if self._data is None:
return
with autograd.pause():
self._data = [i.astype(dtype) for i in self._data]
if self._grad is None:
return
self._grad = [i.astype(dtype) for i in self._grad]
autograd.mark_variables(self._data, self._grad, self.grad_req)
|
[
"def",
"cast",
"(",
"self",
",",
"dtype",
")",
":",
"self",
".",
"dtype",
"=",
"dtype",
"if",
"self",
".",
"_data",
"is",
"None",
":",
"return",
"with",
"autograd",
".",
"pause",
"(",
")",
":",
"self",
".",
"_data",
"=",
"[",
"i",
".",
"astype",
"(",
"dtype",
")",
"for",
"i",
"in",
"self",
".",
"_data",
"]",
"if",
"self",
".",
"_grad",
"is",
"None",
":",
"return",
"self",
".",
"_grad",
"=",
"[",
"i",
".",
"astype",
"(",
"dtype",
")",
"for",
"i",
"in",
"self",
".",
"_grad",
"]",
"autograd",
".",
"mark_variables",
"(",
"self",
".",
"_data",
",",
"self",
".",
"_grad",
",",
"self",
".",
"grad_req",
")"
] |
Cast data and gradient of this Parameter to a new data type.
Parameters
----------
dtype : str or numpy.dtype
The new data type.
|
[
"Cast",
"data",
"and",
"gradient",
"of",
"this",
"Parameter",
"to",
"a",
"new",
"data",
"type",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L558-L574
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
ParameterDict.get
|
def get(self, name, **kwargs):
"""Retrieves a :py:class:`Parameter` with name ``self.prefix+name``. If not found,
:py:func:`get` will first try to retrieve it from "shared" dict. If still not
found, :py:func:`get` will create a new :py:class:`Parameter` with key-word arguments and
insert it to self.
Parameters
----------
name : str
Name of the desired Parameter. It will be prepended with this dictionary's
prefix.
**kwargs : dict
The rest of key-word arguments for the created :py:class:`Parameter`.
Returns
-------
Parameter
The created or retrieved :py:class:`Parameter`.
"""
name = self.prefix + name
param = self._get_impl(name)
if param is None: # pylint: disable=too-many-nested-blocks
param = Parameter(name, **kwargs)
self._params[name] = param
else:
for k, v in kwargs.items():
if hasattr(param, k) and getattr(param, k) is not None:
existing = getattr(param, k)
if k == 'shape' and len(v) == len(existing):
inferred_shape = []
matched = True
for dim1, dim2 in zip(v, existing):
if dim1 != dim2 and dim1 * dim2 != 0:
matched = False
break
elif dim1 == dim2:
inferred_shape.append(dim1)
elif dim1 == 0:
inferred_shape.append(dim2)
else:
inferred_shape.append(dim1)
if matched:
param._shape = tuple(inferred_shape)
continue
elif k == 'dtype' and np.dtype(v) == np.dtype(existing):
continue
assert v is None or v == existing, \
"Cannot retrieve Parameter '%s' because desired attribute " \
"does not match with stored for attribute '%s': " \
"desired '%s' vs stored '%s'."%(
name, k, str(v), str(getattr(param, k)))
else:
setattr(param, k, v)
return param
|
python
|
def get(self, name, **kwargs):
"""Retrieves a :py:class:`Parameter` with name ``self.prefix+name``. If not found,
:py:func:`get` will first try to retrieve it from "shared" dict. If still not
found, :py:func:`get` will create a new :py:class:`Parameter` with key-word arguments and
insert it to self.
Parameters
----------
name : str
Name of the desired Parameter. It will be prepended with this dictionary's
prefix.
**kwargs : dict
The rest of key-word arguments for the created :py:class:`Parameter`.
Returns
-------
Parameter
The created or retrieved :py:class:`Parameter`.
"""
name = self.prefix + name
param = self._get_impl(name)
if param is None: # pylint: disable=too-many-nested-blocks
param = Parameter(name, **kwargs)
self._params[name] = param
else:
for k, v in kwargs.items():
if hasattr(param, k) and getattr(param, k) is not None:
existing = getattr(param, k)
if k == 'shape' and len(v) == len(existing):
inferred_shape = []
matched = True
for dim1, dim2 in zip(v, existing):
if dim1 != dim2 and dim1 * dim2 != 0:
matched = False
break
elif dim1 == dim2:
inferred_shape.append(dim1)
elif dim1 == 0:
inferred_shape.append(dim2)
else:
inferred_shape.append(dim1)
if matched:
param._shape = tuple(inferred_shape)
continue
elif k == 'dtype' and np.dtype(v) == np.dtype(existing):
continue
assert v is None or v == existing, \
"Cannot retrieve Parameter '%s' because desired attribute " \
"does not match with stored for attribute '%s': " \
"desired '%s' vs stored '%s'."%(
name, k, str(v), str(getattr(param, k)))
else:
setattr(param, k, v)
return param
|
[
"def",
"get",
"(",
"self",
",",
"name",
",",
"*",
"*",
"kwargs",
")",
":",
"name",
"=",
"self",
".",
"prefix",
"+",
"name",
"param",
"=",
"self",
".",
"_get_impl",
"(",
"name",
")",
"if",
"param",
"is",
"None",
":",
"# pylint: disable=too-many-nested-blocks",
"param",
"=",
"Parameter",
"(",
"name",
",",
"*",
"*",
"kwargs",
")",
"self",
".",
"_params",
"[",
"name",
"]",
"=",
"param",
"else",
":",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"if",
"hasattr",
"(",
"param",
",",
"k",
")",
"and",
"getattr",
"(",
"param",
",",
"k",
")",
"is",
"not",
"None",
":",
"existing",
"=",
"getattr",
"(",
"param",
",",
"k",
")",
"if",
"k",
"==",
"'shape'",
"and",
"len",
"(",
"v",
")",
"==",
"len",
"(",
"existing",
")",
":",
"inferred_shape",
"=",
"[",
"]",
"matched",
"=",
"True",
"for",
"dim1",
",",
"dim2",
"in",
"zip",
"(",
"v",
",",
"existing",
")",
":",
"if",
"dim1",
"!=",
"dim2",
"and",
"dim1",
"*",
"dim2",
"!=",
"0",
":",
"matched",
"=",
"False",
"break",
"elif",
"dim1",
"==",
"dim2",
":",
"inferred_shape",
".",
"append",
"(",
"dim1",
")",
"elif",
"dim1",
"==",
"0",
":",
"inferred_shape",
".",
"append",
"(",
"dim2",
")",
"else",
":",
"inferred_shape",
".",
"append",
"(",
"dim1",
")",
"if",
"matched",
":",
"param",
".",
"_shape",
"=",
"tuple",
"(",
"inferred_shape",
")",
"continue",
"elif",
"k",
"==",
"'dtype'",
"and",
"np",
".",
"dtype",
"(",
"v",
")",
"==",
"np",
".",
"dtype",
"(",
"existing",
")",
":",
"continue",
"assert",
"v",
"is",
"None",
"or",
"v",
"==",
"existing",
",",
"\"Cannot retrieve Parameter '%s' because desired attribute \"",
"\"does not match with stored for attribute '%s': \"",
"\"desired '%s' vs stored '%s'.\"",
"%",
"(",
"name",
",",
"k",
",",
"str",
"(",
"v",
")",
",",
"str",
"(",
"getattr",
"(",
"param",
",",
"k",
")",
")",
")",
"else",
":",
"setattr",
"(",
"param",
",",
"k",
",",
"v",
")",
"return",
"param"
] |
Retrieves a :py:class:`Parameter` with name ``self.prefix+name``. If not found,
:py:func:`get` will first try to retrieve it from "shared" dict. If still not
found, :py:func:`get` will create a new :py:class:`Parameter` with key-word arguments and
insert it to self.
Parameters
----------
name : str
Name of the desired Parameter. It will be prepended with this dictionary's
prefix.
**kwargs : dict
The rest of key-word arguments for the created :py:class:`Parameter`.
Returns
-------
Parameter
The created or retrieved :py:class:`Parameter`.
|
[
"Retrieves",
"a",
":",
"py",
":",
"class",
":",
"Parameter",
"with",
"name",
"self",
".",
"prefix",
"+",
"name",
".",
"If",
"not",
"found",
":",
"py",
":",
"func",
":",
"get",
"will",
"first",
"try",
"to",
"retrieve",
"it",
"from",
"shared",
"dict",
".",
"If",
"still",
"not",
"found",
":",
"py",
":",
"func",
":",
"get",
"will",
"create",
"a",
"new",
":",
"py",
":",
"class",
":",
"Parameter",
"with",
"key",
"-",
"word",
"arguments",
"and",
"insert",
"it",
"to",
"self",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L685-L740
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
ParameterDict.get_constant
|
def get_constant(self, name, value=None):
"""Retrieves a :py:class:`.Constant` with name ``self.prefix+name``. If not found,
:py:func:`get` will first try to retrieve it from "shared" dict. If still not
found, :py:func:`get` will create a new :py:class:`.Constant` with key-word
arguments and insert it to self.
Parameters
----------
name : str
Name of the desired Constant. It will be prepended with this dictionary's
prefix.
value : array-like
Initial value of constant.
Returns
-------
:py:class:`.Constant`
The created or retrieved :py:class:`.Constant`.
"""
name = self.prefix + name
param = self._get_impl(name)
if param is None:
if value is None:
raise KeyError("No constant named '{}'. Please specify value " \
"if you want to create a new constant.".format(
name))
param = Constant(name, value)
self._params[name] = param
elif value is not None:
assert isinstance(param, Constant), \
"Parameter '{}' already exists but it is not a constant.".format(
name)
if isinstance(value, ndarray.NDArray):
value = value.asnumpy()
assert param.shape == value.shape and \
(param.value.asnumpy() == value).all(), \
"Constant '{}' already exists but it's value doesn't match new " \
"value".format(name)
return param
|
python
|
def get_constant(self, name, value=None):
"""Retrieves a :py:class:`.Constant` with name ``self.prefix+name``. If not found,
:py:func:`get` will first try to retrieve it from "shared" dict. If still not
found, :py:func:`get` will create a new :py:class:`.Constant` with key-word
arguments and insert it to self.
Parameters
----------
name : str
Name of the desired Constant. It will be prepended with this dictionary's
prefix.
value : array-like
Initial value of constant.
Returns
-------
:py:class:`.Constant`
The created or retrieved :py:class:`.Constant`.
"""
name = self.prefix + name
param = self._get_impl(name)
if param is None:
if value is None:
raise KeyError("No constant named '{}'. Please specify value " \
"if you want to create a new constant.".format(
name))
param = Constant(name, value)
self._params[name] = param
elif value is not None:
assert isinstance(param, Constant), \
"Parameter '{}' already exists but it is not a constant.".format(
name)
if isinstance(value, ndarray.NDArray):
value = value.asnumpy()
assert param.shape == value.shape and \
(param.value.asnumpy() == value).all(), \
"Constant '{}' already exists but it's value doesn't match new " \
"value".format(name)
return param
|
[
"def",
"get_constant",
"(",
"self",
",",
"name",
",",
"value",
"=",
"None",
")",
":",
"name",
"=",
"self",
".",
"prefix",
"+",
"name",
"param",
"=",
"self",
".",
"_get_impl",
"(",
"name",
")",
"if",
"param",
"is",
"None",
":",
"if",
"value",
"is",
"None",
":",
"raise",
"KeyError",
"(",
"\"No constant named '{}'. Please specify value \"",
"\"if you want to create a new constant.\"",
".",
"format",
"(",
"name",
")",
")",
"param",
"=",
"Constant",
"(",
"name",
",",
"value",
")",
"self",
".",
"_params",
"[",
"name",
"]",
"=",
"param",
"elif",
"value",
"is",
"not",
"None",
":",
"assert",
"isinstance",
"(",
"param",
",",
"Constant",
")",
",",
"\"Parameter '{}' already exists but it is not a constant.\"",
".",
"format",
"(",
"name",
")",
"if",
"isinstance",
"(",
"value",
",",
"ndarray",
".",
"NDArray",
")",
":",
"value",
"=",
"value",
".",
"asnumpy",
"(",
")",
"assert",
"param",
".",
"shape",
"==",
"value",
".",
"shape",
"and",
"(",
"param",
".",
"value",
".",
"asnumpy",
"(",
")",
"==",
"value",
")",
".",
"all",
"(",
")",
",",
"\"Constant '{}' already exists but it's value doesn't match new \"",
"\"value\"",
".",
"format",
"(",
"name",
")",
"return",
"param"
] |
Retrieves a :py:class:`.Constant` with name ``self.prefix+name``. If not found,
:py:func:`get` will first try to retrieve it from "shared" dict. If still not
found, :py:func:`get` will create a new :py:class:`.Constant` with key-word
arguments and insert it to self.
Parameters
----------
name : str
Name of the desired Constant. It will be prepended with this dictionary's
prefix.
value : array-like
Initial value of constant.
Returns
-------
:py:class:`.Constant`
The created or retrieved :py:class:`.Constant`.
|
[
"Retrieves",
"a",
":",
"py",
":",
"class",
":",
".",
"Constant",
"with",
"name",
"self",
".",
"prefix",
"+",
"name",
".",
"If",
"not",
"found",
":",
"py",
":",
"func",
":",
"get",
"will",
"first",
"try",
"to",
"retrieve",
"it",
"from",
"shared",
"dict",
".",
"If",
"still",
"not",
"found",
":",
"py",
":",
"func",
":",
"get",
"will",
"create",
"a",
"new",
":",
"py",
":",
"class",
":",
".",
"Constant",
"with",
"key",
"-",
"word",
"arguments",
"and",
"insert",
"it",
"to",
"self",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L742-L780
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
ParameterDict.update
|
def update(self, other):
"""Copies all Parameters in ``other`` to self."""
for k, v in other.items():
if k in self._params:
assert self._params[k] is v, \
"Cannot update self with other because they have different " \
"Parameters with the same name '%s'"%k
for k, v in other.items():
self._params[k] = v
|
python
|
def update(self, other):
"""Copies all Parameters in ``other`` to self."""
for k, v in other.items():
if k in self._params:
assert self._params[k] is v, \
"Cannot update self with other because they have different " \
"Parameters with the same name '%s'"%k
for k, v in other.items():
self._params[k] = v
|
[
"def",
"update",
"(",
"self",
",",
"other",
")",
":",
"for",
"k",
",",
"v",
"in",
"other",
".",
"items",
"(",
")",
":",
"if",
"k",
"in",
"self",
".",
"_params",
":",
"assert",
"self",
".",
"_params",
"[",
"k",
"]",
"is",
"v",
",",
"\"Cannot update self with other because they have different \"",
"\"Parameters with the same name '%s'\"",
"%",
"k",
"for",
"k",
",",
"v",
"in",
"other",
".",
"items",
"(",
")",
":",
"self",
".",
"_params",
"[",
"k",
"]",
"=",
"v"
] |
Copies all Parameters in ``other`` to self.
|
[
"Copies",
"all",
"Parameters",
"in",
"other",
"to",
"self",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L782-L791
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
ParameterDict.initialize
|
def initialize(self, init=initializer.Uniform(), ctx=None, verbose=False,
force_reinit=False):
"""Initializes all Parameters managed by this dictionary to be used for :py:class:`NDArray`
API. It has no effect when using :py:class:`Symbol` API.
Parameters
----------
init : Initializer
Global default Initializer to be used when :py:meth:`Parameter.init` is ``None``.
Otherwise, :py:meth:`Parameter.init` takes precedence.
ctx : Context or list of Context
Keeps a copy of Parameters on one or many context(s).
verbose : bool, default False
Whether to verbosely print out details on initialization.
force_reinit : bool, default False
Whether to force re-initialization if parameter is already initialized.
"""
if verbose:
init.set_verbosity(verbose=verbose)
for _, v in self.items():
v.initialize(None, ctx, init, force_reinit=force_reinit)
|
python
|
def initialize(self, init=initializer.Uniform(), ctx=None, verbose=False,
force_reinit=False):
"""Initializes all Parameters managed by this dictionary to be used for :py:class:`NDArray`
API. It has no effect when using :py:class:`Symbol` API.
Parameters
----------
init : Initializer
Global default Initializer to be used when :py:meth:`Parameter.init` is ``None``.
Otherwise, :py:meth:`Parameter.init` takes precedence.
ctx : Context or list of Context
Keeps a copy of Parameters on one or many context(s).
verbose : bool, default False
Whether to verbosely print out details on initialization.
force_reinit : bool, default False
Whether to force re-initialization if parameter is already initialized.
"""
if verbose:
init.set_verbosity(verbose=verbose)
for _, v in self.items():
v.initialize(None, ctx, init, force_reinit=force_reinit)
|
[
"def",
"initialize",
"(",
"self",
",",
"init",
"=",
"initializer",
".",
"Uniform",
"(",
")",
",",
"ctx",
"=",
"None",
",",
"verbose",
"=",
"False",
",",
"force_reinit",
"=",
"False",
")",
":",
"if",
"verbose",
":",
"init",
".",
"set_verbosity",
"(",
"verbose",
"=",
"verbose",
")",
"for",
"_",
",",
"v",
"in",
"self",
".",
"items",
"(",
")",
":",
"v",
".",
"initialize",
"(",
"None",
",",
"ctx",
",",
"init",
",",
"force_reinit",
"=",
"force_reinit",
")"
] |
Initializes all Parameters managed by this dictionary to be used for :py:class:`NDArray`
API. It has no effect when using :py:class:`Symbol` API.
Parameters
----------
init : Initializer
Global default Initializer to be used when :py:meth:`Parameter.init` is ``None``.
Otherwise, :py:meth:`Parameter.init` takes precedence.
ctx : Context or list of Context
Keeps a copy of Parameters on one or many context(s).
verbose : bool, default False
Whether to verbosely print out details on initialization.
force_reinit : bool, default False
Whether to force re-initialization if parameter is already initialized.
|
[
"Initializes",
"all",
"Parameters",
"managed",
"by",
"this",
"dictionary",
"to",
"be",
"used",
"for",
":",
"py",
":",
"class",
":",
"NDArray",
"API",
".",
"It",
"has",
"no",
"effect",
"when",
"using",
":",
"py",
":",
"class",
":",
"Symbol",
"API",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L793-L813
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
ParameterDict.setattr
|
def setattr(self, name, value):
"""Set an attribute to a new value for all Parameters.
For example, set grad_req to null if you don't need gradient w.r.t a
model's Parameters::
model.collect_params().setattr('grad_req', 'null')
or change the learning rate multiplier::
model.collect_params().setattr('lr_mult', 0.5)
Parameters
----------
name : str
Name of the attribute.
value : valid type for attribute name
The new value for the attribute.
"""
for i in self.values():
setattr(i, name, value)
|
python
|
def setattr(self, name, value):
"""Set an attribute to a new value for all Parameters.
For example, set grad_req to null if you don't need gradient w.r.t a
model's Parameters::
model.collect_params().setattr('grad_req', 'null')
or change the learning rate multiplier::
model.collect_params().setattr('lr_mult', 0.5)
Parameters
----------
name : str
Name of the attribute.
value : valid type for attribute name
The new value for the attribute.
"""
for i in self.values():
setattr(i, name, value)
|
[
"def",
"setattr",
"(",
"self",
",",
"name",
",",
"value",
")",
":",
"for",
"i",
"in",
"self",
".",
"values",
"(",
")",
":",
"setattr",
"(",
"i",
",",
"name",
",",
"value",
")"
] |
Set an attribute to a new value for all Parameters.
For example, set grad_req to null if you don't need gradient w.r.t a
model's Parameters::
model.collect_params().setattr('grad_req', 'null')
or change the learning rate multiplier::
model.collect_params().setattr('lr_mult', 0.5)
Parameters
----------
name : str
Name of the attribute.
value : valid type for attribute name
The new value for the attribute.
|
[
"Set",
"an",
"attribute",
"to",
"a",
"new",
"value",
"for",
"all",
"Parameters",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L832-L852
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
ParameterDict.save
|
def save(self, filename, strip_prefix=''):
"""Save parameters to file.
Parameters
----------
filename : str
Path to parameter file.
strip_prefix : str, default ''
Strip prefix from parameter names before saving.
"""
arg_dict = {}
for param in self.values():
weight = param._reduce()
if not param.name.startswith(strip_prefix):
raise ValueError(
"Prefix '%s' is to be striped before saving, but Parameter's "
"name '%s' does not start with '%s'. "
"this may be due to your Block shares parameters from other "
"Blocks or you forgot to use 'with name_scope()' when creating "
"child blocks. For more info on naming, please see "
"http://mxnet.incubator.apache.org/tutorials/basic/naming.html"%(
strip_prefix, param.name, strip_prefix))
arg_dict[param.name[len(strip_prefix):]] = weight
ndarray.save(filename, arg_dict)
|
python
|
def save(self, filename, strip_prefix=''):
"""Save parameters to file.
Parameters
----------
filename : str
Path to parameter file.
strip_prefix : str, default ''
Strip prefix from parameter names before saving.
"""
arg_dict = {}
for param in self.values():
weight = param._reduce()
if not param.name.startswith(strip_prefix):
raise ValueError(
"Prefix '%s' is to be striped before saving, but Parameter's "
"name '%s' does not start with '%s'. "
"this may be due to your Block shares parameters from other "
"Blocks or you forgot to use 'with name_scope()' when creating "
"child blocks. For more info on naming, please see "
"http://mxnet.incubator.apache.org/tutorials/basic/naming.html"%(
strip_prefix, param.name, strip_prefix))
arg_dict[param.name[len(strip_prefix):]] = weight
ndarray.save(filename, arg_dict)
|
[
"def",
"save",
"(",
"self",
",",
"filename",
",",
"strip_prefix",
"=",
"''",
")",
":",
"arg_dict",
"=",
"{",
"}",
"for",
"param",
"in",
"self",
".",
"values",
"(",
")",
":",
"weight",
"=",
"param",
".",
"_reduce",
"(",
")",
"if",
"not",
"param",
".",
"name",
".",
"startswith",
"(",
"strip_prefix",
")",
":",
"raise",
"ValueError",
"(",
"\"Prefix '%s' is to be striped before saving, but Parameter's \"",
"\"name '%s' does not start with '%s'. \"",
"\"this may be due to your Block shares parameters from other \"",
"\"Blocks or you forgot to use 'with name_scope()' when creating \"",
"\"child blocks. For more info on naming, please see \"",
"\"http://mxnet.incubator.apache.org/tutorials/basic/naming.html\"",
"%",
"(",
"strip_prefix",
",",
"param",
".",
"name",
",",
"strip_prefix",
")",
")",
"arg_dict",
"[",
"param",
".",
"name",
"[",
"len",
"(",
"strip_prefix",
")",
":",
"]",
"]",
"=",
"weight",
"ndarray",
".",
"save",
"(",
"filename",
",",
"arg_dict",
")"
] |
Save parameters to file.
Parameters
----------
filename : str
Path to parameter file.
strip_prefix : str, default ''
Strip prefix from parameter names before saving.
|
[
"Save",
"parameters",
"to",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L854-L877
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/parameter.py
|
ParameterDict.load
|
def load(self, filename, ctx=None, allow_missing=False,
ignore_extra=False, restore_prefix=''):
"""Load parameters from file.
Parameters
----------
filename : str
Path to parameter file.
ctx : Context or list of Context
Context(s) initialize loaded parameters on.
allow_missing : bool, default False
Whether to silently skip loading parameters not represents in the file.
ignore_extra : bool, default False
Whether to silently ignore parameters from the file that are not
present in this ParameterDict.
restore_prefix : str, default ''
prepend prefix to names of stored parameters before loading.
"""
if restore_prefix:
for name in self.keys():
assert name.startswith(restore_prefix), \
"restore_prefix is '%s' but Parameters name '%s' does not start " \
"with '%s'"%(restore_prefix, name, restore_prefix)
lprefix = len(restore_prefix)
loaded = [(k[4:] if k.startswith('arg:') or k.startswith('aux:') else k, v) \
for k, v in ndarray.load(filename).items()]
arg_dict = {restore_prefix+k: v for k, v in loaded}
if not allow_missing:
for name in self.keys():
assert name in arg_dict, \
"Parameter '%s' is missing in file '%s', which contains parameters: %s. " \
"Please make sure source and target networks have the same prefix."%(
name[lprefix:], filename, _brief_print_list(arg_dict.keys()))
for name in arg_dict:
if name not in self._params:
assert ignore_extra, \
"Parameter '%s' loaded from file '%s' is not present in ParameterDict, " \
"choices are: %s. Set ignore_extra to True to ignore. " \
"Please make sure source and target networks have the same prefix."%(
name[lprefix:], filename, _brief_print_list(self._params.keys()))
continue
self[name]._load_init(arg_dict[name], ctx)
|
python
|
def load(self, filename, ctx=None, allow_missing=False,
ignore_extra=False, restore_prefix=''):
"""Load parameters from file.
Parameters
----------
filename : str
Path to parameter file.
ctx : Context or list of Context
Context(s) initialize loaded parameters on.
allow_missing : bool, default False
Whether to silently skip loading parameters not represents in the file.
ignore_extra : bool, default False
Whether to silently ignore parameters from the file that are not
present in this ParameterDict.
restore_prefix : str, default ''
prepend prefix to names of stored parameters before loading.
"""
if restore_prefix:
for name in self.keys():
assert name.startswith(restore_prefix), \
"restore_prefix is '%s' but Parameters name '%s' does not start " \
"with '%s'"%(restore_prefix, name, restore_prefix)
lprefix = len(restore_prefix)
loaded = [(k[4:] if k.startswith('arg:') or k.startswith('aux:') else k, v) \
for k, v in ndarray.load(filename).items()]
arg_dict = {restore_prefix+k: v for k, v in loaded}
if not allow_missing:
for name in self.keys():
assert name in arg_dict, \
"Parameter '%s' is missing in file '%s', which contains parameters: %s. " \
"Please make sure source and target networks have the same prefix."%(
name[lprefix:], filename, _brief_print_list(arg_dict.keys()))
for name in arg_dict:
if name not in self._params:
assert ignore_extra, \
"Parameter '%s' loaded from file '%s' is not present in ParameterDict, " \
"choices are: %s. Set ignore_extra to True to ignore. " \
"Please make sure source and target networks have the same prefix."%(
name[lprefix:], filename, _brief_print_list(self._params.keys()))
continue
self[name]._load_init(arg_dict[name], ctx)
|
[
"def",
"load",
"(",
"self",
",",
"filename",
",",
"ctx",
"=",
"None",
",",
"allow_missing",
"=",
"False",
",",
"ignore_extra",
"=",
"False",
",",
"restore_prefix",
"=",
"''",
")",
":",
"if",
"restore_prefix",
":",
"for",
"name",
"in",
"self",
".",
"keys",
"(",
")",
":",
"assert",
"name",
".",
"startswith",
"(",
"restore_prefix",
")",
",",
"\"restore_prefix is '%s' but Parameters name '%s' does not start \"",
"\"with '%s'\"",
"%",
"(",
"restore_prefix",
",",
"name",
",",
"restore_prefix",
")",
"lprefix",
"=",
"len",
"(",
"restore_prefix",
")",
"loaded",
"=",
"[",
"(",
"k",
"[",
"4",
":",
"]",
"if",
"k",
".",
"startswith",
"(",
"'arg:'",
")",
"or",
"k",
".",
"startswith",
"(",
"'aux:'",
")",
"else",
"k",
",",
"v",
")",
"for",
"k",
",",
"v",
"in",
"ndarray",
".",
"load",
"(",
"filename",
")",
".",
"items",
"(",
")",
"]",
"arg_dict",
"=",
"{",
"restore_prefix",
"+",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"loaded",
"}",
"if",
"not",
"allow_missing",
":",
"for",
"name",
"in",
"self",
".",
"keys",
"(",
")",
":",
"assert",
"name",
"in",
"arg_dict",
",",
"\"Parameter '%s' is missing in file '%s', which contains parameters: %s. \"",
"\"Please make sure source and target networks have the same prefix.\"",
"%",
"(",
"name",
"[",
"lprefix",
":",
"]",
",",
"filename",
",",
"_brief_print_list",
"(",
"arg_dict",
".",
"keys",
"(",
")",
")",
")",
"for",
"name",
"in",
"arg_dict",
":",
"if",
"name",
"not",
"in",
"self",
".",
"_params",
":",
"assert",
"ignore_extra",
",",
"\"Parameter '%s' loaded from file '%s' is not present in ParameterDict, \"",
"\"choices are: %s. Set ignore_extra to True to ignore. \"",
"\"Please make sure source and target networks have the same prefix.\"",
"%",
"(",
"name",
"[",
"lprefix",
":",
"]",
",",
"filename",
",",
"_brief_print_list",
"(",
"self",
".",
"_params",
".",
"keys",
"(",
")",
")",
")",
"continue",
"self",
"[",
"name",
"]",
".",
"_load_init",
"(",
"arg_dict",
"[",
"name",
"]",
",",
"ctx",
")"
] |
Load parameters from file.
Parameters
----------
filename : str
Path to parameter file.
ctx : Context or list of Context
Context(s) initialize loaded parameters on.
allow_missing : bool, default False
Whether to silently skip loading parameters not represents in the file.
ignore_extra : bool, default False
Whether to silently ignore parameters from the file that are not
present in this ParameterDict.
restore_prefix : str, default ''
prepend prefix to names of stored parameters before loading.
|
[
"Load",
"parameters",
"from",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/parameter.py#L879-L920
|
train
|
apache/incubator-mxnet
|
python/mxnet/torch.py
|
_make_torch_function
|
def _make_torch_function(handle):
"""Create a Torch function from the FunctionHandle."""
# Get the property of function
n_used_vars = mx_uint()
n_scalars = mx_uint()
n_mutate_vars = mx_uint()
type_mask = ctypes.c_int()
check_call(_LIB.MXFuncDescribe(
handle,
ctypes.byref(n_used_vars),
ctypes.byref(n_scalars),
ctypes.byref(n_mutate_vars),
ctypes.byref(type_mask)))
n_mutate_vars = n_mutate_vars.value
n_used_vars = n_used_vars.value
n_scalars = n_scalars.value
type_mask = type_mask.value
# Get the information from the function
name = ctypes.c_char_p()
desc = ctypes.c_char_p()
num_args = mx_uint()
arg_names = ctypes.POINTER(ctypes.c_char_p)()
arg_types = ctypes.POINTER(ctypes.c_char_p)()
arg_descs = ctypes.POINTER(ctypes.c_char_p)()
ret_type = ctypes.c_char_p()
check_call(_LIB.MXFuncGetInfo(
handle, ctypes.byref(name), ctypes.byref(desc),
ctypes.byref(num_args),
ctypes.byref(arg_names),
ctypes.byref(arg_types),
ctypes.byref(arg_descs),
ctypes.byref(ret_type)))
func_name = py_str(name.value)
if not func_name.startswith('_th_'):
return None
narg = int(num_args.value)
param_str = _build_param_doc(
[py_str(arg_names[i]) for i in range(narg)],
[py_str(arg_types[i]) for i in range(narg)],
[py_str(arg_descs[i]) for i in range(narg)])
if n_mutate_vars > 1:
res = ','.join(['res%d '%i for i in range(n_mutate_vars)])
else:
res = 'res '
doc_str = (('Interface for Torch function {name}.\n' +
'Invoke with\n{res}= mxnet.th.{name}(Parameters)\nor\n'+
'mxnet.th.{name}({res}, Parameters).\n\n' +
'{param_str}\n' +
'References: ' +
'https://github.com/torch/torch7/blob/master/doc/maths.md\n').format(
name=func_name[4:], param_str=param_str,
res=res))
def generic_torch_function(*args, **kwargs):
"""Invoke this function by passing in parameters.
Parameters
----------
*args
Positional arguments of inputs (both scalar and `NDArray`).
Returns
-------
out : NDArray
The result NDArray(tuple) of result of computation.
"""
ndargs = []
arg_format = ''
value = ''
for arg in args:
if isinstance(arg, NDArray):
ndargs.append(arg)
arg_format += 'n'
value += ','
elif isinstance(arg, int):
arg_format += 'i'
value += str(arg) + ','
elif isinstance(arg, str):
arg_format += 's'
value += str(arg) + ','
elif isinstance(arg, float):
arg_format += 'f'
value += str(arg) + ','
elif isinstance(arg, bool):
arg_format += 'b'
value += str(arg) + ','
value = value[:-1]
if len(ndargs) == n_used_vars:
ndargs = [NDArray(_new_empty_handle()) for _ in range(n_mutate_vars)] + ndargs
arg_format = 'n'*n_mutate_vars + arg_format
value = ','*n_mutate_vars + value
elif len(ndargs) == n_mutate_vars + n_used_vars:
pass
else:
raise AssertionError(('Incorrect number of input NDArrays. ' +
'Need to be either %d (inputs) or %d ' +
'(output buffer) + %d (input)') %
(n_used_vars, n_mutate_vars, n_used_vars))
kwargs['format'] = arg_format
kwargs['args'] = value
for k in kwargs:
kwargs[k] = str(kwargs[k])
check_call(_LIB.MXFuncInvokeEx(
handle,
c_handle_array(ndargs[n_mutate_vars:]), # pylint: disable=invalid-slice-index
c_array(mx_float, []),
c_handle_array(ndargs[:n_mutate_vars]), # pylint: disable=invalid-slice-index
ctypes.c_int(len(kwargs)),
c_str_array(kwargs.keys()),
c_str_array(kwargs.values())))
if n_mutate_vars == 1:
return ndargs[0]
else:
return ndargs[:n_mutate_vars] # pylint: disable=invalid-slice-index
# End of function declaration
ret_function = generic_torch_function
ret_function.__name__ = func_name[4:]
ret_function.__doc__ = doc_str
return ret_function
|
python
|
def _make_torch_function(handle):
"""Create a Torch function from the FunctionHandle."""
# Get the property of function
n_used_vars = mx_uint()
n_scalars = mx_uint()
n_mutate_vars = mx_uint()
type_mask = ctypes.c_int()
check_call(_LIB.MXFuncDescribe(
handle,
ctypes.byref(n_used_vars),
ctypes.byref(n_scalars),
ctypes.byref(n_mutate_vars),
ctypes.byref(type_mask)))
n_mutate_vars = n_mutate_vars.value
n_used_vars = n_used_vars.value
n_scalars = n_scalars.value
type_mask = type_mask.value
# Get the information from the function
name = ctypes.c_char_p()
desc = ctypes.c_char_p()
num_args = mx_uint()
arg_names = ctypes.POINTER(ctypes.c_char_p)()
arg_types = ctypes.POINTER(ctypes.c_char_p)()
arg_descs = ctypes.POINTER(ctypes.c_char_p)()
ret_type = ctypes.c_char_p()
check_call(_LIB.MXFuncGetInfo(
handle, ctypes.byref(name), ctypes.byref(desc),
ctypes.byref(num_args),
ctypes.byref(arg_names),
ctypes.byref(arg_types),
ctypes.byref(arg_descs),
ctypes.byref(ret_type)))
func_name = py_str(name.value)
if not func_name.startswith('_th_'):
return None
narg = int(num_args.value)
param_str = _build_param_doc(
[py_str(arg_names[i]) for i in range(narg)],
[py_str(arg_types[i]) for i in range(narg)],
[py_str(arg_descs[i]) for i in range(narg)])
if n_mutate_vars > 1:
res = ','.join(['res%d '%i for i in range(n_mutate_vars)])
else:
res = 'res '
doc_str = (('Interface for Torch function {name}.\n' +
'Invoke with\n{res}= mxnet.th.{name}(Parameters)\nor\n'+
'mxnet.th.{name}({res}, Parameters).\n\n' +
'{param_str}\n' +
'References: ' +
'https://github.com/torch/torch7/blob/master/doc/maths.md\n').format(
name=func_name[4:], param_str=param_str,
res=res))
def generic_torch_function(*args, **kwargs):
"""Invoke this function by passing in parameters.
Parameters
----------
*args
Positional arguments of inputs (both scalar and `NDArray`).
Returns
-------
out : NDArray
The result NDArray(tuple) of result of computation.
"""
ndargs = []
arg_format = ''
value = ''
for arg in args:
if isinstance(arg, NDArray):
ndargs.append(arg)
arg_format += 'n'
value += ','
elif isinstance(arg, int):
arg_format += 'i'
value += str(arg) + ','
elif isinstance(arg, str):
arg_format += 's'
value += str(arg) + ','
elif isinstance(arg, float):
arg_format += 'f'
value += str(arg) + ','
elif isinstance(arg, bool):
arg_format += 'b'
value += str(arg) + ','
value = value[:-1]
if len(ndargs) == n_used_vars:
ndargs = [NDArray(_new_empty_handle()) for _ in range(n_mutate_vars)] + ndargs
arg_format = 'n'*n_mutate_vars + arg_format
value = ','*n_mutate_vars + value
elif len(ndargs) == n_mutate_vars + n_used_vars:
pass
else:
raise AssertionError(('Incorrect number of input NDArrays. ' +
'Need to be either %d (inputs) or %d ' +
'(output buffer) + %d (input)') %
(n_used_vars, n_mutate_vars, n_used_vars))
kwargs['format'] = arg_format
kwargs['args'] = value
for k in kwargs:
kwargs[k] = str(kwargs[k])
check_call(_LIB.MXFuncInvokeEx(
handle,
c_handle_array(ndargs[n_mutate_vars:]), # pylint: disable=invalid-slice-index
c_array(mx_float, []),
c_handle_array(ndargs[:n_mutate_vars]), # pylint: disable=invalid-slice-index
ctypes.c_int(len(kwargs)),
c_str_array(kwargs.keys()),
c_str_array(kwargs.values())))
if n_mutate_vars == 1:
return ndargs[0]
else:
return ndargs[:n_mutate_vars] # pylint: disable=invalid-slice-index
# End of function declaration
ret_function = generic_torch_function
ret_function.__name__ = func_name[4:]
ret_function.__doc__ = doc_str
return ret_function
|
[
"def",
"_make_torch_function",
"(",
"handle",
")",
":",
"# Get the property of function",
"n_used_vars",
"=",
"mx_uint",
"(",
")",
"n_scalars",
"=",
"mx_uint",
"(",
")",
"n_mutate_vars",
"=",
"mx_uint",
"(",
")",
"type_mask",
"=",
"ctypes",
".",
"c_int",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXFuncDescribe",
"(",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"n_used_vars",
")",
",",
"ctypes",
".",
"byref",
"(",
"n_scalars",
")",
",",
"ctypes",
".",
"byref",
"(",
"n_mutate_vars",
")",
",",
"ctypes",
".",
"byref",
"(",
"type_mask",
")",
")",
")",
"n_mutate_vars",
"=",
"n_mutate_vars",
".",
"value",
"n_used_vars",
"=",
"n_used_vars",
".",
"value",
"n_scalars",
"=",
"n_scalars",
".",
"value",
"type_mask",
"=",
"type_mask",
".",
"value",
"# Get the information from the function",
"name",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"desc",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"num_args",
"=",
"mx_uint",
"(",
")",
"arg_names",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"arg_types",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"arg_descs",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"ret_type",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXFuncGetInfo",
"(",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"name",
")",
",",
"ctypes",
".",
"byref",
"(",
"desc",
")",
",",
"ctypes",
".",
"byref",
"(",
"num_args",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_names",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_types",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_descs",
")",
",",
"ctypes",
".",
"byref",
"(",
"ret_type",
")",
")",
")",
"func_name",
"=",
"py_str",
"(",
"name",
".",
"value",
")",
"if",
"not",
"func_name",
".",
"startswith",
"(",
"'_th_'",
")",
":",
"return",
"None",
"narg",
"=",
"int",
"(",
"num_args",
".",
"value",
")",
"param_str",
"=",
"_build_param_doc",
"(",
"[",
"py_str",
"(",
"arg_names",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"narg",
")",
"]",
",",
"[",
"py_str",
"(",
"arg_types",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"narg",
")",
"]",
",",
"[",
"py_str",
"(",
"arg_descs",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"narg",
")",
"]",
")",
"if",
"n_mutate_vars",
">",
"1",
":",
"res",
"=",
"','",
".",
"join",
"(",
"[",
"'res%d '",
"%",
"i",
"for",
"i",
"in",
"range",
"(",
"n_mutate_vars",
")",
"]",
")",
"else",
":",
"res",
"=",
"'res '",
"doc_str",
"=",
"(",
"(",
"'Interface for Torch function {name}.\\n'",
"+",
"'Invoke with\\n{res}= mxnet.th.{name}(Parameters)\\nor\\n'",
"+",
"'mxnet.th.{name}({res}, Parameters).\\n\\n'",
"+",
"'{param_str}\\n'",
"+",
"'References: '",
"+",
"'https://github.com/torch/torch7/blob/master/doc/maths.md\\n'",
")",
".",
"format",
"(",
"name",
"=",
"func_name",
"[",
"4",
":",
"]",
",",
"param_str",
"=",
"param_str",
",",
"res",
"=",
"res",
")",
")",
"def",
"generic_torch_function",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"\"\"\"Invoke this function by passing in parameters.\n\n Parameters\n ----------\n *args\n Positional arguments of inputs (both scalar and `NDArray`).\n\n Returns\n -------\n out : NDArray\n The result NDArray(tuple) of result of computation.\n \"\"\"",
"ndargs",
"=",
"[",
"]",
"arg_format",
"=",
"''",
"value",
"=",
"''",
"for",
"arg",
"in",
"args",
":",
"if",
"isinstance",
"(",
"arg",
",",
"NDArray",
")",
":",
"ndargs",
".",
"append",
"(",
"arg",
")",
"arg_format",
"+=",
"'n'",
"value",
"+=",
"','",
"elif",
"isinstance",
"(",
"arg",
",",
"int",
")",
":",
"arg_format",
"+=",
"'i'",
"value",
"+=",
"str",
"(",
"arg",
")",
"+",
"','",
"elif",
"isinstance",
"(",
"arg",
",",
"str",
")",
":",
"arg_format",
"+=",
"'s'",
"value",
"+=",
"str",
"(",
"arg",
")",
"+",
"','",
"elif",
"isinstance",
"(",
"arg",
",",
"float",
")",
":",
"arg_format",
"+=",
"'f'",
"value",
"+=",
"str",
"(",
"arg",
")",
"+",
"','",
"elif",
"isinstance",
"(",
"arg",
",",
"bool",
")",
":",
"arg_format",
"+=",
"'b'",
"value",
"+=",
"str",
"(",
"arg",
")",
"+",
"','",
"value",
"=",
"value",
"[",
":",
"-",
"1",
"]",
"if",
"len",
"(",
"ndargs",
")",
"==",
"n_used_vars",
":",
"ndargs",
"=",
"[",
"NDArray",
"(",
"_new_empty_handle",
"(",
")",
")",
"for",
"_",
"in",
"range",
"(",
"n_mutate_vars",
")",
"]",
"+",
"ndargs",
"arg_format",
"=",
"'n'",
"*",
"n_mutate_vars",
"+",
"arg_format",
"value",
"=",
"','",
"*",
"n_mutate_vars",
"+",
"value",
"elif",
"len",
"(",
"ndargs",
")",
"==",
"n_mutate_vars",
"+",
"n_used_vars",
":",
"pass",
"else",
":",
"raise",
"AssertionError",
"(",
"(",
"'Incorrect number of input NDArrays. '",
"+",
"'Need to be either %d (inputs) or %d '",
"+",
"'(output buffer) + %d (input)'",
")",
"%",
"(",
"n_used_vars",
",",
"n_mutate_vars",
",",
"n_used_vars",
")",
")",
"kwargs",
"[",
"'format'",
"]",
"=",
"arg_format",
"kwargs",
"[",
"'args'",
"]",
"=",
"value",
"for",
"k",
"in",
"kwargs",
":",
"kwargs",
"[",
"k",
"]",
"=",
"str",
"(",
"kwargs",
"[",
"k",
"]",
")",
"check_call",
"(",
"_LIB",
".",
"MXFuncInvokeEx",
"(",
"handle",
",",
"c_handle_array",
"(",
"ndargs",
"[",
"n_mutate_vars",
":",
"]",
")",
",",
"# pylint: disable=invalid-slice-index",
"c_array",
"(",
"mx_float",
",",
"[",
"]",
")",
",",
"c_handle_array",
"(",
"ndargs",
"[",
":",
"n_mutate_vars",
"]",
")",
",",
"# pylint: disable=invalid-slice-index",
"ctypes",
".",
"c_int",
"(",
"len",
"(",
"kwargs",
")",
")",
",",
"c_str_array",
"(",
"kwargs",
".",
"keys",
"(",
")",
")",
",",
"c_str_array",
"(",
"kwargs",
".",
"values",
"(",
")",
")",
")",
")",
"if",
"n_mutate_vars",
"==",
"1",
":",
"return",
"ndargs",
"[",
"0",
"]",
"else",
":",
"return",
"ndargs",
"[",
":",
"n_mutate_vars",
"]",
"# pylint: disable=invalid-slice-index",
"# End of function declaration",
"ret_function",
"=",
"generic_torch_function",
"ret_function",
".",
"__name__",
"=",
"func_name",
"[",
"4",
":",
"]",
"ret_function",
".",
"__doc__",
"=",
"doc_str",
"return",
"ret_function"
] |
Create a Torch function from the FunctionHandle.
|
[
"Create",
"a",
"Torch",
"function",
"from",
"the",
"FunctionHandle",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/torch.py#L37-L163
|
train
|
apache/incubator-mxnet
|
python/mxnet/torch.py
|
_init_torch_module
|
def _init_torch_module():
"""List and add all the torch backed ndarray functions to current module."""
plist = ctypes.POINTER(FunctionHandle)()
size = ctypes.c_uint()
check_call(_LIB.MXListFunctions(ctypes.byref(size),
ctypes.byref(plist)))
module_obj = sys.modules[__name__]
for i in range(size.value):
hdl = FunctionHandle(plist[i])
function = _make_torch_function(hdl)
# if function name starts with underscore, register as static method of NDArray
if function is not None:
setattr(module_obj, function.__name__, function)
|
python
|
def _init_torch_module():
"""List and add all the torch backed ndarray functions to current module."""
plist = ctypes.POINTER(FunctionHandle)()
size = ctypes.c_uint()
check_call(_LIB.MXListFunctions(ctypes.byref(size),
ctypes.byref(plist)))
module_obj = sys.modules[__name__]
for i in range(size.value):
hdl = FunctionHandle(plist[i])
function = _make_torch_function(hdl)
# if function name starts with underscore, register as static method of NDArray
if function is not None:
setattr(module_obj, function.__name__, function)
|
[
"def",
"_init_torch_module",
"(",
")",
":",
"plist",
"=",
"ctypes",
".",
"POINTER",
"(",
"FunctionHandle",
")",
"(",
")",
"size",
"=",
"ctypes",
".",
"c_uint",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXListFunctions",
"(",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"plist",
")",
")",
")",
"module_obj",
"=",
"sys",
".",
"modules",
"[",
"__name__",
"]",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
":",
"hdl",
"=",
"FunctionHandle",
"(",
"plist",
"[",
"i",
"]",
")",
"function",
"=",
"_make_torch_function",
"(",
"hdl",
")",
"# if function name starts with underscore, register as static method of NDArray",
"if",
"function",
"is",
"not",
"None",
":",
"setattr",
"(",
"module_obj",
",",
"function",
".",
"__name__",
",",
"function",
")"
] |
List and add all the torch backed ndarray functions to current module.
|
[
"List",
"and",
"add",
"all",
"the",
"torch",
"backed",
"ndarray",
"functions",
"to",
"current",
"module",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/torch.py#L167-L180
|
train
|
apache/incubator-mxnet
|
python/mxnet/gluon/model_zoo/vision/inception.py
|
inception_v3
|
def inception_v3(pretrained=False, ctx=cpu(),
root=os.path.join(base.data_dir(), 'models'), **kwargs):
r"""Inception v3 model from
`"Rethinking the Inception Architecture for Computer Vision"
<http://arxiv.org/abs/1512.00567>`_ paper.
Parameters
----------
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.
"""
net = Inception3(**kwargs)
if pretrained:
from ..model_store import get_model_file
net.load_parameters(get_model_file('inceptionv3', root=root), ctx=ctx)
return net
|
python
|
def inception_v3(pretrained=False, ctx=cpu(),
root=os.path.join(base.data_dir(), 'models'), **kwargs):
r"""Inception v3 model from
`"Rethinking the Inception Architecture for Computer Vision"
<http://arxiv.org/abs/1512.00567>`_ paper.
Parameters
----------
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.
"""
net = Inception3(**kwargs)
if pretrained:
from ..model_store import get_model_file
net.load_parameters(get_model_file('inceptionv3', root=root), ctx=ctx)
return net
|
[
"def",
"inception_v3",
"(",
"pretrained",
"=",
"False",
",",
"ctx",
"=",
"cpu",
"(",
")",
",",
"root",
"=",
"os",
".",
"path",
".",
"join",
"(",
"base",
".",
"data_dir",
"(",
")",
",",
"'models'",
")",
",",
"*",
"*",
"kwargs",
")",
":",
"net",
"=",
"Inception3",
"(",
"*",
"*",
"kwargs",
")",
"if",
"pretrained",
":",
"from",
".",
".",
"model_store",
"import",
"get_model_file",
"net",
".",
"load_parameters",
"(",
"get_model_file",
"(",
"'inceptionv3'",
",",
"root",
"=",
"root",
")",
",",
"ctx",
"=",
"ctx",
")",
"return",
"net"
] |
r"""Inception v3 model from
`"Rethinking the Inception Architecture for Computer Vision"
<http://arxiv.org/abs/1512.00567>`_ paper.
Parameters
----------
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",
"Inception",
"v3",
"model",
"from",
"Rethinking",
"the",
"Inception",
"Architecture",
"for",
"Computer",
"Vision",
"<http",
":",
"//",
"arxiv",
".",
"org",
"/",
"abs",
"/",
"1512",
".",
"00567",
">",
"_",
"paper",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/gluon/model_zoo/vision/inception.py#L202-L221
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
pack
|
def pack(header, s):
"""Pack a string into MXImageRecord.
Parameters
----------
header : IRHeader
Header of the image record.
``header.label`` can be a number or an array. See more detail in ``IRHeader``.
s : str
Raw image string to be packed.
Returns
-------
s : str
The packed string.
Examples
--------
>>> label = 4 # label can also be a 1-D array, for example: label = [1,2,3]
>>> id = 2574
>>> header = mx.recordio.IRHeader(0, label, id, 0)
>>> with open(path, 'r') as file:
... s = file.read()
>>> packed_s = mx.recordio.pack(header, s)
"""
header = IRHeader(*header)
if isinstance(header.label, numbers.Number):
header = header._replace(flag=0)
else:
label = np.asarray(header.label, dtype=np.float32)
header = header._replace(flag=label.size, label=0)
s = label.tostring() + s
s = struct.pack(_IR_FORMAT, *header) + s
return s
|
python
|
def pack(header, s):
"""Pack a string into MXImageRecord.
Parameters
----------
header : IRHeader
Header of the image record.
``header.label`` can be a number or an array. See more detail in ``IRHeader``.
s : str
Raw image string to be packed.
Returns
-------
s : str
The packed string.
Examples
--------
>>> label = 4 # label can also be a 1-D array, for example: label = [1,2,3]
>>> id = 2574
>>> header = mx.recordio.IRHeader(0, label, id, 0)
>>> with open(path, 'r') as file:
... s = file.read()
>>> packed_s = mx.recordio.pack(header, s)
"""
header = IRHeader(*header)
if isinstance(header.label, numbers.Number):
header = header._replace(flag=0)
else:
label = np.asarray(header.label, dtype=np.float32)
header = header._replace(flag=label.size, label=0)
s = label.tostring() + s
s = struct.pack(_IR_FORMAT, *header) + s
return s
|
[
"def",
"pack",
"(",
"header",
",",
"s",
")",
":",
"header",
"=",
"IRHeader",
"(",
"*",
"header",
")",
"if",
"isinstance",
"(",
"header",
".",
"label",
",",
"numbers",
".",
"Number",
")",
":",
"header",
"=",
"header",
".",
"_replace",
"(",
"flag",
"=",
"0",
")",
"else",
":",
"label",
"=",
"np",
".",
"asarray",
"(",
"header",
".",
"label",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
"header",
"=",
"header",
".",
"_replace",
"(",
"flag",
"=",
"label",
".",
"size",
",",
"label",
"=",
"0",
")",
"s",
"=",
"label",
".",
"tostring",
"(",
")",
"+",
"s",
"s",
"=",
"struct",
".",
"pack",
"(",
"_IR_FORMAT",
",",
"*",
"header",
")",
"+",
"s",
"return",
"s"
] |
Pack a string into MXImageRecord.
Parameters
----------
header : IRHeader
Header of the image record.
``header.label`` can be a number or an array. See more detail in ``IRHeader``.
s : str
Raw image string to be packed.
Returns
-------
s : str
The packed string.
Examples
--------
>>> label = 4 # label can also be a 1-D array, for example: label = [1,2,3]
>>> id = 2574
>>> header = mx.recordio.IRHeader(0, label, id, 0)
>>> with open(path, 'r') as file:
... s = file.read()
>>> packed_s = mx.recordio.pack(header, s)
|
[
"Pack",
"a",
"string",
"into",
"MXImageRecord",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L358-L391
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
unpack
|
def unpack(s):
"""Unpack a MXImageRecord to string.
Parameters
----------
s : str
String buffer from ``MXRecordIO.read``.
Returns
-------
header : IRHeader
Header of the image record.
s : str
Unpacked string.
Examples
--------
>>> record = mx.recordio.MXRecordIO('test.rec', 'r')
>>> item = record.read()
>>> header, s = mx.recordio.unpack(item)
>>> header
HEADER(flag=0, label=14.0, id=20129312, id2=0)
"""
header = IRHeader(*struct.unpack(_IR_FORMAT, s[:_IR_SIZE]))
s = s[_IR_SIZE:]
if header.flag > 0:
header = header._replace(label=np.frombuffer(s, np.float32, header.flag))
s = s[header.flag*4:]
return header, s
|
python
|
def unpack(s):
"""Unpack a MXImageRecord to string.
Parameters
----------
s : str
String buffer from ``MXRecordIO.read``.
Returns
-------
header : IRHeader
Header of the image record.
s : str
Unpacked string.
Examples
--------
>>> record = mx.recordio.MXRecordIO('test.rec', 'r')
>>> item = record.read()
>>> header, s = mx.recordio.unpack(item)
>>> header
HEADER(flag=0, label=14.0, id=20129312, id2=0)
"""
header = IRHeader(*struct.unpack(_IR_FORMAT, s[:_IR_SIZE]))
s = s[_IR_SIZE:]
if header.flag > 0:
header = header._replace(label=np.frombuffer(s, np.float32, header.flag))
s = s[header.flag*4:]
return header, s
|
[
"def",
"unpack",
"(",
"s",
")",
":",
"header",
"=",
"IRHeader",
"(",
"*",
"struct",
".",
"unpack",
"(",
"_IR_FORMAT",
",",
"s",
"[",
":",
"_IR_SIZE",
"]",
")",
")",
"s",
"=",
"s",
"[",
"_IR_SIZE",
":",
"]",
"if",
"header",
".",
"flag",
">",
"0",
":",
"header",
"=",
"header",
".",
"_replace",
"(",
"label",
"=",
"np",
".",
"frombuffer",
"(",
"s",
",",
"np",
".",
"float32",
",",
"header",
".",
"flag",
")",
")",
"s",
"=",
"s",
"[",
"header",
".",
"flag",
"*",
"4",
":",
"]",
"return",
"header",
",",
"s"
] |
Unpack a MXImageRecord to string.
Parameters
----------
s : str
String buffer from ``MXRecordIO.read``.
Returns
-------
header : IRHeader
Header of the image record.
s : str
Unpacked string.
Examples
--------
>>> record = mx.recordio.MXRecordIO('test.rec', 'r')
>>> item = record.read()
>>> header, s = mx.recordio.unpack(item)
>>> header
HEADER(flag=0, label=14.0, id=20129312, id2=0)
|
[
"Unpack",
"a",
"MXImageRecord",
"to",
"string",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L393-L421
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
unpack_img
|
def unpack_img(s, iscolor=-1):
"""Unpack a MXImageRecord to image.
Parameters
----------
s : str
String buffer from ``MXRecordIO.read``.
iscolor : int
Image format option for ``cv2.imdecode``.
Returns
-------
header : IRHeader
Header of the image record.
img : numpy.ndarray
Unpacked image.
Examples
--------
>>> record = mx.recordio.MXRecordIO('test.rec', 'r')
>>> item = record.read()
>>> header, img = mx.recordio.unpack_img(item)
>>> header
HEADER(flag=0, label=14.0, id=20129312, id2=0)
>>> img
array([[[ 23, 27, 45],
[ 28, 32, 50],
...,
[ 36, 40, 59],
[ 35, 39, 58]],
...,
[[ 91, 92, 113],
[ 97, 98, 119],
...,
[168, 169, 167],
[166, 167, 165]]], dtype=uint8)
"""
header, s = unpack(s)
img = np.frombuffer(s, dtype=np.uint8)
assert cv2 is not None
img = cv2.imdecode(img, iscolor)
return header, img
|
python
|
def unpack_img(s, iscolor=-1):
"""Unpack a MXImageRecord to image.
Parameters
----------
s : str
String buffer from ``MXRecordIO.read``.
iscolor : int
Image format option for ``cv2.imdecode``.
Returns
-------
header : IRHeader
Header of the image record.
img : numpy.ndarray
Unpacked image.
Examples
--------
>>> record = mx.recordio.MXRecordIO('test.rec', 'r')
>>> item = record.read()
>>> header, img = mx.recordio.unpack_img(item)
>>> header
HEADER(flag=0, label=14.0, id=20129312, id2=0)
>>> img
array([[[ 23, 27, 45],
[ 28, 32, 50],
...,
[ 36, 40, 59],
[ 35, 39, 58]],
...,
[[ 91, 92, 113],
[ 97, 98, 119],
...,
[168, 169, 167],
[166, 167, 165]]], dtype=uint8)
"""
header, s = unpack(s)
img = np.frombuffer(s, dtype=np.uint8)
assert cv2 is not None
img = cv2.imdecode(img, iscolor)
return header, img
|
[
"def",
"unpack_img",
"(",
"s",
",",
"iscolor",
"=",
"-",
"1",
")",
":",
"header",
",",
"s",
"=",
"unpack",
"(",
"s",
")",
"img",
"=",
"np",
".",
"frombuffer",
"(",
"s",
",",
"dtype",
"=",
"np",
".",
"uint8",
")",
"assert",
"cv2",
"is",
"not",
"None",
"img",
"=",
"cv2",
".",
"imdecode",
"(",
"img",
",",
"iscolor",
")",
"return",
"header",
",",
"img"
] |
Unpack a MXImageRecord to image.
Parameters
----------
s : str
String buffer from ``MXRecordIO.read``.
iscolor : int
Image format option for ``cv2.imdecode``.
Returns
-------
header : IRHeader
Header of the image record.
img : numpy.ndarray
Unpacked image.
Examples
--------
>>> record = mx.recordio.MXRecordIO('test.rec', 'r')
>>> item = record.read()
>>> header, img = mx.recordio.unpack_img(item)
>>> header
HEADER(flag=0, label=14.0, id=20129312, id2=0)
>>> img
array([[[ 23, 27, 45],
[ 28, 32, 50],
...,
[ 36, 40, 59],
[ 35, 39, 58]],
...,
[[ 91, 92, 113],
[ 97, 98, 119],
...,
[168, 169, 167],
[166, 167, 165]]], dtype=uint8)
|
[
"Unpack",
"a",
"MXImageRecord",
"to",
"image",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L423-L464
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
pack_img
|
def pack_img(header, img, quality=95, img_fmt='.jpg'):
"""Pack an image into ``MXImageRecord``.
Parameters
----------
header : IRHeader
Header of the image record.
``header.label`` can be a number or an array. See more detail in ``IRHeader``.
img : numpy.ndarray
Image to be packed.
quality : int
Quality for JPEG encoding in range 1-100, or compression for PNG encoding in range 1-9.
img_fmt : str
Encoding of the image (.jpg for JPEG, .png for PNG).
Returns
-------
s : str
The packed string.
Examples
--------
>>> label = 4 # label can also be a 1-D array, for example: label = [1,2,3]
>>> id = 2574
>>> header = mx.recordio.IRHeader(0, label, id, 0)
>>> img = cv2.imread('test.jpg')
>>> packed_s = mx.recordio.pack_img(header, img)
"""
assert cv2 is not None
jpg_formats = ['.JPG', '.JPEG']
png_formats = ['.PNG']
encode_params = None
if img_fmt.upper() in jpg_formats:
encode_params = [cv2.IMWRITE_JPEG_QUALITY, quality]
elif img_fmt.upper() in png_formats:
encode_params = [cv2.IMWRITE_PNG_COMPRESSION, quality]
ret, buf = cv2.imencode(img_fmt, img, encode_params)
assert ret, 'failed to encode image'
return pack(header, buf.tostring())
|
python
|
def pack_img(header, img, quality=95, img_fmt='.jpg'):
"""Pack an image into ``MXImageRecord``.
Parameters
----------
header : IRHeader
Header of the image record.
``header.label`` can be a number or an array. See more detail in ``IRHeader``.
img : numpy.ndarray
Image to be packed.
quality : int
Quality for JPEG encoding in range 1-100, or compression for PNG encoding in range 1-9.
img_fmt : str
Encoding of the image (.jpg for JPEG, .png for PNG).
Returns
-------
s : str
The packed string.
Examples
--------
>>> label = 4 # label can also be a 1-D array, for example: label = [1,2,3]
>>> id = 2574
>>> header = mx.recordio.IRHeader(0, label, id, 0)
>>> img = cv2.imread('test.jpg')
>>> packed_s = mx.recordio.pack_img(header, img)
"""
assert cv2 is not None
jpg_formats = ['.JPG', '.JPEG']
png_formats = ['.PNG']
encode_params = None
if img_fmt.upper() in jpg_formats:
encode_params = [cv2.IMWRITE_JPEG_QUALITY, quality]
elif img_fmt.upper() in png_formats:
encode_params = [cv2.IMWRITE_PNG_COMPRESSION, quality]
ret, buf = cv2.imencode(img_fmt, img, encode_params)
assert ret, 'failed to encode image'
return pack(header, buf.tostring())
|
[
"def",
"pack_img",
"(",
"header",
",",
"img",
",",
"quality",
"=",
"95",
",",
"img_fmt",
"=",
"'.jpg'",
")",
":",
"assert",
"cv2",
"is",
"not",
"None",
"jpg_formats",
"=",
"[",
"'.JPG'",
",",
"'.JPEG'",
"]",
"png_formats",
"=",
"[",
"'.PNG'",
"]",
"encode_params",
"=",
"None",
"if",
"img_fmt",
".",
"upper",
"(",
")",
"in",
"jpg_formats",
":",
"encode_params",
"=",
"[",
"cv2",
".",
"IMWRITE_JPEG_QUALITY",
",",
"quality",
"]",
"elif",
"img_fmt",
".",
"upper",
"(",
")",
"in",
"png_formats",
":",
"encode_params",
"=",
"[",
"cv2",
".",
"IMWRITE_PNG_COMPRESSION",
",",
"quality",
"]",
"ret",
",",
"buf",
"=",
"cv2",
".",
"imencode",
"(",
"img_fmt",
",",
"img",
",",
"encode_params",
")",
"assert",
"ret",
",",
"'failed to encode image'",
"return",
"pack",
"(",
"header",
",",
"buf",
".",
"tostring",
"(",
")",
")"
] |
Pack an image into ``MXImageRecord``.
Parameters
----------
header : IRHeader
Header of the image record.
``header.label`` can be a number or an array. See more detail in ``IRHeader``.
img : numpy.ndarray
Image to be packed.
quality : int
Quality for JPEG encoding in range 1-100, or compression for PNG encoding in range 1-9.
img_fmt : str
Encoding of the image (.jpg for JPEG, .png for PNG).
Returns
-------
s : str
The packed string.
Examples
--------
>>> label = 4 # label can also be a 1-D array, for example: label = [1,2,3]
>>> id = 2574
>>> header = mx.recordio.IRHeader(0, label, id, 0)
>>> img = cv2.imread('test.jpg')
>>> packed_s = mx.recordio.pack_img(header, img)
|
[
"Pack",
"an",
"image",
"into",
"MXImageRecord",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L466-L505
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXRecordIO.open
|
def open(self):
"""Opens the record file."""
if self.flag == "w":
check_call(_LIB.MXRecordIOWriterCreate(self.uri, ctypes.byref(self.handle)))
self.writable = True
elif self.flag == "r":
check_call(_LIB.MXRecordIOReaderCreate(self.uri, ctypes.byref(self.handle)))
self.writable = False
else:
raise ValueError("Invalid flag %s"%self.flag)
self.pid = current_process().pid
self.is_open = True
|
python
|
def open(self):
"""Opens the record file."""
if self.flag == "w":
check_call(_LIB.MXRecordIOWriterCreate(self.uri, ctypes.byref(self.handle)))
self.writable = True
elif self.flag == "r":
check_call(_LIB.MXRecordIOReaderCreate(self.uri, ctypes.byref(self.handle)))
self.writable = False
else:
raise ValueError("Invalid flag %s"%self.flag)
self.pid = current_process().pid
self.is_open = True
|
[
"def",
"open",
"(",
"self",
")",
":",
"if",
"self",
".",
"flag",
"==",
"\"w\"",
":",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOWriterCreate",
"(",
"self",
".",
"uri",
",",
"ctypes",
".",
"byref",
"(",
"self",
".",
"handle",
")",
")",
")",
"self",
".",
"writable",
"=",
"True",
"elif",
"self",
".",
"flag",
"==",
"\"r\"",
":",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOReaderCreate",
"(",
"self",
".",
"uri",
",",
"ctypes",
".",
"byref",
"(",
"self",
".",
"handle",
")",
")",
")",
"self",
".",
"writable",
"=",
"False",
"else",
":",
"raise",
"ValueError",
"(",
"\"Invalid flag %s\"",
"%",
"self",
".",
"flag",
")",
"self",
".",
"pid",
"=",
"current_process",
"(",
")",
".",
"pid",
"self",
".",
"is_open",
"=",
"True"
] |
Opens the record file.
|
[
"Opens",
"the",
"record",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L73-L84
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXRecordIO._check_pid
|
def _check_pid(self, allow_reset=False):
"""Check process id to ensure integrity, reset if in new process."""
if not self.pid == current_process().pid:
if allow_reset:
self.reset()
else:
raise RuntimeError("Forbidden operation in multiple processes")
|
python
|
def _check_pid(self, allow_reset=False):
"""Check process id to ensure integrity, reset if in new process."""
if not self.pid == current_process().pid:
if allow_reset:
self.reset()
else:
raise RuntimeError("Forbidden operation in multiple processes")
|
[
"def",
"_check_pid",
"(",
"self",
",",
"allow_reset",
"=",
"False",
")",
":",
"if",
"not",
"self",
".",
"pid",
"==",
"current_process",
"(",
")",
".",
"pid",
":",
"if",
"allow_reset",
":",
"self",
".",
"reset",
"(",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"\"Forbidden operation in multiple processes\"",
")"
] |
Check process id to ensure integrity, reset if in new process.
|
[
"Check",
"process",
"id",
"to",
"ensure",
"integrity",
"reset",
"if",
"in",
"new",
"process",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L115-L121
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXRecordIO.close
|
def close(self):
"""Closes the record file."""
if not self.is_open:
return
if self.writable:
check_call(_LIB.MXRecordIOWriterFree(self.handle))
else:
check_call(_LIB.MXRecordIOReaderFree(self.handle))
self.is_open = False
self.pid = None
|
python
|
def close(self):
"""Closes the record file."""
if not self.is_open:
return
if self.writable:
check_call(_LIB.MXRecordIOWriterFree(self.handle))
else:
check_call(_LIB.MXRecordIOReaderFree(self.handle))
self.is_open = False
self.pid = None
|
[
"def",
"close",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"is_open",
":",
"return",
"if",
"self",
".",
"writable",
":",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOWriterFree",
"(",
"self",
".",
"handle",
")",
")",
"else",
":",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOReaderFree",
"(",
"self",
".",
"handle",
")",
")",
"self",
".",
"is_open",
"=",
"False",
"self",
".",
"pid",
"=",
"None"
] |
Closes the record file.
|
[
"Closes",
"the",
"record",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L123-L132
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXRecordIO.write
|
def write(self, buf):
"""Inserts a string buffer as a record.
Examples
---------
>>> record = mx.recordio.MXRecordIO('tmp.rec', 'w')
>>> for i in range(5):
... record.write('record_%d'%i)
>>> record.close()
Parameters
----------
buf : string (python2), bytes (python3)
Buffer to write.
"""
assert self.writable
self._check_pid(allow_reset=False)
check_call(_LIB.MXRecordIOWriterWriteRecord(self.handle,
ctypes.c_char_p(buf),
ctypes.c_size_t(len(buf))))
|
python
|
def write(self, buf):
"""Inserts a string buffer as a record.
Examples
---------
>>> record = mx.recordio.MXRecordIO('tmp.rec', 'w')
>>> for i in range(5):
... record.write('record_%d'%i)
>>> record.close()
Parameters
----------
buf : string (python2), bytes (python3)
Buffer to write.
"""
assert self.writable
self._check_pid(allow_reset=False)
check_call(_LIB.MXRecordIOWriterWriteRecord(self.handle,
ctypes.c_char_p(buf),
ctypes.c_size_t(len(buf))))
|
[
"def",
"write",
"(",
"self",
",",
"buf",
")",
":",
"assert",
"self",
".",
"writable",
"self",
".",
"_check_pid",
"(",
"allow_reset",
"=",
"False",
")",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOWriterWriteRecord",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"c_char_p",
"(",
"buf",
")",
",",
"ctypes",
".",
"c_size_t",
"(",
"len",
"(",
"buf",
")",
")",
")",
")"
] |
Inserts a string buffer as a record.
Examples
---------
>>> record = mx.recordio.MXRecordIO('tmp.rec', 'w')
>>> for i in range(5):
... record.write('record_%d'%i)
>>> record.close()
Parameters
----------
buf : string (python2), bytes (python3)
Buffer to write.
|
[
"Inserts",
"a",
"string",
"buffer",
"as",
"a",
"record",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L155-L174
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXRecordIO.read
|
def read(self):
"""Returns record as a string.
Examples
---------
>>> record = mx.recordio.MXRecordIO('tmp.rec', 'r')
>>> for i in range(5):
... item = record.read()
... print(item)
record_0
record_1
record_2
record_3
record_4
>>> record.close()
Returns
----------
buf : string
Buffer read.
"""
assert not self.writable
# trying to implicitly read from multiple processes is forbidden,
# there's no elegant way to handle unless lock is introduced
self._check_pid(allow_reset=False)
buf = ctypes.c_char_p()
size = ctypes.c_size_t()
check_call(_LIB.MXRecordIOReaderReadRecord(self.handle,
ctypes.byref(buf),
ctypes.byref(size)))
if buf:
buf = ctypes.cast(buf, ctypes.POINTER(ctypes.c_char*size.value))
return buf.contents.raw
else:
return None
|
python
|
def read(self):
"""Returns record as a string.
Examples
---------
>>> record = mx.recordio.MXRecordIO('tmp.rec', 'r')
>>> for i in range(5):
... item = record.read()
... print(item)
record_0
record_1
record_2
record_3
record_4
>>> record.close()
Returns
----------
buf : string
Buffer read.
"""
assert not self.writable
# trying to implicitly read from multiple processes is forbidden,
# there's no elegant way to handle unless lock is introduced
self._check_pid(allow_reset=False)
buf = ctypes.c_char_p()
size = ctypes.c_size_t()
check_call(_LIB.MXRecordIOReaderReadRecord(self.handle,
ctypes.byref(buf),
ctypes.byref(size)))
if buf:
buf = ctypes.cast(buf, ctypes.POINTER(ctypes.c_char*size.value))
return buf.contents.raw
else:
return None
|
[
"def",
"read",
"(",
"self",
")",
":",
"assert",
"not",
"self",
".",
"writable",
"# trying to implicitly read from multiple processes is forbidden,",
"# there's no elegant way to handle unless lock is introduced",
"self",
".",
"_check_pid",
"(",
"allow_reset",
"=",
"False",
")",
"buf",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"size",
"=",
"ctypes",
".",
"c_size_t",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOReaderReadRecord",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"buf",
")",
",",
"ctypes",
".",
"byref",
"(",
"size",
")",
")",
")",
"if",
"buf",
":",
"buf",
"=",
"ctypes",
".",
"cast",
"(",
"buf",
",",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char",
"*",
"size",
".",
"value",
")",
")",
"return",
"buf",
".",
"contents",
".",
"raw",
"else",
":",
"return",
"None"
] |
Returns record as a string.
Examples
---------
>>> record = mx.recordio.MXRecordIO('tmp.rec', 'r')
>>> for i in range(5):
... item = record.read()
... print(item)
record_0
record_1
record_2
record_3
record_4
>>> record.close()
Returns
----------
buf : string
Buffer read.
|
[
"Returns",
"record",
"as",
"a",
"string",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L176-L210
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXIndexedRecordIO.close
|
def close(self):
"""Closes the record file."""
if not self.is_open:
return
super(MXIndexedRecordIO, self).close()
self.fidx.close()
|
python
|
def close(self):
"""Closes the record file."""
if not self.is_open:
return
super(MXIndexedRecordIO, self).close()
self.fidx.close()
|
[
"def",
"close",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"is_open",
":",
"return",
"super",
"(",
"MXIndexedRecordIO",
",",
"self",
")",
".",
"close",
"(",
")",
"self",
".",
"fidx",
".",
"close",
"(",
")"
] |
Closes the record file.
|
[
"Closes",
"the",
"record",
"file",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L255-L260
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXIndexedRecordIO.seek
|
def seek(self, idx):
"""Sets the current read pointer position.
This function is internally called by `read_idx(idx)` to find the current
reader pointer position. It doesn't return anything."""
assert not self.writable
self._check_pid(allow_reset=True)
pos = ctypes.c_size_t(self.idx[idx])
check_call(_LIB.MXRecordIOReaderSeek(self.handle, pos))
|
python
|
def seek(self, idx):
"""Sets the current read pointer position.
This function is internally called by `read_idx(idx)` to find the current
reader pointer position. It doesn't return anything."""
assert not self.writable
self._check_pid(allow_reset=True)
pos = ctypes.c_size_t(self.idx[idx])
check_call(_LIB.MXRecordIOReaderSeek(self.handle, pos))
|
[
"def",
"seek",
"(",
"self",
",",
"idx",
")",
":",
"assert",
"not",
"self",
".",
"writable",
"self",
".",
"_check_pid",
"(",
"allow_reset",
"=",
"True",
")",
"pos",
"=",
"ctypes",
".",
"c_size_t",
"(",
"self",
".",
"idx",
"[",
"idx",
"]",
")",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOReaderSeek",
"(",
"self",
".",
"handle",
",",
"pos",
")",
")"
] |
Sets the current read pointer position.
This function is internally called by `read_idx(idx)` to find the current
reader pointer position. It doesn't return anything.
|
[
"Sets",
"the",
"current",
"read",
"pointer",
"position",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L268-L276
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXIndexedRecordIO.tell
|
def tell(self):
"""Returns the current position of write head.
Examples
---------
>>> record = mx.recordio.MXIndexedRecordIO('tmp.idx', 'tmp.rec', 'w')
>>> print(record.tell())
0
>>> for i in range(5):
... record.write_idx(i, 'record_%d'%i)
... print(record.tell())
16
32
48
64
80
"""
assert self.writable
pos = ctypes.c_size_t()
check_call(_LIB.MXRecordIOWriterTell(self.handle, ctypes.byref(pos)))
return pos.value
|
python
|
def tell(self):
"""Returns the current position of write head.
Examples
---------
>>> record = mx.recordio.MXIndexedRecordIO('tmp.idx', 'tmp.rec', 'w')
>>> print(record.tell())
0
>>> for i in range(5):
... record.write_idx(i, 'record_%d'%i)
... print(record.tell())
16
32
48
64
80
"""
assert self.writable
pos = ctypes.c_size_t()
check_call(_LIB.MXRecordIOWriterTell(self.handle, ctypes.byref(pos)))
return pos.value
|
[
"def",
"tell",
"(",
"self",
")",
":",
"assert",
"self",
".",
"writable",
"pos",
"=",
"ctypes",
".",
"c_size_t",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXRecordIOWriterTell",
"(",
"self",
".",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"pos",
")",
")",
")",
"return",
"pos",
".",
"value"
] |
Returns the current position of write head.
Examples
---------
>>> record = mx.recordio.MXIndexedRecordIO('tmp.idx', 'tmp.rec', 'w')
>>> print(record.tell())
0
>>> for i in range(5):
... record.write_idx(i, 'record_%d'%i)
... print(record.tell())
16
32
48
64
80
|
[
"Returns",
"the",
"current",
"position",
"of",
"write",
"head",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L278-L298
|
train
|
apache/incubator-mxnet
|
python/mxnet/recordio.py
|
MXIndexedRecordIO.write_idx
|
def write_idx(self, idx, buf):
"""Inserts input record at given index.
Examples
---------
>>> for i in range(5):
... record.write_idx(i, 'record_%d'%i)
>>> record.close()
Parameters
----------
idx : int
Index of a file.
buf :
Record to write.
"""
key = self.key_type(idx)
pos = self.tell()
self.write(buf)
self.fidx.write('%s\t%d\n'%(str(key), pos))
self.idx[key] = pos
self.keys.append(key)
|
python
|
def write_idx(self, idx, buf):
"""Inserts input record at given index.
Examples
---------
>>> for i in range(5):
... record.write_idx(i, 'record_%d'%i)
>>> record.close()
Parameters
----------
idx : int
Index of a file.
buf :
Record to write.
"""
key = self.key_type(idx)
pos = self.tell()
self.write(buf)
self.fidx.write('%s\t%d\n'%(str(key), pos))
self.idx[key] = pos
self.keys.append(key)
|
[
"def",
"write_idx",
"(",
"self",
",",
"idx",
",",
"buf",
")",
":",
"key",
"=",
"self",
".",
"key_type",
"(",
"idx",
")",
"pos",
"=",
"self",
".",
"tell",
"(",
")",
"self",
".",
"write",
"(",
"buf",
")",
"self",
".",
"fidx",
".",
"write",
"(",
"'%s\\t%d\\n'",
"%",
"(",
"str",
"(",
"key",
")",
",",
"pos",
")",
")",
"self",
".",
"idx",
"[",
"key",
"]",
"=",
"pos",
"self",
".",
"keys",
".",
"append",
"(",
"key",
")"
] |
Inserts input record at given index.
Examples
---------
>>> for i in range(5):
... record.write_idx(i, 'record_%d'%i)
>>> record.close()
Parameters
----------
idx : int
Index of a file.
buf :
Record to write.
|
[
"Inserts",
"input",
"record",
"at",
"given",
"index",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/recordio.py#L316-L337
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
_add_new_columns
|
def _add_new_columns(dataframe, metrics):
"""Add new metrics as new columns to selected pandas dataframe.
Parameters
----------
dataframe : pandas.DataFrame
Selected dataframe needs to be modified.
metrics : metric.EvalMetric
New metrics to be added.
"""
#TODO(leodirac): we don't really need to do this on every update. Optimize
new_columns = set(metrics.keys()) - set(dataframe.columns)
for col in new_columns:
dataframe[col] = None
|
python
|
def _add_new_columns(dataframe, metrics):
"""Add new metrics as new columns to selected pandas dataframe.
Parameters
----------
dataframe : pandas.DataFrame
Selected dataframe needs to be modified.
metrics : metric.EvalMetric
New metrics to be added.
"""
#TODO(leodirac): we don't really need to do this on every update. Optimize
new_columns = set(metrics.keys()) - set(dataframe.columns)
for col in new_columns:
dataframe[col] = None
|
[
"def",
"_add_new_columns",
"(",
"dataframe",
",",
"metrics",
")",
":",
"#TODO(leodirac): we don't really need to do this on every update. Optimize",
"new_columns",
"=",
"set",
"(",
"metrics",
".",
"keys",
"(",
")",
")",
"-",
"set",
"(",
"dataframe",
".",
"columns",
")",
"for",
"col",
"in",
"new_columns",
":",
"dataframe",
"[",
"col",
"]",
"=",
"None"
] |
Add new metrics as new columns to selected pandas dataframe.
Parameters
----------
dataframe : pandas.DataFrame
Selected dataframe needs to be modified.
metrics : metric.EvalMetric
New metrics to be added.
|
[
"Add",
"new",
"metrics",
"as",
"new",
"columns",
"to",
"selected",
"pandas",
"dataframe",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L49-L62
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
args_wrapper
|
def args_wrapper(*args):
"""Generates callback arguments for model.fit()
for a set of callback objects.
Callback objects like PandasLogger(), LiveLearningCurve()
get passed in. This assembles all their callback arguments.
"""
out = defaultdict(list)
for callback in args:
callback_args = callback.callback_args()
for k, v in callback_args.items():
out[k].append(v)
return dict(out)
|
python
|
def args_wrapper(*args):
"""Generates callback arguments for model.fit()
for a set of callback objects.
Callback objects like PandasLogger(), LiveLearningCurve()
get passed in. This assembles all their callback arguments.
"""
out = defaultdict(list)
for callback in args:
callback_args = callback.callback_args()
for k, v in callback_args.items():
out[k].append(v)
return dict(out)
|
[
"def",
"args_wrapper",
"(",
"*",
"args",
")",
":",
"out",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"callback",
"in",
"args",
":",
"callback_args",
"=",
"callback",
".",
"callback_args",
"(",
")",
"for",
"k",
",",
"v",
"in",
"callback_args",
".",
"items",
"(",
")",
":",
"out",
"[",
"k",
"]",
".",
"append",
"(",
"v",
")",
"return",
"dict",
"(",
"out",
")"
] |
Generates callback arguments for model.fit()
for a set of callback objects.
Callback objects like PandasLogger(), LiveLearningCurve()
get passed in. This assembles all their callback arguments.
|
[
"Generates",
"callback",
"arguments",
"for",
"model",
".",
"fit",
"()",
"for",
"a",
"set",
"of",
"callback",
"objects",
".",
"Callback",
"objects",
"like",
"PandasLogger",
"()",
"LiveLearningCurve",
"()",
"get",
"passed",
"in",
".",
"This",
"assembles",
"all",
"their",
"callback",
"arguments",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L392-L403
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
PandasLogger.append_metrics
|
def append_metrics(self, metrics, df_name):
"""Append new metrics to selected dataframes.
Parameters
----------
metrics : metric.EvalMetric
New metrics to be added.
df_name : str
Name of the dataframe to be modified.
"""
dataframe = self._dataframes[df_name]
_add_new_columns(dataframe, metrics)
dataframe.loc[len(dataframe)] = metrics
|
python
|
def append_metrics(self, metrics, df_name):
"""Append new metrics to selected dataframes.
Parameters
----------
metrics : metric.EvalMetric
New metrics to be added.
df_name : str
Name of the dataframe to be modified.
"""
dataframe = self._dataframes[df_name]
_add_new_columns(dataframe, metrics)
dataframe.loc[len(dataframe)] = metrics
|
[
"def",
"append_metrics",
"(",
"self",
",",
"metrics",
",",
"df_name",
")",
":",
"dataframe",
"=",
"self",
".",
"_dataframes",
"[",
"df_name",
"]",
"_add_new_columns",
"(",
"dataframe",
",",
"metrics",
")",
"dataframe",
".",
"loc",
"[",
"len",
"(",
"dataframe",
")",
"]",
"=",
"metrics"
] |
Append new metrics to selected dataframes.
Parameters
----------
metrics : metric.EvalMetric
New metrics to be added.
df_name : str
Name of the dataframe to be modified.
|
[
"Append",
"new",
"metrics",
"to",
"selected",
"dataframes",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L130-L142
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
PandasLogger.train_cb
|
def train_cb(self, param):
"""Callback funtion for training.
"""
if param.nbatch % self.frequent == 0:
self._process_batch(param, 'train')
|
python
|
def train_cb(self, param):
"""Callback funtion for training.
"""
if param.nbatch % self.frequent == 0:
self._process_batch(param, 'train')
|
[
"def",
"train_cb",
"(",
"self",
",",
"param",
")",
":",
"if",
"param",
".",
"nbatch",
"%",
"self",
".",
"frequent",
"==",
"0",
":",
"self",
".",
"_process_batch",
"(",
"param",
",",
"'train'",
")"
] |
Callback funtion for training.
|
[
"Callback",
"funtion",
"for",
"training",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L144-L148
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
PandasLogger._process_batch
|
def _process_batch(self, param, dataframe):
"""Update parameters for selected dataframe after a completed batch
Parameters
----------
dataframe : pandas.DataFrame
Selected dataframe needs to be modified.
"""
now = time.time()
if param.eval_metric is not None:
metrics = dict(param.eval_metric.get_name_value())
param.eval_metric.reset()
else:
metrics = {}
# #11504
try:
speed = self.frequent / (now - self.last_time)
except ZeroDivisionError:
speed = float('inf')
metrics['batches_per_sec'] = speed * self.batch_size
metrics['records_per_sec'] = speed
metrics['elapsed'] = self.elapsed()
metrics['minibatch_count'] = param.nbatch
metrics['epoch'] = param.epoch
self.append_metrics(metrics, dataframe)
self.last_time = now
|
python
|
def _process_batch(self, param, dataframe):
"""Update parameters for selected dataframe after a completed batch
Parameters
----------
dataframe : pandas.DataFrame
Selected dataframe needs to be modified.
"""
now = time.time()
if param.eval_metric is not None:
metrics = dict(param.eval_metric.get_name_value())
param.eval_metric.reset()
else:
metrics = {}
# #11504
try:
speed = self.frequent / (now - self.last_time)
except ZeroDivisionError:
speed = float('inf')
metrics['batches_per_sec'] = speed * self.batch_size
metrics['records_per_sec'] = speed
metrics['elapsed'] = self.elapsed()
metrics['minibatch_count'] = param.nbatch
metrics['epoch'] = param.epoch
self.append_metrics(metrics, dataframe)
self.last_time = now
|
[
"def",
"_process_batch",
"(",
"self",
",",
"param",
",",
"dataframe",
")",
":",
"now",
"=",
"time",
".",
"time",
"(",
")",
"if",
"param",
".",
"eval_metric",
"is",
"not",
"None",
":",
"metrics",
"=",
"dict",
"(",
"param",
".",
"eval_metric",
".",
"get_name_value",
"(",
")",
")",
"param",
".",
"eval_metric",
".",
"reset",
"(",
")",
"else",
":",
"metrics",
"=",
"{",
"}",
"# #11504",
"try",
":",
"speed",
"=",
"self",
".",
"frequent",
"/",
"(",
"now",
"-",
"self",
".",
"last_time",
")",
"except",
"ZeroDivisionError",
":",
"speed",
"=",
"float",
"(",
"'inf'",
")",
"metrics",
"[",
"'batches_per_sec'",
"]",
"=",
"speed",
"*",
"self",
".",
"batch_size",
"metrics",
"[",
"'records_per_sec'",
"]",
"=",
"speed",
"metrics",
"[",
"'elapsed'",
"]",
"=",
"self",
".",
"elapsed",
"(",
")",
"metrics",
"[",
"'minibatch_count'",
"]",
"=",
"param",
".",
"nbatch",
"metrics",
"[",
"'epoch'",
"]",
"=",
"param",
".",
"epoch",
"self",
".",
"append_metrics",
"(",
"metrics",
",",
"dataframe",
")",
"self",
".",
"last_time",
"=",
"now"
] |
Update parameters for selected dataframe after a completed batch
Parameters
----------
dataframe : pandas.DataFrame
Selected dataframe needs to be modified.
|
[
"Update",
"parameters",
"for",
"selected",
"dataframe",
"after",
"a",
"completed",
"batch",
"Parameters",
"----------",
"dataframe",
":",
"pandas",
".",
"DataFrame",
"Selected",
"dataframe",
"needs",
"to",
"be",
"modified",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L155-L179
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
PandasLogger.epoch_cb
|
def epoch_cb(self):
"""Callback function after each epoch. Now it records each epoch time
and append it to epoch dataframe.
"""
metrics = {}
metrics['elapsed'] = self.elapsed()
now = datetime.datetime.now()
metrics['epoch_time'] = now - self.last_epoch_time
self.append_metrics(metrics, 'epoch')
self.last_epoch_time = now
|
python
|
def epoch_cb(self):
"""Callback function after each epoch. Now it records each epoch time
and append it to epoch dataframe.
"""
metrics = {}
metrics['elapsed'] = self.elapsed()
now = datetime.datetime.now()
metrics['epoch_time'] = now - self.last_epoch_time
self.append_metrics(metrics, 'epoch')
self.last_epoch_time = now
|
[
"def",
"epoch_cb",
"(",
"self",
")",
":",
"metrics",
"=",
"{",
"}",
"metrics",
"[",
"'elapsed'",
"]",
"=",
"self",
".",
"elapsed",
"(",
")",
"now",
"=",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
"metrics",
"[",
"'epoch_time'",
"]",
"=",
"now",
"-",
"self",
".",
"last_epoch_time",
"self",
".",
"append_metrics",
"(",
"metrics",
",",
"'epoch'",
")",
"self",
".",
"last_epoch_time",
"=",
"now"
] |
Callback function after each epoch. Now it records each epoch time
and append it to epoch dataframe.
|
[
"Callback",
"function",
"after",
"each",
"epoch",
".",
"Now",
"it",
"records",
"each",
"epoch",
"time",
"and",
"append",
"it",
"to",
"epoch",
"dataframe",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L181-L190
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
LiveBokehChart._push_render
|
def _push_render(self):
"""Render the plot with bokeh.io and push to notebook.
"""
bokeh.io.push_notebook(handle=self.handle)
self.last_update = time.time()
|
python
|
def _push_render(self):
"""Render the plot with bokeh.io and push to notebook.
"""
bokeh.io.push_notebook(handle=self.handle)
self.last_update = time.time()
|
[
"def",
"_push_render",
"(",
"self",
")",
":",
"bokeh",
".",
"io",
".",
"push_notebook",
"(",
"handle",
"=",
"self",
".",
"handle",
")",
"self",
".",
"last_update",
"=",
"time",
".",
"time",
"(",
")"
] |
Render the plot with bokeh.io and push to notebook.
|
[
"Render",
"the",
"plot",
"with",
"bokeh",
".",
"io",
"and",
"push",
"to",
"notebook",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L243-L247
|
train
|
apache/incubator-mxnet
|
python/mxnet/notebook/callback.py
|
LiveLearningCurve._process_batch
|
def _process_batch(self, param, df_name):
"""Update selected dataframe after a completed batch
Parameters
----------
df_name : str
Selected dataframe name needs to be modified.
"""
if param.eval_metric is not None:
metrics = dict(param.eval_metric.get_name_value())
param.eval_metric.reset()
else:
metrics = {}
metrics['elapsed'] = datetime.datetime.now() - self.start_time
for key, value in metrics.items():
if key not in self._data[df_name]:
self._data[df_name][key] = []
self._data[df_name][key].append(value)
|
python
|
def _process_batch(self, param, df_name):
"""Update selected dataframe after a completed batch
Parameters
----------
df_name : str
Selected dataframe name needs to be modified.
"""
if param.eval_metric is not None:
metrics = dict(param.eval_metric.get_name_value())
param.eval_metric.reset()
else:
metrics = {}
metrics['elapsed'] = datetime.datetime.now() - self.start_time
for key, value in metrics.items():
if key not in self._data[df_name]:
self._data[df_name][key] = []
self._data[df_name][key].append(value)
|
[
"def",
"_process_batch",
"(",
"self",
",",
"param",
",",
"df_name",
")",
":",
"if",
"param",
".",
"eval_metric",
"is",
"not",
"None",
":",
"metrics",
"=",
"dict",
"(",
"param",
".",
"eval_metric",
".",
"get_name_value",
"(",
")",
")",
"param",
".",
"eval_metric",
".",
"reset",
"(",
")",
"else",
":",
"metrics",
"=",
"{",
"}",
"metrics",
"[",
"'elapsed'",
"]",
"=",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
"-",
"self",
".",
"start_time",
"for",
"key",
",",
"value",
"in",
"metrics",
".",
"items",
"(",
")",
":",
"if",
"key",
"not",
"in",
"self",
".",
"_data",
"[",
"df_name",
"]",
":",
"self",
".",
"_data",
"[",
"df_name",
"]",
"[",
"key",
"]",
"=",
"[",
"]",
"self",
".",
"_data",
"[",
"df_name",
"]",
"[",
"key",
"]",
".",
"append",
"(",
"value",
")"
] |
Update selected dataframe after a completed batch
Parameters
----------
df_name : str
Selected dataframe name needs to be modified.
|
[
"Update",
"selected",
"dataframe",
"after",
"a",
"completed",
"batch",
"Parameters",
"----------",
"df_name",
":",
"str",
"Selected",
"dataframe",
"name",
"needs",
"to",
"be",
"modified",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/notebook/callback.py#L360-L376
|
train
|
apache/incubator-mxnet
|
example/named_entity_recognition/src/ner.py
|
build_vocab
|
def build_vocab(nested_list):
"""
:param nested_list: list of list of string
:return: dictionary mapping from string to int, inverse of that dictionary
"""
# Build vocabulary
word_counts = Counter(itertools.chain(*nested_list))
# Mapping from index to label
vocabulary_inv = [x[0] for x in word_counts.most_common()]
# Mapping from label to index
vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}
return vocabulary, vocabulary_inv
|
python
|
def build_vocab(nested_list):
"""
:param nested_list: list of list of string
:return: dictionary mapping from string to int, inverse of that dictionary
"""
# Build vocabulary
word_counts = Counter(itertools.chain(*nested_list))
# Mapping from index to label
vocabulary_inv = [x[0] for x in word_counts.most_common()]
# Mapping from label to index
vocabulary = {x: i for i, x in enumerate(vocabulary_inv)}
return vocabulary, vocabulary_inv
|
[
"def",
"build_vocab",
"(",
"nested_list",
")",
":",
"# Build vocabulary",
"word_counts",
"=",
"Counter",
"(",
"itertools",
".",
"chain",
"(",
"*",
"nested_list",
")",
")",
"# Mapping from index to label",
"vocabulary_inv",
"=",
"[",
"x",
"[",
"0",
"]",
"for",
"x",
"in",
"word_counts",
".",
"most_common",
"(",
")",
"]",
"# Mapping from label to index",
"vocabulary",
"=",
"{",
"x",
":",
"i",
"for",
"i",
",",
"x",
"in",
"enumerate",
"(",
"vocabulary_inv",
")",
"}",
"return",
"vocabulary",
",",
"vocabulary_inv"
] |
:param nested_list: list of list of string
:return: dictionary mapping from string to int, inverse of that dictionary
|
[
":",
"param",
"nested_list",
":",
"list",
"of",
"list",
"of",
"string",
":",
"return",
":",
"dictionary",
"mapping",
"from",
"string",
"to",
"int",
"inverse",
"of",
"that",
"dictionary"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/named_entity_recognition/src/ner.py#L89-L102
|
train
|
apache/incubator-mxnet
|
example/named_entity_recognition/src/ner.py
|
build_iters
|
def build_iters(data_dir, max_records, train_fraction, batch_size, buckets=None):
"""
Reads a csv of sentences/tag sequences into a pandas dataframe.
Converts into X = array(list(int)) & Y = array(list(int))
Splits into training and test sets
Builds dictionaries mapping from index labels to labels/ indexed features to features
:param data_dir: directory to read in csv data from
:param max_records: total number of records to randomly select from input data
:param train_fraction: fraction of the data to use for training
:param batch_size: records in mini-batches during training
:param buckets: size of each bucket in the iterators
:return: train_iter, val_iter, word_to_index, index_to_word, pos_to_index, index_to_pos
"""
# Read in data as numpy array
df = pd.read_pickle(os.path.join(data_dir, "ner_data.pkl"))[:max_records]
# Get feature lists
entities=[list(array) for array in df["BILOU_tag"].values]
sentences = [list(array) for array in df["token"].values]
chars=[[[c for c in word] for word in sentence] for sentence in sentences]
# Build vocabularies
entity_to_index, index_to_entity = build_vocab(entities)
word_to_index, index_to_word = build_vocab(sentences)
char_to_index, index_to_char = build_vocab([np.array([c for c in word]) for word in index_to_word])
save_obj(entity_to_index, os.path.join(args.data_dir, "tag_to_index"))
# Map strings to integer values
indexed_entities=[list(map(entity_to_index.get, l)) for l in entities]
indexed_tokens=[list(map(word_to_index.get, l)) for l in sentences]
indexed_chars=[[list(map(char_to_index.get, word)) for word in sentence] for sentence in chars]
# Split into training and testing data
idx=int(len(indexed_tokens)*train_fraction)
X_token_train, X_char_train, Y_train = indexed_tokens[:idx], indexed_chars[:idx], indexed_entities[:idx]
X_token_test, X_char_test, Y_test = indexed_tokens[idx:], indexed_chars[idx:], indexed_entities[idx:]
# build iterators to feed batches to network
train_iter = iterators.BucketNerIter(sentences=X_token_train, characters=X_char_train, label=Y_train,
max_token_chars=5, batch_size=batch_size, buckets=buckets)
val_iter = iterators.BucketNerIter(sentences=X_token_test, characters=X_char_test, label=Y_test,
max_token_chars=train_iter.max_token_chars, batch_size=batch_size, buckets=train_iter.buckets)
return train_iter, val_iter, word_to_index, char_to_index, entity_to_index
|
python
|
def build_iters(data_dir, max_records, train_fraction, batch_size, buckets=None):
"""
Reads a csv of sentences/tag sequences into a pandas dataframe.
Converts into X = array(list(int)) & Y = array(list(int))
Splits into training and test sets
Builds dictionaries mapping from index labels to labels/ indexed features to features
:param data_dir: directory to read in csv data from
:param max_records: total number of records to randomly select from input data
:param train_fraction: fraction of the data to use for training
:param batch_size: records in mini-batches during training
:param buckets: size of each bucket in the iterators
:return: train_iter, val_iter, word_to_index, index_to_word, pos_to_index, index_to_pos
"""
# Read in data as numpy array
df = pd.read_pickle(os.path.join(data_dir, "ner_data.pkl"))[:max_records]
# Get feature lists
entities=[list(array) for array in df["BILOU_tag"].values]
sentences = [list(array) for array in df["token"].values]
chars=[[[c for c in word] for word in sentence] for sentence in sentences]
# Build vocabularies
entity_to_index, index_to_entity = build_vocab(entities)
word_to_index, index_to_word = build_vocab(sentences)
char_to_index, index_to_char = build_vocab([np.array([c for c in word]) for word in index_to_word])
save_obj(entity_to_index, os.path.join(args.data_dir, "tag_to_index"))
# Map strings to integer values
indexed_entities=[list(map(entity_to_index.get, l)) for l in entities]
indexed_tokens=[list(map(word_to_index.get, l)) for l in sentences]
indexed_chars=[[list(map(char_to_index.get, word)) for word in sentence] for sentence in chars]
# Split into training and testing data
idx=int(len(indexed_tokens)*train_fraction)
X_token_train, X_char_train, Y_train = indexed_tokens[:idx], indexed_chars[:idx], indexed_entities[:idx]
X_token_test, X_char_test, Y_test = indexed_tokens[idx:], indexed_chars[idx:], indexed_entities[idx:]
# build iterators to feed batches to network
train_iter = iterators.BucketNerIter(sentences=X_token_train, characters=X_char_train, label=Y_train,
max_token_chars=5, batch_size=batch_size, buckets=buckets)
val_iter = iterators.BucketNerIter(sentences=X_token_test, characters=X_char_test, label=Y_test,
max_token_chars=train_iter.max_token_chars, batch_size=batch_size, buckets=train_iter.buckets)
return train_iter, val_iter, word_to_index, char_to_index, entity_to_index
|
[
"def",
"build_iters",
"(",
"data_dir",
",",
"max_records",
",",
"train_fraction",
",",
"batch_size",
",",
"buckets",
"=",
"None",
")",
":",
"# Read in data as numpy array",
"df",
"=",
"pd",
".",
"read_pickle",
"(",
"os",
".",
"path",
".",
"join",
"(",
"data_dir",
",",
"\"ner_data.pkl\"",
")",
")",
"[",
":",
"max_records",
"]",
"# Get feature lists",
"entities",
"=",
"[",
"list",
"(",
"array",
")",
"for",
"array",
"in",
"df",
"[",
"\"BILOU_tag\"",
"]",
".",
"values",
"]",
"sentences",
"=",
"[",
"list",
"(",
"array",
")",
"for",
"array",
"in",
"df",
"[",
"\"token\"",
"]",
".",
"values",
"]",
"chars",
"=",
"[",
"[",
"[",
"c",
"for",
"c",
"in",
"word",
"]",
"for",
"word",
"in",
"sentence",
"]",
"for",
"sentence",
"in",
"sentences",
"]",
"# Build vocabularies",
"entity_to_index",
",",
"index_to_entity",
"=",
"build_vocab",
"(",
"entities",
")",
"word_to_index",
",",
"index_to_word",
"=",
"build_vocab",
"(",
"sentences",
")",
"char_to_index",
",",
"index_to_char",
"=",
"build_vocab",
"(",
"[",
"np",
".",
"array",
"(",
"[",
"c",
"for",
"c",
"in",
"word",
"]",
")",
"for",
"word",
"in",
"index_to_word",
"]",
")",
"save_obj",
"(",
"entity_to_index",
",",
"os",
".",
"path",
".",
"join",
"(",
"args",
".",
"data_dir",
",",
"\"tag_to_index\"",
")",
")",
"# Map strings to integer values",
"indexed_entities",
"=",
"[",
"list",
"(",
"map",
"(",
"entity_to_index",
".",
"get",
",",
"l",
")",
")",
"for",
"l",
"in",
"entities",
"]",
"indexed_tokens",
"=",
"[",
"list",
"(",
"map",
"(",
"word_to_index",
".",
"get",
",",
"l",
")",
")",
"for",
"l",
"in",
"sentences",
"]",
"indexed_chars",
"=",
"[",
"[",
"list",
"(",
"map",
"(",
"char_to_index",
".",
"get",
",",
"word",
")",
")",
"for",
"word",
"in",
"sentence",
"]",
"for",
"sentence",
"in",
"chars",
"]",
"# Split into training and testing data",
"idx",
"=",
"int",
"(",
"len",
"(",
"indexed_tokens",
")",
"*",
"train_fraction",
")",
"X_token_train",
",",
"X_char_train",
",",
"Y_train",
"=",
"indexed_tokens",
"[",
":",
"idx",
"]",
",",
"indexed_chars",
"[",
":",
"idx",
"]",
",",
"indexed_entities",
"[",
":",
"idx",
"]",
"X_token_test",
",",
"X_char_test",
",",
"Y_test",
"=",
"indexed_tokens",
"[",
"idx",
":",
"]",
",",
"indexed_chars",
"[",
"idx",
":",
"]",
",",
"indexed_entities",
"[",
"idx",
":",
"]",
"# build iterators to feed batches to network",
"train_iter",
"=",
"iterators",
".",
"BucketNerIter",
"(",
"sentences",
"=",
"X_token_train",
",",
"characters",
"=",
"X_char_train",
",",
"label",
"=",
"Y_train",
",",
"max_token_chars",
"=",
"5",
",",
"batch_size",
"=",
"batch_size",
",",
"buckets",
"=",
"buckets",
")",
"val_iter",
"=",
"iterators",
".",
"BucketNerIter",
"(",
"sentences",
"=",
"X_token_test",
",",
"characters",
"=",
"X_char_test",
",",
"label",
"=",
"Y_test",
",",
"max_token_chars",
"=",
"train_iter",
".",
"max_token_chars",
",",
"batch_size",
"=",
"batch_size",
",",
"buckets",
"=",
"train_iter",
".",
"buckets",
")",
"return",
"train_iter",
",",
"val_iter",
",",
"word_to_index",
",",
"char_to_index",
",",
"entity_to_index"
] |
Reads a csv of sentences/tag sequences into a pandas dataframe.
Converts into X = array(list(int)) & Y = array(list(int))
Splits into training and test sets
Builds dictionaries mapping from index labels to labels/ indexed features to features
:param data_dir: directory to read in csv data from
:param max_records: total number of records to randomly select from input data
:param train_fraction: fraction of the data to use for training
:param batch_size: records in mini-batches during training
:param buckets: size of each bucket in the iterators
:return: train_iter, val_iter, word_to_index, index_to_word, pos_to_index, index_to_pos
|
[
"Reads",
"a",
"csv",
"of",
"sentences",
"/",
"tag",
"sequences",
"into",
"a",
"pandas",
"dataframe",
".",
"Converts",
"into",
"X",
"=",
"array",
"(",
"list",
"(",
"int",
"))",
"&",
"Y",
"=",
"array",
"(",
"list",
"(",
"int",
"))",
"Splits",
"into",
"training",
"and",
"test",
"sets",
"Builds",
"dictionaries",
"mapping",
"from",
"index",
"labels",
"to",
"labels",
"/",
"indexed",
"features",
"to",
"features",
":",
"param",
"data_dir",
":",
"directory",
"to",
"read",
"in",
"csv",
"data",
"from",
":",
"param",
"max_records",
":",
"total",
"number",
"of",
"records",
"to",
"randomly",
"select",
"from",
"input",
"data",
":",
"param",
"train_fraction",
":",
"fraction",
"of",
"the",
"data",
"to",
"use",
"for",
"training",
":",
"param",
"batch_size",
":",
"records",
"in",
"mini",
"-",
"batches",
"during",
"training",
":",
"param",
"buckets",
":",
"size",
"of",
"each",
"bucket",
"in",
"the",
"iterators",
":",
"return",
":",
"train_iter",
"val_iter",
"word_to_index",
"index_to_word",
"pos_to_index",
"index_to_pos"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/named_entity_recognition/src/ner.py#L104-L146
|
train
|
apache/incubator-mxnet
|
example/named_entity_recognition/src/ner.py
|
sym_gen
|
def sym_gen(seq_len):
"""
Build NN symbol depending on the length of the input sequence
"""
sentence_shape = train_iter.provide_data[0][1]
char_sentence_shape = train_iter.provide_data[1][1]
entities_shape = train_iter.provide_label[0][1]
X_sent = mx.symbol.Variable(train_iter.provide_data[0].name)
X_char_sent = mx.symbol.Variable(train_iter.provide_data[1].name)
Y = mx.sym.Variable(train_iter.provide_label[0].name)
###############################
# Character embedding component
###############################
char_embeddings = mx.sym.Embedding(data=X_char_sent, input_dim=len(char_to_index), output_dim=args.char_embed, name='char_embed')
char_embeddings = mx.sym.reshape(data=char_embeddings, shape=(0,1,seq_len,-1,args.char_embed), name='char_embed2')
char_cnn_outputs = []
for i, filter_size in enumerate(args.char_filter_list):
# Kernel that slides over entire words resulting in a 1d output
convi = mx.sym.Convolution(data=char_embeddings, kernel=(1, filter_size, args.char_embed), stride=(1, 1, 1),
num_filter=args.char_filters, name="char_conv_layer_" + str(i))
acti = mx.sym.Activation(data=convi, act_type='tanh')
pooli = mx.sym.Pooling(data=acti, pool_type='max', kernel=(1, char_sentence_shape[2] - filter_size + 1, 1),
stride=(1, 1, 1), name="char_pool_layer_" + str(i))
pooli = mx.sym.transpose(mx.sym.Reshape(pooli, shape=(0, 0, 0)), axes=(0, 2, 1), name="cchar_conv_layer_" + str(i))
char_cnn_outputs.append(pooli)
# combine features from all filters & apply dropout
cnn_char_features = mx.sym.Concat(*char_cnn_outputs, dim=2, name="cnn_char_features")
regularized_cnn_char_features = mx.sym.Dropout(data=cnn_char_features, p=args.dropout, mode='training',
name='regularized charCnn features')
##################################
# Combine char and word embeddings
##################################
word_embeddings = mx.sym.Embedding(data=X_sent, input_dim=len(word_to_index), output_dim=args.word_embed, name='word_embed')
rnn_features = mx.sym.Concat(*[word_embeddings, regularized_cnn_char_features], dim=2, name='rnn input')
##############################
# Bidirectional LSTM component
##############################
# unroll the lstm cell in time, merging outputs
bi_cell.reset()
output, states = bi_cell.unroll(length=seq_len, inputs=rnn_features, merge_outputs=True)
# Map to num entity classes
rnn_output = mx.sym.Reshape(output, shape=(-1, args.lstm_state_size * 2), name='r_output')
fc = mx.sym.FullyConnected(data=rnn_output, num_hidden=len(entity_to_index), name='fc_layer')
# reshape back to same shape as loss will be
reshaped_fc = mx.sym.transpose(mx.sym.reshape(fc, shape=(-1, seq_len, len(entity_to_index))), axes=(0, 2, 1))
sm = mx.sym.SoftmaxOutput(data=reshaped_fc, label=Y, ignore_label=-1, use_ignore=True, multi_output=True, name='softmax')
return sm, [v.name for v in train_iter.provide_data], [v.name for v in train_iter.provide_label]
|
python
|
def sym_gen(seq_len):
"""
Build NN symbol depending on the length of the input sequence
"""
sentence_shape = train_iter.provide_data[0][1]
char_sentence_shape = train_iter.provide_data[1][1]
entities_shape = train_iter.provide_label[0][1]
X_sent = mx.symbol.Variable(train_iter.provide_data[0].name)
X_char_sent = mx.symbol.Variable(train_iter.provide_data[1].name)
Y = mx.sym.Variable(train_iter.provide_label[0].name)
###############################
# Character embedding component
###############################
char_embeddings = mx.sym.Embedding(data=X_char_sent, input_dim=len(char_to_index), output_dim=args.char_embed, name='char_embed')
char_embeddings = mx.sym.reshape(data=char_embeddings, shape=(0,1,seq_len,-1,args.char_embed), name='char_embed2')
char_cnn_outputs = []
for i, filter_size in enumerate(args.char_filter_list):
# Kernel that slides over entire words resulting in a 1d output
convi = mx.sym.Convolution(data=char_embeddings, kernel=(1, filter_size, args.char_embed), stride=(1, 1, 1),
num_filter=args.char_filters, name="char_conv_layer_" + str(i))
acti = mx.sym.Activation(data=convi, act_type='tanh')
pooli = mx.sym.Pooling(data=acti, pool_type='max', kernel=(1, char_sentence_shape[2] - filter_size + 1, 1),
stride=(1, 1, 1), name="char_pool_layer_" + str(i))
pooli = mx.sym.transpose(mx.sym.Reshape(pooli, shape=(0, 0, 0)), axes=(0, 2, 1), name="cchar_conv_layer_" + str(i))
char_cnn_outputs.append(pooli)
# combine features from all filters & apply dropout
cnn_char_features = mx.sym.Concat(*char_cnn_outputs, dim=2, name="cnn_char_features")
regularized_cnn_char_features = mx.sym.Dropout(data=cnn_char_features, p=args.dropout, mode='training',
name='regularized charCnn features')
##################################
# Combine char and word embeddings
##################################
word_embeddings = mx.sym.Embedding(data=X_sent, input_dim=len(word_to_index), output_dim=args.word_embed, name='word_embed')
rnn_features = mx.sym.Concat(*[word_embeddings, regularized_cnn_char_features], dim=2, name='rnn input')
##############################
# Bidirectional LSTM component
##############################
# unroll the lstm cell in time, merging outputs
bi_cell.reset()
output, states = bi_cell.unroll(length=seq_len, inputs=rnn_features, merge_outputs=True)
# Map to num entity classes
rnn_output = mx.sym.Reshape(output, shape=(-1, args.lstm_state_size * 2), name='r_output')
fc = mx.sym.FullyConnected(data=rnn_output, num_hidden=len(entity_to_index), name='fc_layer')
# reshape back to same shape as loss will be
reshaped_fc = mx.sym.transpose(mx.sym.reshape(fc, shape=(-1, seq_len, len(entity_to_index))), axes=(0, 2, 1))
sm = mx.sym.SoftmaxOutput(data=reshaped_fc, label=Y, ignore_label=-1, use_ignore=True, multi_output=True, name='softmax')
return sm, [v.name for v in train_iter.provide_data], [v.name for v in train_iter.provide_label]
|
[
"def",
"sym_gen",
"(",
"seq_len",
")",
":",
"sentence_shape",
"=",
"train_iter",
".",
"provide_data",
"[",
"0",
"]",
"[",
"1",
"]",
"char_sentence_shape",
"=",
"train_iter",
".",
"provide_data",
"[",
"1",
"]",
"[",
"1",
"]",
"entities_shape",
"=",
"train_iter",
".",
"provide_label",
"[",
"0",
"]",
"[",
"1",
"]",
"X_sent",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"train_iter",
".",
"provide_data",
"[",
"0",
"]",
".",
"name",
")",
"X_char_sent",
"=",
"mx",
".",
"symbol",
".",
"Variable",
"(",
"train_iter",
".",
"provide_data",
"[",
"1",
"]",
".",
"name",
")",
"Y",
"=",
"mx",
".",
"sym",
".",
"Variable",
"(",
"train_iter",
".",
"provide_label",
"[",
"0",
"]",
".",
"name",
")",
"###############################",
"# Character embedding component",
"###############################",
"char_embeddings",
"=",
"mx",
".",
"sym",
".",
"Embedding",
"(",
"data",
"=",
"X_char_sent",
",",
"input_dim",
"=",
"len",
"(",
"char_to_index",
")",
",",
"output_dim",
"=",
"args",
".",
"char_embed",
",",
"name",
"=",
"'char_embed'",
")",
"char_embeddings",
"=",
"mx",
".",
"sym",
".",
"reshape",
"(",
"data",
"=",
"char_embeddings",
",",
"shape",
"=",
"(",
"0",
",",
"1",
",",
"seq_len",
",",
"-",
"1",
",",
"args",
".",
"char_embed",
")",
",",
"name",
"=",
"'char_embed2'",
")",
"char_cnn_outputs",
"=",
"[",
"]",
"for",
"i",
",",
"filter_size",
"in",
"enumerate",
"(",
"args",
".",
"char_filter_list",
")",
":",
"# Kernel that slides over entire words resulting in a 1d output",
"convi",
"=",
"mx",
".",
"sym",
".",
"Convolution",
"(",
"data",
"=",
"char_embeddings",
",",
"kernel",
"=",
"(",
"1",
",",
"filter_size",
",",
"args",
".",
"char_embed",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
",",
"1",
")",
",",
"num_filter",
"=",
"args",
".",
"char_filters",
",",
"name",
"=",
"\"char_conv_layer_\"",
"+",
"str",
"(",
"i",
")",
")",
"acti",
"=",
"mx",
".",
"sym",
".",
"Activation",
"(",
"data",
"=",
"convi",
",",
"act_type",
"=",
"'tanh'",
")",
"pooli",
"=",
"mx",
".",
"sym",
".",
"Pooling",
"(",
"data",
"=",
"acti",
",",
"pool_type",
"=",
"'max'",
",",
"kernel",
"=",
"(",
"1",
",",
"char_sentence_shape",
"[",
"2",
"]",
"-",
"filter_size",
"+",
"1",
",",
"1",
")",
",",
"stride",
"=",
"(",
"1",
",",
"1",
",",
"1",
")",
",",
"name",
"=",
"\"char_pool_layer_\"",
"+",
"str",
"(",
"i",
")",
")",
"pooli",
"=",
"mx",
".",
"sym",
".",
"transpose",
"(",
"mx",
".",
"sym",
".",
"Reshape",
"(",
"pooli",
",",
"shape",
"=",
"(",
"0",
",",
"0",
",",
"0",
")",
")",
",",
"axes",
"=",
"(",
"0",
",",
"2",
",",
"1",
")",
",",
"name",
"=",
"\"cchar_conv_layer_\"",
"+",
"str",
"(",
"i",
")",
")",
"char_cnn_outputs",
".",
"append",
"(",
"pooli",
")",
"# combine features from all filters & apply dropout",
"cnn_char_features",
"=",
"mx",
".",
"sym",
".",
"Concat",
"(",
"*",
"char_cnn_outputs",
",",
"dim",
"=",
"2",
",",
"name",
"=",
"\"cnn_char_features\"",
")",
"regularized_cnn_char_features",
"=",
"mx",
".",
"sym",
".",
"Dropout",
"(",
"data",
"=",
"cnn_char_features",
",",
"p",
"=",
"args",
".",
"dropout",
",",
"mode",
"=",
"'training'",
",",
"name",
"=",
"'regularized charCnn features'",
")",
"##################################",
"# Combine char and word embeddings",
"##################################",
"word_embeddings",
"=",
"mx",
".",
"sym",
".",
"Embedding",
"(",
"data",
"=",
"X_sent",
",",
"input_dim",
"=",
"len",
"(",
"word_to_index",
")",
",",
"output_dim",
"=",
"args",
".",
"word_embed",
",",
"name",
"=",
"'word_embed'",
")",
"rnn_features",
"=",
"mx",
".",
"sym",
".",
"Concat",
"(",
"*",
"[",
"word_embeddings",
",",
"regularized_cnn_char_features",
"]",
",",
"dim",
"=",
"2",
",",
"name",
"=",
"'rnn input'",
")",
"##############################",
"# Bidirectional LSTM component",
"##############################",
"# unroll the lstm cell in time, merging outputs",
"bi_cell",
".",
"reset",
"(",
")",
"output",
",",
"states",
"=",
"bi_cell",
".",
"unroll",
"(",
"length",
"=",
"seq_len",
",",
"inputs",
"=",
"rnn_features",
",",
"merge_outputs",
"=",
"True",
")",
"# Map to num entity classes",
"rnn_output",
"=",
"mx",
".",
"sym",
".",
"Reshape",
"(",
"output",
",",
"shape",
"=",
"(",
"-",
"1",
",",
"args",
".",
"lstm_state_size",
"*",
"2",
")",
",",
"name",
"=",
"'r_output'",
")",
"fc",
"=",
"mx",
".",
"sym",
".",
"FullyConnected",
"(",
"data",
"=",
"rnn_output",
",",
"num_hidden",
"=",
"len",
"(",
"entity_to_index",
")",
",",
"name",
"=",
"'fc_layer'",
")",
"# reshape back to same shape as loss will be",
"reshaped_fc",
"=",
"mx",
".",
"sym",
".",
"transpose",
"(",
"mx",
".",
"sym",
".",
"reshape",
"(",
"fc",
",",
"shape",
"=",
"(",
"-",
"1",
",",
"seq_len",
",",
"len",
"(",
"entity_to_index",
")",
")",
")",
",",
"axes",
"=",
"(",
"0",
",",
"2",
",",
"1",
")",
")",
"sm",
"=",
"mx",
".",
"sym",
".",
"SoftmaxOutput",
"(",
"data",
"=",
"reshaped_fc",
",",
"label",
"=",
"Y",
",",
"ignore_label",
"=",
"-",
"1",
",",
"use_ignore",
"=",
"True",
",",
"multi_output",
"=",
"True",
",",
"name",
"=",
"'softmax'",
")",
"return",
"sm",
",",
"[",
"v",
".",
"name",
"for",
"v",
"in",
"train_iter",
".",
"provide_data",
"]",
",",
"[",
"v",
".",
"name",
"for",
"v",
"in",
"train_iter",
".",
"provide_label",
"]"
] |
Build NN symbol depending on the length of the input sequence
|
[
"Build",
"NN",
"symbol",
"depending",
"on",
"the",
"length",
"of",
"the",
"input",
"sequence"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/example/named_entity_recognition/src/ner.py#L148-L203
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/contrib.py
|
rand_zipfian
|
def rand_zipfian(true_classes, num_sampled, range_max):
"""Draw random samples from an approximately log-uniform or Zipfian distribution.
This operation randomly samples *num_sampled* candidates the range of integers [0, range_max).
The elements of sampled_candidates are drawn with replacement from the base distribution.
The base distribution for this operator is an approximately log-uniform or Zipfian distribution:
P(class) = (log(class + 2) - log(class + 1)) / log(range_max + 1)
This sampler is useful when the true classes approximately follow such a distribution.
For example, if the classes represent words in a lexicon sorted in decreasing order of \
frequency. If your classes are not ordered by decreasing frequency, do not use this op.
Additionaly, it also returns the number of times each of the \
true classes and the sampled classes is expected to occur.
Parameters
----------
true_classes : Symbol
The target classes in 1-D.
num_sampled: int
The number of classes to randomly sample.
range_max: int
The number of possible classes.
Returns
-------
samples: Symbol
The sampled candidate classes in 1-D `int64` dtype.
expected_count_true: Symbol
The expected count for true classes in 1-D `float64` dtype.
expected_count_sample: Symbol
The expected count for sampled candidates in 1-D `float64` dtype.
Examples
--------
>>> true_cls = mx.sym.Variable('true_cls')
>>> samples, exp_count_true, exp_count_sample = mx.sym.contrib.rand_zipfian(true_cls, 4, 5)
>>> samples.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([1, 3, 3, 3])
>>> exp_count_true.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([0.12453879])
>>> exp_count_sample.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([0.22629439, 0.12453879, 0.12453879, 0.12453879])
"""
assert(isinstance(true_classes, Symbol)), "unexpected type %s" % type(true_classes)
log_range = math.log(range_max + 1)
rand = uniform(0, log_range, shape=(num_sampled,), dtype='float64')
# make sure sampled_classes are in the range of [0, range_max)
sampled_classes = (rand.exp() - 1).astype('int64') % range_max
true_classes = true_classes.astype('float64')
expected_prob_true = ((true_classes + 2.0) / (true_classes + 1.0)).log() / log_range
expected_count_true = expected_prob_true * num_sampled
# cast sampled classes to fp64 to avoid interget division
sampled_cls_fp64 = sampled_classes.astype('float64')
expected_prob_sampled = ((sampled_cls_fp64 + 2.0) / (sampled_cls_fp64 + 1.0)).log() / log_range
expected_count_sampled = expected_prob_sampled * num_sampled
return sampled_classes, expected_count_true, expected_count_sampled
|
python
|
def rand_zipfian(true_classes, num_sampled, range_max):
"""Draw random samples from an approximately log-uniform or Zipfian distribution.
This operation randomly samples *num_sampled* candidates the range of integers [0, range_max).
The elements of sampled_candidates are drawn with replacement from the base distribution.
The base distribution for this operator is an approximately log-uniform or Zipfian distribution:
P(class) = (log(class + 2) - log(class + 1)) / log(range_max + 1)
This sampler is useful when the true classes approximately follow such a distribution.
For example, if the classes represent words in a lexicon sorted in decreasing order of \
frequency. If your classes are not ordered by decreasing frequency, do not use this op.
Additionaly, it also returns the number of times each of the \
true classes and the sampled classes is expected to occur.
Parameters
----------
true_classes : Symbol
The target classes in 1-D.
num_sampled: int
The number of classes to randomly sample.
range_max: int
The number of possible classes.
Returns
-------
samples: Symbol
The sampled candidate classes in 1-D `int64` dtype.
expected_count_true: Symbol
The expected count for true classes in 1-D `float64` dtype.
expected_count_sample: Symbol
The expected count for sampled candidates in 1-D `float64` dtype.
Examples
--------
>>> true_cls = mx.sym.Variable('true_cls')
>>> samples, exp_count_true, exp_count_sample = mx.sym.contrib.rand_zipfian(true_cls, 4, 5)
>>> samples.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([1, 3, 3, 3])
>>> exp_count_true.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([0.12453879])
>>> exp_count_sample.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([0.22629439, 0.12453879, 0.12453879, 0.12453879])
"""
assert(isinstance(true_classes, Symbol)), "unexpected type %s" % type(true_classes)
log_range = math.log(range_max + 1)
rand = uniform(0, log_range, shape=(num_sampled,), dtype='float64')
# make sure sampled_classes are in the range of [0, range_max)
sampled_classes = (rand.exp() - 1).astype('int64') % range_max
true_classes = true_classes.astype('float64')
expected_prob_true = ((true_classes + 2.0) / (true_classes + 1.0)).log() / log_range
expected_count_true = expected_prob_true * num_sampled
# cast sampled classes to fp64 to avoid interget division
sampled_cls_fp64 = sampled_classes.astype('float64')
expected_prob_sampled = ((sampled_cls_fp64 + 2.0) / (sampled_cls_fp64 + 1.0)).log() / log_range
expected_count_sampled = expected_prob_sampled * num_sampled
return sampled_classes, expected_count_true, expected_count_sampled
|
[
"def",
"rand_zipfian",
"(",
"true_classes",
",",
"num_sampled",
",",
"range_max",
")",
":",
"assert",
"(",
"isinstance",
"(",
"true_classes",
",",
"Symbol",
")",
")",
",",
"\"unexpected type %s\"",
"%",
"type",
"(",
"true_classes",
")",
"log_range",
"=",
"math",
".",
"log",
"(",
"range_max",
"+",
"1",
")",
"rand",
"=",
"uniform",
"(",
"0",
",",
"log_range",
",",
"shape",
"=",
"(",
"num_sampled",
",",
")",
",",
"dtype",
"=",
"'float64'",
")",
"# make sure sampled_classes are in the range of [0, range_max)",
"sampled_classes",
"=",
"(",
"rand",
".",
"exp",
"(",
")",
"-",
"1",
")",
".",
"astype",
"(",
"'int64'",
")",
"%",
"range_max",
"true_classes",
"=",
"true_classes",
".",
"astype",
"(",
"'float64'",
")",
"expected_prob_true",
"=",
"(",
"(",
"true_classes",
"+",
"2.0",
")",
"/",
"(",
"true_classes",
"+",
"1.0",
")",
")",
".",
"log",
"(",
")",
"/",
"log_range",
"expected_count_true",
"=",
"expected_prob_true",
"*",
"num_sampled",
"# cast sampled classes to fp64 to avoid interget division",
"sampled_cls_fp64",
"=",
"sampled_classes",
".",
"astype",
"(",
"'float64'",
")",
"expected_prob_sampled",
"=",
"(",
"(",
"sampled_cls_fp64",
"+",
"2.0",
")",
"/",
"(",
"sampled_cls_fp64",
"+",
"1.0",
")",
")",
".",
"log",
"(",
")",
"/",
"log_range",
"expected_count_sampled",
"=",
"expected_prob_sampled",
"*",
"num_sampled",
"return",
"sampled_classes",
",",
"expected_count_true",
",",
"expected_count_sampled"
] |
Draw random samples from an approximately log-uniform or Zipfian distribution.
This operation randomly samples *num_sampled* candidates the range of integers [0, range_max).
The elements of sampled_candidates are drawn with replacement from the base distribution.
The base distribution for this operator is an approximately log-uniform or Zipfian distribution:
P(class) = (log(class + 2) - log(class + 1)) / log(range_max + 1)
This sampler is useful when the true classes approximately follow such a distribution.
For example, if the classes represent words in a lexicon sorted in decreasing order of \
frequency. If your classes are not ordered by decreasing frequency, do not use this op.
Additionaly, it also returns the number of times each of the \
true classes and the sampled classes is expected to occur.
Parameters
----------
true_classes : Symbol
The target classes in 1-D.
num_sampled: int
The number of classes to randomly sample.
range_max: int
The number of possible classes.
Returns
-------
samples: Symbol
The sampled candidate classes in 1-D `int64` dtype.
expected_count_true: Symbol
The expected count for true classes in 1-D `float64` dtype.
expected_count_sample: Symbol
The expected count for sampled candidates in 1-D `float64` dtype.
Examples
--------
>>> true_cls = mx.sym.Variable('true_cls')
>>> samples, exp_count_true, exp_count_sample = mx.sym.contrib.rand_zipfian(true_cls, 4, 5)
>>> samples.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([1, 3, 3, 3])
>>> exp_count_true.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([0.12453879])
>>> exp_count_sample.eval(true_cls=mx.nd.array([3]))[0].asnumpy()
array([0.22629439, 0.12453879, 0.12453879, 0.12453879])
|
[
"Draw",
"random",
"samples",
"from",
"an",
"approximately",
"log",
"-",
"uniform",
"or",
"Zipfian",
"distribution",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/contrib.py#L39-L98
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/contrib.py
|
foreach
|
def foreach(body, data, init_states, name="foreach"):
"""Run a for loop with user-defined computation over Symbols on dimension 0.
This operator simulates a for loop and body has the computation for an iteration
of the for loop. It runs the computation in body on each slice from the input
NDArrays.
body takes two arguments as input and outputs a tuple of two elements,
as illustrated below:
out, states = body(data1, states)
data1 can be either a symbol or a list of symbols. If data is a symbol,
data1 is a symbol. Otherwise, data1 is a list of symbols and has the same
size as data. states is a list of symbols and have the same size as init_states.
Similarly, out can be either a symbol or a list of symbols, which are concatenated
as the first output of foreach; states from the last execution of body
are the second output of foreach.
foreach can output only output data or states. If a user only wants states,
the body function can return ([], states). Similarly, if a user only wants
output data, the body function can return (out, []).
The computation done by this operator is equivalent to the pseudo code below
when the input data is NDArray::
states = init_states
outs = []
for i in data.shape[0]:
s = data[i]
out, states = body(s, states)
outs.append(out)
outs = stack(*outs)
Parameters
----------
body : a Python function.
Define computation in an iteration.
data: a symbol or a list of symbols.
The input data.
init_states: a Symbol or nested lists of symbols.
The initial values of the loop states.
name: string.
The name of the operator.
Returns
-------
outputs: a Symbol or nested lists of Symbols.
The output data concatenated from the output of all iterations.
states: a Symbol or nested lists of Symbols.
The loop states in the last iteration.
Examples
--------
>>> step = lambda data, states: (data + states[0], [states[0] * 2])
>>> data = mx.sym.var('data')
>>> states = [mx.sym.var('state')]
>>> outs, states = mx.sym.contrib.foreach(step, data, states)
"""
flatten_data, data_fmt = _flatten(data, "foreach input")
_check_data(flatten_data, symbol.Symbol,
"data should be a symbol or a nested list of symbols")
init_flatten_states, init_state_fmt = _flatten(init_states, "foreach states")
_check_data(init_flatten_states, symbol.Symbol,
"init_states should be a symbol or a nested list of symbols")
# If the input python function references to the symbols outside
# the python function, we need to prune the computation graph constructed from
# the function. One way of doing it is to mark the nodes in the computation graph
# with AttrScope and prune the nodes without the special attribute.
name = _get_unique_subgraph_name(name)
with AttrScope(__subgraph_name__=name):
in_eles = [symbol.var(_get_sym_uniq_name(sym)) for sym in flatten_data]
in_eles, _ = _regroup(in_eles, data_fmt)
states = [symbol.var(_get_sym_uniq_name(s)) for s in init_flatten_states]
states, _ = _regroup(states, copy.deepcopy(init_state_fmt))
sym_out, sym_states = body(in_eles, states)
sym_out, out_fmt = _flatten(sym_out, "foreach output")
sym_states, state_fmt = _flatten(sym_states, "foreach loop_vars")
assert init_state_fmt == state_fmt, "The input and output loop_vars have different format"
_check_data(sym_out, symbol.Symbol,
"the output should be an NDArray or a nested list of NDArrays")
_check_data(sym_states, symbol.Symbol,
"the output states should be an NDArray or a nested list of NDArrays")
num_out_data = len(sym_out)
num_states = len(sym_states)
num_outputs = num_out_data + num_states
g = _construct_subgraph(sym_out, sym_states, name)
input_syms = _get_graph_inputs(g)
cut_syms = _cut_subgraph(g)
input_syms = _get_graph_inputs(g)
# Here we need to find out how the input symbols are ordered as well as
# where the loop states are located in the list of inputs.
# This dict contains the symbols of the subgraph.
input_syms = {sym.name:sym for sym in input_syms}
gin_names = input_syms.keys()
# This array contains the symbols for the inputs of foreach.
# They are ordered according to the inputs of the subgraph.
state_names = [_get_sym_uniq_name(sym) for sym in init_flatten_states]
data_names = [_get_sym_uniq_name(sym) for sym in flatten_data]
cut_var_map = {sym.list_outputs()[0]:sym for sym in cut_syms}
cut_var_names = cut_var_map.keys()
subg_input_names = g.list_inputs()
assert len(set(subg_input_names)) == len(subg_input_names), \
"The inputs of the subgraph don't have unique names: " + str(subg_input_names)
# ordered_ins contains input symbols in the following order:
# data_syms, state_syms, followed by cut_vars and vars in the closure.
ordered_ins = [x for x in flatten_data]
# this defines the location of data_syms in the list of subgraph inputs
in_data_locs = []
for dname in data_names:
# Some data may not be used.
if dname in subg_input_names:
in_data_locs.append(subg_input_names.index(dname))
else:
raise AssertionError("the data arrays have to be used in the loop body")
ordered_ins.extend(init_flatten_states)
# this defines the location of state_syms in the list of subgraph inputs.
in_state_locs = []
for sname in state_names:
# Some state may not be used.
if sname in subg_input_names:
in_state_locs.append(subg_input_names.index(sname))
else:
raise AssertionError("the state arrays have to be used in the loop body")
remain_locs = []
for in_name in subg_input_names:
assert in_name in gin_names, "The input variable %s can't be found in graph inputs: %s" \
% (in_name, str(gin_names))
if in_name in cut_var_names:
ordered_ins.append(cut_var_map[in_name])
remain_locs.append(subg_input_names.index(in_name))
elif in_name not in data_names and in_name not in state_names:
# The remaining inputs are the variable nodes created inside the UDF.
# The subgraph can't have nodes shared with the main graph. As such,
# we need to make a copy of these variable nodes.
assert in_name in gin_names
ordered_ins.append(copy.deepcopy(input_syms[in_name]))
remain_locs.append(subg_input_names.index(in_name))
ret = symbol._internal._foreach(g, *ordered_ins, num_outputs=num_outputs,
num_out_data=num_out_data, in_state_locs=in_state_locs,
in_data_locs=in_data_locs, remain_locs=remain_locs)
outs = []
for i in range(num_outputs - num_states):
outs.append(ret[i])
outs, _ = _regroup(outs, out_fmt)
states = []
for i in range(num_states):
states.append(ret[num_outputs - num_states + i])
states, _ = _regroup(states, state_fmt)
return (outs, states)
|
python
|
def foreach(body, data, init_states, name="foreach"):
"""Run a for loop with user-defined computation over Symbols on dimension 0.
This operator simulates a for loop and body has the computation for an iteration
of the for loop. It runs the computation in body on each slice from the input
NDArrays.
body takes two arguments as input and outputs a tuple of two elements,
as illustrated below:
out, states = body(data1, states)
data1 can be either a symbol or a list of symbols. If data is a symbol,
data1 is a symbol. Otherwise, data1 is a list of symbols and has the same
size as data. states is a list of symbols and have the same size as init_states.
Similarly, out can be either a symbol or a list of symbols, which are concatenated
as the first output of foreach; states from the last execution of body
are the second output of foreach.
foreach can output only output data or states. If a user only wants states,
the body function can return ([], states). Similarly, if a user only wants
output data, the body function can return (out, []).
The computation done by this operator is equivalent to the pseudo code below
when the input data is NDArray::
states = init_states
outs = []
for i in data.shape[0]:
s = data[i]
out, states = body(s, states)
outs.append(out)
outs = stack(*outs)
Parameters
----------
body : a Python function.
Define computation in an iteration.
data: a symbol or a list of symbols.
The input data.
init_states: a Symbol or nested lists of symbols.
The initial values of the loop states.
name: string.
The name of the operator.
Returns
-------
outputs: a Symbol or nested lists of Symbols.
The output data concatenated from the output of all iterations.
states: a Symbol or nested lists of Symbols.
The loop states in the last iteration.
Examples
--------
>>> step = lambda data, states: (data + states[0], [states[0] * 2])
>>> data = mx.sym.var('data')
>>> states = [mx.sym.var('state')]
>>> outs, states = mx.sym.contrib.foreach(step, data, states)
"""
flatten_data, data_fmt = _flatten(data, "foreach input")
_check_data(flatten_data, symbol.Symbol,
"data should be a symbol or a nested list of symbols")
init_flatten_states, init_state_fmt = _flatten(init_states, "foreach states")
_check_data(init_flatten_states, symbol.Symbol,
"init_states should be a symbol or a nested list of symbols")
# If the input python function references to the symbols outside
# the python function, we need to prune the computation graph constructed from
# the function. One way of doing it is to mark the nodes in the computation graph
# with AttrScope and prune the nodes without the special attribute.
name = _get_unique_subgraph_name(name)
with AttrScope(__subgraph_name__=name):
in_eles = [symbol.var(_get_sym_uniq_name(sym)) for sym in flatten_data]
in_eles, _ = _regroup(in_eles, data_fmt)
states = [symbol.var(_get_sym_uniq_name(s)) for s in init_flatten_states]
states, _ = _regroup(states, copy.deepcopy(init_state_fmt))
sym_out, sym_states = body(in_eles, states)
sym_out, out_fmt = _flatten(sym_out, "foreach output")
sym_states, state_fmt = _flatten(sym_states, "foreach loop_vars")
assert init_state_fmt == state_fmt, "The input and output loop_vars have different format"
_check_data(sym_out, symbol.Symbol,
"the output should be an NDArray or a nested list of NDArrays")
_check_data(sym_states, symbol.Symbol,
"the output states should be an NDArray or a nested list of NDArrays")
num_out_data = len(sym_out)
num_states = len(sym_states)
num_outputs = num_out_data + num_states
g = _construct_subgraph(sym_out, sym_states, name)
input_syms = _get_graph_inputs(g)
cut_syms = _cut_subgraph(g)
input_syms = _get_graph_inputs(g)
# Here we need to find out how the input symbols are ordered as well as
# where the loop states are located in the list of inputs.
# This dict contains the symbols of the subgraph.
input_syms = {sym.name:sym for sym in input_syms}
gin_names = input_syms.keys()
# This array contains the symbols for the inputs of foreach.
# They are ordered according to the inputs of the subgraph.
state_names = [_get_sym_uniq_name(sym) for sym in init_flatten_states]
data_names = [_get_sym_uniq_name(sym) for sym in flatten_data]
cut_var_map = {sym.list_outputs()[0]:sym for sym in cut_syms}
cut_var_names = cut_var_map.keys()
subg_input_names = g.list_inputs()
assert len(set(subg_input_names)) == len(subg_input_names), \
"The inputs of the subgraph don't have unique names: " + str(subg_input_names)
# ordered_ins contains input symbols in the following order:
# data_syms, state_syms, followed by cut_vars and vars in the closure.
ordered_ins = [x for x in flatten_data]
# this defines the location of data_syms in the list of subgraph inputs
in_data_locs = []
for dname in data_names:
# Some data may not be used.
if dname in subg_input_names:
in_data_locs.append(subg_input_names.index(dname))
else:
raise AssertionError("the data arrays have to be used in the loop body")
ordered_ins.extend(init_flatten_states)
# this defines the location of state_syms in the list of subgraph inputs.
in_state_locs = []
for sname in state_names:
# Some state may not be used.
if sname in subg_input_names:
in_state_locs.append(subg_input_names.index(sname))
else:
raise AssertionError("the state arrays have to be used in the loop body")
remain_locs = []
for in_name in subg_input_names:
assert in_name in gin_names, "The input variable %s can't be found in graph inputs: %s" \
% (in_name, str(gin_names))
if in_name in cut_var_names:
ordered_ins.append(cut_var_map[in_name])
remain_locs.append(subg_input_names.index(in_name))
elif in_name not in data_names and in_name not in state_names:
# The remaining inputs are the variable nodes created inside the UDF.
# The subgraph can't have nodes shared with the main graph. As such,
# we need to make a copy of these variable nodes.
assert in_name in gin_names
ordered_ins.append(copy.deepcopy(input_syms[in_name]))
remain_locs.append(subg_input_names.index(in_name))
ret = symbol._internal._foreach(g, *ordered_ins, num_outputs=num_outputs,
num_out_data=num_out_data, in_state_locs=in_state_locs,
in_data_locs=in_data_locs, remain_locs=remain_locs)
outs = []
for i in range(num_outputs - num_states):
outs.append(ret[i])
outs, _ = _regroup(outs, out_fmt)
states = []
for i in range(num_states):
states.append(ret[num_outputs - num_states + i])
states, _ = _regroup(states, state_fmt)
return (outs, states)
|
[
"def",
"foreach",
"(",
"body",
",",
"data",
",",
"init_states",
",",
"name",
"=",
"\"foreach\"",
")",
":",
"flatten_data",
",",
"data_fmt",
"=",
"_flatten",
"(",
"data",
",",
"\"foreach input\"",
")",
"_check_data",
"(",
"flatten_data",
",",
"symbol",
".",
"Symbol",
",",
"\"data should be a symbol or a nested list of symbols\"",
")",
"init_flatten_states",
",",
"init_state_fmt",
"=",
"_flatten",
"(",
"init_states",
",",
"\"foreach states\"",
")",
"_check_data",
"(",
"init_flatten_states",
",",
"symbol",
".",
"Symbol",
",",
"\"init_states should be a symbol or a nested list of symbols\"",
")",
"# If the input python function references to the symbols outside",
"# the python function, we need to prune the computation graph constructed from",
"# the function. One way of doing it is to mark the nodes in the computation graph",
"# with AttrScope and prune the nodes without the special attribute.",
"name",
"=",
"_get_unique_subgraph_name",
"(",
"name",
")",
"with",
"AttrScope",
"(",
"__subgraph_name__",
"=",
"name",
")",
":",
"in_eles",
"=",
"[",
"symbol",
".",
"var",
"(",
"_get_sym_uniq_name",
"(",
"sym",
")",
")",
"for",
"sym",
"in",
"flatten_data",
"]",
"in_eles",
",",
"_",
"=",
"_regroup",
"(",
"in_eles",
",",
"data_fmt",
")",
"states",
"=",
"[",
"symbol",
".",
"var",
"(",
"_get_sym_uniq_name",
"(",
"s",
")",
")",
"for",
"s",
"in",
"init_flatten_states",
"]",
"states",
",",
"_",
"=",
"_regroup",
"(",
"states",
",",
"copy",
".",
"deepcopy",
"(",
"init_state_fmt",
")",
")",
"sym_out",
",",
"sym_states",
"=",
"body",
"(",
"in_eles",
",",
"states",
")",
"sym_out",
",",
"out_fmt",
"=",
"_flatten",
"(",
"sym_out",
",",
"\"foreach output\"",
")",
"sym_states",
",",
"state_fmt",
"=",
"_flatten",
"(",
"sym_states",
",",
"\"foreach loop_vars\"",
")",
"assert",
"init_state_fmt",
"==",
"state_fmt",
",",
"\"The input and output loop_vars have different format\"",
"_check_data",
"(",
"sym_out",
",",
"symbol",
".",
"Symbol",
",",
"\"the output should be an NDArray or a nested list of NDArrays\"",
")",
"_check_data",
"(",
"sym_states",
",",
"symbol",
".",
"Symbol",
",",
"\"the output states should be an NDArray or a nested list of NDArrays\"",
")",
"num_out_data",
"=",
"len",
"(",
"sym_out",
")",
"num_states",
"=",
"len",
"(",
"sym_states",
")",
"num_outputs",
"=",
"num_out_data",
"+",
"num_states",
"g",
"=",
"_construct_subgraph",
"(",
"sym_out",
",",
"sym_states",
",",
"name",
")",
"input_syms",
"=",
"_get_graph_inputs",
"(",
"g",
")",
"cut_syms",
"=",
"_cut_subgraph",
"(",
"g",
")",
"input_syms",
"=",
"_get_graph_inputs",
"(",
"g",
")",
"# Here we need to find out how the input symbols are ordered as well as",
"# where the loop states are located in the list of inputs.",
"# This dict contains the symbols of the subgraph.",
"input_syms",
"=",
"{",
"sym",
".",
"name",
":",
"sym",
"for",
"sym",
"in",
"input_syms",
"}",
"gin_names",
"=",
"input_syms",
".",
"keys",
"(",
")",
"# This array contains the symbols for the inputs of foreach.",
"# They are ordered according to the inputs of the subgraph.",
"state_names",
"=",
"[",
"_get_sym_uniq_name",
"(",
"sym",
")",
"for",
"sym",
"in",
"init_flatten_states",
"]",
"data_names",
"=",
"[",
"_get_sym_uniq_name",
"(",
"sym",
")",
"for",
"sym",
"in",
"flatten_data",
"]",
"cut_var_map",
"=",
"{",
"sym",
".",
"list_outputs",
"(",
")",
"[",
"0",
"]",
":",
"sym",
"for",
"sym",
"in",
"cut_syms",
"}",
"cut_var_names",
"=",
"cut_var_map",
".",
"keys",
"(",
")",
"subg_input_names",
"=",
"g",
".",
"list_inputs",
"(",
")",
"assert",
"len",
"(",
"set",
"(",
"subg_input_names",
")",
")",
"==",
"len",
"(",
"subg_input_names",
")",
",",
"\"The inputs of the subgraph don't have unique names: \"",
"+",
"str",
"(",
"subg_input_names",
")",
"# ordered_ins contains input symbols in the following order:",
"# data_syms, state_syms, followed by cut_vars and vars in the closure.",
"ordered_ins",
"=",
"[",
"x",
"for",
"x",
"in",
"flatten_data",
"]",
"# this defines the location of data_syms in the list of subgraph inputs",
"in_data_locs",
"=",
"[",
"]",
"for",
"dname",
"in",
"data_names",
":",
"# Some data may not be used.",
"if",
"dname",
"in",
"subg_input_names",
":",
"in_data_locs",
".",
"append",
"(",
"subg_input_names",
".",
"index",
"(",
"dname",
")",
")",
"else",
":",
"raise",
"AssertionError",
"(",
"\"the data arrays have to be used in the loop body\"",
")",
"ordered_ins",
".",
"extend",
"(",
"init_flatten_states",
")",
"# this defines the location of state_syms in the list of subgraph inputs.",
"in_state_locs",
"=",
"[",
"]",
"for",
"sname",
"in",
"state_names",
":",
"# Some state may not be used.",
"if",
"sname",
"in",
"subg_input_names",
":",
"in_state_locs",
".",
"append",
"(",
"subg_input_names",
".",
"index",
"(",
"sname",
")",
")",
"else",
":",
"raise",
"AssertionError",
"(",
"\"the state arrays have to be used in the loop body\"",
")",
"remain_locs",
"=",
"[",
"]",
"for",
"in_name",
"in",
"subg_input_names",
":",
"assert",
"in_name",
"in",
"gin_names",
",",
"\"The input variable %s can't be found in graph inputs: %s\"",
"%",
"(",
"in_name",
",",
"str",
"(",
"gin_names",
")",
")",
"if",
"in_name",
"in",
"cut_var_names",
":",
"ordered_ins",
".",
"append",
"(",
"cut_var_map",
"[",
"in_name",
"]",
")",
"remain_locs",
".",
"append",
"(",
"subg_input_names",
".",
"index",
"(",
"in_name",
")",
")",
"elif",
"in_name",
"not",
"in",
"data_names",
"and",
"in_name",
"not",
"in",
"state_names",
":",
"# The remaining inputs are the variable nodes created inside the UDF.",
"# The subgraph can't have nodes shared with the main graph. As such,",
"# we need to make a copy of these variable nodes.",
"assert",
"in_name",
"in",
"gin_names",
"ordered_ins",
".",
"append",
"(",
"copy",
".",
"deepcopy",
"(",
"input_syms",
"[",
"in_name",
"]",
")",
")",
"remain_locs",
".",
"append",
"(",
"subg_input_names",
".",
"index",
"(",
"in_name",
")",
")",
"ret",
"=",
"symbol",
".",
"_internal",
".",
"_foreach",
"(",
"g",
",",
"*",
"ordered_ins",
",",
"num_outputs",
"=",
"num_outputs",
",",
"num_out_data",
"=",
"num_out_data",
",",
"in_state_locs",
"=",
"in_state_locs",
",",
"in_data_locs",
"=",
"in_data_locs",
",",
"remain_locs",
"=",
"remain_locs",
")",
"outs",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"num_outputs",
"-",
"num_states",
")",
":",
"outs",
".",
"append",
"(",
"ret",
"[",
"i",
"]",
")",
"outs",
",",
"_",
"=",
"_regroup",
"(",
"outs",
",",
"out_fmt",
")",
"states",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"num_states",
")",
":",
"states",
".",
"append",
"(",
"ret",
"[",
"num_outputs",
"-",
"num_states",
"+",
"i",
"]",
")",
"states",
",",
"_",
"=",
"_regroup",
"(",
"states",
",",
"state_fmt",
")",
"return",
"(",
"outs",
",",
"states",
")"
] |
Run a for loop with user-defined computation over Symbols on dimension 0.
This operator simulates a for loop and body has the computation for an iteration
of the for loop. It runs the computation in body on each slice from the input
NDArrays.
body takes two arguments as input and outputs a tuple of two elements,
as illustrated below:
out, states = body(data1, states)
data1 can be either a symbol or a list of symbols. If data is a symbol,
data1 is a symbol. Otherwise, data1 is a list of symbols and has the same
size as data. states is a list of symbols and have the same size as init_states.
Similarly, out can be either a symbol or a list of symbols, which are concatenated
as the first output of foreach; states from the last execution of body
are the second output of foreach.
foreach can output only output data or states. If a user only wants states,
the body function can return ([], states). Similarly, if a user only wants
output data, the body function can return (out, []).
The computation done by this operator is equivalent to the pseudo code below
when the input data is NDArray::
states = init_states
outs = []
for i in data.shape[0]:
s = data[i]
out, states = body(s, states)
outs.append(out)
outs = stack(*outs)
Parameters
----------
body : a Python function.
Define computation in an iteration.
data: a symbol or a list of symbols.
The input data.
init_states: a Symbol or nested lists of symbols.
The initial values of the loop states.
name: string.
The name of the operator.
Returns
-------
outputs: a Symbol or nested lists of Symbols.
The output data concatenated from the output of all iterations.
states: a Symbol or nested lists of Symbols.
The loop states in the last iteration.
Examples
--------
>>> step = lambda data, states: (data + states[0], [states[0] * 2])
>>> data = mx.sym.var('data')
>>> states = [mx.sym.var('state')]
>>> outs, states = mx.sym.contrib.foreach(step, data, states)
|
[
"Run",
"a",
"for",
"loop",
"with",
"user",
"-",
"defined",
"computation",
"over",
"Symbols",
"on",
"dimension",
"0",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/contrib.py#L212-L373
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/contrib.py
|
while_loop
|
def while_loop(cond, func, loop_vars, max_iterations=None, name="while_loop"):
"""Run a while loop with user-defined computation and loop condition.
This operator simulates a while loop which iterately does customized computation
as long as the condition is satisfied.
`loop_vars` is a Symbol or nested lists of Symbols on which the computation uses.
`cond` is a user-defined function, used as the loop condition.
It consumes `loop_vars`, and produces a scalar MXNet symbol,
indicating the termination of the loop.
The loop ends when `cond` returns false (zero).
The `cond` is variadic, and its signature should be
`cond(*loop_vars) => Symbol`.
`func` is a user-defined function, used as the loop body.
It also consumes `loop_vars`, and produces `step_output` and `new_loop_vars` at each step.
In each step, `step_output` should contain the same number elements.
Through all steps, the i-th element of `step_output` should have the same shape and dtype.
Also, `new_loop_vars` should contain the same number of elements as `loop_vars`,
and the corresponding element should have the same shape and dtype.
The `func` is variadic, and its signature should be
`func(*loop_vars) =>
(Symbol or nested List[Symbol] step_output, Symbol or nested List[Symbol] new_loop_vars)`.
`max_iterations` is a scalar that defines the maximum number of iterations allowed.
This function returns two lists.
The first list has the length of `|step_output|`,
in which the i-th element are all i-th elements of
`step_output` from all steps, stacked along axis 0.
The second list has the length of `|loop_vars|`,
which represents final states of loop variables.
.. warning::
For now, the axis 0 of all Symbols in the first list are `max_iterations`,
due to lack of dynamic shape inference.
.. warning::
Even if `cond` is never satisfied,
while_loop returns a list of outputs with inferred dtype and shape.
This is different from the Symbol version,
where in this case `step_outputs` are assumed as an empty list.
Parameters
----------
cond: a Python function.
The loop condition.
func: a Python function.
The loop body.
loop_vars: a Symbol or nested lists of Symbol.
The initial values of the loop variables.
max_iterations: a python int.
Maximum number of iterations.
Returns
------
outputs: a Symbol or nested lists of Symbols
stacked output from each step
states: a Symbol or nested lists of Symbols
final state
Examples
--------
>>> cond = lambda i, s: i <= 5
>>> func = lambda i, s: ([i + s], [i + 1, s + i])
>>> loop_vars = (mx.sym.var('i'), mx.sym.var('s'))
>>> outputs, states = mx.sym.contrib.while_loop(cond, func, loop_vars, max_iterations=10)
"""
def _to_python_scalar(inputs, type_, name):
"""Converts "inputs", possibly typed mxnet NDArray, a numpy ndarray, other python types,
to the given type
"""
if hasattr(inputs, "asscalar"):
inputs = inputs.asscalar()
try:
inputs = type_(inputs)
except:
raise ValueError("Cannot convert %s to python %s" % (name, type_.__name__))
return inputs
def _cond_wrapper(loop_vars):
result = cond(*loop_vars)
if not isinstance(result, Symbol):
raise ValueError("Return of cond must be a Symbol")
return [], [result], [], []
def _func_wrapper(loop_vars):
"""This wrapper unifies
"func: loop_vars -> new_loop_vars"
and "func: loop_vars -> (step_output, new_loop_vars)"
into "func: loop_vars -> (list of step_outputs, tuple of new_loop_vars)
"""
step_output, new_loop_vars = func(*loop_vars)
if step_output is None:
step_output = []
if new_loop_vars is None:
new_loop_vars = []
if isinstance(step_output, tuple):
step_output = list(step_output)
if isinstance(new_loop_vars, tuple):
new_loop_vars = list(new_loop_vars)
step_output, out_fmt = _flatten(step_output, "while output")
new_loop_vars, var_fmt = _flatten(new_loop_vars, "while loop_vars")
if len(loop_vars) != len(new_loop_vars):
raise ValueError("The number of loop_vars should be consistent during the loop")
return step_output, new_loop_vars, out_fmt, var_fmt
def _create_subgraph(graph_vars, graph_func, subgraph_name):
subgraph_name = _get_unique_subgraph_name(subgraph_name)
with AttrScope(__subgraph_name__=subgraph_name):
# create new variables with the same name,
# them feed them to the given func
graph_vars, var_fmt = _flatten(graph_vars, "while loop_vars")
new_graph_vars = [symbol.var(_get_sym_uniq_name(sym)) for sym in graph_vars]
new_graph_vars, _ = _regroup(new_graph_vars, var_fmt)
outputs, final_state, out_fmt, var_fmt = graph_func(new_graph_vars)
# first `num_out_data` elements belong to `outputs`
# other elements belong to `final_state`
num_out_data = len(outputs)
num_outputs = len(outputs) + len(final_state)
# nnvm cut-graph does not allow inputs and outputs overlap
# so we calculate the name of inputs, and copy outputs once it overlaps with inputs
# group all outputs of graph_func
all_input_names = symbol.Group(outputs + final_state).list_inputs()
in_input = lambda x: x.name in all_input_names
in_graph = lambda x: x.list_attr().get("__subgraph_name__", "") == subgraph_name
make_identity = lambda x: symbol.op.identity(x) if in_input(x) or not in_graph(x) \
else x
graph = symbol.Group(list(map(make_identity, outputs + final_state)))
return graph, num_out_data, num_outputs, out_fmt, var_fmt
flatten_loop_vars, init_loop_var_fmt = _flatten(loop_vars, "while loop_vars")
_check_data(flatten_loop_vars, symbol.Symbol,
"loop_vars should be a symbol or a nested list of symbols")
def _union_inputs(*graphs):
# Given a list of graphs, each whose inputs are either from loop_vars or other variables.
# 1) calculate a list `inputs`, the union of their inputs.
# 2) for each graph, determine in which indices their inputs reside in `inputs`
# 3) for each variable in the input of `graph`, find which index it is
inputs = [] # List[Symbol], result of 1)
locs = [] # List[Tuple(List[Int], List[Int])], a list of tuples,
# where tuples are results of 2) and 3)
input_id_to_loc = {} # Dict[int, int], given id(sym), input_id_to_loc maps it
# to a `loc`, where inputs[loc] = sym
for graph in graphs:
# some loop_vars are inputs to `graph`, some are not
name_to_loop_vars = {_get_sym_uniq_name(sym): sym for sym in flatten_loop_vars}
# other inputs to `graph` created by cut_graph
name_to_cut_g_syms = {sym.list_outputs()[0]: sym for sym in _cut_subgraph(graph)}
# input_syms: all inputs to the `graph`
name_to_input_syms = {sym.name: sym for sym in _get_graph_inputs(graph)}
# also we collect the mapping from var's name to var's loc in loop_vars
name_to_var_locs = {_get_sym_uniq_name(sym): i for i, sym in enumerate(flatten_loop_vars)}
# collect arguments for each subgraph
input_locs = [] # results from the second step
var_locs = [-1] * len(flatten_loop_vars) # results from the third step
subg_input_names = graph.list_inputs()
assert len(set(subg_input_names)) == len(subg_input_names), \
"The inputs of the subgraph don't have unique names: " + str(subg_input_names)
for name in subg_input_names:
assert name in name_to_input_syms # it should obviously hold
# name -> sym
if name in name_to_loop_vars:
sym = name_to_loop_vars[name]
elif name in name_to_cut_g_syms:
sym = name_to_cut_g_syms[name]
else:
sym = copy.deepcopy(name_to_input_syms[name])
# do 2), and 1) is implicitly done
if id(sym) in input_id_to_loc:
loc = input_id_to_loc[id(sym)]
else:
loc = len(input_id_to_loc)
inputs.append(sym)
input_id_to_loc[id(sym)] = loc
input_locs.append(loc)
# do 3)
if name in name_to_var_locs:
var_locs[name_to_var_locs[name]] = len(input_locs) - 1
locs.append((input_locs, var_locs))
return inputs, locs
if max_iterations is None:
raise ValueError("max_iterations should be specified")
max_iterations = _to_python_scalar(max_iterations, int, "max_iteration")
# It should be work as fine if loop_vars are empty I guess,
# but it is semantically unnecessary to include this case.
if len(loop_vars) == 0:
raise ValueError("loop_vars should contain at least one element")
# create graph for `cond'
cond_g, num_out_data, num_outputs, _, _ = \
_create_subgraph(loop_vars, _cond_wrapper, name + "_cond")
assert num_out_data == 0
assert num_outputs == 1
# create graph for `func`
func_g, num_out_data, num_outputs, out_fmt, _ = \
_create_subgraph(loop_vars, _func_wrapper, name + "_func")
# find symbols used in either cond_g or func_g
input_syms, ((cond_input_locs, _), (func_input_locs, func_var_locs)) = \
_union_inputs(cond_g, func_g)
for i_th, loc in enumerate(func_var_locs, 1):
if loc == -1:
raise ValueError("The %d-th loop_var doesn't involve into the computation" % i_th)
result = symbol._internal._while_loop(
cond_g,
func_g,
*input_syms,
max_iterations=max_iterations,
cond_input_locs=cond_input_locs,
func_input_locs=func_input_locs,
func_var_locs=func_var_locs,
num_out_data=num_out_data,
num_outputs=num_outputs
)
outputs = [result[i] for i in range(num_out_data)]
outputs, _ = _regroup(outputs, out_fmt)
final_loop_vars = [result[i] for i in range(num_out_data, num_outputs)]
final_loop_vars, _ = _regroup(final_loop_vars, init_loop_var_fmt)
return outputs, final_loop_vars
|
python
|
def while_loop(cond, func, loop_vars, max_iterations=None, name="while_loop"):
"""Run a while loop with user-defined computation and loop condition.
This operator simulates a while loop which iterately does customized computation
as long as the condition is satisfied.
`loop_vars` is a Symbol or nested lists of Symbols on which the computation uses.
`cond` is a user-defined function, used as the loop condition.
It consumes `loop_vars`, and produces a scalar MXNet symbol,
indicating the termination of the loop.
The loop ends when `cond` returns false (zero).
The `cond` is variadic, and its signature should be
`cond(*loop_vars) => Symbol`.
`func` is a user-defined function, used as the loop body.
It also consumes `loop_vars`, and produces `step_output` and `new_loop_vars` at each step.
In each step, `step_output` should contain the same number elements.
Through all steps, the i-th element of `step_output` should have the same shape and dtype.
Also, `new_loop_vars` should contain the same number of elements as `loop_vars`,
and the corresponding element should have the same shape and dtype.
The `func` is variadic, and its signature should be
`func(*loop_vars) =>
(Symbol or nested List[Symbol] step_output, Symbol or nested List[Symbol] new_loop_vars)`.
`max_iterations` is a scalar that defines the maximum number of iterations allowed.
This function returns two lists.
The first list has the length of `|step_output|`,
in which the i-th element are all i-th elements of
`step_output` from all steps, stacked along axis 0.
The second list has the length of `|loop_vars|`,
which represents final states of loop variables.
.. warning::
For now, the axis 0 of all Symbols in the first list are `max_iterations`,
due to lack of dynamic shape inference.
.. warning::
Even if `cond` is never satisfied,
while_loop returns a list of outputs with inferred dtype and shape.
This is different from the Symbol version,
where in this case `step_outputs` are assumed as an empty list.
Parameters
----------
cond: a Python function.
The loop condition.
func: a Python function.
The loop body.
loop_vars: a Symbol or nested lists of Symbol.
The initial values of the loop variables.
max_iterations: a python int.
Maximum number of iterations.
Returns
------
outputs: a Symbol or nested lists of Symbols
stacked output from each step
states: a Symbol or nested lists of Symbols
final state
Examples
--------
>>> cond = lambda i, s: i <= 5
>>> func = lambda i, s: ([i + s], [i + 1, s + i])
>>> loop_vars = (mx.sym.var('i'), mx.sym.var('s'))
>>> outputs, states = mx.sym.contrib.while_loop(cond, func, loop_vars, max_iterations=10)
"""
def _to_python_scalar(inputs, type_, name):
"""Converts "inputs", possibly typed mxnet NDArray, a numpy ndarray, other python types,
to the given type
"""
if hasattr(inputs, "asscalar"):
inputs = inputs.asscalar()
try:
inputs = type_(inputs)
except:
raise ValueError("Cannot convert %s to python %s" % (name, type_.__name__))
return inputs
def _cond_wrapper(loop_vars):
result = cond(*loop_vars)
if not isinstance(result, Symbol):
raise ValueError("Return of cond must be a Symbol")
return [], [result], [], []
def _func_wrapper(loop_vars):
"""This wrapper unifies
"func: loop_vars -> new_loop_vars"
and "func: loop_vars -> (step_output, new_loop_vars)"
into "func: loop_vars -> (list of step_outputs, tuple of new_loop_vars)
"""
step_output, new_loop_vars = func(*loop_vars)
if step_output is None:
step_output = []
if new_loop_vars is None:
new_loop_vars = []
if isinstance(step_output, tuple):
step_output = list(step_output)
if isinstance(new_loop_vars, tuple):
new_loop_vars = list(new_loop_vars)
step_output, out_fmt = _flatten(step_output, "while output")
new_loop_vars, var_fmt = _flatten(new_loop_vars, "while loop_vars")
if len(loop_vars) != len(new_loop_vars):
raise ValueError("The number of loop_vars should be consistent during the loop")
return step_output, new_loop_vars, out_fmt, var_fmt
def _create_subgraph(graph_vars, graph_func, subgraph_name):
subgraph_name = _get_unique_subgraph_name(subgraph_name)
with AttrScope(__subgraph_name__=subgraph_name):
# create new variables with the same name,
# them feed them to the given func
graph_vars, var_fmt = _flatten(graph_vars, "while loop_vars")
new_graph_vars = [symbol.var(_get_sym_uniq_name(sym)) for sym in graph_vars]
new_graph_vars, _ = _regroup(new_graph_vars, var_fmt)
outputs, final_state, out_fmt, var_fmt = graph_func(new_graph_vars)
# first `num_out_data` elements belong to `outputs`
# other elements belong to `final_state`
num_out_data = len(outputs)
num_outputs = len(outputs) + len(final_state)
# nnvm cut-graph does not allow inputs and outputs overlap
# so we calculate the name of inputs, and copy outputs once it overlaps with inputs
# group all outputs of graph_func
all_input_names = symbol.Group(outputs + final_state).list_inputs()
in_input = lambda x: x.name in all_input_names
in_graph = lambda x: x.list_attr().get("__subgraph_name__", "") == subgraph_name
make_identity = lambda x: symbol.op.identity(x) if in_input(x) or not in_graph(x) \
else x
graph = symbol.Group(list(map(make_identity, outputs + final_state)))
return graph, num_out_data, num_outputs, out_fmt, var_fmt
flatten_loop_vars, init_loop_var_fmt = _flatten(loop_vars, "while loop_vars")
_check_data(flatten_loop_vars, symbol.Symbol,
"loop_vars should be a symbol or a nested list of symbols")
def _union_inputs(*graphs):
# Given a list of graphs, each whose inputs are either from loop_vars or other variables.
# 1) calculate a list `inputs`, the union of their inputs.
# 2) for each graph, determine in which indices their inputs reside in `inputs`
# 3) for each variable in the input of `graph`, find which index it is
inputs = [] # List[Symbol], result of 1)
locs = [] # List[Tuple(List[Int], List[Int])], a list of tuples,
# where tuples are results of 2) and 3)
input_id_to_loc = {} # Dict[int, int], given id(sym), input_id_to_loc maps it
# to a `loc`, where inputs[loc] = sym
for graph in graphs:
# some loop_vars are inputs to `graph`, some are not
name_to_loop_vars = {_get_sym_uniq_name(sym): sym for sym in flatten_loop_vars}
# other inputs to `graph` created by cut_graph
name_to_cut_g_syms = {sym.list_outputs()[0]: sym for sym in _cut_subgraph(graph)}
# input_syms: all inputs to the `graph`
name_to_input_syms = {sym.name: sym for sym in _get_graph_inputs(graph)}
# also we collect the mapping from var's name to var's loc in loop_vars
name_to_var_locs = {_get_sym_uniq_name(sym): i for i, sym in enumerate(flatten_loop_vars)}
# collect arguments for each subgraph
input_locs = [] # results from the second step
var_locs = [-1] * len(flatten_loop_vars) # results from the third step
subg_input_names = graph.list_inputs()
assert len(set(subg_input_names)) == len(subg_input_names), \
"The inputs of the subgraph don't have unique names: " + str(subg_input_names)
for name in subg_input_names:
assert name in name_to_input_syms # it should obviously hold
# name -> sym
if name in name_to_loop_vars:
sym = name_to_loop_vars[name]
elif name in name_to_cut_g_syms:
sym = name_to_cut_g_syms[name]
else:
sym = copy.deepcopy(name_to_input_syms[name])
# do 2), and 1) is implicitly done
if id(sym) in input_id_to_loc:
loc = input_id_to_loc[id(sym)]
else:
loc = len(input_id_to_loc)
inputs.append(sym)
input_id_to_loc[id(sym)] = loc
input_locs.append(loc)
# do 3)
if name in name_to_var_locs:
var_locs[name_to_var_locs[name]] = len(input_locs) - 1
locs.append((input_locs, var_locs))
return inputs, locs
if max_iterations is None:
raise ValueError("max_iterations should be specified")
max_iterations = _to_python_scalar(max_iterations, int, "max_iteration")
# It should be work as fine if loop_vars are empty I guess,
# but it is semantically unnecessary to include this case.
if len(loop_vars) == 0:
raise ValueError("loop_vars should contain at least one element")
# create graph for `cond'
cond_g, num_out_data, num_outputs, _, _ = \
_create_subgraph(loop_vars, _cond_wrapper, name + "_cond")
assert num_out_data == 0
assert num_outputs == 1
# create graph for `func`
func_g, num_out_data, num_outputs, out_fmt, _ = \
_create_subgraph(loop_vars, _func_wrapper, name + "_func")
# find symbols used in either cond_g or func_g
input_syms, ((cond_input_locs, _), (func_input_locs, func_var_locs)) = \
_union_inputs(cond_g, func_g)
for i_th, loc in enumerate(func_var_locs, 1):
if loc == -1:
raise ValueError("The %d-th loop_var doesn't involve into the computation" % i_th)
result = symbol._internal._while_loop(
cond_g,
func_g,
*input_syms,
max_iterations=max_iterations,
cond_input_locs=cond_input_locs,
func_input_locs=func_input_locs,
func_var_locs=func_var_locs,
num_out_data=num_out_data,
num_outputs=num_outputs
)
outputs = [result[i] for i in range(num_out_data)]
outputs, _ = _regroup(outputs, out_fmt)
final_loop_vars = [result[i] for i in range(num_out_data, num_outputs)]
final_loop_vars, _ = _regroup(final_loop_vars, init_loop_var_fmt)
return outputs, final_loop_vars
|
[
"def",
"while_loop",
"(",
"cond",
",",
"func",
",",
"loop_vars",
",",
"max_iterations",
"=",
"None",
",",
"name",
"=",
"\"while_loop\"",
")",
":",
"def",
"_to_python_scalar",
"(",
"inputs",
",",
"type_",
",",
"name",
")",
":",
"\"\"\"Converts \"inputs\", possibly typed mxnet NDArray, a numpy ndarray, other python types,\n to the given type\n \"\"\"",
"if",
"hasattr",
"(",
"inputs",
",",
"\"asscalar\"",
")",
":",
"inputs",
"=",
"inputs",
".",
"asscalar",
"(",
")",
"try",
":",
"inputs",
"=",
"type_",
"(",
"inputs",
")",
"except",
":",
"raise",
"ValueError",
"(",
"\"Cannot convert %s to python %s\"",
"%",
"(",
"name",
",",
"type_",
".",
"__name__",
")",
")",
"return",
"inputs",
"def",
"_cond_wrapper",
"(",
"loop_vars",
")",
":",
"result",
"=",
"cond",
"(",
"*",
"loop_vars",
")",
"if",
"not",
"isinstance",
"(",
"result",
",",
"Symbol",
")",
":",
"raise",
"ValueError",
"(",
"\"Return of cond must be a Symbol\"",
")",
"return",
"[",
"]",
",",
"[",
"result",
"]",
",",
"[",
"]",
",",
"[",
"]",
"def",
"_func_wrapper",
"(",
"loop_vars",
")",
":",
"\"\"\"This wrapper unifies\n \"func: loop_vars -> new_loop_vars\"\n and \"func: loop_vars -> (step_output, new_loop_vars)\"\n into \"func: loop_vars -> (list of step_outputs, tuple of new_loop_vars)\n \"\"\"",
"step_output",
",",
"new_loop_vars",
"=",
"func",
"(",
"*",
"loop_vars",
")",
"if",
"step_output",
"is",
"None",
":",
"step_output",
"=",
"[",
"]",
"if",
"new_loop_vars",
"is",
"None",
":",
"new_loop_vars",
"=",
"[",
"]",
"if",
"isinstance",
"(",
"step_output",
",",
"tuple",
")",
":",
"step_output",
"=",
"list",
"(",
"step_output",
")",
"if",
"isinstance",
"(",
"new_loop_vars",
",",
"tuple",
")",
":",
"new_loop_vars",
"=",
"list",
"(",
"new_loop_vars",
")",
"step_output",
",",
"out_fmt",
"=",
"_flatten",
"(",
"step_output",
",",
"\"while output\"",
")",
"new_loop_vars",
",",
"var_fmt",
"=",
"_flatten",
"(",
"new_loop_vars",
",",
"\"while loop_vars\"",
")",
"if",
"len",
"(",
"loop_vars",
")",
"!=",
"len",
"(",
"new_loop_vars",
")",
":",
"raise",
"ValueError",
"(",
"\"The number of loop_vars should be consistent during the loop\"",
")",
"return",
"step_output",
",",
"new_loop_vars",
",",
"out_fmt",
",",
"var_fmt",
"def",
"_create_subgraph",
"(",
"graph_vars",
",",
"graph_func",
",",
"subgraph_name",
")",
":",
"subgraph_name",
"=",
"_get_unique_subgraph_name",
"(",
"subgraph_name",
")",
"with",
"AttrScope",
"(",
"__subgraph_name__",
"=",
"subgraph_name",
")",
":",
"# create new variables with the same name,",
"# them feed them to the given func",
"graph_vars",
",",
"var_fmt",
"=",
"_flatten",
"(",
"graph_vars",
",",
"\"while loop_vars\"",
")",
"new_graph_vars",
"=",
"[",
"symbol",
".",
"var",
"(",
"_get_sym_uniq_name",
"(",
"sym",
")",
")",
"for",
"sym",
"in",
"graph_vars",
"]",
"new_graph_vars",
",",
"_",
"=",
"_regroup",
"(",
"new_graph_vars",
",",
"var_fmt",
")",
"outputs",
",",
"final_state",
",",
"out_fmt",
",",
"var_fmt",
"=",
"graph_func",
"(",
"new_graph_vars",
")",
"# first `num_out_data` elements belong to `outputs`",
"# other elements belong to `final_state`",
"num_out_data",
"=",
"len",
"(",
"outputs",
")",
"num_outputs",
"=",
"len",
"(",
"outputs",
")",
"+",
"len",
"(",
"final_state",
")",
"# nnvm cut-graph does not allow inputs and outputs overlap",
"# so we calculate the name of inputs, and copy outputs once it overlaps with inputs",
"# group all outputs of graph_func",
"all_input_names",
"=",
"symbol",
".",
"Group",
"(",
"outputs",
"+",
"final_state",
")",
".",
"list_inputs",
"(",
")",
"in_input",
"=",
"lambda",
"x",
":",
"x",
".",
"name",
"in",
"all_input_names",
"in_graph",
"=",
"lambda",
"x",
":",
"x",
".",
"list_attr",
"(",
")",
".",
"get",
"(",
"\"__subgraph_name__\"",
",",
"\"\"",
")",
"==",
"subgraph_name",
"make_identity",
"=",
"lambda",
"x",
":",
"symbol",
".",
"op",
".",
"identity",
"(",
"x",
")",
"if",
"in_input",
"(",
"x",
")",
"or",
"not",
"in_graph",
"(",
"x",
")",
"else",
"x",
"graph",
"=",
"symbol",
".",
"Group",
"(",
"list",
"(",
"map",
"(",
"make_identity",
",",
"outputs",
"+",
"final_state",
")",
")",
")",
"return",
"graph",
",",
"num_out_data",
",",
"num_outputs",
",",
"out_fmt",
",",
"var_fmt",
"flatten_loop_vars",
",",
"init_loop_var_fmt",
"=",
"_flatten",
"(",
"loop_vars",
",",
"\"while loop_vars\"",
")",
"_check_data",
"(",
"flatten_loop_vars",
",",
"symbol",
".",
"Symbol",
",",
"\"loop_vars should be a symbol or a nested list of symbols\"",
")",
"def",
"_union_inputs",
"(",
"*",
"graphs",
")",
":",
"# Given a list of graphs, each whose inputs are either from loop_vars or other variables.",
"# 1) calculate a list `inputs`, the union of their inputs.",
"# 2) for each graph, determine in which indices their inputs reside in `inputs`",
"# 3) for each variable in the input of `graph`, find which index it is",
"inputs",
"=",
"[",
"]",
"# List[Symbol], result of 1)",
"locs",
"=",
"[",
"]",
"# List[Tuple(List[Int], List[Int])], a list of tuples,",
"# where tuples are results of 2) and 3)",
"input_id_to_loc",
"=",
"{",
"}",
"# Dict[int, int], given id(sym), input_id_to_loc maps it",
"# to a `loc`, where inputs[loc] = sym",
"for",
"graph",
"in",
"graphs",
":",
"# some loop_vars are inputs to `graph`, some are not",
"name_to_loop_vars",
"=",
"{",
"_get_sym_uniq_name",
"(",
"sym",
")",
":",
"sym",
"for",
"sym",
"in",
"flatten_loop_vars",
"}",
"# other inputs to `graph` created by cut_graph",
"name_to_cut_g_syms",
"=",
"{",
"sym",
".",
"list_outputs",
"(",
")",
"[",
"0",
"]",
":",
"sym",
"for",
"sym",
"in",
"_cut_subgraph",
"(",
"graph",
")",
"}",
"# input_syms: all inputs to the `graph`",
"name_to_input_syms",
"=",
"{",
"sym",
".",
"name",
":",
"sym",
"for",
"sym",
"in",
"_get_graph_inputs",
"(",
"graph",
")",
"}",
"# also we collect the mapping from var's name to var's loc in loop_vars",
"name_to_var_locs",
"=",
"{",
"_get_sym_uniq_name",
"(",
"sym",
")",
":",
"i",
"for",
"i",
",",
"sym",
"in",
"enumerate",
"(",
"flatten_loop_vars",
")",
"}",
"# collect arguments for each subgraph",
"input_locs",
"=",
"[",
"]",
"# results from the second step",
"var_locs",
"=",
"[",
"-",
"1",
"]",
"*",
"len",
"(",
"flatten_loop_vars",
")",
"# results from the third step",
"subg_input_names",
"=",
"graph",
".",
"list_inputs",
"(",
")",
"assert",
"len",
"(",
"set",
"(",
"subg_input_names",
")",
")",
"==",
"len",
"(",
"subg_input_names",
")",
",",
"\"The inputs of the subgraph don't have unique names: \"",
"+",
"str",
"(",
"subg_input_names",
")",
"for",
"name",
"in",
"subg_input_names",
":",
"assert",
"name",
"in",
"name_to_input_syms",
"# it should obviously hold",
"# name -> sym",
"if",
"name",
"in",
"name_to_loop_vars",
":",
"sym",
"=",
"name_to_loop_vars",
"[",
"name",
"]",
"elif",
"name",
"in",
"name_to_cut_g_syms",
":",
"sym",
"=",
"name_to_cut_g_syms",
"[",
"name",
"]",
"else",
":",
"sym",
"=",
"copy",
".",
"deepcopy",
"(",
"name_to_input_syms",
"[",
"name",
"]",
")",
"# do 2), and 1) is implicitly done",
"if",
"id",
"(",
"sym",
")",
"in",
"input_id_to_loc",
":",
"loc",
"=",
"input_id_to_loc",
"[",
"id",
"(",
"sym",
")",
"]",
"else",
":",
"loc",
"=",
"len",
"(",
"input_id_to_loc",
")",
"inputs",
".",
"append",
"(",
"sym",
")",
"input_id_to_loc",
"[",
"id",
"(",
"sym",
")",
"]",
"=",
"loc",
"input_locs",
".",
"append",
"(",
"loc",
")",
"# do 3)",
"if",
"name",
"in",
"name_to_var_locs",
":",
"var_locs",
"[",
"name_to_var_locs",
"[",
"name",
"]",
"]",
"=",
"len",
"(",
"input_locs",
")",
"-",
"1",
"locs",
".",
"append",
"(",
"(",
"input_locs",
",",
"var_locs",
")",
")",
"return",
"inputs",
",",
"locs",
"if",
"max_iterations",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"max_iterations should be specified\"",
")",
"max_iterations",
"=",
"_to_python_scalar",
"(",
"max_iterations",
",",
"int",
",",
"\"max_iteration\"",
")",
"# It should be work as fine if loop_vars are empty I guess,",
"# but it is semantically unnecessary to include this case.",
"if",
"len",
"(",
"loop_vars",
")",
"==",
"0",
":",
"raise",
"ValueError",
"(",
"\"loop_vars should contain at least one element\"",
")",
"# create graph for `cond'",
"cond_g",
",",
"num_out_data",
",",
"num_outputs",
",",
"_",
",",
"_",
"=",
"_create_subgraph",
"(",
"loop_vars",
",",
"_cond_wrapper",
",",
"name",
"+",
"\"_cond\"",
")",
"assert",
"num_out_data",
"==",
"0",
"assert",
"num_outputs",
"==",
"1",
"# create graph for `func`",
"func_g",
",",
"num_out_data",
",",
"num_outputs",
",",
"out_fmt",
",",
"_",
"=",
"_create_subgraph",
"(",
"loop_vars",
",",
"_func_wrapper",
",",
"name",
"+",
"\"_func\"",
")",
"# find symbols used in either cond_g or func_g",
"input_syms",
",",
"(",
"(",
"cond_input_locs",
",",
"_",
")",
",",
"(",
"func_input_locs",
",",
"func_var_locs",
")",
")",
"=",
"_union_inputs",
"(",
"cond_g",
",",
"func_g",
")",
"for",
"i_th",
",",
"loc",
"in",
"enumerate",
"(",
"func_var_locs",
",",
"1",
")",
":",
"if",
"loc",
"==",
"-",
"1",
":",
"raise",
"ValueError",
"(",
"\"The %d-th loop_var doesn't involve into the computation\"",
"%",
"i_th",
")",
"result",
"=",
"symbol",
".",
"_internal",
".",
"_while_loop",
"(",
"cond_g",
",",
"func_g",
",",
"*",
"input_syms",
",",
"max_iterations",
"=",
"max_iterations",
",",
"cond_input_locs",
"=",
"cond_input_locs",
",",
"func_input_locs",
"=",
"func_input_locs",
",",
"func_var_locs",
"=",
"func_var_locs",
",",
"num_out_data",
"=",
"num_out_data",
",",
"num_outputs",
"=",
"num_outputs",
")",
"outputs",
"=",
"[",
"result",
"[",
"i",
"]",
"for",
"i",
"in",
"range",
"(",
"num_out_data",
")",
"]",
"outputs",
",",
"_",
"=",
"_regroup",
"(",
"outputs",
",",
"out_fmt",
")",
"final_loop_vars",
"=",
"[",
"result",
"[",
"i",
"]",
"for",
"i",
"in",
"range",
"(",
"num_out_data",
",",
"num_outputs",
")",
"]",
"final_loop_vars",
",",
"_",
"=",
"_regroup",
"(",
"final_loop_vars",
",",
"init_loop_var_fmt",
")",
"return",
"outputs",
",",
"final_loop_vars"
] |
Run a while loop with user-defined computation and loop condition.
This operator simulates a while loop which iterately does customized computation
as long as the condition is satisfied.
`loop_vars` is a Symbol or nested lists of Symbols on which the computation uses.
`cond` is a user-defined function, used as the loop condition.
It consumes `loop_vars`, and produces a scalar MXNet symbol,
indicating the termination of the loop.
The loop ends when `cond` returns false (zero).
The `cond` is variadic, and its signature should be
`cond(*loop_vars) => Symbol`.
`func` is a user-defined function, used as the loop body.
It also consumes `loop_vars`, and produces `step_output` and `new_loop_vars` at each step.
In each step, `step_output` should contain the same number elements.
Through all steps, the i-th element of `step_output` should have the same shape and dtype.
Also, `new_loop_vars` should contain the same number of elements as `loop_vars`,
and the corresponding element should have the same shape and dtype.
The `func` is variadic, and its signature should be
`func(*loop_vars) =>
(Symbol or nested List[Symbol] step_output, Symbol or nested List[Symbol] new_loop_vars)`.
`max_iterations` is a scalar that defines the maximum number of iterations allowed.
This function returns two lists.
The first list has the length of `|step_output|`,
in which the i-th element are all i-th elements of
`step_output` from all steps, stacked along axis 0.
The second list has the length of `|loop_vars|`,
which represents final states of loop variables.
.. warning::
For now, the axis 0 of all Symbols in the first list are `max_iterations`,
due to lack of dynamic shape inference.
.. warning::
Even if `cond` is never satisfied,
while_loop returns a list of outputs with inferred dtype and shape.
This is different from the Symbol version,
where in this case `step_outputs` are assumed as an empty list.
Parameters
----------
cond: a Python function.
The loop condition.
func: a Python function.
The loop body.
loop_vars: a Symbol or nested lists of Symbol.
The initial values of the loop variables.
max_iterations: a python int.
Maximum number of iterations.
Returns
------
outputs: a Symbol or nested lists of Symbols
stacked output from each step
states: a Symbol or nested lists of Symbols
final state
Examples
--------
>>> cond = lambda i, s: i <= 5
>>> func = lambda i, s: ([i + s], [i + 1, s + i])
>>> loop_vars = (mx.sym.var('i'), mx.sym.var('s'))
>>> outputs, states = mx.sym.contrib.while_loop(cond, func, loop_vars, max_iterations=10)
|
[
"Run",
"a",
"while",
"loop",
"with",
"user",
"-",
"defined",
"computation",
"and",
"loop",
"condition",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/contrib.py#L375-L596
|
train
|
apache/incubator-mxnet
|
python/mxnet/symbol/contrib.py
|
cond
|
def cond(pred, then_func, else_func, name="cond"):
"""Run an if-then-else using user-defined condition and computation
This operator simulates a if-like branch which chooses to do one of
the two customized computations according to the specified condition.
`pred` is a scalar MXNet Symbol,
indicating which branch of computation should be used.
`then_func` is a user-defined function, used as computation of the then branch.
It produces `outputs`, which is a list of Symbols.
The signature of `then_func` should be
`then_func() => nested List[Symbol]`.
`else_func` is a user-defined function, used as computation of the else branch.
It produces `outputs`, which is a list of Symbols.
The signature of `else_func` should be
`else_func() => nested List[Symbol]`.
The `outputs` produces by `then_func` and `else_func` should have the same number
of elements, all of which should be in the same shape, of the same dtype and stype.
This function returns a list of symbols, representing the computation result.
Parameters
----------
pred: a MXNet Symbol representing a scalar.
The branch condition.
then_func: a Python function.
The computation to be executed if `pred` is true.
else_func: a Python function.
The computation to be executed if `pred` is false.
Returns
-------
outputs: a Symbol or nested lists of Symbols, representing the result of computation.
Examples
--------
>>> a, b = mx.sym.var('a'), mx.sym.var('b')
>>> pred = a * b < 5
>>> then_func = lambda: (a + 5) * (b + 5)
>>> else_func = lambda: (a - 5) * (b - 5)
>>> outputs = mx.sym.contrib.cond(pred, then_func, else_func)
"""
def _create_subgraph(graph_vars, graph_func, subgraph_name):
subgraph_name = _get_unique_subgraph_name(subgraph_name)
with AttrScope(__subgraph_name__=subgraph_name):
# create new variables with the same name,
# them feed them to the given func
new_graph_vars = [symbol.var(sym.name) for sym in graph_vars]
outputs = graph_func(*new_graph_vars)
outputs, out_fmt = _flatten(outputs, "cond outputs")
num_outputs = len(outputs)
# nnvm cut-graph does not allow inputs and outputs overlap
# so we calculate the name of inputs, and copy outputs once it overlaps with inputs
# group all outputs of graph_func
all_input_names = symbol.Group(outputs).list_inputs()
in_input = lambda x: x.name in all_input_names
in_graph = lambda x: x.list_attr().get("__subgraph_name__", "") == subgraph_name
make_identity = lambda x: symbol.op.identity(x) if in_input(x) or not in_graph(x) \
else x
graph = symbol.Group(list(map(make_identity, outputs)))
return graph, num_outputs, out_fmt
def _union_inputs(*graphs):
# Given a list of graphs, each whose inputs are either from input_vars or other variables.
# 1) calculate a list `inputs`, the union of their inputs.
# 2) for each graph, determine in which indices their inputs reside in `inputs`
# 3) for each variable in the input of `graph`, find which index it is
inputs = [] # List[Symbol], result of 1)
locs = [] # List[Tuple(List[Int], List[Int])], a list of tuples,
# where tuples are results of 2) and 3)
input_id_to_loc = {} # Dict[int, int], given id(sym), input_id_to_loc maps it
# to a `loc`, where inputs[loc] = sym
for graph in graphs:
# some input_vars are inputs to `graph`, some are not
name_to_input_vars = {sym.name: sym for sym in inputs}
# other inputs to `graph` created by cut_graph
name_to_cut_g_syms = {sym.list_outputs()[0]: sym for sym in _cut_subgraph(graph)}
# input_syms: all inputs to the `graph`
name_to_input_syms = {sym.name: sym for sym in _get_graph_inputs(graph)}
# collect arguments for each subgraph
input_locs = [] # results from the second step
for name in graph.list_inputs():
assert name in name_to_input_syms # it should obviously hold
# name -> sym
if name in name_to_input_vars:
sym = name_to_input_vars[name]
elif name in name_to_cut_g_syms:
sym = name_to_cut_g_syms[name]
else:
sym = copy.deepcopy(name_to_input_syms[name])
# do 2), and 1) is implicitly done
if id(sym) in input_id_to_loc:
loc = input_id_to_loc[id(sym)]
else:
loc = len(input_id_to_loc)
inputs.append(sym)
input_id_to_loc[id(sym)] = loc
input_locs.append(loc)
locs.append(input_locs)
return inputs, locs
inputs = []
# create graph for `cond_func'
cond_g, cond_num_outputs, _ = _create_subgraph(inputs, lambda: pred, name + "_pred")
if cond_num_outputs != 1:
raise ValueError("pred should always be a single output")
# create graph for `then`
then_g, then_num_outputs, then_fmt = _create_subgraph(inputs, then_func, name + "_then")
# create graph for `else`
else_g, else_num_outputs, _ = _create_subgraph(inputs, else_func, name + "_else")
if then_num_outputs != else_num_outputs:
raise ValueError("Number of outputs differs between then-branch and else-branch")
# find symbols used in either cond_g or func_g
input_syms, (cond_input_locs, then_input_locs, else_input_locs) = \
_union_inputs(cond_g, then_g, else_g)
result = symbol._internal._cond(
# [cond, then_g, else_g, *input_syms]
cond_g,
then_g,
else_g,
*input_syms,
cond_input_locs=cond_input_locs,
then_input_locs=then_input_locs,
else_input_locs=else_input_locs,
num_outputs=then_num_outputs
)
outputs = [result[i] for i in range(then_num_outputs)]
outputs, _ = _regroup(outputs, then_fmt)
return outputs
|
python
|
def cond(pred, then_func, else_func, name="cond"):
"""Run an if-then-else using user-defined condition and computation
This operator simulates a if-like branch which chooses to do one of
the two customized computations according to the specified condition.
`pred` is a scalar MXNet Symbol,
indicating which branch of computation should be used.
`then_func` is a user-defined function, used as computation of the then branch.
It produces `outputs`, which is a list of Symbols.
The signature of `then_func` should be
`then_func() => nested List[Symbol]`.
`else_func` is a user-defined function, used as computation of the else branch.
It produces `outputs`, which is a list of Symbols.
The signature of `else_func` should be
`else_func() => nested List[Symbol]`.
The `outputs` produces by `then_func` and `else_func` should have the same number
of elements, all of which should be in the same shape, of the same dtype and stype.
This function returns a list of symbols, representing the computation result.
Parameters
----------
pred: a MXNet Symbol representing a scalar.
The branch condition.
then_func: a Python function.
The computation to be executed if `pred` is true.
else_func: a Python function.
The computation to be executed if `pred` is false.
Returns
-------
outputs: a Symbol or nested lists of Symbols, representing the result of computation.
Examples
--------
>>> a, b = mx.sym.var('a'), mx.sym.var('b')
>>> pred = a * b < 5
>>> then_func = lambda: (a + 5) * (b + 5)
>>> else_func = lambda: (a - 5) * (b - 5)
>>> outputs = mx.sym.contrib.cond(pred, then_func, else_func)
"""
def _create_subgraph(graph_vars, graph_func, subgraph_name):
subgraph_name = _get_unique_subgraph_name(subgraph_name)
with AttrScope(__subgraph_name__=subgraph_name):
# create new variables with the same name,
# them feed them to the given func
new_graph_vars = [symbol.var(sym.name) for sym in graph_vars]
outputs = graph_func(*new_graph_vars)
outputs, out_fmt = _flatten(outputs, "cond outputs")
num_outputs = len(outputs)
# nnvm cut-graph does not allow inputs and outputs overlap
# so we calculate the name of inputs, and copy outputs once it overlaps with inputs
# group all outputs of graph_func
all_input_names = symbol.Group(outputs).list_inputs()
in_input = lambda x: x.name in all_input_names
in_graph = lambda x: x.list_attr().get("__subgraph_name__", "") == subgraph_name
make_identity = lambda x: symbol.op.identity(x) if in_input(x) or not in_graph(x) \
else x
graph = symbol.Group(list(map(make_identity, outputs)))
return graph, num_outputs, out_fmt
def _union_inputs(*graphs):
# Given a list of graphs, each whose inputs are either from input_vars or other variables.
# 1) calculate a list `inputs`, the union of their inputs.
# 2) for each graph, determine in which indices their inputs reside in `inputs`
# 3) for each variable in the input of `graph`, find which index it is
inputs = [] # List[Symbol], result of 1)
locs = [] # List[Tuple(List[Int], List[Int])], a list of tuples,
# where tuples are results of 2) and 3)
input_id_to_loc = {} # Dict[int, int], given id(sym), input_id_to_loc maps it
# to a `loc`, where inputs[loc] = sym
for graph in graphs:
# some input_vars are inputs to `graph`, some are not
name_to_input_vars = {sym.name: sym for sym in inputs}
# other inputs to `graph` created by cut_graph
name_to_cut_g_syms = {sym.list_outputs()[0]: sym for sym in _cut_subgraph(graph)}
# input_syms: all inputs to the `graph`
name_to_input_syms = {sym.name: sym for sym in _get_graph_inputs(graph)}
# collect arguments for each subgraph
input_locs = [] # results from the second step
for name in graph.list_inputs():
assert name in name_to_input_syms # it should obviously hold
# name -> sym
if name in name_to_input_vars:
sym = name_to_input_vars[name]
elif name in name_to_cut_g_syms:
sym = name_to_cut_g_syms[name]
else:
sym = copy.deepcopy(name_to_input_syms[name])
# do 2), and 1) is implicitly done
if id(sym) in input_id_to_loc:
loc = input_id_to_loc[id(sym)]
else:
loc = len(input_id_to_loc)
inputs.append(sym)
input_id_to_loc[id(sym)] = loc
input_locs.append(loc)
locs.append(input_locs)
return inputs, locs
inputs = []
# create graph for `cond_func'
cond_g, cond_num_outputs, _ = _create_subgraph(inputs, lambda: pred, name + "_pred")
if cond_num_outputs != 1:
raise ValueError("pred should always be a single output")
# create graph for `then`
then_g, then_num_outputs, then_fmt = _create_subgraph(inputs, then_func, name + "_then")
# create graph for `else`
else_g, else_num_outputs, _ = _create_subgraph(inputs, else_func, name + "_else")
if then_num_outputs != else_num_outputs:
raise ValueError("Number of outputs differs between then-branch and else-branch")
# find symbols used in either cond_g or func_g
input_syms, (cond_input_locs, then_input_locs, else_input_locs) = \
_union_inputs(cond_g, then_g, else_g)
result = symbol._internal._cond(
# [cond, then_g, else_g, *input_syms]
cond_g,
then_g,
else_g,
*input_syms,
cond_input_locs=cond_input_locs,
then_input_locs=then_input_locs,
else_input_locs=else_input_locs,
num_outputs=then_num_outputs
)
outputs = [result[i] for i in range(then_num_outputs)]
outputs, _ = _regroup(outputs, then_fmt)
return outputs
|
[
"def",
"cond",
"(",
"pred",
",",
"then_func",
",",
"else_func",
",",
"name",
"=",
"\"cond\"",
")",
":",
"def",
"_create_subgraph",
"(",
"graph_vars",
",",
"graph_func",
",",
"subgraph_name",
")",
":",
"subgraph_name",
"=",
"_get_unique_subgraph_name",
"(",
"subgraph_name",
")",
"with",
"AttrScope",
"(",
"__subgraph_name__",
"=",
"subgraph_name",
")",
":",
"# create new variables with the same name,",
"# them feed them to the given func",
"new_graph_vars",
"=",
"[",
"symbol",
".",
"var",
"(",
"sym",
".",
"name",
")",
"for",
"sym",
"in",
"graph_vars",
"]",
"outputs",
"=",
"graph_func",
"(",
"*",
"new_graph_vars",
")",
"outputs",
",",
"out_fmt",
"=",
"_flatten",
"(",
"outputs",
",",
"\"cond outputs\"",
")",
"num_outputs",
"=",
"len",
"(",
"outputs",
")",
"# nnvm cut-graph does not allow inputs and outputs overlap",
"# so we calculate the name of inputs, and copy outputs once it overlaps with inputs",
"# group all outputs of graph_func",
"all_input_names",
"=",
"symbol",
".",
"Group",
"(",
"outputs",
")",
".",
"list_inputs",
"(",
")",
"in_input",
"=",
"lambda",
"x",
":",
"x",
".",
"name",
"in",
"all_input_names",
"in_graph",
"=",
"lambda",
"x",
":",
"x",
".",
"list_attr",
"(",
")",
".",
"get",
"(",
"\"__subgraph_name__\"",
",",
"\"\"",
")",
"==",
"subgraph_name",
"make_identity",
"=",
"lambda",
"x",
":",
"symbol",
".",
"op",
".",
"identity",
"(",
"x",
")",
"if",
"in_input",
"(",
"x",
")",
"or",
"not",
"in_graph",
"(",
"x",
")",
"else",
"x",
"graph",
"=",
"symbol",
".",
"Group",
"(",
"list",
"(",
"map",
"(",
"make_identity",
",",
"outputs",
")",
")",
")",
"return",
"graph",
",",
"num_outputs",
",",
"out_fmt",
"def",
"_union_inputs",
"(",
"*",
"graphs",
")",
":",
"# Given a list of graphs, each whose inputs are either from input_vars or other variables.",
"# 1) calculate a list `inputs`, the union of their inputs.",
"# 2) for each graph, determine in which indices their inputs reside in `inputs`",
"# 3) for each variable in the input of `graph`, find which index it is",
"inputs",
"=",
"[",
"]",
"# List[Symbol], result of 1)",
"locs",
"=",
"[",
"]",
"# List[Tuple(List[Int], List[Int])], a list of tuples,",
"# where tuples are results of 2) and 3)",
"input_id_to_loc",
"=",
"{",
"}",
"# Dict[int, int], given id(sym), input_id_to_loc maps it",
"# to a `loc`, where inputs[loc] = sym",
"for",
"graph",
"in",
"graphs",
":",
"# some input_vars are inputs to `graph`, some are not",
"name_to_input_vars",
"=",
"{",
"sym",
".",
"name",
":",
"sym",
"for",
"sym",
"in",
"inputs",
"}",
"# other inputs to `graph` created by cut_graph",
"name_to_cut_g_syms",
"=",
"{",
"sym",
".",
"list_outputs",
"(",
")",
"[",
"0",
"]",
":",
"sym",
"for",
"sym",
"in",
"_cut_subgraph",
"(",
"graph",
")",
"}",
"# input_syms: all inputs to the `graph`",
"name_to_input_syms",
"=",
"{",
"sym",
".",
"name",
":",
"sym",
"for",
"sym",
"in",
"_get_graph_inputs",
"(",
"graph",
")",
"}",
"# collect arguments for each subgraph",
"input_locs",
"=",
"[",
"]",
"# results from the second step",
"for",
"name",
"in",
"graph",
".",
"list_inputs",
"(",
")",
":",
"assert",
"name",
"in",
"name_to_input_syms",
"# it should obviously hold",
"# name -> sym",
"if",
"name",
"in",
"name_to_input_vars",
":",
"sym",
"=",
"name_to_input_vars",
"[",
"name",
"]",
"elif",
"name",
"in",
"name_to_cut_g_syms",
":",
"sym",
"=",
"name_to_cut_g_syms",
"[",
"name",
"]",
"else",
":",
"sym",
"=",
"copy",
".",
"deepcopy",
"(",
"name_to_input_syms",
"[",
"name",
"]",
")",
"# do 2), and 1) is implicitly done",
"if",
"id",
"(",
"sym",
")",
"in",
"input_id_to_loc",
":",
"loc",
"=",
"input_id_to_loc",
"[",
"id",
"(",
"sym",
")",
"]",
"else",
":",
"loc",
"=",
"len",
"(",
"input_id_to_loc",
")",
"inputs",
".",
"append",
"(",
"sym",
")",
"input_id_to_loc",
"[",
"id",
"(",
"sym",
")",
"]",
"=",
"loc",
"input_locs",
".",
"append",
"(",
"loc",
")",
"locs",
".",
"append",
"(",
"input_locs",
")",
"return",
"inputs",
",",
"locs",
"inputs",
"=",
"[",
"]",
"# create graph for `cond_func'",
"cond_g",
",",
"cond_num_outputs",
",",
"_",
"=",
"_create_subgraph",
"(",
"inputs",
",",
"lambda",
":",
"pred",
",",
"name",
"+",
"\"_pred\"",
")",
"if",
"cond_num_outputs",
"!=",
"1",
":",
"raise",
"ValueError",
"(",
"\"pred should always be a single output\"",
")",
"# create graph for `then`",
"then_g",
",",
"then_num_outputs",
",",
"then_fmt",
"=",
"_create_subgraph",
"(",
"inputs",
",",
"then_func",
",",
"name",
"+",
"\"_then\"",
")",
"# create graph for `else`",
"else_g",
",",
"else_num_outputs",
",",
"_",
"=",
"_create_subgraph",
"(",
"inputs",
",",
"else_func",
",",
"name",
"+",
"\"_else\"",
")",
"if",
"then_num_outputs",
"!=",
"else_num_outputs",
":",
"raise",
"ValueError",
"(",
"\"Number of outputs differs between then-branch and else-branch\"",
")",
"# find symbols used in either cond_g or func_g",
"input_syms",
",",
"(",
"cond_input_locs",
",",
"then_input_locs",
",",
"else_input_locs",
")",
"=",
"_union_inputs",
"(",
"cond_g",
",",
"then_g",
",",
"else_g",
")",
"result",
"=",
"symbol",
".",
"_internal",
".",
"_cond",
"(",
"# [cond, then_g, else_g, *input_syms]",
"cond_g",
",",
"then_g",
",",
"else_g",
",",
"*",
"input_syms",
",",
"cond_input_locs",
"=",
"cond_input_locs",
",",
"then_input_locs",
"=",
"then_input_locs",
",",
"else_input_locs",
"=",
"else_input_locs",
",",
"num_outputs",
"=",
"then_num_outputs",
")",
"outputs",
"=",
"[",
"result",
"[",
"i",
"]",
"for",
"i",
"in",
"range",
"(",
"then_num_outputs",
")",
"]",
"outputs",
",",
"_",
"=",
"_regroup",
"(",
"outputs",
",",
"then_fmt",
")",
"return",
"outputs"
] |
Run an if-then-else using user-defined condition and computation
This operator simulates a if-like branch which chooses to do one of
the two customized computations according to the specified condition.
`pred` is a scalar MXNet Symbol,
indicating which branch of computation should be used.
`then_func` is a user-defined function, used as computation of the then branch.
It produces `outputs`, which is a list of Symbols.
The signature of `then_func` should be
`then_func() => nested List[Symbol]`.
`else_func` is a user-defined function, used as computation of the else branch.
It produces `outputs`, which is a list of Symbols.
The signature of `else_func` should be
`else_func() => nested List[Symbol]`.
The `outputs` produces by `then_func` and `else_func` should have the same number
of elements, all of which should be in the same shape, of the same dtype and stype.
This function returns a list of symbols, representing the computation result.
Parameters
----------
pred: a MXNet Symbol representing a scalar.
The branch condition.
then_func: a Python function.
The computation to be executed if `pred` is true.
else_func: a Python function.
The computation to be executed if `pred` is false.
Returns
-------
outputs: a Symbol or nested lists of Symbols, representing the result of computation.
Examples
--------
>>> a, b = mx.sym.var('a'), mx.sym.var('b')
>>> pred = a * b < 5
>>> then_func = lambda: (a + 5) * (b + 5)
>>> else_func = lambda: (a - 5) * (b - 5)
>>> outputs = mx.sym.contrib.cond(pred, then_func, else_func)
|
[
"Run",
"an",
"if",
"-",
"then",
"-",
"else",
"using",
"user",
"-",
"defined",
"condition",
"and",
"computation"
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/symbol/contrib.py#L598-L729
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/text/vocab.py
|
Vocabulary._index_unknown_and_reserved_tokens
|
def _index_unknown_and_reserved_tokens(self, unknown_token, reserved_tokens):
"""Indexes unknown and reserved tokens."""
self._unknown_token = unknown_token
# Thus, constants.UNKNOWN_IDX must be 0.
self._idx_to_token = [unknown_token]
if reserved_tokens is None:
self._reserved_tokens = None
else:
self._reserved_tokens = reserved_tokens[:]
self._idx_to_token.extend(reserved_tokens)
self._token_to_idx = {token: idx for idx, token in enumerate(self._idx_to_token)}
|
python
|
def _index_unknown_and_reserved_tokens(self, unknown_token, reserved_tokens):
"""Indexes unknown and reserved tokens."""
self._unknown_token = unknown_token
# Thus, constants.UNKNOWN_IDX must be 0.
self._idx_to_token = [unknown_token]
if reserved_tokens is None:
self._reserved_tokens = None
else:
self._reserved_tokens = reserved_tokens[:]
self._idx_to_token.extend(reserved_tokens)
self._token_to_idx = {token: idx for idx, token in enumerate(self._idx_to_token)}
|
[
"def",
"_index_unknown_and_reserved_tokens",
"(",
"self",
",",
"unknown_token",
",",
"reserved_tokens",
")",
":",
"self",
".",
"_unknown_token",
"=",
"unknown_token",
"# Thus, constants.UNKNOWN_IDX must be 0.",
"self",
".",
"_idx_to_token",
"=",
"[",
"unknown_token",
"]",
"if",
"reserved_tokens",
"is",
"None",
":",
"self",
".",
"_reserved_tokens",
"=",
"None",
"else",
":",
"self",
".",
"_reserved_tokens",
"=",
"reserved_tokens",
"[",
":",
"]",
"self",
".",
"_idx_to_token",
".",
"extend",
"(",
"reserved_tokens",
")",
"self",
".",
"_token_to_idx",
"=",
"{",
"token",
":",
"idx",
"for",
"idx",
",",
"token",
"in",
"enumerate",
"(",
"self",
".",
"_idx_to_token",
")",
"}"
] |
Indexes unknown and reserved tokens.
|
[
"Indexes",
"unknown",
"and",
"reserved",
"tokens",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/vocab.py#L94-L107
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/text/vocab.py
|
Vocabulary._index_counter_keys
|
def _index_counter_keys(self, counter, unknown_token, reserved_tokens, most_freq_count,
min_freq):
"""Indexes keys of `counter`.
Indexes keys of `counter` according to frequency thresholds such as `most_freq_count` and
`min_freq`.
"""
assert isinstance(counter, collections.Counter), \
'`counter` must be an instance of collections.Counter.'
unknown_and_reserved_tokens = set(reserved_tokens) if reserved_tokens is not None else set()
unknown_and_reserved_tokens.add(unknown_token)
token_freqs = sorted(counter.items(), key=lambda x: x[0])
token_freqs.sort(key=lambda x: x[1], reverse=True)
token_cap = len(unknown_and_reserved_tokens) + (
len(counter) if most_freq_count is None else most_freq_count)
for token, freq in token_freqs:
if freq < min_freq or len(self._idx_to_token) == token_cap:
break
if token not in unknown_and_reserved_tokens:
self._idx_to_token.append(token)
self._token_to_idx[token] = len(self._idx_to_token) - 1
|
python
|
def _index_counter_keys(self, counter, unknown_token, reserved_tokens, most_freq_count,
min_freq):
"""Indexes keys of `counter`.
Indexes keys of `counter` according to frequency thresholds such as `most_freq_count` and
`min_freq`.
"""
assert isinstance(counter, collections.Counter), \
'`counter` must be an instance of collections.Counter.'
unknown_and_reserved_tokens = set(reserved_tokens) if reserved_tokens is not None else set()
unknown_and_reserved_tokens.add(unknown_token)
token_freqs = sorted(counter.items(), key=lambda x: x[0])
token_freqs.sort(key=lambda x: x[1], reverse=True)
token_cap = len(unknown_and_reserved_tokens) + (
len(counter) if most_freq_count is None else most_freq_count)
for token, freq in token_freqs:
if freq < min_freq or len(self._idx_to_token) == token_cap:
break
if token not in unknown_and_reserved_tokens:
self._idx_to_token.append(token)
self._token_to_idx[token] = len(self._idx_to_token) - 1
|
[
"def",
"_index_counter_keys",
"(",
"self",
",",
"counter",
",",
"unknown_token",
",",
"reserved_tokens",
",",
"most_freq_count",
",",
"min_freq",
")",
":",
"assert",
"isinstance",
"(",
"counter",
",",
"collections",
".",
"Counter",
")",
",",
"'`counter` must be an instance of collections.Counter.'",
"unknown_and_reserved_tokens",
"=",
"set",
"(",
"reserved_tokens",
")",
"if",
"reserved_tokens",
"is",
"not",
"None",
"else",
"set",
"(",
")",
"unknown_and_reserved_tokens",
".",
"add",
"(",
"unknown_token",
")",
"token_freqs",
"=",
"sorted",
"(",
"counter",
".",
"items",
"(",
")",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
")",
"token_freqs",
".",
"sort",
"(",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"1",
"]",
",",
"reverse",
"=",
"True",
")",
"token_cap",
"=",
"len",
"(",
"unknown_and_reserved_tokens",
")",
"+",
"(",
"len",
"(",
"counter",
")",
"if",
"most_freq_count",
"is",
"None",
"else",
"most_freq_count",
")",
"for",
"token",
",",
"freq",
"in",
"token_freqs",
":",
"if",
"freq",
"<",
"min_freq",
"or",
"len",
"(",
"self",
".",
"_idx_to_token",
")",
"==",
"token_cap",
":",
"break",
"if",
"token",
"not",
"in",
"unknown_and_reserved_tokens",
":",
"self",
".",
"_idx_to_token",
".",
"append",
"(",
"token",
")",
"self",
".",
"_token_to_idx",
"[",
"token",
"]",
"=",
"len",
"(",
"self",
".",
"_idx_to_token",
")",
"-",
"1"
] |
Indexes keys of `counter`.
Indexes keys of `counter` according to frequency thresholds such as `most_freq_count` and
`min_freq`.
|
[
"Indexes",
"keys",
"of",
"counter",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/vocab.py#L109-L135
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/text/vocab.py
|
Vocabulary.to_indices
|
def to_indices(self, tokens):
"""Converts tokens to indices according to the vocabulary.
Parameters
----------
tokens : str or list of strs
A source token or tokens to be converted.
Returns
-------
int or list of ints
A token index or a list of token indices according to the vocabulary.
"""
to_reduce = False
if not isinstance(tokens, list):
tokens = [tokens]
to_reduce = True
indices = [self.token_to_idx[token] if token in self.token_to_idx
else C.UNKNOWN_IDX for token in tokens]
return indices[0] if to_reduce else indices
|
python
|
def to_indices(self, tokens):
"""Converts tokens to indices according to the vocabulary.
Parameters
----------
tokens : str or list of strs
A source token or tokens to be converted.
Returns
-------
int or list of ints
A token index or a list of token indices according to the vocabulary.
"""
to_reduce = False
if not isinstance(tokens, list):
tokens = [tokens]
to_reduce = True
indices = [self.token_to_idx[token] if token in self.token_to_idx
else C.UNKNOWN_IDX for token in tokens]
return indices[0] if to_reduce else indices
|
[
"def",
"to_indices",
"(",
"self",
",",
"tokens",
")",
":",
"to_reduce",
"=",
"False",
"if",
"not",
"isinstance",
"(",
"tokens",
",",
"list",
")",
":",
"tokens",
"=",
"[",
"tokens",
"]",
"to_reduce",
"=",
"True",
"indices",
"=",
"[",
"self",
".",
"token_to_idx",
"[",
"token",
"]",
"if",
"token",
"in",
"self",
".",
"token_to_idx",
"else",
"C",
".",
"UNKNOWN_IDX",
"for",
"token",
"in",
"tokens",
"]",
"return",
"indices",
"[",
"0",
"]",
"if",
"to_reduce",
"else",
"indices"
] |
Converts tokens to indices according to the vocabulary.
Parameters
----------
tokens : str or list of strs
A source token or tokens to be converted.
Returns
-------
int or list of ints
A token index or a list of token indices according to the vocabulary.
|
[
"Converts",
"tokens",
"to",
"indices",
"according",
"to",
"the",
"vocabulary",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/vocab.py#L162-L186
|
train
|
apache/incubator-mxnet
|
python/mxnet/contrib/text/vocab.py
|
Vocabulary.to_tokens
|
def to_tokens(self, indices):
"""Converts token indices to tokens according to the vocabulary.
Parameters
----------
indices : int or list of ints
A source token index or token indices to be converted.
Returns
-------
str or list of strs
A token or a list of tokens according to the vocabulary.
"""
to_reduce = False
if not isinstance(indices, list):
indices = [indices]
to_reduce = True
max_idx = len(self.idx_to_token) - 1
tokens = []
for idx in indices:
if not isinstance(idx, int) or idx > max_idx:
raise ValueError('Token index %d in the provided `indices` is invalid.' % idx)
else:
tokens.append(self.idx_to_token[idx])
return tokens[0] if to_reduce else tokens
|
python
|
def to_tokens(self, indices):
"""Converts token indices to tokens according to the vocabulary.
Parameters
----------
indices : int or list of ints
A source token index or token indices to be converted.
Returns
-------
str or list of strs
A token or a list of tokens according to the vocabulary.
"""
to_reduce = False
if not isinstance(indices, list):
indices = [indices]
to_reduce = True
max_idx = len(self.idx_to_token) - 1
tokens = []
for idx in indices:
if not isinstance(idx, int) or idx > max_idx:
raise ValueError('Token index %d in the provided `indices` is invalid.' % idx)
else:
tokens.append(self.idx_to_token[idx])
return tokens[0] if to_reduce else tokens
|
[
"def",
"to_tokens",
"(",
"self",
",",
"indices",
")",
":",
"to_reduce",
"=",
"False",
"if",
"not",
"isinstance",
"(",
"indices",
",",
"list",
")",
":",
"indices",
"=",
"[",
"indices",
"]",
"to_reduce",
"=",
"True",
"max_idx",
"=",
"len",
"(",
"self",
".",
"idx_to_token",
")",
"-",
"1",
"tokens",
"=",
"[",
"]",
"for",
"idx",
"in",
"indices",
":",
"if",
"not",
"isinstance",
"(",
"idx",
",",
"int",
")",
"or",
"idx",
">",
"max_idx",
":",
"raise",
"ValueError",
"(",
"'Token index %d in the provided `indices` is invalid.'",
"%",
"idx",
")",
"else",
":",
"tokens",
".",
"append",
"(",
"self",
".",
"idx_to_token",
"[",
"idx",
"]",
")",
"return",
"tokens",
"[",
"0",
"]",
"if",
"to_reduce",
"else",
"tokens"
] |
Converts token indices to tokens according to the vocabulary.
Parameters
----------
indices : int or list of ints
A source token index or token indices to be converted.
Returns
-------
str or list of strs
A token or a list of tokens according to the vocabulary.
|
[
"Converts",
"token",
"indices",
"to",
"tokens",
"according",
"to",
"the",
"vocabulary",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/contrib/text/vocab.py#L188-L218
|
train
|
apache/incubator-mxnet
|
python/mxnet/io/io.py
|
_make_io_iterator
|
def _make_io_iterator(handle):
"""Create an io iterator by handle."""
name = ctypes.c_char_p()
desc = ctypes.c_char_p()
num_args = mx_uint()
arg_names = ctypes.POINTER(ctypes.c_char_p)()
arg_types = ctypes.POINTER(ctypes.c_char_p)()
arg_descs = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXDataIterGetIterInfo( \
handle, ctypes.byref(name), ctypes.byref(desc), \
ctypes.byref(num_args), \
ctypes.byref(arg_names), \
ctypes.byref(arg_types), \
ctypes.byref(arg_descs)))
iter_name = py_str(name.value)
narg = int(num_args.value)
param_str = _build_param_doc(
[py_str(arg_names[i]) for i in range(narg)],
[py_str(arg_types[i]) for i in range(narg)],
[py_str(arg_descs[i]) for i in range(narg)])
doc_str = ('%s\n\n' +
'%s\n' +
'Returns\n' +
'-------\n' +
'MXDataIter\n'+
' The result iterator.')
doc_str = doc_str % (desc.value, param_str)
def creator(*args, **kwargs):
"""Create an iterator.
The parameters listed below can be passed in as keyword arguments.
Parameters
----------
name : string, required.
Name of the resulting data iterator.
Returns
-------
dataiter: Dataiter
The resulting data iterator.
"""
param_keys = []
param_vals = []
for k, val in kwargs.items():
param_keys.append(k)
param_vals.append(str(val))
# create atomic symbol
param_keys = c_str_array(param_keys)
param_vals = c_str_array(param_vals)
iter_handle = DataIterHandle()
check_call(_LIB.MXDataIterCreateIter(
handle,
mx_uint(len(param_keys)),
param_keys, param_vals,
ctypes.byref(iter_handle)))
if len(args):
raise TypeError('%s can only accept keyword arguments' % iter_name)
return MXDataIter(iter_handle, **kwargs)
creator.__name__ = iter_name
creator.__doc__ = doc_str
return creator
|
python
|
def _make_io_iterator(handle):
"""Create an io iterator by handle."""
name = ctypes.c_char_p()
desc = ctypes.c_char_p()
num_args = mx_uint()
arg_names = ctypes.POINTER(ctypes.c_char_p)()
arg_types = ctypes.POINTER(ctypes.c_char_p)()
arg_descs = ctypes.POINTER(ctypes.c_char_p)()
check_call(_LIB.MXDataIterGetIterInfo( \
handle, ctypes.byref(name), ctypes.byref(desc), \
ctypes.byref(num_args), \
ctypes.byref(arg_names), \
ctypes.byref(arg_types), \
ctypes.byref(arg_descs)))
iter_name = py_str(name.value)
narg = int(num_args.value)
param_str = _build_param_doc(
[py_str(arg_names[i]) for i in range(narg)],
[py_str(arg_types[i]) for i in range(narg)],
[py_str(arg_descs[i]) for i in range(narg)])
doc_str = ('%s\n\n' +
'%s\n' +
'Returns\n' +
'-------\n' +
'MXDataIter\n'+
' The result iterator.')
doc_str = doc_str % (desc.value, param_str)
def creator(*args, **kwargs):
"""Create an iterator.
The parameters listed below can be passed in as keyword arguments.
Parameters
----------
name : string, required.
Name of the resulting data iterator.
Returns
-------
dataiter: Dataiter
The resulting data iterator.
"""
param_keys = []
param_vals = []
for k, val in kwargs.items():
param_keys.append(k)
param_vals.append(str(val))
# create atomic symbol
param_keys = c_str_array(param_keys)
param_vals = c_str_array(param_vals)
iter_handle = DataIterHandle()
check_call(_LIB.MXDataIterCreateIter(
handle,
mx_uint(len(param_keys)),
param_keys, param_vals,
ctypes.byref(iter_handle)))
if len(args):
raise TypeError('%s can only accept keyword arguments' % iter_name)
return MXDataIter(iter_handle, **kwargs)
creator.__name__ = iter_name
creator.__doc__ = doc_str
return creator
|
[
"def",
"_make_io_iterator",
"(",
"handle",
")",
":",
"name",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"desc",
"=",
"ctypes",
".",
"c_char_p",
"(",
")",
"num_args",
"=",
"mx_uint",
"(",
")",
"arg_names",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"arg_types",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"arg_descs",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_char_p",
")",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXDataIterGetIterInfo",
"(",
"handle",
",",
"ctypes",
".",
"byref",
"(",
"name",
")",
",",
"ctypes",
".",
"byref",
"(",
"desc",
")",
",",
"ctypes",
".",
"byref",
"(",
"num_args",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_names",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_types",
")",
",",
"ctypes",
".",
"byref",
"(",
"arg_descs",
")",
")",
")",
"iter_name",
"=",
"py_str",
"(",
"name",
".",
"value",
")",
"narg",
"=",
"int",
"(",
"num_args",
".",
"value",
")",
"param_str",
"=",
"_build_param_doc",
"(",
"[",
"py_str",
"(",
"arg_names",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"narg",
")",
"]",
",",
"[",
"py_str",
"(",
"arg_types",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"narg",
")",
"]",
",",
"[",
"py_str",
"(",
"arg_descs",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"narg",
")",
"]",
")",
"doc_str",
"=",
"(",
"'%s\\n\\n'",
"+",
"'%s\\n'",
"+",
"'Returns\\n'",
"+",
"'-------\\n'",
"+",
"'MXDataIter\\n'",
"+",
"' The result iterator.'",
")",
"doc_str",
"=",
"doc_str",
"%",
"(",
"desc",
".",
"value",
",",
"param_str",
")",
"def",
"creator",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"\"\"\"Create an iterator.\n The parameters listed below can be passed in as keyword arguments.\n\n Parameters\n ----------\n name : string, required.\n Name of the resulting data iterator.\n\n Returns\n -------\n dataiter: Dataiter\n The resulting data iterator.\n \"\"\"",
"param_keys",
"=",
"[",
"]",
"param_vals",
"=",
"[",
"]",
"for",
"k",
",",
"val",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"param_keys",
".",
"append",
"(",
"k",
")",
"param_vals",
".",
"append",
"(",
"str",
"(",
"val",
")",
")",
"# create atomic symbol",
"param_keys",
"=",
"c_str_array",
"(",
"param_keys",
")",
"param_vals",
"=",
"c_str_array",
"(",
"param_vals",
")",
"iter_handle",
"=",
"DataIterHandle",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXDataIterCreateIter",
"(",
"handle",
",",
"mx_uint",
"(",
"len",
"(",
"param_keys",
")",
")",
",",
"param_keys",
",",
"param_vals",
",",
"ctypes",
".",
"byref",
"(",
"iter_handle",
")",
")",
")",
"if",
"len",
"(",
"args",
")",
":",
"raise",
"TypeError",
"(",
"'%s can only accept keyword arguments'",
"%",
"iter_name",
")",
"return",
"MXDataIter",
"(",
"iter_handle",
",",
"*",
"*",
"kwargs",
")",
"creator",
".",
"__name__",
"=",
"iter_name",
"creator",
".",
"__doc__",
"=",
"doc_str",
"return",
"creator"
] |
Create an io iterator by handle.
|
[
"Create",
"an",
"io",
"iterator",
"by",
"handle",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/io/io.py#L899-L967
|
train
|
apache/incubator-mxnet
|
python/mxnet/io/io.py
|
_init_io_module
|
def _init_io_module():
"""List and add all the data iterators to current module."""
plist = ctypes.POINTER(ctypes.c_void_p)()
size = ctypes.c_uint()
check_call(_LIB.MXListDataIters(ctypes.byref(size), ctypes.byref(plist)))
module_obj = sys.modules[__name__]
for i in range(size.value):
hdl = ctypes.c_void_p(plist[i])
dataiter = _make_io_iterator(hdl)
setattr(module_obj, dataiter.__name__, dataiter)
|
python
|
def _init_io_module():
"""List and add all the data iterators to current module."""
plist = ctypes.POINTER(ctypes.c_void_p)()
size = ctypes.c_uint()
check_call(_LIB.MXListDataIters(ctypes.byref(size), ctypes.byref(plist)))
module_obj = sys.modules[__name__]
for i in range(size.value):
hdl = ctypes.c_void_p(plist[i])
dataiter = _make_io_iterator(hdl)
setattr(module_obj, dataiter.__name__, dataiter)
|
[
"def",
"_init_io_module",
"(",
")",
":",
"plist",
"=",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_void_p",
")",
"(",
")",
"size",
"=",
"ctypes",
".",
"c_uint",
"(",
")",
"check_call",
"(",
"_LIB",
".",
"MXListDataIters",
"(",
"ctypes",
".",
"byref",
"(",
"size",
")",
",",
"ctypes",
".",
"byref",
"(",
"plist",
")",
")",
")",
"module_obj",
"=",
"sys",
".",
"modules",
"[",
"__name__",
"]",
"for",
"i",
"in",
"range",
"(",
"size",
".",
"value",
")",
":",
"hdl",
"=",
"ctypes",
".",
"c_void_p",
"(",
"plist",
"[",
"i",
"]",
")",
"dataiter",
"=",
"_make_io_iterator",
"(",
"hdl",
")",
"setattr",
"(",
"module_obj",
",",
"dataiter",
".",
"__name__",
",",
"dataiter",
")"
] |
List and add all the data iterators to current module.
|
[
"List",
"and",
"add",
"all",
"the",
"data",
"iterators",
"to",
"current",
"module",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/io/io.py#L969-L978
|
train
|
apache/incubator-mxnet
|
python/mxnet/io/io.py
|
DataDesc.get_list
|
def get_list(shapes, types):
"""Get DataDesc list from attribute lists.
Parameters
----------
shapes : a tuple of (name_, shape_)
types : a tuple of (name_, np.dtype)
"""
if types is not None:
type_dict = dict(types)
return [DataDesc(x[0], x[1], type_dict[x[0]]) for x in shapes]
else:
return [DataDesc(x[0], x[1]) for x in shapes]
|
python
|
def get_list(shapes, types):
"""Get DataDesc list from attribute lists.
Parameters
----------
shapes : a tuple of (name_, shape_)
types : a tuple of (name_, np.dtype)
"""
if types is not None:
type_dict = dict(types)
return [DataDesc(x[0], x[1], type_dict[x[0]]) for x in shapes]
else:
return [DataDesc(x[0], x[1]) for x in shapes]
|
[
"def",
"get_list",
"(",
"shapes",
",",
"types",
")",
":",
"if",
"types",
"is",
"not",
"None",
":",
"type_dict",
"=",
"dict",
"(",
"types",
")",
"return",
"[",
"DataDesc",
"(",
"x",
"[",
"0",
"]",
",",
"x",
"[",
"1",
"]",
",",
"type_dict",
"[",
"x",
"[",
"0",
"]",
"]",
")",
"for",
"x",
"in",
"shapes",
"]",
"else",
":",
"return",
"[",
"DataDesc",
"(",
"x",
"[",
"0",
"]",
",",
"x",
"[",
"1",
"]",
")",
"for",
"x",
"in",
"shapes",
"]"
] |
Get DataDesc list from attribute lists.
Parameters
----------
shapes : a tuple of (name_, shape_)
types : a tuple of (name_, np.dtype)
|
[
"Get",
"DataDesc",
"list",
"from",
"attribute",
"lists",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/io/io.py#L100-L112
|
train
|
apache/incubator-mxnet
|
python/mxnet/io/io.py
|
DataIter.next
|
def next(self):
"""Get next data batch from iterator.
Returns
-------
DataBatch
The data of next batch.
Raises
------
StopIteration
If the end of the data is reached.
"""
if self.iter_next():
return DataBatch(data=self.getdata(), label=self.getlabel(), \
pad=self.getpad(), index=self.getindex())
else:
raise StopIteration
|
python
|
def next(self):
"""Get next data batch from iterator.
Returns
-------
DataBatch
The data of next batch.
Raises
------
StopIteration
If the end of the data is reached.
"""
if self.iter_next():
return DataBatch(data=self.getdata(), label=self.getlabel(), \
pad=self.getpad(), index=self.getindex())
else:
raise StopIteration
|
[
"def",
"next",
"(",
"self",
")",
":",
"if",
"self",
".",
"iter_next",
"(",
")",
":",
"return",
"DataBatch",
"(",
"data",
"=",
"self",
".",
"getdata",
"(",
")",
",",
"label",
"=",
"self",
".",
"getlabel",
"(",
")",
",",
"pad",
"=",
"self",
".",
"getpad",
"(",
")",
",",
"index",
"=",
"self",
".",
"getindex",
"(",
")",
")",
"else",
":",
"raise",
"StopIteration"
] |
Get next data batch from iterator.
Returns
-------
DataBatch
The data of next batch.
Raises
------
StopIteration
If the end of the data is reached.
|
[
"Get",
"next",
"data",
"batch",
"from",
"iterator",
"."
] |
1af29e9c060a4c7d60eeaacba32afdb9a7775ba7
|
https://github.com/apache/incubator-mxnet/blob/1af29e9c060a4c7d60eeaacba32afdb9a7775ba7/python/mxnet/io/io.py#L208-L225
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.