[incubator-mxnet-site] branch asf-site updated: Publish triggered by CI

aaronmarkham Fri, 21 Aug 2020 11:44:59 -0700

This is an automated email from the ASF dual-hosted git repository.

aaronmarkham pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/incubator-mxnet-site.git



The following commit(s) were added to refs/heads/asf-site by this push:
     new 666d15d  Publish triggered by CI
666d15d is described below

commit 666d15d8ce2474fc741a00257024b66f39d3d121
Author: mxnet-ci <mxnet-ci>
AuthorDate: Fri Aug 21 18:43:44 2020 +0000

    Publish triggered by CI
---
 api/python/docs/_modules/mxnet/util.html           |  90 ++++++++++-----------
 api/python/docs/api/np/arrays.indexing.html        |   8 +-
 api/python/docs/api/np/arrays.ndarray.html         |  34 ++++----
 .../docs/api/np/generated/mxnet.np.lexsort.html    |   2 +-
 .../docs/api/np/generated/mxnet.np.ndarray.html    |  46 +++++------
 .../api/np/generated/mxnet.np.ndarray.round.html   |   4 +-
 .../api/np/generated/mxnet.np.ndarray.take.html    |   4 +-
 .../docs/api/np/generated/mxnet.np.nonzero.html    |   2 +-
 .../docs/api/np/generated/mxnet.np.reshape.html    |   2 +-
 api/python/docs/objects.inv                        | Bin 93374 -> 93309 bytes
 api/python/docs/searchindex.js                     |   2 +-
 date.txt                                           |   1 -
 feed.xml                                           |   2 +-
 13 files changed, 98 insertions(+), 99 deletions(-)

diff --git a/api/python/docs/_modules/mxnet/util.html 
b/api/python/docs/_modules/mxnet/util.html
index ea46682..8b5aa0f 100644
--- a/api/python/docs/_modules/mxnet/util.html
+++ b/api/python/docs/_modules/mxnet/util.html
@@ -1236,7 +1236,7 @@
     <span class="k">return</span> <span class="n">free_mem</span><span 
class="o">.</span><span class="n">value</span><span class="p">,</span> <span 
class="n">total_mem</span><span class="o">.</span><span class="n">value</span>
 
 
-<div class="viewcode-block" id="set_np_shape"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.set_np_shape">[docs]</a><span 
class="k">def</span> <span class="nf">set_np_shape</span><span 
class="p">(</span><span class="n">active</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">set_np_shape</span><span 
class="p">(</span><span class="n">active</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Turns on/off NumPy shape semantics, in 
which `()` represents the shape of scalar tensors,</span>
 <span class="sd">    and tuples with `0` elements, for example, `(0,)`, `(1, 
0, 2)`, represent the shapes</span>
 <span class="sd">    of zero-size tensors. This is turned off by default for 
keeping backward compatibility.</span>
@@ -1280,10 +1280,10 @@
                          <span class="s1">&#39; deactivate both of 
them.&#39;</span><span class="p">)</span>
     <span class="n">prev</span> <span class="o">=</span> <span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">c_int</span><span class="p">()</span>
     <span class="n">check_call</span><span class="p">(</span><span 
class="n">_LIB</span><span class="o">.</span><span 
class="n">MXSetIsNumpyShape</span><span class="p">(</span><span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">c_int</span><span class="p">(</span><span 
class="n">active</span><span class="p">),</span> <span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">byref</span><span class="p">(</span><span class="n">prev</span><span 
class="p">)))</span>
-    <span class="k">return</span> <span class="nb">bool</span><span 
class="p">(</span><span class="n">prev</span><span class="o">.</span><span 
class="n">value</span><span class="p">)</span></div>
+    <span class="k">return</span> <span class="nb">bool</span><span 
class="p">(</span><span class="n">prev</span><span class="o">.</span><span 
class="n">value</span><span class="p">)</span>
 
 
-<div class="viewcode-block" id="is_np_shape"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.is_np_shape">[docs]</a><span 
class="k">def</span> <span class="nf">is_np_shape</span><span 
class="p">():</span>
+<span class="k">def</span> <span class="nf">is_np_shape</span><span 
class="p">():</span>
     <span class="sd">&quot;&quot;&quot;Checks whether the NumPy shape 
semantics is currently turned on.</span>
 <span class="sd">    In NumPy shape semantics, `()` represents the shape of 
scalar tensors,</span>
 <span class="sd">    and tuples with `0` elements, for example, `(0,)`, `(1, 
0, 2)`, represent</span>
@@ -1314,7 +1314,7 @@
 <span class="sd">    &quot;&quot;&quot;</span>
     <span class="n">curr</span> <span class="o">=</span> <span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">c_bool</span><span class="p">()</span>
     <span class="n">check_call</span><span class="p">(</span><span 
class="n">_LIB</span><span class="o">.</span><span 
class="n">MXIsNumpyShape</span><span class="p">(</span><span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">byref</span><span class="p">(</span><span class="n">curr</span><span 
class="p">)))</span>
-    <span class="k">return</span> <span class="n">curr</span><span 
class="o">.</span><span class="n">value</span></div>
+    <span class="k">return</span> <span class="n">curr</span><span 
class="o">.</span><span class="n">value</span>
 
 
 <span class="k">class</span> <span class="nc">_NumpyShapeScope</span><span 
class="p">(</span><span class="nb">object</span><span class="p">):</span>
@@ -1345,7 +1345,7 @@
             <span class="n">set_np_shape</span><span class="p">(</span><span 
class="bp">self</span><span class="o">.</span><span 
class="n">_prev_is_np_shape</span><span class="p">)</span>
 
 
-<div class="viewcode-block" id="np_shape"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.np_shape">[docs]</a><span 
class="k">def</span> <span class="nf">np_shape</span><span 
class="p">(</span><span class="n">active</span><span class="o">=</span><span 
class="kc">True</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">np_shape</span><span 
class="p">(</span><span class="n">active</span><span class="o">=</span><span 
class="kc">True</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Returns an activated/deactivated NumPy 
shape scope to be used in &#39;with&#39; statement</span>
 <span class="sd">    and captures code that needs the NumPy shape semantics, 
i.e. support of scalar and</span>
 <span class="sd">    zero-size tensors.</span>
@@ -1411,10 +1411,10 @@
 <span class="sd">            assert arg_shapes[0] == ()</span>
 <span class="sd">            assert out_shapes[0] == ()</span>
 <span class="sd">    &quot;&quot;&quot;</span>
-    <span class="k">return</span> <span class="n">_NumpyShapeScope</span><span 
class="p">(</span><span class="n">active</span><span class="p">)</span></div>
+    <span class="k">return</span> <span class="n">_NumpyShapeScope</span><span 
class="p">(</span><span class="n">active</span><span class="p">)</span>
 
 
-<div class="viewcode-block" id="use_np_shape"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.use_np_shape">[docs]</a><span 
class="k">def</span> <span class="nf">use_np_shape</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">use_np_shape</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;A decorator wrapping a function or 
class with activated NumPy-shape semantics.</span>
 <span class="sd">    When `func` is a function, this ensures that the 
execution of the function is scoped with NumPy</span>
 <span class="sd">    shape semantics, such as the support for zero-dim and 
zero size tensors. When</span>
@@ -1485,7 +1485,7 @@
         <span class="k">return</span> <span class="n">_with_np_shape</span>
     <span class="k">else</span><span class="p">:</span>
         <span class="k">raise</span> <span class="ne">TypeError</span><span 
class="p">(</span><span class="s1">&#39;use_np_shape can only decorate classes 
and callable objects, &#39;</span>
-                        <span class="s1">&#39;while received a </span><span 
class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="nb">str</span><span 
class="p">(</span><span class="nb">type</span><span class="p">(</span><span 
class="n">func</span><span class="p">))))</span></div>
+                        <span class="s1">&#39;while received a </span><span 
class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="nb">str</span><span 
class="p">(</span><span class="nb">type</span><span class="p">(</span><span 
class="n">func</span><span class="p">))))</span>
 
 
 <span class="k">def</span> <span class="nf">_sanity_check_params</span><span 
class="p">(</span><span class="n">func_name</span><span class="p">,</span> 
<span class="n">unsupported_params</span><span class="p">,</span> <span 
class="n">param_dict</span><span class="p">):</span>
@@ -1495,7 +1495,7 @@
                                       <span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span 
class="n">func_name</span><span class="p">,</span> <span 
class="n">param_name</span><span class="p">))</span>
 
 
-<div class="viewcode-block" id="set_module"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.set_module">[docs]</a><span 
class="k">def</span> <span class="nf">set_module</span><span 
class="p">(</span><span class="n">module</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">set_module</span><span 
class="p">(</span><span class="n">module</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Decorator for overriding __module__ on 
a function or class.</span>
 
 <span class="sd">    Example usage::</span>
@@ -1510,7 +1510,7 @@
         <span class="k">if</span> <span class="n">module</span> <span 
class="ow">is</span> <span class="ow">not</span> <span 
class="kc">None</span><span class="p">:</span>
             <span class="n">func</span><span class="o">.</span><span 
class="vm">__module__</span> <span class="o">=</span> <span 
class="n">module</span>
         <span class="k">return</span> <span class="n">func</span>
-    <span class="k">return</span> <span class="n">decorator</span></div>
+    <span class="k">return</span> <span class="n">decorator</span>
 
 
 <span class="k">class</span> <span class="nc">_NumpyArrayScope</span><span 
class="p">(</span><span class="nb">object</span><span class="p">):</span>
@@ -1538,7 +1538,7 @@
         <span class="n">_NumpyArrayScope</span><span class="o">.</span><span 
class="n">_current</span><span class="o">.</span><span class="n">value</span> 
<span class="o">=</span> <span class="bp">self</span><span 
class="o">.</span><span class="n">_old_scope</span>
 
 
-<div class="viewcode-block" id="np_array"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.np_array">[docs]</a><span 
class="k">def</span> <span class="nf">np_array</span><span 
class="p">(</span><span class="n">active</span><span class="o">=</span><span 
class="kc">True</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">np_array</span><span 
class="p">(</span><span class="n">active</span><span class="o">=</span><span 
class="kc">True</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Returns an activated/deactivated 
NumPy-array scope to be used in &#39;with&#39; statement</span>
 <span class="sd">    and captures code that needs the NumPy-array 
semantics.</span>
 
@@ -1564,10 +1564,10 @@
 <span class="sd">    _NumpyShapeScope</span>
 <span class="sd">        A scope object for wrapping the code w/ or w/o 
NumPy-shape semantics.</span>
 <span class="sd">    &quot;&quot;&quot;</span>
-    <span class="k">return</span> <span class="n">_NumpyArrayScope</span><span 
class="p">(</span><span class="n">active</span><span class="p">)</span></div>
+    <span class="k">return</span> <span class="n">_NumpyArrayScope</span><span 
class="p">(</span><span class="n">active</span><span class="p">)</span>
 
 
-<div class="viewcode-block" id="is_np_array"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.is_np_array">[docs]</a><span 
class="k">def</span> <span class="nf">is_np_array</span><span 
class="p">():</span>
+<div class="viewcode-block" id="is_np_array"><a class="viewcode-back" 
href="../../api/legacy/image/index.html#mxnet.image.is_np_array">[docs]</a><span
 class="k">def</span> <span class="nf">is_np_array</span><span 
class="p">():</span>
     <span class="sd">&quot;&quot;&quot;Checks whether the NumPy-array 
semantics is currently turned on.</span>
 <span class="sd">    This is currently used in Gluon for checking whether an 
array of type `mxnet.numpy.ndarray`</span>
 <span class="sd">    or `mx.nd.NDArray` should be created. For example, at the 
time when a parameter</span>
@@ -1590,7 +1590,7 @@
         <span class="n">_NumpyArrayScope</span><span class="o">.</span><span 
class="n">_current</span><span class="p">,</span> <span 
class="s2">&quot;value&quot;</span><span class="p">)</span> <span 
class="k">else</span> <span class="kc">False</span></div>
 
 
-<div class="viewcode-block" id="use_np_array"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.use_np_array">[docs]</a><span 
class="k">def</span> <span class="nf">use_np_array</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">use_np_array</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;A decorator wrapping Gluon `Block`s and 
all its methods, properties, and static functions</span>
 <span class="sd">    with the semantics of NumPy-array, which means that where 
ndarrays are created,</span>
 <span class="sd">    `mxnet.numpy.ndarray`s should be created, instead of 
legacy ndarrays of type `mx.nd.NDArray`.</span>
@@ -1669,10 +1669,10 @@
         <span class="k">return</span> <span class="n">_with_np_array</span>
     <span class="k">else</span><span class="p">:</span>
         <span class="k">raise</span> <span class="ne">TypeError</span><span 
class="p">(</span><span class="s1">&#39;use_np_array can only decorate classes 
and callable objects, &#39;</span>
-                        <span class="s1">&#39;while received a </span><span 
class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="nb">str</span><span 
class="p">(</span><span class="nb">type</span><span class="p">(</span><span 
class="n">func</span><span class="p">))))</span></div>
+                        <span class="s1">&#39;while received a </span><span 
class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="nb">str</span><span 
class="p">(</span><span class="nb">type</span><span class="p">(</span><span 
class="n">func</span><span class="p">))))</span>
 
 
-<div class="viewcode-block" id="use_np"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.use_np">[docs]</a><span 
class="k">def</span> <span class="nf">use_np</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">use_np</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;A convenience decorator for wrapping 
user provided functions and classes in the scope of</span>
 <span class="sd">    both NumPy-shape and NumPy-array semantics, which means 
that (1) empty tuples `()` and tuples</span>
 <span class="sd">    with zeros, such as `(0, 1)`, `(1, 0, 2)`, will be 
treated as scalar tensors&#39; shapes and</span>
@@ -1732,10 +1732,10 @@
 <span class="sd">    Function or class</span>
 <span class="sd">        A function or class wrapped in the Numpy-shape and 
NumPy-array scope.</span>
 <span class="sd">    &quot;&quot;&quot;</span>
-    <span class="k">return</span> <span class="n">use_np_shape</span><span 
class="p">(</span><span class="n">use_np_array</span><span 
class="p">(</span><span class="n">func</span><span class="p">))</span></div>
+    <span class="k">return</span> <span class="n">use_np_shape</span><span 
class="p">(</span><span class="n">use_np_array</span><span 
class="p">(</span><span class="n">func</span><span class="p">))</span>
 
 
-<div class="viewcode-block" id="np_ufunc_legal_option"><a 
class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.np_ufunc_legal_option">[docs]</a><span
 class="k">def</span> <span class="nf">np_ufunc_legal_option</span><span 
class="p">(</span><span class="n">key</span><span class="p">,</span> <span 
class="n">value</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">np_ufunc_legal_option</span><span 
class="p">(</span><span class="n">key</span><span class="p">,</span> <span 
class="n">value</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Checking if ufunc arguments are legal 
inputs</span>
 
 <span class="sd">    Parameters</span>
@@ -1767,10 +1767,10 @@
                               <span class="s1">&#39;float16&#39;</span><span 
class="p">,</span> <span class="s1">&#39;float32&#39;</span><span 
class="p">,</span> <span class="s1">&#39;float64&#39;</span><span 
class="p">]))</span>
     <span class="k">elif</span> <span class="n">key</span> <span 
class="o">==</span> <span class="s1">&#39;subok&#39;</span><span 
class="p">:</span>
         <span class="k">return</span> <span class="nb">isinstance</span><span 
class="p">(</span><span class="n">value</span><span class="p">,</span> <span 
class="nb">bool</span><span class="p">)</span>
-    <span class="k">return</span> <span class="kc">False</span></div>
+    <span class="k">return</span> <span class="kc">False</span>
 
 
-<div class="viewcode-block" id="wrap_np_unary_func"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.wrap_np_unary_func">[docs]</a><span 
class="k">def</span> <span class="nf">wrap_np_unary_func</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">wrap_np_unary_func</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;A convenience decorator for wrapping 
numpy-compatible unary ufuncs to provide uniform</span>
 <span class="sd">    error handling.</span>
 
@@ -1800,10 +1800,10 @@
                     <span class="k">raise</span> <span 
class="ne">TypeError</span><span class="p">(</span><span 
class="s2">&quot;</span><span class="si">{}</span><span 
class="s2">=</span><span class="si">{}</span><span class="s2"> not understood 
for operator </span><span class="si">{}</span><span class="s2">&quot;</span>
                                     <span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="n">key</span><span 
class="p">,</span> <span class="n">value</span><span class="p">,</span> <span 
class="n">func</span><span class="o">.</span><span 
class="vm">__name__</span><span class="p">))</span>
         <span class="k">return</span> <span class="n">func</span><span 
class="p">(</span><span class="n">x</span><span class="p">,</span> <span 
class="n">out</span><span class="o">=</span><span class="n">out</span><span 
class="p">)</span>
-    <span class="k">return</span> <span 
class="n">_wrap_np_unary_func</span></div>
+    <span class="k">return</span> <span class="n">_wrap_np_unary_func</span>
 
 
-<div class="viewcode-block" id="wrap_np_binary_func"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.wrap_np_binary_func">[docs]</a><span 
class="k">def</span> <span class="nf">wrap_np_binary_func</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">wrap_np_binary_func</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;A convenience decorator for wrapping 
numpy-compatible binary ufuncs to provide uniform</span>
 <span class="sd">    error handling.</span>
 
@@ -1831,11 +1831,11 @@
                     <span class="c1"># otherwise raise TypeError with not 
understood error message</span>
                     <span class="k">raise</span> <span 
class="ne">TypeError</span><span class="p">(</span><span 
class="s2">&quot;</span><span class="si">{}</span><span class="s2"> 
</span><span class="si">{}</span><span class="s2"> not 
understood&quot;</span><span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="n">key</span><span 
class="p">,</span> <span class="n">value</span><span class="p">))</span>
         <span class="k">return</span> <span class="n">func</span><span 
class="p">(</span><span class="n">x1</span><span class="p">,</span> <span 
class="n">x2</span><span class="p">,</span> <span class="n">out</span><span 
class="o">=</span><span class="n">out</span><span class="p">)</span>
-    <span class="k">return</span> <span 
class="n">_wrap_np_binary_func</span></div>
+    <span class="k">return</span> <span class="n">_wrap_np_binary_func</span>
 
 
 <span class="c1"># pylint: disable=exec-used</span>
-<div class="viewcode-block" id="numpy_fallback"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.numpy_fallback">[docs]</a><span 
class="k">def</span> <span class="nf">numpy_fallback</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">numpy_fallback</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;decorator for falling back to offical 
numpy for a specific function&quot;&quot;&quot;</span>
     <span class="k">def</span> <span class="nf">get_ctx</span><span 
class="p">(</span><span class="n">ctx</span><span class="p">,</span> <span 
class="n">new_ctx</span><span class="p">):</span>
         <span class="k">if</span> <span class="n">ctx</span> <span 
class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
@@ -1917,7 +1917,7 @@
         <span class="n">ret</span> <span class="o">=</span> <span 
class="n">_as_mx_np_array</span><span class="p">(</span><span 
class="n">ret</span><span class="p">,</span> <span class="n">ctx</span><span 
class="o">=</span><span class="n">ctx</span><span class="p">)</span>
         <span class="k">return</span> <span class="n">ret</span>
 
-    <span class="k">return</span> <span 
class="n">_fallback_to_official_np</span></div>
+    <span class="k">return</span> <span 
class="n">_fallback_to_official_np</span>
 <span class="c1"># pylint: enable=exec-used</span>
 
 
@@ -1947,7 +1947,7 @@
     <span class="k">return</span> <span class="n">cur_state</span>
 
 
-<div class="viewcode-block" id="set_np"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.set_np">[docs]</a><span 
class="k">def</span> <span class="nf">set_np</span><span 
class="p">(</span><span class="n">shape</span><span class="o">=</span><span 
class="kc">True</span><span class="p">,</span> <span 
class="n">array</span><span class="o">=</span><span class="kc">True</span><span 
class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span 
class="kc">False< [...]
+<span class="k">def</span> <span class="nf">set_np</span><span 
class="p">(</span><span class="n">shape</span><span class="o">=</span><span 
class="kc">True</span><span class="p">,</span> <span 
class="n">array</span><span class="o">=</span><span class="kc">True</span><span 
class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span 
class="kc">False</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Setting NumPy shape and array semantics 
at the same time.</span>
 <span class="sd">    It is required to keep NumPy shape semantics active while 
activating NumPy array semantics.</span>
 <span class="sd">    Deactivating NumPy shape semantics while NumPy array 
semantics is still active is not allowed.</span>
@@ -2031,18 +2031,18 @@
         <span class="k">raise</span> <span class="ne">ValueError</span><span 
class="p">(</span><span class="s1">&#39;NumPy Shape semantics is required in 
using NumPy array semantics.&#39;</span><span class="p">)</span>
     <span class="n">_set_np_array</span><span class="p">(</span><span 
class="n">array</span><span class="p">)</span>
     <span class="n">set_np_shape</span><span class="p">(</span><span 
class="n">shape</span><span class="p">)</span>
-    <span class="n">set_np_default_dtype</span><span class="p">(</span><span 
class="n">dtype</span><span class="p">)</span></div>
+    <span class="n">set_np_default_dtype</span><span class="p">(</span><span 
class="n">dtype</span><span class="p">)</span>
 
 
-<div class="viewcode-block" id="reset_np"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.reset_np">[docs]</a><span 
class="k">def</span> <span class="nf">reset_np</span><span class="p">():</span>
+<span class="k">def</span> <span class="nf">reset_np</span><span 
class="p">():</span>
     <span class="sd">&quot;&quot;&quot;Deactivate NumPy shape and array and 
deafult dtype semantics at the same time.&quot;&quot;&quot;</span>
-    <span class="n">set_np</span><span class="p">(</span><span 
class="n">shape</span><span class="o">=</span><span 
class="kc">False</span><span class="p">,</span> <span 
class="n">array</span><span class="o">=</span><span 
class="kc">False</span><span class="p">,</span> <span 
class="n">dtype</span><span class="o">=</span><span 
class="kc">False</span><span class="p">)</span></div>
+    <span class="n">set_np</span><span class="p">(</span><span 
class="n">shape</span><span class="o">=</span><span 
class="kc">False</span><span class="p">,</span> <span 
class="n">array</span><span class="o">=</span><span 
class="kc">False</span><span class="p">,</span> <span 
class="n">dtype</span><span class="o">=</span><span 
class="kc">False</span><span class="p">)</span>
 
 
 <span class="n">_CUDA_SUCCESS</span> <span class="o">=</span> <span 
class="mi">0</span>
 
 
-<div class="viewcode-block" id="get_cuda_compute_capability"><a 
class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.get_cuda_compute_capability">[docs]</a><span
 class="k">def</span> <span class="nf">get_cuda_compute_capability</span><span 
class="p">(</span><span class="n">ctx</span><span class="p">):</span>
+<span class="k">def</span> <span 
class="nf">get_cuda_compute_capability</span><span class="p">(</span><span 
class="n">ctx</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Returns the cuda compute capability of 
the input `ctx`.</span>
 
 <span class="sd">    Parameters</span>
@@ -2097,10 +2097,10 @@
         <span class="n">cuda</span><span class="o">.</span><span 
class="n">cuGetErrorString</span><span class="p">(</span><span 
class="n">ret</span><span class="p">,</span> <span class="n">ctypes</span><span 
class="o">.</span><span class="n">byref</span><span class="p">(</span><span 
class="n">error_str</span><span class="p">))</span>
         <span class="k">raise</span> <span class="ne">RuntimeError</span><span 
class="p">(</span><span class="s1">&#39;cuDeviceComputeCapability failed with 
error code </span><span class="si">{}</span><span class="s1">: </span><span 
class="si">{}</span><span class="s1">&#39;</span>
                            <span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="n">ret</span><span 
class="p">,</span> <span class="n">error_str</span><span 
class="o">.</span><span class="n">value</span><span class="o">.</span><span 
class="n">decode</span><span class="p">()))</span>
-    <span class="k">return</span> <span class="n">cc_major</span><span 
class="o">.</span><span class="n">value</span> <span class="o">*</span> <span 
class="mi">10</span> <span class="o">+</span> <span 
class="n">cc_minor</span><span class="o">.</span><span 
class="n">value</span></div>
+    <span class="k">return</span> <span class="n">cc_major</span><span 
class="o">.</span><span class="n">value</span> <span class="o">*</span> <span 
class="mi">10</span> <span class="o">+</span> <span 
class="n">cc_minor</span><span class="o">.</span><span class="n">value</span>
 
 
-<div class="viewcode-block" id="default_array"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.default_array">[docs]</a><span 
class="k">def</span> <span class="nf">default_array</span><span 
class="p">(</span><span class="n">source_array</span><span class="p">,</span> 
<span class="n">ctx</span><span class="o">=</span><span 
class="kc">None</span><span class="p">,</span> <span 
class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span 
class="p">):</span>
+<span class="k">def</span> <span class="nf">default_array</span><span 
class="p">(</span><span class="n">source_array</span><span class="p">,</span> 
<span class="n">ctx</span><span class="o">=</span><span 
class="kc">None</span><span class="p">,</span> <span 
class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span 
class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Creates an array from any object 
exposing the default(nd or np) array interface.</span>
 
 <span class="sd">    Parameters</span>
@@ -2124,7 +2124,7 @@
     <span class="k">if</span> <span class="n">is_np_array</span><span 
class="p">():</span>
         <span class="k">return</span> <span class="n">_mx_np</span><span 
class="o">.</span><span class="n">array</span><span class="p">(</span><span 
class="n">source_array</span><span class="p">,</span> <span 
class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span 
class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span 
class="n">dtype</span><span class="p">)</span>
     <span class="k">else</span><span class="p">:</span>
-        <span class="k">return</span> <span class="n">_mx_nd</span><span 
class="o">.</span><span class="n">array</span><span class="p">(</span><span 
class="n">source_array</span><span class="p">,</span> <span 
class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span 
class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span 
class="n">dtype</span><span class="p">)</span></div>
+        <span class="k">return</span> <span class="n">_mx_nd</span><span 
class="o">.</span><span class="n">array</span><span class="p">(</span><span 
class="n">source_array</span><span class="p">,</span> <span 
class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span 
class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span 
class="n">dtype</span><span class="p">)</span>
 
 <span class="k">class</span> <span 
class="nc">_NumpyDefaultDtypeScope</span><span class="p">(</span><span 
class="nb">object</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Scope for managing NumPy default dtype 
semantics.</span>
@@ -2154,7 +2154,7 @@
            <span class="bp">self</span><span class="o">.</span><span 
class="n">_prev_is_np_default_dtype</span> <span class="o">!=</span> <span 
class="bp">self</span><span class="o">.</span><span 
class="n">_enter_is_np_default_dtype</span><span class="p">:</span>
             <span class="n">set_np_default_dtype</span><span 
class="p">(</span><span class="bp">self</span><span class="o">.</span><span 
class="n">_prev_is_np_default_dtype</span><span class="p">)</span>
 
-<div class="viewcode-block" id="np_default_dtype"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.np_default_dtype">[docs]</a><span 
class="k">def</span> <span class="nf">np_default_dtype</span><span 
class="p">(</span><span class="n">active</span><span class="o">=</span><span 
class="kc">True</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">np_default_dtype</span><span 
class="p">(</span><span class="n">active</span><span class="o">=</span><span 
class="kc">True</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Returns an activated/deactivated 
NumPy-default_dtype scope to be used in &#39;with&#39; statement</span>
 <span class="sd">    and captures code that needs the NumPy default dtype 
semantics. i.e. default dtype is float64.</span>
 
@@ -2186,9 +2186,9 @@
 <span class="sd">            assert arr.dtype == &#39;float32&#39;</span>
 
 <span class="sd">    &quot;&quot;&quot;</span>
-    <span class="k">return</span> <span 
class="n">_NumpyDefaultDtypeScope</span><span class="p">(</span><span 
class="n">active</span><span class="p">)</span></div>
+    <span class="k">return</span> <span 
class="n">_NumpyDefaultDtypeScope</span><span class="p">(</span><span 
class="n">active</span><span class="p">)</span>
 
-<div class="viewcode-block" id="use_np_default_dtype"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.use_np_default_dtype">[docs]</a><span
 class="k">def</span> <span class="nf">use_np_default_dtype</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">use_np_default_dtype</span><span 
class="p">(</span><span class="n">func</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;A decorator wrapping a function or 
class with activated NumPy-default_dtype semantics.</span>
 <span class="sd">    When `func` is a function, this ensures that the 
execution of the function is scoped with NumPy</span>
 <span class="sd">    default dtype semantics, with the support for float64 as 
default dtype.</span>
@@ -2258,9 +2258,9 @@
         <span class="k">return</span> <span 
class="n">_with_np_default_dtype</span>
     <span class="k">else</span><span class="p">:</span>
         <span class="k">raise</span> <span class="ne">TypeError</span><span 
class="p">(</span><span class="s1">&#39;use_np_default_dtype can only decorate 
classes and callable objects, &#39;</span>
-                        <span class="s1">&#39;while received a </span><span 
class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="nb">str</span><span 
class="p">(</span><span class="nb">type</span><span class="p">(</span><span 
class="n">func</span><span class="p">))))</span></div>
+                        <span class="s1">&#39;while received a </span><span 
class="si">{}</span><span class="s1">&#39;</span><span class="o">.</span><span 
class="n">format</span><span class="p">(</span><span class="nb">str</span><span 
class="p">(</span><span class="nb">type</span><span class="p">(</span><span 
class="n">func</span><span class="p">))))</span>
 
-<div class="viewcode-block" id="is_np_default_dtype"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.is_np_default_dtype">[docs]</a><span 
class="k">def</span> <span class="nf">is_np_default_dtype</span><span 
class="p">():</span>
+<span class="k">def</span> <span class="nf">is_np_default_dtype</span><span 
class="p">():</span>
     <span class="sd">&quot;&quot;&quot;Checks whether the NumPy default dtype 
semantics is currently turned on.</span>
 <span class="sd">    In NumPy default dtype semantics, default dtype is 
float64.</span>
 
@@ -2290,9 +2290,9 @@
 <span class="sd">    &quot;&quot;&quot;</span>
     <span class="n">curr</span> <span class="o">=</span> <span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">c_bool</span><span class="p">()</span>
     <span class="n">check_call</span><span class="p">(</span><span 
class="n">_LIB</span><span class="o">.</span><span 
class="n">MXIsNumpyDefaultDtype</span><span class="p">(</span><span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">byref</span><span class="p">(</span><span class="n">curr</span><span 
class="p">)))</span>
-    <span class="k">return</span> <span class="n">curr</span><span 
class="o">.</span><span class="n">value</span></div>
+    <span class="k">return</span> <span class="n">curr</span><span 
class="o">.</span><span class="n">value</span>
 
-<div class="viewcode-block" id="set_np_default_dtype"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.set_np_default_dtype">[docs]</a><span
 class="k">def</span> <span class="nf">set_np_default_dtype</span><span 
class="p">(</span><span class="n">is_np_default_dtype</span><span 
class="o">=</span><span class="kc">True</span><span class="p">):</span>  <span 
class="c1"># pylint: disable=redefined-outer-name</span>
+<span class="k">def</span> <span class="nf">set_np_default_dtype</span><span 
class="p">(</span><span class="n">is_np_default_dtype</span><span 
class="o">=</span><span class="kc">True</span><span class="p">):</span>  <span 
class="c1"># pylint: disable=redefined-outer-name</span>
     <span class="sd">&quot;&quot;&quot;Turns on/off NumPy default dtype 
semantics, because mxnet.numpy.ndarray use</span>
 <span class="sd">    32 bit data storage as default (e.g. float32 and int 32) 
while offical NumPy use</span>
 <span class="sd">    64 bit data storage as default (e.g. float64 and 
int64).</span>
@@ -2330,10 +2330,10 @@
             <span class="n">_set_np_default_dtype_logged</span> <span 
class="o">=</span> <span class="kc">True</span>
     <span class="n">prev</span> <span class="o">=</span> <span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">c_bool</span><span class="p">()</span>
     <span class="n">check_call</span><span class="p">(</span><span 
class="n">_LIB</span><span class="o">.</span><span 
class="n">MXSetIsNumpyDefaultDtype</span><span class="p">(</span><span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">c_bool</span><span class="p">(</span><span 
class="n">is_np_default_dtype</span><span class="p">),</span> <span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">byref</span><span class="p">(</span><span class="n">prev</span><sp 
[...]
-    <span class="k">return</span> <span class="n">prev</span><span 
class="o">.</span><span class="n">value</span></div>
+    <span class="k">return</span> <span class="n">prev</span><span 
class="o">.</span><span class="n">value</span>
 
 
-<div class="viewcode-block" id="getenv"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.getenv">[docs]</a><span 
class="k">def</span> <span class="nf">getenv</span><span 
class="p">(</span><span class="n">name</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">getenv</span><span 
class="p">(</span><span class="n">name</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Get the setting of an environment 
variable from the C Runtime.</span>
 
 <span class="sd">    Parameters</span>
@@ -2348,10 +2348,10 @@
 <span class="sd">    &quot;&quot;&quot;</span>
     <span class="n">ret</span> <span class="o">=</span> <span 
class="n">ctypes</span><span class="o">.</span><span 
class="n">c_char_p</span><span class="p">()</span>
     <span class="n">check_call</span><span class="p">(</span><span 
class="n">_LIB</span><span class="o">.</span><span 
class="n">MXGetEnv</span><span class="p">(</span><span 
class="n">c_str</span><span class="p">(</span><span class="n">name</span><span 
class="p">),</span> <span class="n">ctypes</span><span class="o">.</span><span 
class="n">byref</span><span class="p">(</span><span class="n">ret</span><span 
class="p">)))</span>
-    <span class="k">return</span> <span class="kc">None</span> <span 
class="k">if</span> <span class="n">ret</span><span class="o">.</span><span 
class="n">value</span> <span class="ow">is</span> <span class="kc">None</span> 
<span class="k">else</span> <span class="n">py_str</span><span 
class="p">(</span><span class="n">ret</span><span class="o">.</span><span 
class="n">value</span><span class="p">)</span></div>
+    <span class="k">return</span> <span class="kc">None</span> <span 
class="k">if</span> <span class="n">ret</span><span class="o">.</span><span 
class="n">value</span> <span class="ow">is</span> <span class="kc">None</span> 
<span class="k">else</span> <span class="n">py_str</span><span 
class="p">(</span><span class="n">ret</span><span class="o">.</span><span 
class="n">value</span><span class="p">)</span>
 
 
-<div class="viewcode-block" id="setenv"><a class="viewcode-back" 
href="../../api/util/index.html#mxnet.util.setenv">[docs]</a><span 
class="k">def</span> <span class="nf">setenv</span><span 
class="p">(</span><span class="n">name</span><span class="p">,</span> <span 
class="n">value</span><span class="p">):</span>
+<span class="k">def</span> <span class="nf">setenv</span><span 
class="p">(</span><span class="n">name</span><span class="p">,</span> <span 
class="n">value</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;Set an environment variable in the C 
Runtime.</span>
 
 <span class="sd">    Parameters</span>
@@ -2362,7 +2362,7 @@
 <span class="sd">        The desired value to set the environment value 
to</span>
 <span class="sd">    &quot;&quot;&quot;</span>
     <span class="n">passed_value</span> <span class="o">=</span> <span 
class="kc">None</span> <span class="k">if</span> <span class="n">value</span> 
<span class="ow">is</span> <span class="kc">None</span> <span 
class="k">else</span> <span class="n">c_str</span><span class="p">(</span><span 
class="n">value</span><span class="p">)</span>
-    <span class="n">check_call</span><span class="p">(</span><span 
class="n">_LIB</span><span class="o">.</span><span 
class="n">MXSetEnv</span><span class="p">(</span><span 
class="n">c_str</span><span class="p">(</span><span class="n">name</span><span 
class="p">),</span> <span class="n">passed_value</span><span 
class="p">))</span></div>
+    <span class="n">check_call</span><span class="p">(</span><span 
class="n">_LIB</span><span class="o">.</span><span 
class="n">MXSetEnv</span><span class="p">(</span><span 
class="n">c_str</span><span class="p">(</span><span class="n">name</span><span 
class="p">),</span> <span class="n">passed_value</span><span class="p">))</span>
 </pre></div>
 
         <hr class="feedback-hr-top" />
diff --git a/api/python/docs/api/np/arrays.indexing.html 
b/api/python/docs/api/np/arrays.indexing.html
index cd42535..55c071d 100644
--- a/api/python/docs/api/np/arrays.indexing.html
+++ b/api/python/docs/api/np/arrays.indexing.html
@@ -1454,7 +1454,7 @@ shape (10,2,3,4,30) because the (20,)-shaped subspace has 
been
 replaced with a (2,3,4)-shaped broadcasted indexing subspace. If
 we let <em>i, j, k</em> loop over the (2,3,4)-shaped subspace then
 <code class="docutils literal notranslate"><span 
class="pre">result[...,i,j,k,:]</span> <span class="pre">=</span> <span 
class="pre">x[...,ind[i,j,k],:]</span></code>. This example
-produces the same result as <a class="reference internal" 
href="generated/mxnet.np.ndarray.take.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-meth docutils literal 
notranslate"><span class="pre">x.take(ind,</span> <span 
class="pre">axis=-2)</span></code></a>.</p>
+produces the same result as <a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-meth docutils literal 
notranslate"><span class="pre">x.take(ind,</span> <span 
class="pre">axis=-2)</span></code></a>.</p>
 </div>
 <div class="admonition-example admonition">
 <p class="admonition-title">Example</p>
@@ -1466,7 +1466,7 @@ and <code class="docutils literal notranslate"><span 
class="pre">ind_2</span></c
 <code class="docutils literal notranslate"><span 
class="pre">x[:,ind_1,:,ind_2]</span></code> has shape (2,3,4,10,30,50) because 
there
 is no unambiguous place to drop in the indexing subspace, thus
 it is tacked-on to the beginning. It is always possible to use
-<a class="reference internal" 
href="generated/mxnet.np.ndarray.transpose.html#mxnet.np.ndarray.transpose" 
title="mxnet.np.ndarray.transpose"><code class="xref py py-meth docutils 
literal notranslate"><span class="pre">.transpose()</span></code></a> to move 
the subspace
+<a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.transpose" 
title="mxnet.np.ndarray.transpose"><code class="xref py py-meth docutils 
literal notranslate"><span class="pre">.transpose()</span></code></a> to move 
the subspace
 anywhere desired. Note that this example cannot be replicated
 using <code class="xref py py-func docutils literal notranslate"><span 
class="pre">take()</span></code>.</p>
 </div>
@@ -1477,8 +1477,8 @@ using <code class="xref py py-func docutils literal 
notranslate"><span class="pr
 <p>This advanced indexing occurs when obj is an array object of Boolean
 type, such as may be returned from comparison operators. A single
 boolean index array is practically identical to <code class="docutils literal 
notranslate"><span class="pre">x[obj.nonzero()]</span></code> where,
-as described above, <a class="reference internal" 
href="generated/mxnet.np.ndarray.nonzero.html#mxnet.np.ndarray.nonzero" 
title="mxnet.np.ndarray.nonzero"><code class="xref py py-meth docutils literal 
notranslate"><span class="pre">obj.nonzero()</span></code></a> returns a
-tuple (of length <a class="reference internal" 
href="generated/mxnet.np.ndarray.ndim.html#mxnet.np.ndarray.ndim" 
title="mxnet.np.ndarray.ndim"><code class="xref py py-attr docutils literal 
notranslate"><span class="pre">obj.ndim</span></code></a>) of integer index
+as described above, <a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.nonzero" 
title="mxnet.np.ndarray.nonzero"><code class="xref py py-meth docutils literal 
notranslate"><span class="pre">obj.nonzero()</span></code></a> returns a
+tuple (of length <a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.ndim" 
title="mxnet.np.ndarray.ndim"><code class="xref py py-attr docutils literal 
notranslate"><span class="pre">obj.ndim</span></code></a>) of integer index
 arrays showing the <code class="xref py py-const docutils literal 
notranslate"><span class="pre">True</span></code> elements of <em>obj</em>. 
However, it is
 faster when <code class="docutils literal notranslate"><span 
class="pre">obj.shape</span> <span class="pre">==</span> <span 
class="pre">x.shape</span></code>.</p>
 <p>If <code class="docutils literal notranslate"><span 
class="pre">obj.ndim</span> <span class="pre">==</span> <span 
class="pre">x.ndim</span></code>, <code class="docutils literal 
notranslate"><span class="pre">x[obj]</span></code> returns a 1-dimensional 
array
diff --git a/api/python/docs/api/np/arrays.ndarray.html 
b/api/python/docs/api/np/arrays.ndarray.html
index f866294..829695b 100644
--- a/api/python/docs/api/np/arrays.ndarray.html
+++ b/api/python/docs/api/np/arrays.ndarray.html
@@ -1199,7 +1199,7 @@ Show Source
 <span id="arrays-ndarray"></span><h1>The N-dimensional array (<code 
class="xref py py-class docutils literal notranslate"><span 
class="pre">ndarray</span></code>)<a class="headerlink" 
href="#the-n-dimensional-array-ndarray" title="Permalink to this 
headline">¶</a></h1>
 <p>An <a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray" 
title="mxnet.np.ndarray"><code class="xref py py-class docutils literal 
notranslate"><span class="pre">ndarray</span></code></a> is a (usually 
fixed-size) multidimensional
 container of items of the same type and size. The number of dimensions
-and items in an array is defined by its <a class="reference internal" 
href="generated/mxnet.np.ndarray.shape.html#mxnet.np.ndarray.shape" 
title="mxnet.np.ndarray.shape"><code class="xref py py-attr docutils literal 
notranslate"><span class="pre">shape</span></code></a>,
+and items in an array is defined by its <a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.shape" 
title="mxnet.np.ndarray.shape"><code class="xref py py-attr docutils literal 
notranslate"><span class="pre">shape</span></code></a>,
 which is a <code class="xref py py-class docutils literal notranslate"><span 
class="pre">tuple</span></code> of <em>N</em> non-negative integers that 
specify the
 sizes of each dimension. The type of items in the array is specified by
 a separate <span class="xref std std-ref">data-type object (dtype)</span>, one 
of which
@@ -1275,7 +1275,7 @@ fields in a <span class="xref std std-term">structured 
data type</span>.</p>
 one-dimensional segment of computer memory (owned by the array, or by
 some other object), combined with an indexing scheme that maps <em>N</em>
 integers into the location of an item in the block.  The ranges in
-which the indices can vary is specified by the <a class="reference internal" 
href="generated/mxnet.np.ndarray.shape.html#mxnet.np.ndarray.shape" 
title="mxnet.np.ndarray.shape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">shape</span></code></a> of the array. How many 
bytes each item takes and how
+which the indices can vary is specified by the <a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.shape" 
title="mxnet.np.ndarray.shape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">shape</span></code></a> of the array. How many 
bytes each item takes and how
 the bytes are interpreted is defined by the <span class="xref std 
std-ref">data-type object</span> associated with the array.</p>
 <div class="admonition note" id="index-1">
 <p class="admonition-title">Note</p>
@@ -1372,13 +1372,13 @@ of the array:</p>
 <col style="width: 90%" />
 </colgroup>
 <tbody>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.shape.html#mxnet.np.ndarray.shape" 
title="mxnet.np.ndarray.shape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.shape</span></code></a></p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.shape" 
title="mxnet.np.ndarray.shape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.shape</span></code></a></p></td>
 <td><p>Tuple of array dimensions.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.ndim.html#mxnet.np.ndarray.ndim" 
title="mxnet.np.ndarray.ndim"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.ndim</span></code></a></p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.ndim" 
title="mxnet.np.ndarray.ndim"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.ndim</span></code></a></p></td>
 <td><p>Number of array dimensions.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.size.html#mxnet.np.ndarray.size" 
title="mxnet.np.ndarray.size"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.size</span></code></a></p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.size" 
title="mxnet.np.ndarray.size"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.size</span></code></a></p></td>
 <td><p>Number of elements in the array.</p></td>
 </tr>
 </tbody>
@@ -1496,19 +1496,19 @@ replaced with <code class="docutils literal 
notranslate"><span class="pre">n</sp
 <col style="width: 90%" />
 </colgroup>
 <tbody>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.reshape.html#mxnet.np.ndarray.reshape" 
title="mxnet.np.ndarray.reshape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.reshape</span></code></a>(*args, 
**kwargs)</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.reshape" 
title="mxnet.np.ndarray.reshape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.reshape</span></code></a>(*args, 
**kwargs)</p></td>
 <td><p>Returns a copy of the array with a new shape.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.transpose.html#mxnet.np.ndarray.transpose" 
title="mxnet.np.ndarray.transpose"><code class="xref py py-obj docutils literal 
notranslate"><span 
class="pre">ndarray.transpose</span></code></a>(*axes)</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.transpose" 
title="mxnet.np.ndarray.transpose"><code class="xref py py-obj docutils literal 
notranslate"><span 
class="pre">ndarray.transpose</span></code></a>(*axes)</p></td>
 <td><p>Permute the dimensions of an array.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.swapaxes.html#mxnet.np.ndarray.swapaxes" 
title="mxnet.np.ndarray.swapaxes"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.swapaxes</span></code></a>(axis1, 
axis2)</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.swapaxes" 
title="mxnet.np.ndarray.swapaxes"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.swapaxes</span></code></a>(axis1, 
axis2)</p></td>
 <td><p>Return a copy of the array with axis1 and axis2 interchanged.</p></td>
 </tr>
 <tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.flatten" 
title="mxnet.np.ndarray.flatten"><code class="xref py py-obj docutils literal 
notranslate"><span 
class="pre">ndarray.flatten</span></code></a>([order])</p></td>
 <td><p>Return a copy of the array collapsed into one dimension.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.squeeze.html#mxnet.np.ndarray.squeeze" 
title="mxnet.np.ndarray.squeeze"><code class="xref py py-obj docutils literal 
notranslate"><span 
class="pre">ndarray.squeeze</span></code></a>([axis])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.squeeze" 
title="mxnet.np.ndarray.squeeze"><code class="xref py py-obj docutils literal 
notranslate"><span 
class="pre">ndarray.squeeze</span></code></a>([axis])</p></td>
 <td><p>Remove single-dimensional entries from the shape of a.</p></td>
 </tr>
 </tbody>
@@ -1530,13 +1530,13 @@ the operation should proceed.</p>
 <col style="width: 90%" />
 </colgroup>
 <tbody>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.nonzero.html#mxnet.np.ndarray.nonzero" 
title="mxnet.np.ndarray.nonzero"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.nonzero</span></code></a>()</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.nonzero" 
title="mxnet.np.ndarray.nonzero"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.nonzero</span></code></a>()</p></td>
 <td><p>Return the indices of the elements that are non-zero.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.take.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.take</span></code></a>(indices[, axis, 
mode])</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.take</span></code></a>(indices[, axis, 
mode])</p></td>
 <td><p>Convenience fluent method for <code class="xref py py-func docutils 
literal notranslate"><span class="pre">take()</span></code>.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.repeat.html#mxnet.np.ndarray.repeat" 
title="mxnet.np.ndarray.repeat"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.repeat</span></code></a>(repeats[, 
axis])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.repeat" 
title="mxnet.np.ndarray.repeat"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.repeat</span></code></a>(repeats[, 
axis])</p></td>
 <td><p>Repeat elements of an array.</p></td>
 </tr>
 </tbody>
@@ -1620,7 +1620,7 @@ be performed.</p>
 <tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.argmax" 
title="mxnet.np.ndarray.argmax"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.argmax</span></code></a>([axis, 
out])</p></td>
 <td><p>Return indices of the maximum values along the given axis.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.min.html#mxnet.np.ndarray.min" 
title="mxnet.np.ndarray.min"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.min</span></code></a>([axis, out, 
keepdims])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.min" 
title="mxnet.np.ndarray.min"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.min</span></code></a>([axis, out, 
keepdims])</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="generated/mxnet.np.min.html#mxnet.np.min" title="mxnet.np.min"><code 
class="xref py py-func docutils literal notranslate"><span 
class="pre">min()</span></code></a>.</p></td>
 </tr>
 <tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.argmin" 
title="mxnet.np.ndarray.argmin"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.argmin</span></code></a>([axis, 
out])</p></td>
@@ -1629,22 +1629,22 @@ be performed.</p>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.clip" 
title="mxnet.np.ndarray.clip"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.clip</span></code></a>([min, max, 
out])</p></td>
 <td><p>Return an array whose values are limited to [min, max].</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.sum.html#mxnet.np.ndarray.sum" 
title="mxnet.np.ndarray.sum"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.sum</span></code></a>([axis, dtype, out, 
keepdims])</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.sum" 
title="mxnet.np.ndarray.sum"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.sum</span></code></a>([axis, dtype, out, 
keepdims])</p></td>
 <td><p>Return the sum of the array elements over the given axis.</p></td>
 </tr>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.mean" 
title="mxnet.np.ndarray.mean"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.mean</span></code></a>([axis, dtype, 
out, keepdims])</p></td>
 <td><p>Returns the average of the array elements along given axis.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.prod.html#mxnet.np.ndarray.prod" 
title="mxnet.np.ndarray.prod"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.prod</span></code></a>([axis, dtype, 
out, keepdims])</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.prod" 
title="mxnet.np.ndarray.prod"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.prod</span></code></a>([axis, dtype, 
out, keepdims])</p></td>
 <td><p>Return the product of the array elements over the given axis.</p></td>
 </tr>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.cumsum" 
title="mxnet.np.ndarray.cumsum"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.cumsum</span></code></a>([axis, dtype, 
out])</p></td>
 <td><p>Return the cumulative sum of the elements along the given axis.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.var.html#mxnet.np.ndarray.var" 
title="mxnet.np.ndarray.var"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.var</span></code></a>([axis, dtype, out, 
ddof, keepdims])</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.var" 
title="mxnet.np.ndarray.var"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.var</span></code></a>([axis, dtype, out, 
ddof, keepdims])</p></td>
 <td><p>Returns the variance of the array elements, along given axis.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.std.html#mxnet.np.ndarray.std" 
title="mxnet.np.ndarray.std"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.std</span></code></a>([axis, dtype, out, 
ddof, keepdims])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="generated/mxnet.np.ndarray.html#mxnet.np.ndarray.std" 
title="mxnet.np.ndarray.std"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndarray.std</span></code></a>([axis, dtype, out, 
ddof, keepdims])</p></td>
 <td><p>Returns the standard deviation of the array elements along given 
axis.</p></td>
 </tr>
 </tbody>
diff --git a/api/python/docs/api/np/generated/mxnet.np.lexsort.html 
b/api/python/docs/api/np/generated/mxnet.np.lexsort.html
index 6dab12b..81f71aa 100644
--- a/api/python/docs/api/np/generated/mxnet.np.lexsort.html
+++ b/api/python/docs/api/np/generated/mxnet.np.lexsort.html
@@ -1224,7 +1224,7 @@ sorting is according to the last row, second last row 
etc.</p>
 <dl class="simple">
 <dt><a class="reference internal" 
href="mxnet.np.argsort.html#mxnet.np.argsort" title="mxnet.np.argsort"><code 
class="xref py py-func docutils literal notranslate"><span 
class="pre">argsort()</span></code></a></dt><dd><p>Indirect sort.</p>
 </dd>
-<dt><a class="reference internal" 
href="mxnet.np.ndarray.sort.html#mxnet.np.ndarray.sort" 
title="mxnet.np.ndarray.sort"><code class="xref py py-func docutils literal 
notranslate"><span 
class="pre">ndarray.sort()</span></code></a></dt><dd><p>In-place sort.</p>
+<dt><a class="reference internal" 
href="mxnet.np.ndarray.html#mxnet.np.ndarray.sort" 
title="mxnet.np.ndarray.sort"><code class="xref py py-func docutils literal 
notranslate"><span 
class="pre">ndarray.sort()</span></code></a></dt><dd><p>In-place sort.</p>
 </dd>
 <dt><a class="reference internal" href="mxnet.np.sort.html#mxnet.np.sort" 
title="mxnet.np.sort"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">sort()</span></code></a></dt><dd><p>Return a 
sorted copy of an array.</p>
 </dd>
diff --git a/api/python/docs/api/np/generated/mxnet.np.ndarray.html 
b/api/python/docs/api/np/generated/mxnet.np.ndarray.html
index e63c4da..388c4fb 100644
--- a/api/python/docs/api/np/generated/mxnet.np.ndarray.html
+++ b/api/python/docs/api/np/generated/mxnet.np.ndarray.html
@@ -1462,7 +1462,7 @@ methods and attributes of an array.</p>
 <tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.mean" title="mxnet.np.ndarray.mean"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">mean</span></code></a>([axis, dtype, out, keepdims])</p></td>
 <td><p>Returns the average of the array elements along given axis.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.min.html#mxnet.np.ndarray.min" 
title="mxnet.np.ndarray.min"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">min</span></code></a>([axis, out, 
keepdims])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.min" title="mxnet.np.ndarray.min"><code class="xref py 
py-obj docutils literal notranslate"><span 
class="pre">min</span></code></a>([axis, out, keepdims])</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.min.html#mxnet.np.min" title="mxnet.np.min"><code class="xref py 
py-func docutils literal notranslate"><span 
class="pre">min()</span></code></a>.</p></td>
 </tr>
 <tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.nanprod" title="mxnet.np.ndarray.nanprod"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">nanprod</span></code></a>(*args, **kwargs)</p></td>
@@ -1471,7 +1471,7 @@ methods and attributes of an array.</p>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.nansum" title="mxnet.np.ndarray.nansum"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">nansum</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.nansum" title="mxnet.np.ndarray.nansum"><code 
class="xref py py-func docutils literal notranslate"><span 
class="pre">nansum()</span></code></a>.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.nonzero.html#mxnet.np.ndarray.nonzero" 
title="mxnet.np.ndarray.nonzero"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">nonzero</span></code></a>()</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.nonzero" title="mxnet.np.ndarray.nonzero"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">nonzero</span></code></a>()</p></td>
 <td><p>Return the indices of the elements that are non-zero.</p></td>
 </tr>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.norm" title="mxnet.np.ndarray.norm"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">norm</span></code></a>(*args, **kwargs)</p></td>
@@ -1489,7 +1489,7 @@ methods and attributes of an array.</p>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.pick" title="mxnet.np.ndarray.pick"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">pick</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.pick" title="mxnet.np.ndarray.pick"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">pick()</span></code></a>.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.prod.html#mxnet.np.ndarray.prod" 
title="mxnet.np.ndarray.prod"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">prod</span></code></a>([axis, dtype, out, 
keepdims])</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.prod" title="mxnet.np.ndarray.prod"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">prod</span></code></a>([axis, dtype, out, keepdims])</p></td>
 <td><p>Return the product of the array elements over the given axis.</p></td>
 </tr>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.radians" title="mxnet.np.ndarray.radians"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">radians</span></code></a>(*args, **kwargs)</p></td>
@@ -1504,10 +1504,10 @@ methods and attributes of an array.</p>
 <tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.relu" title="mxnet.np.ndarray.relu"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">relu</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.relu" title="mxnet.np.ndarray.relu"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">relu()</span></code></a>.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.repeat.html#mxnet.np.ndarray.repeat" 
title="mxnet.np.ndarray.repeat"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">repeat</span></code></a>(repeats[, 
axis])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.repeat" title="mxnet.np.ndarray.repeat"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">repeat</span></code></a>(repeats[, axis])</p></td>
 <td><p>Repeat elements of an array.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.reshape.html#mxnet.np.ndarray.reshape" 
title="mxnet.np.ndarray.reshape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">reshape</span></code></a>(*args, 
**kwargs)</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.reshape" title="mxnet.np.ndarray.reshape"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">reshape</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Returns a copy of the array with a new shape.</p></td>
 </tr>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.reshape_like" 
title="mxnet.np.ndarray.reshape_like"><code class="xref py py-obj docutils 
literal notranslate"><span class="pre">reshape_like</span></code></a>(*args, 
**kwargs)</p></td>
@@ -1519,8 +1519,8 @@ methods and attributes of an array.</p>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.rint" title="mxnet.np.ndarray.rint"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">rint</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.rint.html#mxnet.np.rint" title="mxnet.np.rint"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">rint()</span></code></a>.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.round.html#mxnet.np.ndarray.round" 
title="mxnet.np.ndarray.round"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">round</span></code></a>([decimals, out])</p></td>
-<td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.ndarray.round.html#mxnet.np.ndarray.round" 
title="mxnet.np.ndarray.round"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">round()</span></code></a>.</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.round" title="mxnet.np.ndarray.round"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">round</span></code></a>([decimals, out])</p></td>
+<td><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.round" title="mxnet.np.ndarray.round"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">round()</span></code></a>.</p></td>
 </tr>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.rsqrt" title="mxnet.np.ndarray.rsqrt"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">rsqrt</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.rsqrt" title="mxnet.np.ndarray.rsqrt"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">rsqrt()</span></code></a>.</p></td>
@@ -1564,7 +1564,7 @@ methods and attributes of an array.</p>
 <tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.softmin" title="mxnet.np.ndarray.softmin"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">softmin</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.softmin" title="mxnet.np.ndarray.softmin"><code 
class="xref py py-func docutils literal notranslate"><span 
class="pre">softmin()</span></code></a>.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.sort.html#mxnet.np.ndarray.sort" 
title="mxnet.np.ndarray.sort"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">sort</span></code></a>([axis, kind, 
order])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.sort" title="mxnet.np.ndarray.sort"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">sort</span></code></a>([axis, kind, order])</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.sort.html#mxnet.np.sort" title="mxnet.np.sort"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">sort()</span></code></a>.</p></td>
 </tr>
 <tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.space_to_depth" 
title="mxnet.np.ndarray.space_to_depth"><code class="xref py py-obj docutils 
literal notranslate"><span class="pre">space_to_depth</span></code></a>(*args, 
**kwargs)</p></td>
@@ -1582,20 +1582,20 @@ methods and attributes of an array.</p>
 <tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.square" title="mxnet.np.ndarray.square"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">square</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.square.html#mxnet.np.square" title="mxnet.np.square"><code 
class="xref py py-func docutils literal notranslate"><span 
class="pre">square()</span></code></a>.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.squeeze.html#mxnet.np.ndarray.squeeze" 
title="mxnet.np.ndarray.squeeze"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">squeeze</span></code></a>([axis])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.squeeze" title="mxnet.np.ndarray.squeeze"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">squeeze</span></code></a>([axis])</p></td>
 <td><p>Remove single-dimensional entries from the shape of a.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.std.html#mxnet.np.ndarray.std" 
title="mxnet.np.ndarray.std"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">std</span></code></a>([axis, dtype, out, ddof, 
keepdims])</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.std" title="mxnet.np.ndarray.std"><code class="xref py 
py-obj docutils literal notranslate"><span 
class="pre">std</span></code></a>([axis, dtype, out, ddof, keepdims])</p></td>
 <td><p>Returns the standard deviation of the array elements along given 
axis.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.sum.html#mxnet.np.ndarray.sum" 
title="mxnet.np.ndarray.sum"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">sum</span></code></a>([axis, dtype, out, 
keepdims])</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.sum" title="mxnet.np.ndarray.sum"><code class="xref py 
py-obj docutils literal notranslate"><span 
class="pre">sum</span></code></a>([axis, dtype, out, keepdims])</p></td>
 <td><p>Return the sum of the array elements over the given axis.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.swapaxes.html#mxnet.np.ndarray.swapaxes" 
title="mxnet.np.ndarray.swapaxes"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">swapaxes</span></code></a>(axis1, axis2)</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.swapaxes" title="mxnet.np.ndarray.swapaxes"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">swapaxes</span></code></a>(axis1, axis2)</p></td>
 <td><p>Return a copy of the array with axis1 and axis2 interchanged.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.take.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">take</span></code></a>(indices[, axis, 
mode])</p></td>
-<td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.ndarray.take.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">take()</span></code></a>.</p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.take" title="mxnet.np.ndarray.take"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">take</span></code></a>(indices[, axis, mode])</p></td>
+<td><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.take" title="mxnet.np.ndarray.take"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">take()</span></code></a>.</p></td>
 </tr>
 <tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.tan" title="mxnet.np.ndarray.tan"><code class="xref py 
py-obj docutils literal notranslate"><span 
class="pre">tan</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.tan.html#mxnet.np.tan" title="mxnet.np.tan"><code class="xref py 
py-func docutils literal notranslate"><span 
class="pre">tan()</span></code></a>.</p></td>
@@ -1621,13 +1621,13 @@ methods and attributes of an array.</p>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.tostype" title="mxnet.np.ndarray.tostype"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">tostype</span></code></a>(stype)</p></td>
 <td><p>Return a copy of the array with chosen storage type.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.transpose.html#mxnet.np.ndarray.transpose" 
title="mxnet.np.ndarray.transpose"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">transpose</span></code></a>(*axes)</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.transpose" title="mxnet.np.ndarray.transpose"><code 
class="xref py py-obj docutils literal notranslate"><span 
class="pre">transpose</span></code></a>(*axes)</p></td>
 <td><p>Permute the dimensions of an array.</p></td>
 </tr>
 <tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.trunc" title="mxnet.np.ndarray.trunc"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">trunc</span></code></a>(*args, **kwargs)</p></td>
 <td><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.trunc.html#mxnet.np.trunc" title="mxnet.np.trunc"><code 
class="xref py py-func docutils literal notranslate"><span 
class="pre">trunc()</span></code></a>.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.var.html#mxnet.np.ndarray.var" 
title="mxnet.np.ndarray.var"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">var</span></code></a>([axis, dtype, out, ddof, 
keepdims])</p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.var" title="mxnet.np.ndarray.var"><code class="xref py 
py-obj docutils literal notranslate"><span 
class="pre">var</span></code></a>([axis, dtype, out, ddof, keepdims])</p></td>
 <td><p>Returns the variance of the array elements, along given axis.</p></td>
 </tr>
 <tr class="row-odd"><td><p><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">wait_to_read</span></code>()</p></td>
@@ -1663,13 +1663,13 @@ methods and attributes of an array.</p>
 <tr class="row-even"><td><p><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">handle</span></code></p></td>
 <td><p></p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.ndim.html#mxnet.np.ndarray.ndim" 
title="mxnet.np.ndarray.ndim"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">ndim</span></code></a></p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.ndim" title="mxnet.np.ndarray.ndim"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">ndim</span></code></a></p></td>
 <td><p>Number of array dimensions.</p></td>
 </tr>
-<tr class="row-even"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.shape.html#mxnet.np.ndarray.shape" 
title="mxnet.np.ndarray.shape"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">shape</span></code></a></p></td>
+<tr class="row-even"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.shape" title="mxnet.np.ndarray.shape"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">shape</span></code></a></p></td>
 <td><p>Tuple of array dimensions.</p></td>
 </tr>
-<tr class="row-odd"><td><p><a class="reference internal" 
href="mxnet.np.ndarray.size.html#mxnet.np.ndarray.size" 
title="mxnet.np.ndarray.size"><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">size</span></code></a></p></td>
+<tr class="row-odd"><td><p><a class="reference internal" 
href="#mxnet.np.ndarray.size" title="mxnet.np.ndarray.size"><code class="xref 
py py-obj docutils literal notranslate"><span 
class="pre">size</span></code></a></p></td>
 <td><p>Number of elements in the array.</p></td>
 </tr>
 <tr class="row-even"><td><p><code class="xref py py-obj docutils literal 
notranslate"><span class="pre">stype</span></code></p></td>
@@ -2465,8 +2465,8 @@ this array as data.</p>
 <dl class="method">
 <dt id="mxnet.np.ndarray.round">
 <code class="sig-name descname">round</code><span 
class="sig-paren">(</span><em class="sig-param">decimals=0</em>, <em 
class="sig-param">out=None</em>, <em class="sig-param">**kwargs</em><span 
class="sig-paren">)</span><a class="headerlink" href="#mxnet.np.ndarray.round" 
title="Permalink to this definition">¶</a></dt>
-<dd><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.ndarray.round.html#mxnet.np.ndarray.round" 
title="mxnet.np.ndarray.round"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">round()</span></code></a>.</p>
-<p>The arguments are the same as for <a class="reference internal" 
href="mxnet.np.ndarray.round.html#mxnet.np.ndarray.round" 
title="mxnet.np.ndarray.round"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">round()</span></code></a>, with
+<dd><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.round" title="mxnet.np.ndarray.round"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">round()</span></code></a>.</p>
+<p>The arguments are the same as for <a class="reference internal" 
href="#mxnet.np.ndarray.round" title="mxnet.np.ndarray.round"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">round()</span></code></a>, with
 this array as data.</p>
 </dd></dl>
 
@@ -2765,8 +2765,8 @@ Refer to <cite>mxnet.numpy.swapaxes</cite> for full 
documentation.</p>
 <dl class="method">
 <dt id="mxnet.np.ndarray.take">
 <code class="sig-name descname">take</code><span class="sig-paren">(</span><em 
class="sig-param">indices</em>, <em class="sig-param">axis=None</em>, <em 
class="sig-param">mode='raise'</em><span class="sig-paren">)</span><a 
class="headerlink" href="#mxnet.np.ndarray.take" title="Permalink to this 
definition">¶</a></dt>
-<dd><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.ndarray.take.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">take()</span></code></a>.</p>
-<p>The arguments are the same as for <a class="reference internal" 
href="mxnet.np.ndarray.take.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">take()</span></code></a>, with
+<dd><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.take" title="mxnet.np.ndarray.take"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">take()</span></code></a>.</p>
+<p>The arguments are the same as for <a class="reference internal" 
href="#mxnet.np.ndarray.take" title="mxnet.np.ndarray.take"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">take()</span></code></a>, with
 this array as data.</p>
 </dd></dl>
 
diff --git a/api/python/docs/api/np/generated/mxnet.np.ndarray.round.html 
b/api/python/docs/api/np/generated/mxnet.np.ndarray.round.html
index 9237510..8d616e9 100644
--- a/api/python/docs/api/np/generated/mxnet.np.ndarray.round.html
+++ b/api/python/docs/api/np/generated/mxnet.np.ndarray.round.html
@@ -1195,8 +1195,8 @@ Show Source
 <dl class="method">
 <dt id="mxnet.np.ndarray.round">
 <code class="sig-prename descclassname">ndarray.</code><code class="sig-name 
descname">round</code><span class="sig-paren">(</span><em 
class="sig-param">decimals=0</em>, <em class="sig-param">out=None</em>, <em 
class="sig-param">**kwargs</em><span class="sig-paren">)</span><a 
class="headerlink" href="#mxnet.np.ndarray.round" title="Permalink to this 
definition">¶</a></dt>
-<dd><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.round" title="mxnet.np.ndarray.round"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">round()</span></code></a>.</p>
-<p>The arguments are the same as for <a class="reference internal" 
href="#mxnet.np.ndarray.round" title="mxnet.np.ndarray.round"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">round()</span></code></a>, with
+<dd><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.ndarray.html#mxnet.np.ndarray.round" 
title="mxnet.np.ndarray.round"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">round()</span></code></a>.</p>
+<p>The arguments are the same as for <a class="reference internal" 
href="mxnet.np.ndarray.html#mxnet.np.ndarray.round" 
title="mxnet.np.ndarray.round"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">round()</span></code></a>, with
 this array as data.</p>
 </dd></dl>
 
diff --git a/api/python/docs/api/np/generated/mxnet.np.ndarray.take.html 
b/api/python/docs/api/np/generated/mxnet.np.ndarray.take.html
index 770affa..9bfb0c6 100644
--- a/api/python/docs/api/np/generated/mxnet.np.ndarray.take.html
+++ b/api/python/docs/api/np/generated/mxnet.np.ndarray.take.html
@@ -1201,8 +1201,8 @@ Show Source
 <dl class="method">
 <dt id="mxnet.np.ndarray.take">
 <code class="sig-prename descclassname">ndarray.</code><code class="sig-name 
descname">take</code><span class="sig-paren">(</span><em 
class="sig-param">indices</em>, <em class="sig-param">axis=None</em>, <em 
class="sig-param">mode='raise'</em><span class="sig-paren">)</span><a 
class="headerlink" href="#mxnet.np.ndarray.take" title="Permalink to this 
definition">¶</a></dt>
-<dd><p>Convenience fluent method for <a class="reference internal" 
href="#mxnet.np.ndarray.take" title="mxnet.np.ndarray.take"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">take()</span></code></a>.</p>
-<p>The arguments are the same as for <a class="reference internal" 
href="#mxnet.np.ndarray.take" title="mxnet.np.ndarray.take"><code class="xref 
py py-func docutils literal notranslate"><span 
class="pre">take()</span></code></a>, with
+<dd><p>Convenience fluent method for <a class="reference internal" 
href="mxnet.np.ndarray.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">take()</span></code></a>.</p>
+<p>The arguments are the same as for <a class="reference internal" 
href="mxnet.np.ndarray.html#mxnet.np.ndarray.take" 
title="mxnet.np.ndarray.take"><code class="xref py py-func docutils literal 
notranslate"><span class="pre">take()</span></code></a>, with
 this array as data.</p>
 </dd></dl>
 
diff --git a/api/python/docs/api/np/generated/mxnet.np.nonzero.html 
b/api/python/docs/api/np/generated/mxnet.np.nonzero.html
index 09bc010..ab9e166 100644
--- a/api/python/docs/api/np/generated/mxnet.np.nonzero.html
+++ b/api/python/docs/api/np/generated/mxnet.np.nonzero.html
@@ -1216,7 +1216,7 @@ which returns a row for each non-zero element.</p>
 <div class="admonition seealso">
 <p class="admonition-title">See also</p>
 <dl class="simple">
-<dt><a class="reference internal" 
href="mxnet.np.ndarray.nonzero.html#mxnet.np.ndarray.nonzero" 
title="mxnet.np.ndarray.nonzero"><code class="xref py py-func docutils literal 
notranslate"><span 
class="pre">ndarray.nonzero()</span></code></a></dt><dd><p>Equivalent ndarray 
method.</p>
+<dt><a class="reference internal" 
href="mxnet.np.ndarray.html#mxnet.np.ndarray.nonzero" 
title="mxnet.np.ndarray.nonzero"><code class="xref py py-func docutils literal 
notranslate"><span 
class="pre">ndarray.nonzero()</span></code></a></dt><dd><p>Equivalent ndarray 
method.</p>
 </dd>
 </dl>
 </div>
diff --git a/api/python/docs/api/np/generated/mxnet.np.reshape.html 
b/api/python/docs/api/np/generated/mxnet.np.reshape.html
index 96e4e4c..5df70c2 100644
--- a/api/python/docs/api/np/generated/mxnet.np.reshape.html
+++ b/api/python/docs/api/np/generated/mxnet.np.reshape.html
@@ -1232,7 +1232,7 @@ generated.</p>
 <div class="admonition seealso">
 <p class="admonition-title">See also</p>
 <dl class="simple">
-<dt><a class="reference internal" 
href="mxnet.np.ndarray.reshape.html#mxnet.np.ndarray.reshape" 
title="mxnet.np.ndarray.reshape"><code class="xref py py-func docutils literal 
notranslate"><span 
class="pre">ndarray.reshape()</span></code></a></dt><dd><p>Equivalent 
method.</p>
+<dt><a class="reference internal" 
href="mxnet.np.ndarray.html#mxnet.np.ndarray.reshape" 
title="mxnet.np.ndarray.reshape"><code class="xref py py-func docutils literal 
notranslate"><span 
class="pre">ndarray.reshape()</span></code></a></dt><dd><p>Equivalent 
method.</p>
 </dd>
 </dl>
 </div>
diff --git a/api/python/docs/objects.inv b/api/python/docs/objects.inv
index 2e6dbe6..77ba1e9 100644
Binary files a/api/python/docs/objects.inv and b/api/python/docs/objects.inv 
differ
diff --git a/api/python/docs/searchindex.js b/api/python/docs/searchindex.js
index d8ef8c1..69c52f7 100644
--- a/api/python/docs/searchindex.js
+++ b/api/python/docs/searchindex.js
@@ -1 +1 @@
-Search.setIndex({docnames:["api/autograd/index","api/context/index","api/contrib/autograd/index","api/contrib/index","api/contrib/io/index","api/contrib/ndarray/index","api/contrib/onnx/index","api/contrib/quantization/index","api/contrib/symbol/index","api/contrib/tensorboard/index","api/contrib/tensorrt/index","api/contrib/text/index","api/engine/index","api/executor/index","api/gluon/block","api/gluon/constant","api/gluon/contrib/index","api/gluon/data/index","api/gluon/data/vision/da
 [...]
\ No newline at end of file
+Search.setIndex({docnames:["api/autograd/index","api/context/index","api/contrib/autograd/index","api/contrib/index","api/contrib/io/index","api/contrib/ndarray/index","api/contrib/onnx/index","api/contrib/quantization/index","api/contrib/symbol/index","api/contrib/tensorboard/index","api/contrib/tensorrt/index","api/contrib/text/index","api/engine/index","api/executor/index","api/gluon/block","api/gluon/constant","api/gluon/contrib/index","api/gluon/data/index","api/gluon/data/vision/da
 [...]
\ No newline at end of file
diff --git a/date.txt b/date.txt
deleted file mode 100644
index 45f66f5..0000000
--- a/date.txt
+++ /dev/null
@@ -1 +0,0 @@
-Fri Aug 21 12:43:54 UTC 2020
diff --git a/feed.xml b/feed.xml
index 7007af4..89c2b74 100644
--- a/feed.xml
+++ b/feed.xml
@@ -1 +1 @@
-<?xml version="1.0" encoding="utf-8"?><feed 
xmlns="http://www.w3.org/2005/Atom"; ><generator uri="https://jekyllrb.com/"; 
version="4.0.0">Jekyll</generator><link 
href="https://mxnet.apache.org/feed.xml"; rel="self" type="application/atom+xml" 
/><link href="https://mxnet.apache.org/"; rel="alternate" type="text/html" 
/><updated>2020-08-21T12:34:23+00:00</updated><id>https://mxnet.apache.org/feed.xml</id><title
 type="html">Apache MXNet</title><subtitle>A flexible and efficient library for 
deep [...]
\ No newline at end of file
+<?xml version="1.0" encoding="utf-8"?><feed 
xmlns="http://www.w3.org/2005/Atom"; ><generator uri="https://jekyllrb.com/"; 
version="4.0.0">Jekyll</generator><link 
href="https://mxnet.apache.org/feed.xml"; rel="self" type="application/atom+xml" 
/><link href="https://mxnet.apache.org/"; rel="alternate" type="text/html" 
/><updated>2020-08-21T18:34:25+00:00</updated><id>https://mxnet.apache.org/feed.xml</id><title
 type="html">Apache MXNet</title><subtitle>A flexible and efficient library for 
deep [...]
\ No newline at end of file

[incubator-mxnet-site] branch asf-site updated: Publish triggered by CI

Reply via email to