api/python/symbol/sparse.html - mxnet-site - Git at Google

 <!DOCTYPE html>

 <html lang="en">
 <head>
 <meta charset="utf-8"/>
 <meta content="IE=edge" http-equiv="X-UA-Compatible"/>
 <meta content="width=device-width, initial-scale=1" name="viewport"/>
 <title>Sparse Symbol API — mxnet  documentation</title>
 <link crossorigin="anonymous" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" rel="stylesheet"/>
 <link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.5.0/css/font-awesome.min.css" rel="stylesheet"/>
 <link href="../../../_static/basic.css" rel="stylesheet" type="text/css">
 <link href="../../../_static/pygments.css" rel="stylesheet" type="text/css">
 <link href="../../../_static/mxnet.css" rel="stylesheet" type="text/css"/>
 <script type="text/javascript">
       var DOCUMENTATION_OPTIONS = {
         URL_ROOT:    '../../../',
         VERSION:     '',
         COLLAPSE_INDEX: false,
         FILE_SUFFIX: '.html',
         HAS_SOURCE:  true,
         SOURCELINK_SUFFIX: ''
       };
     </script>
 <script src="https://code.jquery.com/jquery-1.11.1.min.js" type="text/javascript"></script>
 <script src="../../../_static/underscore.js" type="text/javascript"></script>
 <script src="../../../_static/searchtools_custom.js" type="text/javascript"></script>
 <script src="../../../_static/doctools.js" type="text/javascript"></script>
 <script src="../../../_static/selectlang.js" type="text/javascript"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js?config=TeX-AMS-MML_HTMLorMML" type="text/javascript"></script>
 <script type="text/javascript"> jQuery(function() { Search.loadIndex("/searchindex.js"); Search.init();}); </script>
 <script>
       (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
       (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new
       Date();a=s.createElement(o),
       m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
       })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

       ga('create', 'UA-96378503-1', 'auto');
       ga('send', 'pageview');

     </script>
 <!-- -->
 <!-- <script type="text/javascript" src="../../../_static/jquery.js"></script> -->
 <!-- -->
 <!-- <script type="text/javascript" src="../../../_static/underscore.js"></script> -->
 <!-- -->
 <!-- <script type="text/javascript" src="../../../_static/doctools.js"></script> -->
 <!-- -->
 <!-- <script type="text/javascript" src="https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> -->
 <!-- -->
 <link href="../index.html" rel="up" title="MXNet - Python API">
 <link href="contrib.html" rel="next" title="Contrib Symbol API"/>
 <link href="linalg.html" rel="prev" title="Linear Algebra Symbol API"/>
 <link href="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/mxnet-icon.png" rel="icon" type="image/png"/>
 </link></link></link></head>
 <body background="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/mxnet-background-compressed.jpeg" role="document">
 <div class="content-block"><div class="navbar navbar-fixed-top">
 <div class="container" id="navContainer">
 <div class="innder" id="header-inner">
 <h1 id="logo-wrap">
 <a href="../../../" id="logo"><img src="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/mxnet_logo.png"/></a>
 </h1>
 <nav class="nav-bar" id="main-nav">
 <a class="main-nav-link" href="../../../install/index.html">Install</a>
 <a class="main-nav-link" href="../../../tutorials/index.html">Tutorials</a>
 <span id="dropdown-menu-position-anchor">
 <a aria-expanded="true" aria-haspopup="true" class="main-nav-link dropdown-toggle" data-toggle="dropdown" href="#" role="button">Gluon <span class="caret"></span></a>
 <ul class="dropdown-menu navbar-menu" id="package-dropdown-menu">
 <li><a class="main-nav-link" href="../../../gluon/index.html">About</a></li>
 <li><a class="main-nav-link" href="http://gluon.mxnet.io">Tutorials</a></li>
 </ul>
 </span>
 <span id="dropdown-menu-position-anchor">
 <a aria-expanded="true" aria-haspopup="true" class="main-nav-link dropdown-toggle" data-toggle="dropdown" href="#" role="button">API <span class="caret"></span></a>
 <ul class="dropdown-menu navbar-menu" id="package-dropdown-menu">
 <li><a class="main-nav-link" href="../../../api/python/index.html">Python</a></li>
 <li><a class="main-nav-link" href="../../../api/scala/index.html">Scala</a></li>
 <li><a class="main-nav-link" href="../../../api/r/index.html">R</a></li>
 <li><a class="main-nav-link" href="../../../api/julia/index.html">Julia</a></li>
 <li><a class="main-nav-link" href="../../../api/c++/index.html">C++</a></li>
 <li><a class="main-nav-link" href="../../../api/perl/index.html">Perl</a></li>
 </ul>
 </span>
 <span id="dropdown-menu-position-anchor-docs">
 <a aria-expanded="true" aria-haspopup="true" class="main-nav-link dropdown-toggle" data-toggle="dropdown" href="#" role="button">Docs <span class="caret"></span></a>
 <ul class="dropdown-menu navbar-menu" id="package-dropdown-menu-docs">
 <li><a class="main-nav-link" href="../../../faq/index.html">FAQ</a></li>
 <li><a class="main-nav-link" href="../../../architecture/index.html">Architecture</a></li>
 <li><a class="main-nav-link" href="https://github.com/apache/incubator-mxnet/tree/1.0.0/example">Examples</a></li>
 <li><a class="main-nav-link" href="../../../model_zoo/index.html">Model Zoo</a></li>
 </ul>
 </span>
 <a class="main-nav-link" href="https://github.com/dmlc/mxnet">Github</a>
 <span id="dropdown-menu-position-anchor-community">
 <a aria-expanded="true" aria-haspopup="true" class="main-nav-link dropdown-toggle" data-toggle="dropdown" href="#" role="button">Community <span class="caret"></span></a>
 <ul class="dropdown-menu navbar-menu" id="package-dropdown-menu-community">
 <li><a class="main-nav-link" href="../../../community/index.html">Community</a></li>
 <li><a class="main-nav-link" href="../../../community/contribute.html">Contribute</a></li>
 <li><a class="main-nav-link" href="../../../community/powered_by.html">Powered By</a></li>
 </ul>
 </span>
 <a class="main-nav-link" href="http://discuss.mxnet.io">Discuss</a>
 <span id="dropdown-menu-position-anchor-version" style="position: relative"><a href="#" class="main-nav-link dropdown-toggle" data-toggle="dropdown" role="button" aria-haspopup="true" aria-expanded="true">Versions(1.0.0)<span class="caret"></span></a><ul id="package-dropdown-menu" class="dropdown-menu"><li><a class="main-nav-link" href=https://mxnet.incubator.apache.org/>1.0.0</a></li><li><a class="main-nav-link" href=https://mxnet.incubator.apache.org/versions/0.12.1/index.html>0.12.1</a></li><li><a class="main-nav-link" href=https://mxnet.incubator.apache.org/versions/0.12.0/index.html>0.12.0</a></li><li><a class="main-nav-link" href=https://mxnet.incubator.apache.org/versions/0.11.0/index.html>0.11.0</a></li><li><a class="main-nav-link" href=https://mxnet.incubator.apache.org/versions/master/index.html>master</a></li></ul></span></nav>
 <script> function getRootPath(){ return "../../../" } </script>
 <div class="burgerIcon dropdown">
 <a class="dropdown-toggle" data-toggle="dropdown" href="#" role="button">☰</a>
 <ul class="dropdown-menu" id="burgerMenu">
 <li><a href="../../../install/index.html">Install</a></li>
 <li><a class="main-nav-link" href="../../../tutorials/index.html">Tutorials</a></li>
 <li class="dropdown-submenu">
 <a href="#" tabindex="-1">Community</a>
 <ul class="dropdown-menu">
 <li><a href="../../../community/index.html" tabindex="-1">Community</a></li>
 <li><a href="../../../community/contribute.html" tabindex="-1">Contribute</a></li>
 <li><a href="../../../community/powered_by.html" tabindex="-1">Powered By</a></li>
 </ul>
 </li>
 <li class="dropdown-submenu">
 <a href="#" tabindex="-1">API</a>
 <ul class="dropdown-menu">
 <li><a href="../../../api/python/index.html" tabindex="-1">Python</a>
 </li>
 <li><a href="../../../api/scala/index.html" tabindex="-1">Scala</a>
 </li>
 <li><a href="../../../api/r/index.html" tabindex="-1">R</a>
 </li>
 <li><a href="../../../api/julia/index.html" tabindex="-1">Julia</a>
 </li>
 <li><a href="../../../api/c++/index.html" tabindex="-1">C++</a>
 </li>
 <li><a href="../../../api/perl/index.html" tabindex="-1">Perl</a>
 </li>
 </ul>
 </li>
 <li class="dropdown-submenu">
 <a href="#" tabindex="-1">Docs</a>
 <ul class="dropdown-menu">
 <li><a href="../../../tutorials/index.html" tabindex="-1">Tutorials</a></li>
 <li><a href="../../../faq/index.html" tabindex="-1">FAQ</a></li>
 <li><a href="../../../architecture/index.html" tabindex="-1">Architecture</a></li>
 <li><a href="https://github.com/apache/incubator-mxnet/tree/1.0.0/example" tabindex="-1">Examples</a></li>
 <li><a href="../../../model_zoo/index.html" tabindex="-1">Model Zoo</a></li>
 </ul>
 </li>
 <li><a href="../../../architecture/index.html">Architecture</a></li>
 <li><a class="main-nav-link" href="https://github.com/dmlc/mxnet">Github</a></li>
 <li id="dropdown-menu-position-anchor-version-mobile" class="dropdown-submenu" style="position: relative"><a href="#" tabindex="-1">Versions(1.0.0)</a><ul class="dropdown-menu"><li><a tabindex="-1" href=https://mxnet.incubator.apache.org/>1.0.0</a></li><li><a tabindex="-1" href=https://mxnet.incubator.apache.org/versions/0.12.1/index.html>0.12.1</a></li><li><a tabindex="-1" href=https://mxnet.incubator.apache.org/versions/0.12.0/index.html>0.12.0</a></li><li><a tabindex="-1" href=https://mxnet.incubator.apache.org/versions/0.11.0/index.html>0.11.0</a></li><li><a tabindex="-1" href=https://mxnet.incubator.apache.org/versions/master/index.html>master</a></li></ul></li></ul>
 </div>
 <div class="plusIcon dropdown">
 <a class="dropdown-toggle" data-toggle="dropdown" href="#" role="button"><span aria-hidden="true" class="glyphicon glyphicon-plus"></span></a>
 <ul class="dropdown-menu dropdown-menu-right" id="plusMenu"></ul>
 </div>
 <div id="search-input-wrap">
 <form action="../../../search.html" autocomplete="off" class="" method="get" role="search">
 <div class="form-group inner-addon left-addon">
 <i class="glyphicon glyphicon-search"></i>
 <input class="form-control" name="q" placeholder="Search" type="text"/>
 </div>
 <input name="check_keywords" type="hidden" value="yes">
 <input name="area" type="hidden" value="default"/>
 </input></form>
 <div id="search-preview"></div>
 </div>
 <div id="searchIcon">
 <span aria-hidden="true" class="glyphicon glyphicon-search"></span>
 </div>
 <!-- <div id="lang-select-wrap"> -->
 <!--   <label id="lang-select-label"> -->
 <!--     <\!-- <i class="fa fa-globe"></i> -\-> -->
 <!--     <span></span> -->
 <!--   </label> -->
 <!--   <select id="lang-select"> -->
 <!--     <option value="en">Eng</option> -->
 <!--     <option value="zh">中文</option> -->
 <!--   </select> -->
 <!-- </div> -->
 <!--     <a id="mobile-nav-toggle">
         <span class="mobile-nav-toggle-bar"></span>
         <span class="mobile-nav-toggle-bar"></span>
         <span class="mobile-nav-toggle-bar"></span>
       </a> -->
 </div>
 </div>
 </div>
 <script type="text/javascript">
         $('body').css('background', 'white');
     </script>
 <div class="container">
 <div class="row">
 <div aria-label="main navigation" class="sphinxsidebar leftsidebar" role="navigation">
 <div class="sphinxsidebarwrapper">
 <ul class="current">
 <li class="toctree-l1 current"><a class="reference internal" href="../index.html">Python Documents</a><ul class="current">
 <li class="toctree-l2"><a class="reference internal" href="../index.html#ndarray-api">NDArray API</a></li>
 <li class="toctree-l2 current"><a class="reference internal" href="../index.html#symbol-api">Symbol API</a><ul class="current">
 <li class="toctree-l3"><a class="reference internal" href="symbol.html">Symbol API</a></li>
 <li class="toctree-l3"><a class="reference internal" href="random.html">Random Distribution Generator Symbol API</a></li>
 <li class="toctree-l3"><a class="reference internal" href="linalg.html">Linear Algebra Symbol API</a></li>
 <li class="toctree-l3 current"><a class="current reference internal" href="">Sparse Symbol API</a><ul>
 <li class="toctree-l4"><a class="reference internal" href="#overview">Overview</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#symbol-creation-routines">Symbol creation routines</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#symbol-manipulation-routines">Symbol manipulation routines</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#mathematical-functions">Mathematical functions</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#neural-network">Neural network</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#api-reference">API Reference</a></li>
 </ul>
 </li>
 <li class="toctree-l3"><a class="reference internal" href="contrib.html">Contrib Symbol API</a></li>
 <li class="toctree-l3"><a class="reference internal" href="rnn.html">RNN Cell Symbol API</a></li>
 </ul>
 </li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#module-api">Module API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#autograd-api">Autograd API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#gluon-api">Gluon API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#kvstore-api">KVStore API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#io-api">IO API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#image-api">Image API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#optimization-api">Optimization API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#callback-api">Callback API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#metric-api">Metric API</a></li>
 <li class="toctree-l2"><a class="reference internal" href="../index.html#run-time-compilation-api">Run-Time Compilation API</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="../../r/index.html">R Documents</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../julia/index.html">Julia Documents</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../c++/index.html">C++ Documents</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../scala/index.html">Scala Documents</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../perl/index.html">Perl Documents</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../../faq/index.html">HowTo Documents</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../../architecture/index.html">System Documents</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../../tutorials/index.html">Tutorials</a></li>
 <li class="toctree-l1"><a class="reference internal" href="../../../community/index.html">Community</a></li>
 </ul>
 </div>
 </div>
 <div class="content">
 <div class="page-tracker"></div>
 <div class="section" id="sparse-symbol-api">
 <span id="sparse-symbol-api"></span><h1>Sparse Symbol API<a class="headerlink" href="#sparse-symbol-api" title="Permalink to this headline">¶</a></h1>
 <div class="section" id="overview">
 <span id="overview"></span><h2>Overview<a class="headerlink" href="#overview" title="Permalink to this headline">¶</a></h2>
 <p>This document lists the routines of the sparse symbolic expression package:</p>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#module-mxnet.symbol.sparse" title="mxnet.symbol.sparse"><code class="xref py py-obj docutils literal"><span class="pre">mxnet.symbol.sparse</span></code></a></td>
 <td>Sparse Symbol API of MXNet.</td>
 </tr>
 </tbody>
 </table>
 <p>The <code class="docutils literal"><span class="pre">Sparse</span> <span class="pre">Symbol</span></code> API, defined in the <code class="docutils literal"><span class="pre">symbol.sparse</span></code> package, provides
 sparse neural network graphs and auto-differentiation on CPU.</p>
 <p>The storage type of a variable is speficied by the <code class="docutils literal"><span class="pre">stype</span></code> attribute of the variable.
 The storage type of a symbolic expression is inferred based on the storage types of the variables and the operators.</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">a</span> <span class="o">=</span> <span class="n">mx</span><span class="o">.</span><span class="n">sym</span><span class="o">.</span><span class="n">Variable</span><span class="p">(</span><span class="s1">'a'</span><span class="p">,</span> <span class="n">stype</span><span class="o">=</span><span class="s1">'csr'</span><span class="p">)</span>
 <span class="gp">>>> </span><span class="n">b</span> <span class="o">=</span> <span class="n">mx</span><span class="o">.</span><span class="n">sym</span><span class="o">.</span><span class="n">Variable</span><span class="p">(</span><span class="s1">'b'</span><span class="p">)</span>
 <span class="gp">>>> </span><span class="n">c</span> <span class="o">=</span> <span class="n">mx</span><span class="o">.</span><span class="n">sym</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">transpose_a</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
 <span class="gp">>>> </span><span class="nb">type</span><span class="p">(</span><span class="n">c</span><span class="p">)</span>
 <span class="go"><class 'mxnet.symbol.Symbol'></span>
 <span class="gp">>>> </span><span class="n">e</span> <span class="o">=</span> <span class="n">c</span><span class="o">.</span><span class="n">bind</span><span class="p">(</span><span class="n">mx</span><span class="o">.</span><span class="n">cpu</span><span class="p">(),</span> <span class="p">{</span><span class="s1">'a'</span><span class="p">:</span> <span class="n">mx</span><span class="o">.</span><span class="n">nd</span><span class="o">.</span><span class="n">array</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]])</span><span class="o">.</span><span class="n">tostype</span><span class="p">(</span><span class="s1">'csr'</span><span class="p">),</span> <span class="s1">'b'</span><span class="p">:</span><span class="n">mx</span><span class="o">.</span><span class="n">nd</span><span class="o">.</span><span class="n">ones</span><span class="p">((</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">))})</span>
 <span class="gp">>>> </span><span class="n">y</span> <span class="o">=</span> <span class="n">e</span><span class="o">.</span><span class="n">forward</span><span class="p">()</span>
 <span class="go"># the result storage type of dot(csr.T, dense) is inferred to be `row_sparse`</span>
 <span class="gp">>>> </span><span class="n">y</span>
 <span class="go">[<RowSparseNDArray 3x2 @cpu(0)>]</span>
 <span class="gp">>>> </span><span class="n">y</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
 <span class="go">array([ 1.,  1.],</span>
 <span class="go">      [ 0.,  0.],</span>
 <span class="go">      [ 0.,  0.]], dtype=float32)</span>
 </pre></div>
 </div>
 <div class="admonition note">
 <p class="first admonition-title">Note</p>
 <p>most operators provided in <code class="docutils literal"><span class="pre">mxnet.symbol.sparse</span></code> are similar to those in
 <code class="docutils literal"><span class="pre">mxnet.symbol</span></code> although there are few differences:</p>
 <ul class="last simple">
 <li>Only a subset of operators in <code class="docutils literal"><span class="pre">mxnet.symbol</span></code> have specialized implementations in <code class="docutils literal"><span class="pre">mxnet.symbol.sparse</span></code>.
 Operators such as reduction and broadcasting do not have sparse implementations yet.</li>
 <li>The storage types (<code class="docutils literal"><span class="pre">stype</span></code>) of sparse operators’ outputs depend on the storage types of inputs.
 By default the operators not available in <code class="docutils literal"><span class="pre">mxnet.symbol.sparse</span></code> infer “default” (dense) storage type for outputs.
 Please refer to the API reference section for further details on specific operators.</li>
 <li>GPU support for <code class="docutils literal"><span class="pre">mxnet.symbol.sparse</span></code> is experimental.</li>
 </ul>
 </div>
 <p>In the rest of this document, we list sparse related routines provided by the
 <code class="docutils literal"><span class="pre">symbol.sparse</span></code> package.</p>
 </div>
 <div class="section" id="symbol-creation-routines">
 <span id="symbol-creation-routines"></span><h2>Symbol creation routines<a class="headerlink" href="#symbol-creation-routines" title="Permalink to this headline">¶</a></h2>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.zeros_like" title="mxnet.symbol.sparse.zeros_like"><code class="xref py py-obj docutils literal"><span class="pre">zeros_like</span></code></a></td>
 <td>Return an array of zeros with the same shape and type as the input array.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="symbol.html#mxnet.symbol.var" title="mxnet.symbol.var"><code class="xref py py-obj docutils literal"><span class="pre">mxnet.symbol.var</span></code></a></td>
 <td>Creates a symbolic variable with specified name.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="symbol-manipulation-routines">
 <span id="symbol-manipulation-routines"></span><h2>Symbol manipulation routines<a class="headerlink" href="#symbol-manipulation-routines" title="Permalink to this headline">¶</a></h2>
 <div class="section" id="changing-symbol-storage-type">
 <span id="changing-symbol-storage-type"></span><h3>Changing symbol storage type<a class="headerlink" href="#changing-symbol-storage-type" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.cast_storage" title="mxnet.symbol.sparse.cast_storage"><code class="xref py py-obj docutils literal"><span class="pre">cast_storage</span></code></a></td>
 <td>Casts tensor storage type to the new type.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="indexing-routines">
 <span id="indexing-routines"></span><h3>Indexing routines<a class="headerlink" href="#indexing-routines" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.slice" title="mxnet.symbol.sparse.slice"><code class="xref py py-obj docutils literal"><span class="pre">slice</span></code></a></td>
 <td>Slices a region of the array.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.retain" title="mxnet.symbol.sparse.retain"><code class="xref py py-obj docutils literal"><span class="pre">retain</span></code></a></td>
 <td>pick rows specified by user input index array from a row sparse matrix</td>
 </tr>
 </tbody>
 </table>
 </div>
 </div>
 <div class="section" id="mathematical-functions">
 <span id="mathematical-functions"></span><h2>Mathematical functions<a class="headerlink" href="#mathematical-functions" title="Permalink to this headline">¶</a></h2>
 <div class="section" id="arithmetic-operations">
 <span id="arithmetic-operations"></span><h3>Arithmetic operations<a class="headerlink" href="#arithmetic-operations" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.elemwise_add" title="mxnet.symbol.sparse.elemwise_add"><code class="xref py py-obj docutils literal"><span class="pre">elemwise_add</span></code></a></td>
 <td>Adds arguments element-wise.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.elemwise_sub" title="mxnet.symbol.sparse.elemwise_sub"><code class="xref py py-obj docutils literal"><span class="pre">elemwise_sub</span></code></a></td>
 <td>Subtracts arguments element-wise.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.elemwise_mul" title="mxnet.symbol.sparse.elemwise_mul"><code class="xref py py-obj docutils literal"><span class="pre">elemwise_mul</span></code></a></td>
 <td>Multiplies arguments element-wise.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.negative" title="mxnet.symbol.sparse.negative"><code class="xref py py-obj docutils literal"><span class="pre">negative</span></code></a></td>
 <td>Numerical negative of the argument, element-wise.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.dot" title="mxnet.symbol.sparse.dot"><code class="xref py py-obj docutils literal"><span class="pre">dot</span></code></a></td>
 <td>Dot product of two arrays.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.add_n" title="mxnet.symbol.sparse.add_n"><code class="xref py py-obj docutils literal"><span class="pre">add_n</span></code></a></td>
 <td>Adds all input arguments element-wise.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="trigonometric-functions">
 <span id="trigonometric-functions"></span><h3>Trigonometric functions<a class="headerlink" href="#trigonometric-functions" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.sin" title="mxnet.symbol.sparse.sin"><code class="xref py py-obj docutils literal"><span class="pre">sin</span></code></a></td>
 <td>Computes the element-wise sine of the input array.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.tan" title="mxnet.symbol.sparse.tan"><code class="xref py py-obj docutils literal"><span class="pre">tan</span></code></a></td>
 <td>Computes the element-wise tangent of the input array.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.arcsin" title="mxnet.symbol.sparse.arcsin"><code class="xref py py-obj docutils literal"><span class="pre">arcsin</span></code></a></td>
 <td>Returns element-wise inverse sine of the input array.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.arctan" title="mxnet.symbol.sparse.arctan"><code class="xref py py-obj docutils literal"><span class="pre">arctan</span></code></a></td>
 <td>Returns element-wise inverse tangent of the input array.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.degrees" title="mxnet.symbol.sparse.degrees"><code class="xref py py-obj docutils literal"><span class="pre">degrees</span></code></a></td>
 <td>Converts each element of the input array from radians to degrees.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.radians" title="mxnet.symbol.sparse.radians"><code class="xref py py-obj docutils literal"><span class="pre">radians</span></code></a></td>
 <td>Converts each element of the input array from degrees to radians.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="hyperbolic-functions">
 <span id="hyperbolic-functions"></span><h3>Hyperbolic functions<a class="headerlink" href="#hyperbolic-functions" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.sinh" title="mxnet.symbol.sparse.sinh"><code class="xref py py-obj docutils literal"><span class="pre">sinh</span></code></a></td>
 <td>Returns the hyperbolic sine of the input array, computed element-wise.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.tanh" title="mxnet.symbol.sparse.tanh"><code class="xref py py-obj docutils literal"><span class="pre">tanh</span></code></a></td>
 <td>Returns the hyperbolic tangent of the input array, computed element-wise.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.arcsinh" title="mxnet.symbol.sparse.arcsinh"><code class="xref py py-obj docutils literal"><span class="pre">arcsinh</span></code></a></td>
 <td>Returns the element-wise inverse hyperbolic sine of the input array, computed element-wise.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.arctanh" title="mxnet.symbol.sparse.arctanh"><code class="xref py py-obj docutils literal"><span class="pre">arctanh</span></code></a></td>
 <td>Returns the element-wise inverse hyperbolic tangent of the input array, computed element-wise.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="reduce-functions">
 <span id="reduce-functions"></span><h3>Reduce functions<a class="headerlink" href="#reduce-functions" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.sum" title="mxnet.symbol.sparse.sum"><code class="xref py py-obj docutils literal"><span class="pre">sum</span></code></a></td>
 <td>Computes the sum of array elements over given axes.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.mean" title="mxnet.symbol.sparse.mean"><code class="xref py py-obj docutils literal"><span class="pre">mean</span></code></a></td>
 <td>Computes the mean of array elements over given axes.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="rounding">
 <span id="rounding"></span><h3>Rounding<a class="headerlink" href="#rounding" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.round" title="mxnet.symbol.sparse.round"><code class="xref py py-obj docutils literal"><span class="pre">round</span></code></a></td>
 <td>Returns element-wise rounded value to the nearest integer of the input.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.rint" title="mxnet.symbol.sparse.rint"><code class="xref py py-obj docutils literal"><span class="pre">rint</span></code></a></td>
 <td>Returns element-wise rounded value to the nearest integer of the input.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.fix" title="mxnet.symbol.sparse.fix"><code class="xref py py-obj docutils literal"><span class="pre">fix</span></code></a></td>
 <td>Returns element-wise rounded value to the nearest integer towards zero of the input.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.floor" title="mxnet.symbol.sparse.floor"><code class="xref py py-obj docutils literal"><span class="pre">floor</span></code></a></td>
 <td>Returns element-wise floor of the input.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.ceil" title="mxnet.symbol.sparse.ceil"><code class="xref py py-obj docutils literal"><span class="pre">ceil</span></code></a></td>
 <td>Returns element-wise ceiling of the input.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.trunc" title="mxnet.symbol.sparse.trunc"><code class="xref py py-obj docutils literal"><span class="pre">trunc</span></code></a></td>
 <td>Return the element-wise truncated value of the input.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="exponents-and-logarithms">
 <span id="exponents-and-logarithms"></span><h3>Exponents and logarithms<a class="headerlink" href="#exponents-and-logarithms" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.expm1" title="mxnet.symbol.sparse.expm1"><code class="xref py py-obj docutils literal"><span class="pre">expm1</span></code></a></td>
 <td>Returns <code class="docutils literal"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code> computed element-wise on the input.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.log1p" title="mxnet.symbol.sparse.log1p"><code class="xref py py-obj docutils literal"><span class="pre">log1p</span></code></a></td>
 <td>Returns element-wise <code class="docutils literal"><span class="pre">log(1</span> <span class="pre">+</span> <span class="pre">x)</span></code> value of the input.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="powers">
 <span id="powers"></span><h3>Powers<a class="headerlink" href="#powers" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.sqrt" title="mxnet.symbol.sparse.sqrt"><code class="xref py py-obj docutils literal"><span class="pre">sqrt</span></code></a></td>
 <td>Returns element-wise square-root value of the input.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.square" title="mxnet.symbol.sparse.square"><code class="xref py py-obj docutils literal"><span class="pre">square</span></code></a></td>
 <td>Returns element-wise squared value of the input.</td>
 </tr>
 </tbody>
 </table>
 </div>
 <div class="section" id="miscellaneous">
 <span id="miscellaneous"></span><h3>Miscellaneous<a class="headerlink" href="#miscellaneous" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.clip" title="mxnet.symbol.sparse.clip"><code class="xref py py-obj docutils literal"><span class="pre">clip</span></code></a></td>
 <td>Clips (limits) the values in an array.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.abs" title="mxnet.symbol.sparse.abs"><code class="xref py py-obj docutils literal"><span class="pre">abs</span></code></a></td>
 <td>Returns element-wise absolute value of the input.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.sign" title="mxnet.symbol.sparse.sign"><code class="xref py py-obj docutils literal"><span class="pre">sign</span></code></a></td>
 <td>Returns element-wise sign of the input.</td>
 </tr>
 </tbody>
 </table>
 </div>
 </div>
 <div class="section" id="neural-network">
 <span id="neural-network"></span><h2>Neural network<a class="headerlink" href="#neural-network" title="Permalink to this headline">¶</a></h2>
 <div class="section" id="more">
 <span id="more"></span><h3>More<a class="headerlink" href="#more" title="Permalink to this headline">¶</a></h3>
 <table border="1" class="longtable docutils">
 <colgroup>
 <col width="10%"/>
 <col width="90%"/>
 </colgroup>
 <tbody valign="top">
 <tr class="row-odd"><td><a class="reference internal" href="#mxnet.symbol.sparse.make_loss" title="mxnet.symbol.sparse.make_loss"><code class="xref py py-obj docutils literal"><span class="pre">make_loss</span></code></a></td>
 <td>Make your own loss function in network construction.</td>
 </tr>
 <tr class="row-even"><td><a class="reference internal" href="#mxnet.symbol.sparse.stop_gradient" title="mxnet.symbol.sparse.stop_gradient"><code class="xref py py-obj docutils literal"><span class="pre">stop_gradient</span></code></a></td>
 <td>Stops gradient computation.</td>
 </tr>
 <tr class="row-odd"><td><a class="reference internal" href="contrib.html#mxnet.symbol.contrib.SparseEmbedding" title="mxnet.symbol.contrib.SparseEmbedding"><code class="xref py py-obj docutils literal"><span class="pre">mxnet.symbol.contrib.SparseEmbedding</span></code></a></td>
 <td>Maps integer indices to vector representations (embeddings).</td>
 </tr>
 </tbody>
 </table>
 </div>
 </div>
 <div class="section" id="api-reference">
 <span id="api-reference"></span><h2>API Reference<a class="headerlink" href="#api-reference" title="Permalink to this headline">¶</a></h2>
 <script src="../../../_static/js/auto_module_index.js" type="text/javascript"></script><span class="target" id="module-mxnet.symbol.sparse"></span><p>Sparse Symbol API of MXNet.</p>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.ElementWiseSum">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">ElementWiseSum</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.ElementWiseSum" title="Permalink to this definition">¶</a></dt>
 <dd><p>Adds all input arguments element-wise.</p>
 <div class="math">
 \[add\_n(a_1, a_2, ..., a_n) = a_1 + a_2 + ... + a_n\]</div>
 <p><code class="docutils literal"><span class="pre">add_n</span></code> is potentially more efficient than calling <code class="docutils literal"><span class="pre">add</span></code> by <cite>n</cite> times.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">add_n</span></code> output depends on storage types of inputs</p>
 <ul class="simple">
 <li>add_n(row_sparse, row_sparse, ..) = row_sparse</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">add_n</span></code> generates output with default storage</li>
 </ul>
 <p>Defined in src/operator/tensor/elemwise_sum.cc:L123
 This function support variable length of positional input.</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>args</strong> (<em>Symbol[]</em>) – Positional input arguments</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.abs">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">abs</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.abs" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise absolute value of the input.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="nb">abs</span><span class="p">([</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">abs</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>abs(default) = default</li>
 <li>abs(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L386</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.adam_update">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">adam_update</code><span class="sig-paren">(</span><em>weight=None</em>, <em>grad=None</em>, <em>mean=None</em>, <em>var=None</em>, <em>lr=_Null</em>, <em>beta1=_Null</em>, <em>beta2=_Null</em>, <em>epsilon=_Null</em>, <em>wd=_Null</em>, <em>rescale_grad=_Null</em>, <em>clip_gradient=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.adam_update" title="Permalink to this definition">¶</a></dt>
 <dd><p>Update function for Adam optimizer. Adam is seen as a generalization
 of AdaGrad.</p>
 <p>Adam update consists of the following steps, where g represents gradient and m, v
 are 1st and 2nd order moment estimates (mean and variance).</p>
 <div class="math">
 \[\begin{split}g_t = \nabla J(W_{t-1})\\
 m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t\\
 v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2\\
 W_t = W_{t-1} - \alpha \frac{ m_t }{ \sqrt{ v_t } + \epsilon }\end{split}\]</div>
 <p>It updates the weights using:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">m</span> <span class="o">=</span> <span class="n">beta1</span><span class="o">*</span><span class="n">m</span> <span class="o">+</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">beta1</span><span class="p">)</span><span class="o">*</span><span class="n">grad</span>
 <span class="n">v</span> <span class="o">=</span> <span class="n">beta2</span><span class="o">*</span><span class="n">v</span> <span class="o">+</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">beta2</span><span class="p">)</span><span class="o">*</span><span class="p">(</span><span class="n">grad</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
 <span class="n">w</span> <span class="o">+=</span> <span class="o">-</span> <span class="n">learning_rate</span> <span class="o">*</span> <span class="n">m</span> <span class="o">/</span> <span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="n">v</span><span class="p">)</span> <span class="o">+</span> <span class="n">epsilon</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>If w, m and v are all of <code class="docutils literal"><span class="pre">row_sparse</span></code> storage type,
 only the row slices whose indices appear in grad.indices are updated (for w, m and v):</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">grad</span><span class="o">.</span><span class="n">indices</span><span class="p">:</span>
     <span class="n">m</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">=</span> <span class="n">beta1</span><span class="o">*</span><span class="n">m</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">+</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">beta1</span><span class="p">)</span><span class="o">*</span><span class="n">grad</span><span class="p">[</span><span class="n">row</span><span class="p">]</span>
     <span class="n">v</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">=</span> <span class="n">beta2</span><span class="o">*</span><span class="n">v</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">+</span> <span class="p">(</span><span class="mi">1</span><span class="o">-</span><span class="n">beta2</span><span class="p">)</span><span class="o">*</span><span class="p">(</span><span class="n">grad</span><span class="p">[</span><span class="n">row</span><span class="p">]</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span>
     <span class="n">w</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">+=</span> <span class="o">-</span> <span class="n">learning_rate</span> <span class="o">*</span> <span class="n">m</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">/</span> <span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="n">v</span><span class="p">[</span><span class="n">row</span><span class="p">])</span> <span class="o">+</span> <span class="n">epsilon</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>Defined in src/operator/optimizer_op.cc:L175</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>weight</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Weight</li>
 <li><strong>grad</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Gradient</li>
 <li><strong>mean</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Moving mean</li>
 <li><strong>var</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Moving variance</li>
 <li><strong>lr</strong> (<em>float, required</em>) – Learning rate</li>
 <li><strong>beta1</strong> (<em>float, optional, default=0.9</em>) – The decay rate for the 1st moment estimates.</li>
 <li><strong>beta2</strong> (<em>float, optional, default=0.999</em>) – The decay rate for the 2nd moment estimates.</li>
 <li><strong>epsilon</strong> (<em>float, optional, default=1e-08</em>) – A small constant for numerical stability.</li>
 <li><strong>wd</strong> (<em>float, optional, default=0</em>) – Weight decay augments the objective function with a regularization term that penalizes large weights. The penalty scales with the square of the magnitude of each weight.</li>
 <li><strong>rescale_grad</strong> (<em>float, optional, default=1</em>) – Rescale gradient to grad = rescale_grad*grad.</li>
 <li><strong>clip_gradient</strong> (<em>float, optional, default=-1</em>) – Clip gradient to the range of [-clip_gradient, clip_gradient] If clip_gradient <= 0, gradient clipping is turned off. grad = max(min(grad, clip_gradient), -clip_gradient).</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.add_n">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">add_n</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.add_n" title="Permalink to this definition">¶</a></dt>
 <dd><p>Adds all input arguments element-wise.</p>
 <div class="math">
 \[add\_n(a_1, a_2, ..., a_n) = a_1 + a_2 + ... + a_n\]</div>
 <p><code class="docutils literal"><span class="pre">add_n</span></code> is potentially more efficient than calling <code class="docutils literal"><span class="pre">add</span></code> by <cite>n</cite> times.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">add_n</span></code> output depends on storage types of inputs</p>
 <ul class="simple">
 <li>add_n(row_sparse, row_sparse, ..) = row_sparse</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">add_n</span></code> generates output with default storage</li>
 </ul>
 <p>Defined in src/operator/tensor/elemwise_sum.cc:L123
 This function support variable length of positional input.</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>args</strong> (<em>Symbol[]</em>) – Positional input arguments</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.arccos">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">arccos</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.arccos" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise inverse cosine of the input array.</p>
 <p>The input should be in range <cite>[-1, 1]</cite>.
 The output is in the closed interval <span class="math">\([0, \pi]\)</span></p>
 <div class="math">
 \[arccos([-1, -.707, 0, .707, 1]) = [\pi, 3\pi/4, \pi/2, \pi/4, 0]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">arccos</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L123</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.arccosh">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">arccosh</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.arccosh" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns the element-wise inverse hyperbolic cosine of the input array, computed element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">arccosh</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L264</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.arcsin">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">arcsin</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.arcsin" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise inverse sine of the input array.</p>
 <p>The input should be in the range <cite>[-1, 1]</cite>.
 The output is in the closed interval of [<span class="math">\(-\pi/2\)</span>, <span class="math">\(\pi/2\)</span>].</p>
 <div class="math">
 \[arcsin([-1, -.707, 0, .707, 1]) = [-\pi/2, -\pi/4, 0, \pi/4, \pi/2]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">arcsin</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>arcsin(default) = default</li>
 <li>arcsin(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L104</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.arcsinh">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">arcsinh</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.arcsinh" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns the element-wise inverse hyperbolic sine of the input array, computed element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">arcsinh</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>arcsinh(default) = default</li>
 <li>arcsinh(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L250</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.arctan">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">arctan</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.arctan" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise inverse tangent of the input array.</p>
 <p>The output is in the closed interval <span class="math">\([-\pi/2, \pi/2]\)</span></p>
 <div class="math">
 \[arctan([-1, 0, 1]) = [-\pi/4, 0, \pi/4]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">arctan</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>arctan(default) = default</li>
 <li>arctan(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L144</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.arctanh">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">arctanh</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.arctanh" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns the element-wise inverse hyperbolic tangent of the input array, computed element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">arctanh</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>arctanh(default) = default</li>
 <li>arctanh(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L281</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.cast_storage">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">cast_storage</code><span class="sig-paren">(</span><em>data=None</em>, <em>stype=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.cast_storage" title="Permalink to this definition">¶</a></dt>
 <dd><p>Casts tensor storage type to the new type.</p>
 <p>When an NDArray with default storage type is cast to csr or row_sparse storage,
 the result is compact, which means:</p>
 <ul class="simple">
 <li>for csr, zero values will not be retained</li>
 <li>for row_sparse, row slices of all zeros will not be retained</li>
 </ul>
 <p>The storage type of <code class="docutils literal"><span class="pre">cast_storage</span></code> output depends on stype parameter:</p>
 <ul class="simple">
 <li>cast_storage(csr, ‘default’) = default</li>
 <li>cast_storage(row_sparse, ‘default’) = default</li>
 <li>cast_storage(default, ‘csr’) = csr</li>
 <li>cast_storage(default, ‘row_sparse’) = row_sparse</li>
 </ul>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">dense</span> <span class="o">=</span> <span class="p">[[</span> <span class="mf">0.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">],</span>
          <span class="p">[</span> <span class="mf">2.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">,</span>  <span class="mf">3.</span><span class="p">],</span>
          <span class="p">[</span> <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">],</span>
          <span class="p">[</span> <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">]]</span>

 <span class="c1"># cast to row_sparse storage type</span>
 <span class="n">rsp</span> <span class="o">=</span> <span class="n">cast_storage</span><span class="p">(</span><span class="n">dense</span><span class="p">,</span> <span class="s1">'row_sparse'</span><span class="p">)</span>
 <span class="n">rsp</span><span class="o">.</span><span class="n">indices</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
 <span class="n">rsp</span><span class="o">.</span><span class="n">values</span> <span class="o">=</span> <span class="p">[[</span> <span class="mf">0.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">],</span>
               <span class="p">[</span> <span class="mf">2.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">,</span>  <span class="mf">3.</span><span class="p">]]</span>

 <span class="c1"># cast to csr storage type</span>
 <span class="n">csr</span> <span class="o">=</span> <span class="n">cast_storage</span><span class="p">(</span><span class="n">dense</span><span class="p">,</span> <span class="s1">'csr'</span><span class="p">)</span>
 <span class="n">csr</span><span class="o">.</span><span class="n">indices</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">]</span>
 <span class="n">csr</span><span class="o">.</span><span class="n">values</span> <span class="o">=</span> <span class="p">[</span> <span class="mf">1.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">,</span>  <span class="mf">3.</span><span class="p">]</span>
 <span class="n">csr</span><span class="o">.</span><span class="n">indptr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>Defined in src/operator/tensor/cast_storage.cc:L69</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input.</li>
 <li><strong>stype</strong> (<em>{'csr', 'default', 'row_sparse'}, required</em>) – Output storage type.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.ceil">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">ceil</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.ceil" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise ceiling of the input.</p>
 <p>The ceil of the scalar x is the smallest integer i, such that i >= x.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">ceil</span><span class="p">([</span><span class="o">-</span><span class="mf">2.1</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.9</span><span class="p">,</span> <span class="mf">1.5</span><span class="p">,</span> <span class="mf">1.9</span><span class="p">,</span> <span class="mf">2.1</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mf">2.</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">,</span>  <span class="mf">3.</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">ceil</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>ceil(default) = default</li>
 <li>ceil(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L463</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.clip">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">clip</code><span class="sig-paren">(</span><em>data=None</em>, <em>a_min=_Null</em>, <em>a_max=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.clip" title="Permalink to this definition">¶</a></dt>
 <dd><p>Clips (limits) the values in an array.</p>
 <p>Given an interval, values outside the interval are clipped to the interval edges.
 Clipping <code class="docutils literal"><span class="pre">x</span></code> between <cite>a_min</cite> and <cite>a_x</cite> would be:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span>clip(x, a_min, a_max) = max(min(x, a_max), a_min))
 </pre></div>
 </div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">]</span>

 <span class="n">clip</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">8</span><span class="p">)</span> <span class="o">=</span> <span class="p">[</span> <span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">,</span>  <span class="mf">3.</span><span class="p">,</span>  <span class="mf">4.</span><span class="p">,</span>  <span class="mf">5.</span><span class="p">,</span>  <span class="mf">6.</span><span class="p">,</span>  <span class="mf">7.</span><span class="p">,</span>  <span class="mf">8.</span><span class="p">,</span>  <span class="mf">8.</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">clip</span></code> output depends on storage types of inputs and the a_min, a_max parameter values:</p>
 <blockquote>
 <div><ul class="simple">
 <li>clip(default) = default</li>
 <li>clip(row_sparse, a_min <= 0, a_max >= 0) = row_sparse</li>
 <li>clip(csr, a_min <= 0, a_max >= 0) = csr</li>
 <li>clip(row_sparse, a_min < 0, a_max < 0) = default</li>
 <li>clip(row_sparse, a_min > 0, a_max > 0) = default</li>
 <li>clip(csr, a_min < 0, a_max < 0) = csr</li>
 <li>clip(csr, a_min > 0, a_max > 0) = csr</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/matrix_op.cc:L424</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Input array.</li>
 <li><strong>a_min</strong> (<em>float, required</em>) – Minimum value</li>
 <li><strong>a_max</strong> (<em>float, required</em>) – Maximum value</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.cos">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">cos</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.cos" title="Permalink to this definition">¶</a></dt>
 <dd><p>Computes the element-wise cosine of the input array.</p>
 <p>The input should be in radians (<span class="math">\(2\pi\)</span> rad equals 360 degrees).</p>
 <div class="math">
 \[cos([0, \pi/4, \pi/2]) = [1, 0.707, 0]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">cos</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L63</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.cosh">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">cosh</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.cosh" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns the hyperbolic cosine  of the input array, computed element-wise.</p>
 <div class="math">
 \[cosh(x) = 0.5\times(exp(x) + exp(-x))\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">cosh</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L216</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.degrees">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">degrees</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.degrees" title="Permalink to this definition">¶</a></dt>
 <dd><p>Converts each element of the input array from radians to degrees.</p>
 <div class="math">
 \[degrees([0, \pi/2, \pi, 3\pi/2, 2\pi]) = [0, 90, 180, 270, 360]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">degrees</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>degrees(default) = default</li>
 <li>degrees(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L163</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.dot">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">dot</code><span class="sig-paren">(</span><em>lhs=None</em>, <em>rhs=None</em>, <em>transpose_a=_Null</em>, <em>transpose_b=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.dot" title="Permalink to this definition">¶</a></dt>
 <dd><p>Dot product of two arrays.</p>
 <p><code class="docutils literal"><span class="pre">dot</span></code>‘s behavior depends on the input array dimensions:</p>
 <ul>
 <li><p class="first">1-D arrays: inner product of vectors</p>
 </li>
 <li><p class="first">2-D arrays: matrix multiplication</p>
 </li>
 <li><p class="first">N-D arrays: a sum product over the last axis of the first input and the first
 axis of the second input</p>
 <p>For example, given 3-D <code class="docutils literal"><span class="pre">x</span></code> with shape <cite>(n,m,k)</cite> and <code class="docutils literal"><span class="pre">y</span></code> with shape <cite>(k,r,s)</cite>, the
 result array will have shape <cite>(n,m,r,s)</cite>. It is computed by:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">dot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">)[</span><span class="n">i</span><span class="p">,</span><span class="n">j</span><span class="p">,</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">]</span> <span class="o">=</span> <span class="nb">sum</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="n">i</span><span class="p">,</span><span class="n">j</span><span class="p">,:]</span><span class="o">*</span><span class="n">y</span><span class="p">[:,</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">])</span>
 </pre></div>
 </div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="n">reshape</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">],</span> <span class="n">shape</span><span class="o">=</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">))</span>
 <span class="n">y</span> <span class="o">=</span> <span class="n">reshape</span><span class="p">([</span><span class="mi">7</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span> <span class="n">shape</span><span class="o">=</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">))</span>
 <span class="n">dot</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="n">y</span><span class="p">)[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>
 <span class="nb">sum</span><span class="p">(</span><span class="n">x</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">,:]</span><span class="o">*</span><span class="n">y</span><span class="p">[:,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">])</span> <span class="o">=</span> <span class="mi">0</span>
 </pre></div>
 </div>
 </li>
 </ul>
 <p>The storage type of <code class="docutils literal"><span class="pre">dot</span></code> output depends on storage types of inputs and transpose options:</p>
 <ul class="simple">
 <li>dot(csr, default) = default</li>
 <li>dot(csr.T, default) = row_sparse</li>
 <li>dot(csr, row_sparse) = default</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">dot</span></code> generates output with default storage</li>
 </ul>
 <p>Defined in src/operator/tensor/dot.cc:L61</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>lhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The first input</li>
 <li><strong>rhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The second input</li>
 <li><strong>transpose_a</strong> (<em>boolean, optional, default=0</em>) – If true then transpose the first input before dot.</li>
 <li><strong>transpose_b</strong> (<em>boolean, optional, default=0</em>) – If true then transpose the second input before dot.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.elemwise_add">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">elemwise_add</code><span class="sig-paren">(</span><em>lhs=None</em>, <em>rhs=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.elemwise_add" title="Permalink to this definition">¶</a></dt>
 <dd><p>Adds arguments element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">elemwise_add</span></code> output depends on storage types of inputs</p>
 <blockquote>
 <div><ul class="simple">
 <li>elemwise_add(row_sparse, row_sparse) = row_sparse</li>
 <li>elemwise_add(csr, csr) = csr</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">elemwise_add</span></code> generates output with default storage</li>
 </ul>
 </div></blockquote>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>lhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – first input</li>
 <li><strong>rhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – second input</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.elemwise_div">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">elemwise_div</code><span class="sig-paren">(</span><em>lhs=None</em>, <em>rhs=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.elemwise_div" title="Permalink to this definition">¶</a></dt>
 <dd><p>Divides arguments element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">elemwise_div</span></code> output is always dense</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>lhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – first input</li>
 <li><strong>rhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – second input</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.elemwise_mul">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">elemwise_mul</code><span class="sig-paren">(</span><em>lhs=None</em>, <em>rhs=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.elemwise_mul" title="Permalink to this definition">¶</a></dt>
 <dd><p>Multiplies arguments element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">elemwise_mul</span></code> output depends on storage types of inputs</p>
 <blockquote>
 <div><ul class="simple">
 <li>elemwise_mul(default, default) = default</li>
 <li>elemwise_mul(row_sparse, row_sparse) = row_sparse</li>
 <li>elemwise_mul(default, row_sparse) = default</li>
 <li>elemwise_mul(row_sparse, default) = default</li>
 <li>elemwise_mul(csr, csr) = csr</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">elemwise_mul</span></code> generates output with default storage</li>
 </ul>
 </div></blockquote>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>lhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – first input</li>
 <li><strong>rhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – second input</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.elemwise_sub">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">elemwise_sub</code><span class="sig-paren">(</span><em>lhs=None</em>, <em>rhs=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.elemwise_sub" title="Permalink to this definition">¶</a></dt>
 <dd><p>Subtracts arguments element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">elemwise_sub</span></code> output depends on storage types of inputs</p>
 <blockquote>
 <div><ul class="simple">
 <li>elemwise_sub(row_sparse, row_sparse) = row_sparse</li>
 <li>elemwise_sub(csr, csr) = csr</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">elemwise_sub</span></code> generates output with default storage</li>
 </ul>
 </div></blockquote>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>lhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – first input</li>
 <li><strong>rhs</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – second input</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.exp">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">exp</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.exp" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise exponential value of the input.</p>
 <div class="math">
 \[exp(x) = e^x \approx 2.718^x\]</div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">exp</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">2.71828175</span><span class="p">,</span> <span class="mf">7.38905621</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">exp</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L637</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.expm1">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">expm1</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.expm1" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns <code class="docutils literal"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code> computed element-wise on the input.</p>
 <p>This function provides greater precision than <code class="docutils literal"><span class="pre">exp(x)</span> <span class="pre">-</span> <span class="pre">1</span></code> for small values of <code class="docutils literal"><span class="pre">x</span></code>.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">expm1</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>expm1(default) = default</li>
 <li>expm1(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L716</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.fix">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">fix</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.fix" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise rounded value to the nearest integer towards zero of the input.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">fix</span><span class="p">([</span><span class="o">-</span><span class="mf">2.1</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.9</span><span class="p">,</span> <span class="mf">1.9</span><span class="p">,</span> <span class="mf">2.1</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mf">2.</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span> <span class="mf">2.</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">fix</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>fix(default) = default</li>
 <li>fix(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L517</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.floor">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">floor</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.floor" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise floor of the input.</p>
 <p>The floor of the scalar x is the largest integer i, such that i <= x.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">floor</span><span class="p">([</span><span class="o">-</span><span class="mf">2.1</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.9</span><span class="p">,</span> <span class="mf">1.5</span><span class="p">,</span> <span class="mf">1.9</span><span class="p">,</span> <span class="mf">2.1</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mf">3.</span><span class="p">,</span> <span class="o">-</span><span class="mf">2.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">floor</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>floor(default) = default</li>
 <li>floor(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L481</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.ftrl_update">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">ftrl_update</code><span class="sig-paren">(</span><em>weight=None</em>, <em>grad=None</em>, <em>z=None</em>, <em>n=None</em>, <em>lr=_Null</em>, <em>lamda1=_Null</em>, <em>beta=_Null</em>, <em>wd=_Null</em>, <em>rescale_grad=_Null</em>, <em>clip_gradient=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.ftrl_update" title="Permalink to this definition">¶</a></dt>
 <dd><p>Update function for Ftrl optimizer.
 Referenced from <em>Ad Click Prediction: a View from the Trenches</em>, available at
 <a class="reference external" href="http://dl.acm.org/citation.cfm?id=2488200">http://dl.acm.org/citation.cfm?id=2488200</a>.</p>
 <p>It updates the weights using:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">rescaled_grad</span> <span class="o">=</span> <span class="n">clip</span><span class="p">(</span><span class="n">grad</span> <span class="o">*</span> <span class="n">rescale_grad</span><span class="p">,</span> <span class="n">clip_gradient</span><span class="p">)</span>
 <span class="n">z</span> <span class="o">+=</span> <span class="n">rescaled_grad</span> <span class="o">-</span> <span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="n">n</span> <span class="o">+</span> <span class="n">rescaled_grad</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span> <span class="o">-</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">n</span><span class="p">))</span> <span class="o">*</span> <span class="n">weight</span> <span class="o">/</span> <span class="n">learning_rate</span>
 <span class="n">n</span> <span class="o">+=</span> <span class="n">rescaled_grad</span><span class="o">**</span><span class="mi">2</span>
 <span class="n">w</span> <span class="o">=</span> <span class="p">(</span><span class="n">sign</span><span class="p">(</span><span class="n">z</span><span class="p">)</span> <span class="o">*</span> <span class="n">lamda1</span> <span class="o">-</span> <span class="n">z</span><span class="p">)</span> <span class="o">/</span> <span class="p">((</span><span class="n">beta</span> <span class="o">+</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">n</span><span class="p">))</span> <span class="o">/</span> <span class="n">learning_rate</span> <span class="o">+</span> <span class="n">wd</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="nb">abs</span><span class="p">(</span><span class="n">z</span><span class="p">)</span> <span class="o">></span> <span class="n">lamda1</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>If w, z and n are all of <code class="docutils literal"><span class="pre">row_sparse</span></code> storage type,
 only the row slices whose indices appear in grad.indices are updated (for w, z and n):</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">grad</span><span class="o">.</span><span class="n">indices</span><span class="p">:</span>
     <span class="n">rescaled_grad</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">=</span> <span class="n">clip</span><span class="p">(</span><span class="n">grad</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">*</span> <span class="n">rescale_grad</span><span class="p">,</span> <span class="n">clip_gradient</span><span class="p">)</span>
     <span class="n">z</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">+=</span> <span class="n">rescaled_grad</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">-</span> <span class="p">(</span><span class="n">sqrt</span><span class="p">(</span><span class="n">n</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">+</span> <span class="n">rescaled_grad</span><span class="p">[</span><span class="n">row</span><span class="p">]</span><span class="o">**</span><span class="mi">2</span><span class="p">)</span> <span class="o">-</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">n</span><span class="p">[</span><span class="n">row</span><span class="p">]))</span> <span class="o">*</span> <span class="n">weight</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">/</span> <span class="n">learning_rate</span>
     <span class="n">n</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">+=</span> <span class="n">rescaled_grad</span><span class="p">[</span><span class="n">row</span><span class="p">]</span><span class="o">**</span><span class="mi">2</span>
     <span class="n">w</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">=</span> <span class="p">(</span><span class="n">sign</span><span class="p">(</span><span class="n">z</span><span class="p">[</span><span class="n">row</span><span class="p">])</span> <span class="o">*</span> <span class="n">lamda1</span> <span class="o">-</span> <span class="n">z</span><span class="p">[</span><span class="n">row</span><span class="p">])</span> <span class="o">/</span> <span class="p">((</span><span class="n">beta</span> <span class="o">+</span> <span class="n">sqrt</span><span class="p">(</span><span class="n">n</span><span class="p">[</span><span class="n">row</span><span class="p">]))</span> <span class="o">/</span> <span class="n">learning_rate</span> <span class="o">+</span> <span class="n">wd</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="nb">abs</span><span class="p">(</span><span class="n">z</span><span class="p">[</span><span class="n">row</span><span class="p">])</span> <span class="o">></span> <span class="n">lamda1</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>Defined in src/operator/optimizer_op.cc:L308</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>weight</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Weight</li>
 <li><strong>grad</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Gradient</li>
 <li><strong>z</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – z</li>
 <li><strong>n</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Square of grad</li>
 <li><strong>lr</strong> (<em>float, required</em>) – Learning rate</li>
 <li><strong>lamda1</strong> (<em>float, optional, default=0.01</em>) – The L1 regularization coefficient.</li>
 <li><strong>beta</strong> (<em>float, optional, default=1</em>) – Per-Coordinate Learning Rate beta.</li>
 <li><strong>wd</strong> (<em>float, optional, default=0</em>) – Weight decay augments the objective function with a regularization term that penalizes large weights. The penalty scales with the square of the magnitude of each weight.</li>
 <li><strong>rescale_grad</strong> (<em>float, optional, default=1</em>) – Rescale gradient to grad = rescale_grad*grad.</li>
 <li><strong>clip_gradient</strong> (<em>float, optional, default=-1</em>) – Clip gradient to the range of [-clip_gradient, clip_gradient] If clip_gradient <= 0, gradient clipping is turned off. grad = max(min(grad, clip_gradient), -clip_gradient).</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.gamma">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">gamma</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.gamma" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns the gamma function (extension of the factorial function to the reals), computed element-wise on the input array.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">gamma</span></code> output is always dense</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.gammaln">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">gammaln</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.gammaln" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise log of the absolute value of the gamma function of the input.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">gammaln</span></code> output is always dense</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.log">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">log</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.log" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise Natural logarithmic value of the input.</p>
 <p>The natural logarithm is logarithm in base <em>e</em>, so that <code class="docutils literal"><span class="pre">log(exp(x))</span> <span class="pre">=</span> <span class="pre">x</span></code></p>
 <p>The storage type of <code class="docutils literal"><span class="pre">log</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L649</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.log10">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">log10</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.log10" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise Base-10 logarithmic value of the input.</p>
 <p><code class="docutils literal"><span class="pre">10**log10(x)</span> <span class="pre">=</span> <span class="pre">x</span></code></p>
 <p>The storage type of <code class="docutils literal"><span class="pre">log10</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L661</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.log1p">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">log1p</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.log1p" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise <code class="docutils literal"><span class="pre">log(1</span> <span class="pre">+</span> <span class="pre">x)</span></code> value of the input.</p>
 <p>This function is more accurate than <code class="docutils literal"><span class="pre">log(1</span> <span class="pre">+</span> <span class="pre">x)</span></code>  for small <code class="docutils literal"><span class="pre">x</span></code> so that
 <span class="math">\(1+x\approx 1\)</span></p>
 <p>The storage type of <code class="docutils literal"><span class="pre">log1p</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>log1p(default) = default</li>
 <li>log1p(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L698</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.log2">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">log2</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.log2" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise Base-2 logarithmic value of the input.</p>
 <p><code class="docutils literal"><span class="pre">2**log2(x)</span> <span class="pre">=</span> <span class="pre">x</span></code></p>
 <p>The storage type of <code class="docutils literal"><span class="pre">log2</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L673</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.make_loss">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">make_loss</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.make_loss" title="Permalink to this definition">¶</a></dt>
 <dd><p>Make your own loss function in network construction.</p>
 <p>This operator accepts a customized loss function symbol as a terminal loss and
 the symbol should be an operator with no backward dependency.
 The output of this function is the gradient of loss with respect to the input data.</p>
 <p>For example, if you are a making a cross entropy loss function. Assume <code class="docutils literal"><span class="pre">out</span></code> is the
 predicted output and <code class="docutils literal"><span class="pre">label</span></code> is the true label, then the cross entropy can be defined as:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">cross_entropy</span> <span class="o">=</span> <span class="n">label</span> <span class="o">*</span> <span class="n">log</span><span class="p">(</span><span class="n">out</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span><span class="mi">1</span> <span class="o">-</span> <span class="n">label</span><span class="p">)</span> <span class="o">*</span> <span class="n">log</span><span class="p">(</span><span class="mi">1</span> <span class="o">-</span> <span class="n">out</span><span class="p">)</span>
 <span class="n">loss</span> <span class="o">=</span> <span class="n">make_loss</span><span class="p">(</span><span class="n">cross_entropy</span><span class="p">)</span>
 </pre></div>
 </div>
 <p>We will need to use <code class="docutils literal"><span class="pre">make_loss</span></code> when we are creating our own loss function or we want to
 combine multiple loss functions. Also we may want to stop some variables’ gradients
 from backpropagation. See more detail in <code class="docutils literal"><span class="pre">BlockGrad</span></code> or <code class="docutils literal"><span class="pre">stop_gradient</span></code>.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">make_loss</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>make_loss(default) = default</li>
 <li>make_loss(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L200</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.mean">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">mean</code><span class="sig-paren">(</span><em>data=None</em>, <em>axis=_Null</em>, <em>keepdims=_Null</em>, <em>exclude=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.mean" title="Permalink to this definition">¶</a></dt>
 <dd><p>Computes the mean of array elements over given axes.</p>
 <p>Defined in src/operator/tensor/broadcast_reduce_op_value.cc:L101</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input</li>
 <li><strong>axis</strong> (<em>Shape(tuple), optional, default=[]</em>) – <p>The axis or axes along which to perform the reduction.</p>
 <p>The default, <cite>axis=()</cite>, will compute over all elements into a
 scalar array with shape <cite>(1,)</cite>.</p>
 <p>If <cite>axis</cite> is int, a reduction is performed on a particular axis.</p>
 <p>If <cite>axis</cite> is a tuple of ints, a reduction is performed on all the axes
 specified in the tuple.</p>
 <p>If <cite>exclude</cite> is true, reduction will be performed on the axes that are
 NOT in axis instead.</p>
 <p>Negative values means indexing from right to left.</p>
 </li>
 <li><strong>keepdims</strong> (<em>boolean, optional, default=0</em>) – If this is set to <cite>True</cite>, the reduced axes are left in the result as dimension with size one.</li>
 <li><strong>exclude</strong> (<em>boolean, optional, default=0</em>) – Whether to perform reduction on axis that are NOT in axis instead.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.negative">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">negative</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.negative" title="Permalink to this definition">¶</a></dt>
 <dd><p>Numerical negative of the argument, element-wise.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">negative</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>negative(default) = default</li>
 <li>negative(row_sparse) = row_sparse</li>
 <li>negative(csr) = csr</li>
 </ul>
 </div></blockquote>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.radians">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">radians</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.radians" title="Permalink to this definition">¶</a></dt>
 <dd><p>Converts each element of the input array from degrees to radians.</p>
 <div class="math">
 \[radians([0, 90, 180, 270, 360]) = [0, \pi/2, \pi, 3\pi/2, 2\pi]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">radians</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>radians(default) = default</li>
 <li>radians(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L182</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.relu">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">relu</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.relu" title="Permalink to this definition">¶</a></dt>
 <dd><p>Computes rectified linear.</p>
 <div class="math">
 \[max(features, 0)\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">relu</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>relu(default) = default</li>
 <li>relu(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L84</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.retain">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">retain</code><span class="sig-paren">(</span><em>data=None</em>, <em>indices=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.retain" title="Permalink to this definition">¶</a></dt>
 <dd><p>pick rows specified by user input index array from a row sparse matrix
 and save them in the output sparse matrix.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">data</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]</span>
 <span class="n">indices</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
 <span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
 <span class="n">rsp_in</span> <span class="o">=</span> <span class="n">row_sparse</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">indices</span><span class="p">)</span>
 <span class="n">to_retain</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
 <span class="n">rsp_out</span> <span class="o">=</span> <span class="n">retain</span><span class="p">(</span><span class="n">rsp_in</span><span class="p">,</span> <span class="n">to_retain</span><span class="p">)</span>
 <span class="n">rsp_out</span><span class="o">.</span><span class="n">values</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">]]</span>
 <span class="n">rsp_out</span><span class="o">.</span><span class="n">indices</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">retain</span></code> output depends on storage types of inputs</p>
 <ul class="simple">
 <li>retain(row_sparse, default) = row_sparse</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">retain</span></code> is not supported</li>
 </ul>
 <p>Defined in src/operator/tensor/sparse_retain.cc:L53</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array for sparse_retain operator.</li>
 <li><strong>indices</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The index array of rows ids that will be retained.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.rint">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">rint</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.rint" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise rounded value to the nearest integer of the input.</p>
 <div class="admonition note">
 <p class="first admonition-title">Note</p>
 <ul class="last simple">
 <li>For input <code class="docutils literal"><span class="pre">n.5</span></code> <code class="docutils literal"><span class="pre">rint</span></code> returns <code class="docutils literal"><span class="pre">n</span></code> while <code class="docutils literal"><span class="pre">round</span></code> returns <code class="docutils literal"><span class="pre">n+1</span></code>.</li>
 <li>For input <code class="docutils literal"><span class="pre">-n.5</span></code> both <code class="docutils literal"><span class="pre">rint</span></code> and <code class="docutils literal"><span class="pre">round</span></code> returns <code class="docutils literal"><span class="pre">-n-1</span></code>.</li>
 </ul>
 </div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">rint</span><span class="p">([</span><span class="o">-</span><span class="mf">1.5</span><span class="p">,</span> <span class="mf">1.5</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.9</span><span class="p">,</span> <span class="mf">1.9</span><span class="p">,</span> <span class="mf">2.1</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mf">2.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span> <span class="o">-</span><span class="mf">2.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">rint</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>rint(default) = default</li>
 <li>rint(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L445</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.round">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">round</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.round" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise rounded value to the nearest integer of the input.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="nb">round</span><span class="p">([</span><span class="o">-</span><span class="mf">1.5</span><span class="p">,</span> <span class="mf">1.5</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.9</span><span class="p">,</span> <span class="mf">1.9</span><span class="p">,</span> <span class="mf">2.1</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mf">2.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">,</span> <span class="o">-</span><span class="mf">2.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">round</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>round(default) = default</li>
 <li>round(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L424</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.rsqrt">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">rsqrt</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.rsqrt" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise inverse square-root value of the input.</p>
 <div class="math">
 \[rsqrt(x) = 1/\sqrt{x}\]</div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">rsqrt</span><span class="p">([</span><span class="mi">4</span><span class="p">,</span><span class="mi">9</span><span class="p">,</span><span class="mi">16</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="mf">0.5</span><span class="p">,</span> <span class="mf">0.33333334</span><span class="p">,</span> <span class="mf">0.25</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">rsqrt</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L580</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sgd_mom_update">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sgd_mom_update</code><span class="sig-paren">(</span><em>weight=None</em>, <em>grad=None</em>, <em>mom=None</em>, <em>lr=_Null</em>, <em>momentum=_Null</em>, <em>wd=_Null</em>, <em>rescale_grad=_Null</em>, <em>clip_gradient=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sgd_mom_update" title="Permalink to this definition">¶</a></dt>
 <dd><p>Momentum update function for Stochastic Gradient Descent (SDG) optimizer.</p>
 <p>Momentum update has better convergence rates on neural networks. Mathematically it looks
 like below:</p>
 <div class="math">
 \[\begin{split}v_1 = \alpha * \nabla J(W_0)\\
 v_t = \gamma v_{t-1} - \alpha * \nabla J(W_{t-1})\\
 W_t = W_{t-1} + v_t\end{split}\]</div>
 <p>It updates the weights using:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">v</span> <span class="o">=</span> <span class="n">momentum</span> <span class="o">*</span> <span class="n">v</span> <span class="o">-</span> <span class="n">learning_rate</span> <span class="o">*</span> <span class="n">gradient</span>
 <span class="n">weight</span> <span class="o">+=</span> <span class="n">v</span>
 </pre></div>
 </div>
 <p>Where the parameter <code class="docutils literal"><span class="pre">momentum</span></code> is the decay rate of momentum estimates at each epoch.</p>
 <p>If weight and momentum are both of <code class="docutils literal"><span class="pre">row_sparse</span></code> storage type,
 only the row slices whose indices appear in grad.indices are updated (for both weight and momentum):</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">gradient</span><span class="o">.</span><span class="n">indices</span><span class="p">:</span>
     <span class="n">v</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">=</span> <span class="n">momentum</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">*</span> <span class="n">v</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">-</span> <span class="n">learning_rate</span> <span class="o">*</span> <span class="n">gradient</span><span class="p">[</span><span class="n">row</span><span class="p">]</span>
     <span class="n">weight</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">+=</span> <span class="n">v</span><span class="p">[</span><span class="n">row</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>Defined in src/operator/optimizer_op.cc:L93</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>weight</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Weight</li>
 <li><strong>grad</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Gradient</li>
 <li><strong>mom</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Momentum</li>
 <li><strong>lr</strong> (<em>float, required</em>) – Learning rate</li>
 <li><strong>momentum</strong> (<em>float, optional, default=0</em>) – The decay rate of momentum estimates at each epoch.</li>
 <li><strong>wd</strong> (<em>float, optional, default=0</em>) – Weight decay augments the objective function with a regularization term that penalizes large weights. The penalty scales with the square of the magnitude of each weight.</li>
 <li><strong>rescale_grad</strong> (<em>float, optional, default=1</em>) – Rescale gradient to grad = rescale_grad*grad.</li>
 <li><strong>clip_gradient</strong> (<em>float, optional, default=-1</em>) – Clip gradient to the range of [-clip_gradient, clip_gradient] If clip_gradient <= 0, gradient clipping is turned off. grad = max(min(grad, clip_gradient), -clip_gradient).</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sgd_update">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sgd_update</code><span class="sig-paren">(</span><em>weight=None</em>, <em>grad=None</em>, <em>lr=_Null</em>, <em>wd=_Null</em>, <em>rescale_grad=_Null</em>, <em>clip_gradient=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sgd_update" title="Permalink to this definition">¶</a></dt>
 <dd><p>Update function for Stochastic Gradient Descent (SDG) optimizer.</p>
 <p>It updates the weights using:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">weight</span> <span class="o">=</span> <span class="n">weight</span> <span class="o">-</span> <span class="n">learning_rate</span> <span class="o">*</span> <span class="n">gradient</span>
 </pre></div>
 </div>
 <p>If weight is of <code class="docutils literal"><span class="pre">row_sparse</span></code> storage type,
 only the row slices whose indices appear in grad.indices are updated:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">row</span> <span class="ow">in</span> <span class="n">gradient</span><span class="o">.</span><span class="n">indices</span><span class="p">:</span>
     <span class="n">weight</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">=</span> <span class="n">weight</span><span class="p">[</span><span class="n">row</span><span class="p">]</span> <span class="o">-</span> <span class="n">learning_rate</span> <span class="o">*</span> <span class="n">gradient</span><span class="p">[</span><span class="n">row</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>Defined in src/operator/optimizer_op.cc:L53</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>weight</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Weight</li>
 <li><strong>grad</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Gradient</li>
 <li><strong>lr</strong> (<em>float, required</em>) – Learning rate</li>
 <li><strong>wd</strong> (<em>float, optional, default=0</em>) – Weight decay augments the objective function with a regularization term that penalizes large weights. The penalty scales with the square of the magnitude of each weight.</li>
 <li><strong>rescale_grad</strong> (<em>float, optional, default=1</em>) – Rescale gradient to grad = rescale_grad*grad.</li>
 <li><strong>clip_gradient</strong> (<em>float, optional, default=-1</em>) – Clip gradient to the range of [-clip_gradient, clip_gradient] If clip_gradient <= 0, gradient clipping is turned off. grad = max(min(grad, clip_gradient), -clip_gradient).</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sigmoid">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sigmoid</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sigmoid" title="Permalink to this definition">¶</a></dt>
 <dd><p>Computes sigmoid of x element-wise.</p>
 <div class="math">
 \[y = 1 / (1 + exp(-x))\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">sigmoid</span></code> output is always dense</p>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L103</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sign">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sign</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sign" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise sign of the input.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">sign</span><span class="p">([</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">sign</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>sign(default) = default</li>
 <li>sign(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L405</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sin">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sin</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sin" title="Permalink to this definition">¶</a></dt>
 <dd><p>Computes the element-wise sine of the input array.</p>
 <p>The input should be in radians (<span class="math">\(2\pi\)</span> rad equals 360 degrees).</p>
 <div class="math">
 \[sin([0, \pi/4, \pi/2]) = [0, 0.707, 1]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">sin</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>sin(default) = default</li>
 <li>sin(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L46</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sinh">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sinh</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sinh" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns the hyperbolic sine of the input array, computed element-wise.</p>
 <div class="math">
 \[sinh(x) = 0.5\times(exp(x) - exp(-x))\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">sinh</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>sinh(default) = default</li>
 <li>sinh(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L201</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.slice">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">slice</code><span class="sig-paren">(</span><em>data=None</em>, <em>begin=_Null</em>, <em>end=_Null</em>, <em>step=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.slice" title="Permalink to this definition">¶</a></dt>
 <dd><p>Slices a region of the array.</p>
 <div class="admonition note">
 <p class="first admonition-title">Note</p>
 <p class="last"><code class="docutils literal"><span class="pre">crop</span></code> is deprecated. Use <code class="docutils literal"><span class="pre">slice</span></code> instead.</p>
 </div>
 <p>This function returns a sliced array between the indices given
 by <cite>begin</cite> and <cite>end</cite> with the corresponding <cite>step</cite>.</p>
 <p>For an input array of <code class="docutils literal"><span class="pre">shape=(d_0,</span> <span class="pre">d_1,</span> <span class="pre">...,</span> <span class="pre">d_n-1)</span></code>,
 slice operation with <code class="docutils literal"><span class="pre">begin=(b_0,</span> <span class="pre">b_1...b_m-1)</span></code>,
 <code class="docutils literal"><span class="pre">end=(e_0,</span> <span class="pre">e_1,</span> <span class="pre">...,</span> <span class="pre">e_m-1)</span></code>, and <code class="docutils literal"><span class="pre">step=(s_0,</span> <span class="pre">s_1,</span> <span class="pre">...,</span> <span class="pre">s_m-1)</span></code>,
 where m <= n, results in an array with the shape
 <code class="docutils literal"><span class="pre">(|e_0-b_0|/|s_0|,</span> <span class="pre">...,</span> <span class="pre">|e_m-1-b_m-1|/|s_m-1|,</span> <span class="pre">d_m,</span> <span class="pre">...,</span> <span class="pre">d_n-1)</span></code>.</p>
 <p>The resulting array’s <em>k</em>-th dimension contains elements
 from the <em>k</em>-th dimension of the input array starting
 from index <code class="docutils literal"><span class="pre">b_k</span></code> (inclusive) with step <code class="docutils literal"><span class="pre">s_k</span></code>
 until reaching <code class="docutils literal"><span class="pre">e_k</span></code> (exclusive).</p>
 <p>If the <em>k</em>-th elements are <cite>None</cite> in the sequence of <cite>begin</cite>, <cite>end</cite>,
 and <cite>step</cite>, the following rule will be used to set default values.
 If <cite>s_k</cite> is <cite>None</cite>, set <cite>s_k=1</cite>. If <cite>s_k > 0</cite>, set <cite>b_k=0</cite>, <cite>e_k=d_k</cite>;
 else, set <cite>b_k=d_k-1</cite>, <cite>e_k=-1</cite>.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">slice</span></code> output depends on storage types of inputs</p>
 <ul class="simple">
 <li>slice(csr) = csr</li>
 <li>otherwise, <code class="docutils literal"><span class="pre">slice</span></code> generates output with default storage</li>
 </ul>
 <div class="admonition note">
 <p class="first admonition-title">Note</p>
 <p class="last">When input data storage type is csr, it only supports</p>
 </div>
 <p>step=(), or step=(None,), or step=(1,) to generate a csr output.
 For other step parameter values, it falls back to slicing
 a dense tensor.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="p">[[</span>  <span class="mf">1.</span><span class="p">,</span>   <span class="mf">2.</span><span class="p">,</span>   <span class="mf">3.</span><span class="p">,</span>   <span class="mf">4.</span><span class="p">],</span>
      <span class="p">[</span>  <span class="mf">5.</span><span class="p">,</span>   <span class="mf">6.</span><span class="p">,</span>   <span class="mf">7.</span><span class="p">,</span>   <span class="mf">8.</span><span class="p">],</span>
      <span class="p">[</span>  <span class="mf">9.</span><span class="p">,</span>  <span class="mf">10.</span><span class="p">,</span>  <span class="mf">11.</span><span class="p">,</span>  <span class="mf">12.</span><span class="p">]]</span>

 <span class="nb">slice</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">begin</span><span class="o">=</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">),</span> <span class="n">end</span><span class="o">=</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">))</span> <span class="o">=</span> <span class="p">[[</span> <span class="mf">2.</span><span class="p">,</span>  <span class="mf">3.</span><span class="p">,</span>  <span class="mf">4.</span><span class="p">],</span>
                                    <span class="p">[</span> <span class="mf">6.</span><span class="p">,</span>  <span class="mf">7.</span><span class="p">,</span>  <span class="mf">8.</span><span class="p">]]</span>
 <span class="nb">slice</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">begin</span><span class="o">=</span><span class="p">(</span><span class="bp">None</span><span class="p">,</span> <span class="mi">0</span><span class="p">),</span> <span class="n">end</span><span class="o">=</span><span class="p">(</span><span class="bp">None</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="n">step</span><span class="o">=</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span> <span class="o">=</span> <span class="p">[[</span><span class="mf">9.</span><span class="p">,</span> <span class="mf">11.</span><span class="p">],</span>
                                                           <span class="p">[</span><span class="mf">5.</span><span class="p">,</span>  <span class="mf">7.</span><span class="p">],</span>
                                                           <span class="p">[</span><span class="mf">1.</span><span class="p">,</span>  <span class="mf">3.</span><span class="p">]]</span>
 </pre></div>
 </div>
 <p>Defined in src/operator/tensor/matrix_op.cc:L297</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – Source input</li>
 <li><strong>begin</strong> (<em>Shape(tuple), required</em>) – starting indices for the slice operation, supports negative indices.</li>
 <li><strong>end</strong> (<em>Shape(tuple), required</em>) – ending indices for the slice operation, supports negative indices.</li>
 <li><strong>step</strong> (<em>Shape(tuple), optional, default=[]</em>) – step for the slice operation, supports negative values.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sqrt">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sqrt</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sqrt" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise square-root value of the input.</p>
 <div class="math">
 \[\textrm{sqrt}(x) = \sqrt{x}\]</div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">sqrt</span><span class="p">([</span><span class="mi">4</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">16</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">sqrt</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>sqrt(default) = default</li>
 <li>sqrt(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L560</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.square">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">square</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.square" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns element-wise squared value of the input.</p>
 <div class="math">
 \[square(x) = x^2\]</div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">square</span><span class="p">([</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">9</span><span class="p">,</span> <span class="mi">16</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">square</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>square(default) = default</li>
 <li>square(row_sparse) = row_sparse</li>
 <li>square(csr) = csr</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L537</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.stop_gradient">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">stop_gradient</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.stop_gradient" title="Permalink to this definition">¶</a></dt>
 <dd><p>Stops gradient computation.</p>
 <p>Stops the accumulated gradient of the inputs from flowing through this operator
 in the backward direction. In other words, this operator prevents the contribution
 of its inputs to be taken into account for computing gradients.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span>v1 = [1, 2]
 v2 = [0, 1]
 a = Variable('a')
 b = Variable('b')
 b_stop_grad = stop_gradient(3 * b)
 loss = MakeLoss(b_stop_grad + a)

 executor = loss.simple_bind(ctx=cpu(), a=(1,2), b=(1,2))
 executor.forward(is_train=True, a=v1, b=v2)
 executor.outputs
 [ 1.  5.]

 executor.backward()
 executor.grad_arrays
 [ 0.  0.]
 [ 1.  1.]
 </pre></div>
 </div>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L167</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.sum">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">sum</code><span class="sig-paren">(</span><em>data=None</em>, <em>axis=_Null</em>, <em>keepdims=_Null</em>, <em>exclude=_Null</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.sum" title="Permalink to this definition">¶</a></dt>
 <dd><p>Computes the sum of array elements over given axes.</p>
 <div class="admonition note">
 <p class="first admonition-title">Note</p>
 <p class="last"><cite>sum</cite> and <cite>sum_axis</cite> are equivalent.
 For ndarray of csr storage type summation along axis 0 and axis 1 is supported.
 Setting keepdims or exclude to True will cause a fallback to dense operator.</p>
 </div>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span>data = [[[1,2],[2,3],[1,3]],
         [[1,4],[4,3],[5,2]],
         [[7,1],[7,2],[7,3]]]

 sum(data, axis=1)
 [[  4.   8.]
  [ 10.   9.]
  [ 21.   6.]]

 sum(data, axis=[1,2])
 [ 12.  19.  27.]

 data = [[1,2,0],
         [3,0,1],
         [4,1,0]]

 csr = cast_storage(data, 'csr')

 sum(csr, axis=0)
 [ 8.  2.  2.]

 sum(csr, axis=1)
 [ 3.  4.  5.]
 </pre></div>
 </div>
 <p>Defined in src/operator/tensor/broadcast_reduce_op_value.cc:L85</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input</li>
 <li><strong>axis</strong> (<em>Shape(tuple), optional, default=[]</em>) – <p>The axis or axes along which to perform the reduction.</p>
 <p>The default, <cite>axis=()</cite>, will compute over all elements into a
 scalar array with shape <cite>(1,)</cite>.</p>
 <p>If <cite>axis</cite> is int, a reduction is performed on a particular axis.</p>
 <p>If <cite>axis</cite> is a tuple of ints, a reduction is performed on all the axes
 specified in the tuple.</p>
 <p>If <cite>exclude</cite> is true, reduction will be performed on the axes that are
 NOT in axis instead.</p>
 <p>Negative values means indexing from right to left.</p>
 </li>
 <li><strong>keepdims</strong> (<em>boolean, optional, default=0</em>) – If this is set to <cite>True</cite>, the reduced axes are left in the result as dimension with size one.</li>
 <li><strong>exclude</strong> (<em>boolean, optional, default=0</em>) – Whether to perform reduction on axis that are NOT in axis instead.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.tan">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">tan</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.tan" title="Permalink to this definition">¶</a></dt>
 <dd><p>Computes the element-wise tangent of the input array.</p>
 <p>The input should be in radians (<span class="math">\(2\pi\)</span> rad equals 360 degrees).</p>
 <div class="math">
 \[tan([0, \pi/4, \pi/2]) = [0, 1, -inf]\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">tan</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>tan(default) = default</li>
 <li>tan(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L83</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.tanh">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">tanh</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.tanh" title="Permalink to this definition">¶</a></dt>
 <dd><p>Returns the hyperbolic tangent of the input array, computed element-wise.</p>
 <div class="math">
 \[tanh(x) = sinh(x) / cosh(x)\]</div>
 <p>The storage type of <code class="docutils literal"><span class="pre">tanh</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>tanh(default) = default</li>
 <li>tanh(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_trig.cc:L234</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.trunc">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">trunc</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.trunc" title="Permalink to this definition">¶</a></dt>
 <dd><p>Return the element-wise truncated value of the input.</p>
 <p>The truncated value of the scalar x is the nearest integer i which is closer to
 zero than x is. In short, the fractional part of the signed number x is discarded.</p>
 <p>Example:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">trunc</span><span class="p">([</span><span class="o">-</span><span class="mf">2.1</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.9</span><span class="p">,</span> <span class="mf">1.5</span><span class="p">,</span> <span class="mf">1.9</span><span class="p">,</span> <span class="mf">2.1</span><span class="p">])</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mf">2.</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">2.</span><span class="p">]</span>
 </pre></div>
 </div>
 <p>The storage type of <code class="docutils literal"><span class="pre">trunc</span></code> output depends upon the input storage type:</p>
 <blockquote>
 <div><ul class="simple">
 <li>trunc(default) = default</li>
 <li>trunc(row_sparse) = row_sparse</li>
 </ul>
 </div></blockquote>
 <p>Defined in src/operator/tensor/elemwise_unary_op_basic.cc:L500</p>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input array.</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <dl class="function">
 <dt id="mxnet.symbol.sparse.zeros_like">
 <code class="descclassname">mxnet.symbol.sparse.</code><code class="descname">zeros_like</code><span class="sig-paren">(</span><em>data=None</em>, <em>name=None</em>, <em>attr=None</em>, <em>out=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#mxnet.symbol.sparse.zeros_like" title="Permalink to this definition">¶</a></dt>
 <dd><p>Return an array of zeros with the same shape and type
 as the input array.</p>
 <p>The storage type of <code class="docutils literal"><span class="pre">zeros_like</span></code> output depends on the storage type of the input</p>
 <ul class="simple">
 <li>zeros_like(row_sparse) = row_sparse</li>
 <li>zeros_like(csr) = csr</li>
 <li>zeros_like(default) = default</li>
 </ul>
 <p>Examples:</p>
 <div class="highlight-python"><div class="highlight"><pre><span></span><span class="n">x</span> <span class="o">=</span> <span class="p">[[</span> <span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">],</span>
      <span class="p">[</span> <span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">,</span>  <span class="mf">1.</span><span class="p">]]</span>

 <span class="n">zeros_like</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">=</span> <span class="p">[[</span> <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">],</span>
                  <span class="p">[</span> <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">,</span>  <span class="mf">0.</span><span class="p">]]</span>
 </pre></div>
 </div>
 <table class="docutils field-list" frame="void" rules="none">
 <col class="field-name"/>
 <col class="field-body"/>
 <tbody valign="top">
 <tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
 <li><strong>data</strong> (<a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol"><em>Symbol</em></a>) – The input</li>
 <li><strong>name</strong> (<em>string, optional.</em>) – Name of the resulting symbol.</li>
 </ul>
 </td>
 </tr>
 <tr class="field-even field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">The result symbol.</p>
 </td>
 </tr>
 <tr class="field-odd field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><a class="reference internal" href="symbol.html#mxnet.symbol.Symbol" title="mxnet.symbol.Symbol">Symbol</a></p>
 </td>
 </tr>
 </tbody>
 </table>
 </dd></dl>
 <script>auto_index("api-reference");</script></div>
 </div>
 </div>
 </div>
 <div aria-label="main navigation" class="sphinxsidebar rightsidebar" role="navigation">
 <div class="sphinxsidebarwrapper">
 <h3><a href="../../../index.html">Table Of Contents</a></h3>
 <ul>
 <li><a class="reference internal" href="#">Sparse Symbol API</a><ul>
 <li><a class="reference internal" href="#overview">Overview</a></li>
 <li><a class="reference internal" href="#symbol-creation-routines">Symbol creation routines</a></li>
 <li><a class="reference internal" href="#symbol-manipulation-routines">Symbol manipulation routines</a><ul>
 <li><a class="reference internal" href="#changing-symbol-storage-type">Changing symbol storage type</a></li>
 <li><a class="reference internal" href="#indexing-routines">Indexing routines</a></li>
 </ul>
 </li>
 <li><a class="reference internal" href="#mathematical-functions">Mathematical functions</a><ul>
 <li><a class="reference internal" href="#arithmetic-operations">Arithmetic operations</a></li>
 <li><a class="reference internal" href="#trigonometric-functions">Trigonometric functions</a></li>
 <li><a class="reference internal" href="#hyperbolic-functions">Hyperbolic functions</a></li>
 <li><a class="reference internal" href="#reduce-functions">Reduce functions</a></li>
 <li><a class="reference internal" href="#rounding">Rounding</a></li>
 <li><a class="reference internal" href="#exponents-and-logarithms">Exponents and logarithms</a></li>
 <li><a class="reference internal" href="#powers">Powers</a></li>
 <li><a class="reference internal" href="#miscellaneous">Miscellaneous</a></li>
 </ul>
 </li>
 <li><a class="reference internal" href="#neural-network">Neural network</a><ul>
 <li><a class="reference internal" href="#more">More</a></li>
 </ul>
 </li>
 <li><a class="reference internal" href="#api-reference">API Reference</a></li>
 </ul>
 </li>
 </ul>
 </div>
 </div>
 </div><div class="footer">
 <div class="section-disclaimer">
 <div class="container">
 <div>
 <img height="60" src="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/apache_incubator_logo.png"/>
 <p>
             Apache MXNet is an effort undergoing incubation at The Apache Software Foundation (ASF), <strong>sponsored by the <i>Apache Incubator</i></strong>. Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.
         </p>
 <p>
             "Copyright © 2017, The Apache Software Foundation
             Apache MXNet, MXNet, Apache, the Apache feather, and the Apache MXNet project logo are either registered trademarks or trademarks of the Apache Software Foundation."
         </p>
 </div>
 </div>
 </div>
 </div> <!-- pagename != index -->
 </div>
 <script crossorigin="anonymous" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>
 <script src="../../../_static/js/sidebar.js" type="text/javascript"></script>
 <script src="../../../_static/js/search.js" type="text/javascript"></script>
 <script src="../../../_static/js/navbar.js" type="text/javascript"></script>
 <script src="../../../_static/js/clipboard.min.js" type="text/javascript"></script>
 <script src="../../../_static/js/copycode.js" type="text/javascript"></script>
 <script src="../../../_static/js/page.js" type="text/javascript"></script>
 <script type="text/javascript">
         $('body').ready(function () {
             $('body').css('visibility', 'visible');
         });
     </script>
 </body>
 </html>