Google Git
Sign in
apache / mxnet-site / 5d2e45b9c41410156d7d50982069a8e0f3991694 / . / versions / 1.4.1 / _modules / mxnet / ndarray / sparse.html
blob: bb6c0ff5c9b06d3d26b93beda931c50f021dcb64 [file] [log] [blame]
<!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"/>
<meta content="mxnet.ndarray.sparse" property="og:title">
<meta content="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/og-logo.png" property="og:image">
<meta content="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/og-logo.png" property="og:image:secure_url">
<meta content="mxnet.ndarray.sparse" property="og:description"/>
<title>mxnet.ndarray.sparse — 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: '.txt'
};
</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("/versions/1.4.1/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://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML"></script> -->
<!-- -->
<link href="../../../genindex.html" rel="index" title="Index">
<link href="../../../search.html" rel="search" title="Search"/>
<link href="../../index.html" rel="up" title="Module code"/>
<link href="https://raw.githubusercontent.com/dmlc/web-data/master/mxnet/image/mxnet-icon.png" rel="icon" type="image/png"/>
</link></link></link></meta></meta></meta></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="/versions/1.4.1/install/index.html">Install</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="/versions/1.4.1/tutorials/gluon/gluon.html">About</a></li>
<li><a class="main-nav-link" href="https://www.d2l.ai/">Dive into Deep Learning</a></li>
<li><a class="main-nav-link" href="https://gluon-cv.mxnet.io">GluonCV Toolkit</a></li>
<li><a class="main-nav-link" href="https://gluon-nlp.mxnet.io/">GluonNLP Toolkit</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="/versions/1.4.1/api/python/index.html">Python</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/c++/index.html">C++</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/clojure/index.html">Clojure</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/java/index.html">Java</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/julia/index.html">Julia</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/perl/index.html">Perl</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/r/index.html">R</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/scala/index.html">Scala</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="/versions/1.4.1/faq/index.html">FAQ</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/tutorials/index.html">Tutorials</a>
<li><a class="main-nav-link" href="https://github.com/apache/incubator-mxnet/tree/1.4.1/example">Examples</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/architecture/index.html">Architecture</a></li>
<li><a class="main-nav-link" href="https://cwiki.apache.org/confluence/display/MXNET/Apache+MXNet+Home">Developer Wiki</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/model_zoo/index.html">Model Zoo</a></li>
<li><a class="main-nav-link" href="https://github.com/onnx/onnx-mxnet">ONNX</a></li>
</li></ul>
</span>
<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="http://discuss.mxnet.io">Forum</a></li>
<li><a class="main-nav-link" href="https://github.com/apache/incubator-mxnet/tree/1.4.1">Github</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/community/contribute.html">Contribute</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/community/ecosystem.html">Ecosystem</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/community/powered_by.html">Powered By</a></li>
</ul>
</span>
<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">1.4.1<span class="caret"></span></a><ul id="package-dropdown-menu" class="dropdown-menu"><li><a href="/">master</a></li><li><a href="/versions/1.7.0/">1.7.0</a></li><li><a href=/versions/1.6.0/>1.6.0</a></li><li><a href=/versions/1.5.0/>1.5.0</a></li><li><a href=/versions/1.4.1/>1.4.1</a></li><li><a href=/versions/1.3.1/>1.3.1</a></li><li><a href=/versions/1.2.1/>1.2.1</a></li><li><a href=/versions/1.1.0/>1.1.0</a></li><li><a href=/versions/1.0.0/>1.0.0</a></li><li><a href=/versions/0.12.1/>0.12.1</a></li><li><a href=/versions/0.11.0/>0.11.0</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="/versions/1.4.1/install/index.html">Install</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/tutorials/index.html">Tutorials</a></li>
<li class="dropdown-submenu dropdown">
<a aria-expanded="true" aria-haspopup="true" class="dropdown-toggle burger-link" data-toggle="dropdown" href="#" tabindex="-1">Gluon</a>
<ul class="dropdown-menu navbar-menu" id="package-dropdown-menu">
<li><a class="main-nav-link" href="/versions/1.4.1/tutorials/gluon/gluon.html">About</a></li>
<li><a class="main-nav-link" href="http://gluon.mxnet.io">The Straight Dope (Tutorials)</a></li>
<li><a class="main-nav-link" href="https://gluon-cv.mxnet.io">GluonCV Toolkit</a></li>
<li><a class="main-nav-link" href="https://gluon-nlp.mxnet.io/">GluonNLP Toolkit</a></li>
</ul>
</li>
<li class="dropdown-submenu">
<a aria-expanded="true" aria-haspopup="true" class="dropdown-toggle burger-link" data-toggle="dropdown" href="#" tabindex="-1">API</a>
<ul class="dropdown-menu">
<li><a class="main-nav-link" href="/versions/1.4.1/api/python/index.html">Python</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/c++/index.html">C++</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/clojure/index.html">Clojure</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/java/index.html">Java</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/julia/index.html">Julia</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/perl/index.html">Perl</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/r/index.html">R</a></li>
<li><a class="main-nav-link" href="/versions/1.4.1/api/scala/index.html">Scala</a></li>
</ul>
</li>
<li class="dropdown-submenu">
<a aria-expanded="true" aria-haspopup="true" class="dropdown-toggle burger-link" data-toggle="dropdown" href="#" tabindex="-1">Docs</a>
<ul class="dropdown-menu">
<li><a href="/versions/1.4.1/faq/index.html" tabindex="-1">FAQ</a></li>
<li><a href="/versions/1.4.1/tutorials/index.html" tabindex="-1">Tutorials</a></li>
<li><a href="https://github.com/apache/incubator-mxnet/tree/1.4.1/example" tabindex="-1">Examples</a></li>
<li><a href="/versions/1.4.1/architecture/index.html" tabindex="-1">Architecture</a></li>
<li><a href="https://cwiki.apache.org/confluence/display/MXNET/Apache+MXNet+Home" tabindex="-1">Developer Wiki</a></li>
<li><a href="/versions/1.4.1/model_zoo/index.html" tabindex="-1">Gluon Model Zoo</a></li>
<li><a href="https://github.com/onnx/onnx-mxnet" tabindex="-1">ONNX</a></li>
</ul>
</li>
<li class="dropdown-submenu dropdown">
<a aria-haspopup="true" class="dropdown-toggle burger-link" data-toggle="dropdown" href="#" role="button" tabindex="-1">Community</a>
<ul class="dropdown-menu">
<li><a href="http://discuss.mxnet.io" tabindex="-1">Forum</a></li>
<li><a href="https://github.com/apache/incubator-mxnet/tree/1.4.1" tabindex="-1">Github</a></li>
<li><a href="/versions/1.4.1/community/contribute.html" tabindex="-1">Contribute</a></li>
<li><a href="/versions/1.4.1/community/ecosystem.html" tabindex="-1">Ecosystem</a></li>
<li><a href="/versions/1.4.1/community/powered_by.html" tabindex="-1">Powered By</a></li>
</ul>
</li>
<li id="dropdown-menu-position-anchor-version-mobile" class="dropdown-submenu" style="position: relative"><a href="#" tabindex="-1">1.4.1</a><ul class="dropdown-menu"><li><a tabindex="-1" href=/>master</a></li><li><a tabindex="-1" href=/versions/1.6.0/>1.6.0</a></li><li><a tabindex="-1" href=/versions/1.5.0/>1.5.0</a></li><li><a tabindex="-1" href=/versions/1.4.1/>1.4.1</a></li><li><a tabindex="-1" href=/versions/1.3.1/>1.3.1</a></li><li><a tabindex="-1" href=/versions/1.2.1/>1.2.1</a></li><li><a tabindex="-1" href=/versions/1.1.0/>1.1.0</a></li><li><a tabindex="-1" href=/versions/1.0.0/>1.0.0</a></li><li><a tabindex="-1" href=/versions/0.12.1/>0.12.1</a></li><li><a tabindex="-1" href=/versions/0.11.0/>0.11.0</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>
<li class="toctree-l1"><a class="reference internal" href="../../../api/index.html">MXNet APIs</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../architecture/index.html">MXNet Architecture</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../community/index.html">MXNet Community</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../faq/index.html">MXNet FAQ</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../gluon/index.html">About Gluon</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../install/index.html">Installing MXNet</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../install/index.html#nvidia-jetson-tx-family">Nvidia Jetson TX family</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../install/index.html#source-download">Source Download</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../model_zoo/index.html">MXNet Model Zoo</a></li>
<li class="toctree-l1"><a class="reference internal" href="../../../tutorials/index.html">Tutorials</a></li>
</ul>
</div>
</div>
<div class="content">
<div class="page-tracker"></div>
<h1>Source code for mxnet.ndarray.sparse</h1><div class="highlight"><pre>
<span></span><span class="c1"># Licensed to the Apache Software Foundation (ASF) under one</span>
<span class="c1"># or more contributor license agreements. See the NOTICE file</span>
<span class="c1"># distributed with this work for additional information</span>
<span class="c1"># regarding copyright ownership. The ASF licenses this file</span>
<span class="c1"># to you under the Apache License, Version 2.0 (the</span>
<span class="c1"># "License"); you may not use this file except in compliance</span>
<span class="c1"># with the License. You may obtain a copy of the License at</span>
<span class="c1">#</span>
<span class="c1"># http://www.apache.org/licenses/LICENSE-2.0</span>
<span class="c1">#</span>
<span class="c1"># Unless required by applicable law or agreed to in writing,</span>
<span class="c1"># software distributed under the License is distributed on an</span>
<span class="c1"># "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY</span>
<span class="c1"># KIND, either express or implied. See the License for the</span>
<span class="c1"># specific language governing permissions and limitations</span>
<span class="c1"># under the License.</span>
<span class="c1"># coding: utf-8</span>
<span class="c1"># pylint: disable=wildcard-import, unused-wildcard-import, too-many-lines</span>
<span class="sd">"""Sparse NDArray API of MXNet."""</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">absolute_import</span>
<span class="kn">from</span> <span class="nn">__future__</span> <span class="k">import</span> <span class="n">division</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">__builtin__</span> <span class="k">import</span> <span class="nb">slice</span> <span class="k">as</span> <span class="n">py_slice</span>
<span class="kn">from</span> <span class="nn">__builtin__</span> <span class="k">import</span> <span class="nb">sum</span> <span class="k">as</span> <span class="n">py_sum</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">slice</span> <span class="k">as</span> <span class="n">py_slice</span>
<span class="kn">from</span> <span class="nn">builtins</span> <span class="k">import</span> <span class="nb">sum</span> <span class="k">as</span> <span class="n">py_sum</span>
<span class="kn">import</span> <span class="nn">ctypes</span>
<span class="kn">import</span> <span class="nn">warnings</span>
<span class="kn">import</span> <span class="nn">operator</span>
<span class="kn">from</span> <span class="nn">array</span> <span class="k">import</span> <span class="n">array</span> <span class="k">as</span> <span class="n">native_array</span>
<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span><span class="s2">"_ndarray_cls"</span><span class="p">,</span> <span class="s2">"csr_matrix"</span><span class="p">,</span> <span class="s2">"row_sparse_array"</span><span class="p">,</span>
<span class="s2">"BaseSparseNDArray"</span><span class="p">,</span> <span class="s2">"CSRNDArray"</span><span class="p">,</span> <span class="s2">"RowSparseNDArray"</span><span class="p">,</span>
<span class="s2">"add"</span><span class="p">,</span> <span class="s2">"subtract"</span><span class="p">,</span> <span class="s2">"multiply"</span><span class="p">,</span> <span class="s2">"divide"</span><span class="p">]</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="kn">from</span> <span class="nn">..base</span> <span class="k">import</span> <span class="n">NotSupportedForSparseNDArray</span>
<span class="kn">from</span> <span class="nn">..base</span> <span class="k">import</span> <span class="n">_LIB</span><span class="p">,</span> <span class="n">numeric_types</span>
<span class="kn">from</span> <span class="nn">..base</span> <span class="k">import</span> <span class="n">c_array_buf</span><span class="p">,</span> <span class="n">mx_real_t</span><span class="p">,</span> <span class="n">integer_types</span>
<span class="kn">from</span> <span class="nn">..base</span> <span class="k">import</span> <span class="n">mx_uint</span><span class="p">,</span> <span class="n">NDArrayHandle</span><span class="p">,</span> <span class="n">check_call</span>
<span class="kn">from</span> <span class="nn">..context</span> <span class="k">import</span> <span class="n">Context</span><span class="p">,</span> <span class="n">current_context</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">_internal</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="k">import</span> <span class="n">op</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">from</span> <span class="nn">.gen_sparse</span> <span class="k">import</span> <span class="n">retain</span> <span class="k">as</span> <span class="n">gs_retain</span> <span class="c1"># pylint: disable=redefined-builtin</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="n">gs_retain</span> <span class="o">=</span> <span class="kc">None</span>
<span class="kn">from</span> <span class="nn">._internal</span> <span class="k">import</span> <span class="n">_set_ndarray_class</span>
<span class="kn">from</span> <span class="nn">.ndarray</span> <span class="k">import</span> <span class="n">NDArray</span><span class="p">,</span> <span class="n">_storage_type</span><span class="p">,</span> <span class="n">_DTYPE_NP_TO_MX</span><span class="p">,</span> <span class="n">_DTYPE_MX_TO_NP</span>
<span class="kn">from</span> <span class="nn">.ndarray</span> <span class="k">import</span> <span class="n">_STORAGE_TYPE_STR_TO_ID</span><span class="p">,</span> <span class="n">_STORAGE_TYPE_ROW_SPARSE</span><span class="p">,</span> <span class="n">_STORAGE_TYPE_CSR</span>
<span class="kn">from</span> <span class="nn">.ndarray</span> <span class="k">import</span> <span class="n">_STORAGE_TYPE_UNDEFINED</span><span class="p">,</span> <span class="n">_STORAGE_TYPE_DEFAULT</span>
<span class="kn">from</span> <span class="nn">.ndarray</span> <span class="k">import</span> <span class="n">zeros</span> <span class="k">as</span> <span class="n">_zeros_ndarray</span>
<span class="kn">from</span> <span class="nn">.ndarray</span> <span class="k">import</span> <span class="n">array</span> <span class="k">as</span> <span class="n">_array</span>
<span class="kn">from</span> <span class="nn">.ndarray</span> <span class="k">import</span> <span class="n">_ufunc_helper</span>
<span class="k">try</span><span class="p">:</span>
<span class="kn">import</span> <span class="nn">scipy.sparse</span> <span class="k">as</span> <span class="nn">spsp</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
<span class="n">spsp</span> <span class="o">=</span> <span class="kc">None</span>
<span class="n">_STORAGE_AUX_TYPES</span> <span class="o">=</span> <span class="p">{</span>
<span class="s1">'row_sparse'</span><span class="p">:</span> <span class="p">[</span><span class="n">np</span><span class="o">.</span><span class="n">int64</span><span class="p">],</span>
<span class="s1">'csr'</span><span class="p">:</span> <span class="p">[</span><span class="n">np</span><span class="o">.</span><span class="n">int64</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">int64</span><span class="p">]</span>
<span class="p">}</span>
<span class="k">def</span> <span class="nf">_new_alloc_handle</span><span class="p">(</span><span class="n">stype</span><span class="p">,</span> <span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="n">delay_alloc</span><span class="p">,</span> <span class="n">dtype</span><span class="p">,</span> <span class="n">aux_types</span><span class="p">,</span> <span class="n">aux_shapes</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""Return a new handle with specified storage type, shape, dtype and context.</span>
<span class="sd"> Empty handle is only used to hold results</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> handle</span>
<span class="sd"> A new empty ndarray handle</span>
<span class="sd"> """</span>
<span class="n">hdl</span> <span class="o">=</span> <span class="n">NDArrayHandle</span><span class="p">()</span>
<span class="k">for</span> <span class="n">aux_t</span> <span class="ow">in</span> <span class="n">aux_types</span><span class="p">:</span>
<span class="k">if</span> <span class="n">np</span><span class="o">.</span><span class="n">dtype</span><span class="p">(</span><span class="n">aux_t</span><span class="p">)</span> <span class="o">!=</span> <span class="n">np</span><span class="o">.</span><span class="n">dtype</span><span class="p">(</span><span class="s2">"int64"</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">"only int64 is supported for aux types"</span><span class="p">)</span>
<span class="n">aux_type_ids</span> <span class="o">=</span> <span class="p">[</span><span class="nb">int</span><span class="p">(</span><span class="n">_DTYPE_NP_TO_MX</span><span class="p">[</span><span class="n">np</span><span class="o">.</span><span class="n">dtype</span><span class="p">(</span><span class="n">aux_t</span><span class="p">)</span><span class="o">.</span><span class="n">type</span><span class="p">])</span> <span class="k">for</span> <span class="n">aux_t</span> <span class="ow">in</span> <span class="n">aux_types</span><span class="p">]</span>
<span class="n">aux_shapes</span> <span class="o">=</span> <span class="p">[(</span><span class="mi">0</span><span class="p">,)</span> <span class="k">for</span> <span class="n">aux_t</span> <span class="ow">in</span> <span class="n">aux_types</span><span class="p">]</span> <span class="k">if</span> <span class="n">aux_shapes</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">aux_shapes</span>
<span class="n">aux_shape_lens</span> <span class="o">=</span> <span class="p">[</span><span class="nb">len</span><span class="p">(</span><span class="n">aux_shape</span><span class="p">)</span> <span class="k">for</span> <span class="n">aux_shape</span> <span class="ow">in</span> <span class="n">aux_shapes</span><span class="p">]</span>
<span class="n">aux_shapes</span> <span class="o">=</span> <span class="n">py_sum</span><span class="p">(</span><span class="n">aux_shapes</span><span class="p">,</span> <span class="p">())</span>
<span class="n">num_aux</span> <span class="o">=</span> <span class="n">mx_uint</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">aux_types</span><span class="p">))</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArrayCreateSparseEx</span><span class="p">(</span>
<span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">_STORAGE_TYPE_STR_TO_ID</span><span class="p">[</span><span class="n">stype</span><span class="p">])),</span>
<span class="n">c_array_buf</span><span class="p">(</span><span class="n">mx_uint</span><span class="p">,</span> <span class="n">native_array</span><span class="p">(</span><span class="s1">'I'</span><span class="p">,</span> <span class="n">shape</span><span class="p">)),</span>
<span class="n">mx_uint</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">shape</span><span class="p">)),</span>
<span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="n">ctx</span><span class="o">.</span><span class="n">device_typeid</span><span class="p">),</span>
<span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="n">ctx</span><span class="o">.</span><span class="n">device_id</span><span class="p">),</span>
<span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">delay_alloc</span><span class="p">)),</span>
<span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">_DTYPE_NP_TO_MX</span><span class="p">[</span><span class="n">np</span><span class="o">.</span><span class="n">dtype</span><span class="p">(</span><span class="n">dtype</span><span class="p">)</span><span class="o">.</span><span class="n">type</span><span class="p">])),</span>
<span class="n">num_aux</span><span class="p">,</span>
<span class="n">c_array_buf</span><span class="p">(</span><span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">,</span> <span class="n">native_array</span><span class="p">(</span><span class="s1">'i'</span><span class="p">,</span> <span class="n">aux_type_ids</span><span class="p">)),</span>
<span class="n">c_array_buf</span><span class="p">(</span><span class="n">mx_uint</span><span class="p">,</span> <span class="n">native_array</span><span class="p">(</span><span class="s1">'I'</span><span class="p">,</span> <span class="n">aux_shape_lens</span><span class="p">)),</span>
<span class="n">c_array_buf</span><span class="p">(</span><span class="n">mx_uint</span><span class="p">,</span> <span class="n">native_array</span><span class="p">(</span><span class="s1">'I'</span><span class="p">,</span> <span class="n">aux_shapes</span><span class="p">)),</span>
<span class="n">ctypes</span><span class="o">.</span><span class="n">byref</span><span class="p">(</span><span class="n">hdl</span><span class="p">)))</span>
<span class="k">return</span> <span class="n">hdl</span>
<span class="k">class</span> <span class="nc">BaseSparseNDArray</span><span class="p">(</span><span class="n">NDArray</span><span class="p">):</span>
<span class="sd">"""The base class of an NDArray stored in a sparse storage format.</span>
<span class="sd"> See CSRNDArray and RowSparseNDArray for more details.</span>
<span class="sd"> """</span>
<span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""Returns a string representation of the sparse array."""</span>
<span class="n">shape_info</span> <span class="o">=</span> <span class="s1">'x'</span><span class="o">.</span><span class="n">join</span><span class="p">([</span><span class="s1">'</span><span class="si">%d</span><span class="s1">'</span> <span class="o">%</span> <span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">shape</span><span class="p">])</span>
<span class="c1"># The data content is not displayed since the array usually has big shape</span>
<span class="k">return</span> <span class="s1">'</span><span class="se">\n</span><span class="s1"><</span><span class="si">%s</span><span class="s1"> </span><span class="si">%s</span><span class="s1"> @</span><span class="si">%s</span><span class="s1">>'</span> <span class="o">%</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span><span class="p">,</span>
<span class="n">shape_info</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">context</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__add__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="n">add</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__sub__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="n">subtract</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__mul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="n">multiply</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__div__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">return</span> <span class="n">divide</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">__isub__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">__imul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">__idiv__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">__itruediv__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">_sync_copyfrom</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">source_array</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">_at</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">idx</span><span class="p">):</span>
<span class="k">raise</span> <span class="n">NotSupportedForSparseNDArray</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_at</span><span class="p">,</span> <span class="s1">'[idx]'</span><span class="p">,</span> <span class="n">idx</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_slice</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">):</span>
<span class="k">raise</span> <span class="n">NotSupportedForSparseNDArray</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_slice</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">start</span><span class="p">,</span> <span class="n">stop</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">reshape</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">shape</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="k">raise</span> <span class="n">NotSupportedForSparseNDArray</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">reshape</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">size</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="c1"># the `size` for a sparse ndarray is ambiguous, hence disabled.</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">_aux_type</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">):</span>
<span class="sd">"""Data-type of the array's ith aux data.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> numpy.dtype</span>
<span class="sd"> This BaseSparseNDArray's aux data type.</span>
<span class="sd"> """</span>
<span class="n">aux_type</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">()</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArrayGetAuxType</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">byref</span><span class="p">(</span><span class="n">aux_type</span><span class="p">)))</span>
<span class="k">return</span> <span class="n">_DTYPE_MX_TO_NP</span><span class="p">[</span><span class="n">aux_type</span><span class="o">.</span><span class="n">value</span><span class="p">]</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">_num_aux</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""The number of aux data used to help store the sparse ndarray.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="n">_STORAGE_AUX_TYPES</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">stype</span><span class="p">])</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">_aux_types</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""The data types of the aux data for the BaseSparseNDArray.</span>
<span class="sd"> """</span>
<span class="n">aux_types</span> <span class="o">=</span> <span class="p">[]</span>
<span class="n">num_aux</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_num_aux</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">num_aux</span><span class="p">):</span>
<span class="n">aux_types</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_aux_type</span><span class="p">(</span><span class="n">i</span><span class="p">))</span>
<span class="k">return</span> <span class="n">aux_types</span>
<span class="k">def</span> <span class="nf">asnumpy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""Return a dense ``numpy.ndarray`` object with value copied from this array</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">tostype</span><span class="p">(</span><span class="s1">'default'</span><span class="p">)</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">astype</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">dtype</span><span class="p">,</span> <span class="n">copy</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
<span class="sd">"""Return a copy of the array after casting to a specified type.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> dtype : numpy.dtype or str</span>
<span class="sd"> The type of the returned array.</span>
<span class="sd"> copy : bool</span>
<span class="sd"> Default `True`. By default, astype always returns a newly</span>
<span class="sd"> allocated ndarray on the same context. If this is set to</span>
<span class="sd"> `False`, and the dtype requested is the same as the ndarray's</span>
<span class="sd"> dtype, the ndarray is returned instead of a copy.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> x = mx.nd.sparse.zeros('row_sparse', (2,3), dtype='float32')</span>
<span class="sd"> >>> y = x.astype('int32')</span>
<span class="sd"> >>> y.dtype</span>
<span class="sd"> <type 'numpy.int32'></span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">copy</span> <span class="ow">and</span> <span class="n">np</span><span class="o">.</span><span class="n">dtype</span><span class="p">(</span><span class="n">dtype</span><span class="p">)</span> <span class="o">==</span> <span class="bp">self</span><span class="o">.</span><span class="n">dtype</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">zeros</span><span class="p">(</span><span class="n">shape</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">context</span><span class="p">,</span>
<span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">,</span> <span class="n">stype</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">stype</span><span class="p">)</span>
<span class="bp">self</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="n">res</span><span class="p">)</span>
<span class="k">return</span> <span class="n">res</span>
<span class="k">def</span> <span class="nf">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="sd">"""Copies the value of this array to another array.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> other : NDArray or CSRNDArray or RowSparseNDArray or Context</span>
<span class="sd"> The destination array or context.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray or CSRNDArray or RowSparseNDArray</span>
<span class="sd"> The copied array.</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="k">if</span> <span class="n">other</span><span class="o">.</span><span class="n">handle</span> <span class="ow">is</span> <span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">:</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s1">'You are attempting to copy an array to itself'</span><span class="p">,</span> <span class="ne">RuntimeWarning</span><span class="p">)</span>
<span class="k">return</span> <span class="kc">False</span>
<span class="k">return</span> <span class="n">_internal</span><span class="o">.</span><span class="n">_copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">out</span><span class="o">=</span><span class="n">other</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">Context</span><span class="p">):</span>
<span class="n">hret</span> <span class="o">=</span> <span class="n">_ndarray_cls</span><span class="p">(</span><span class="n">_new_alloc_handle</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">stype</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">other</span><span class="p">,</span>
<span class="kc">True</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">dtype</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">_aux_types</span><span class="p">))</span>
<span class="k">return</span> <span class="n">_internal</span><span class="o">.</span><span class="n">_copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">out</span><span class="o">=</span><span class="n">hret</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'copyto does not support type '</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">other</span><span class="p">)))</span>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<span class="k">def</span> <span class="nf">check_format</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">full_check</span><span class="o">=</span><span class="kc">True</span><span class="p">):</span>
<span class="sd">"""Check whether the NDArray format is valid.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> full_check : bool, optional</span>
<span class="sd"> If `True`, rigorous check, O(N) operations. Otherwise</span>
<span class="sd"> basic check, O(1) operations (default True).</span>
<span class="sd"> """</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArraySyncCheckFormat</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_bool</span><span class="p">(</span><span class="n">full_check</span><span class="p">)))</span>
<span class="k">def</span> <span class="nf">_data</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""A deep copy NDArray of the data array associated with the BaseSparseNDArray.</span>
<span class="sd"> This function blocks. Do not use it in performance critical code.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">wait_to_read</span><span class="p">()</span>
<span class="n">hdl</span> <span class="o">=</span> <span class="n">NDArrayHandle</span><span class="p">()</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArrayGetDataNDArray</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">byref</span><span class="p">(</span><span class="n">hdl</span><span class="p">)))</span>
<span class="k">return</span> <span class="n">NDArray</span><span class="p">(</span><span class="n">hdl</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">_aux_data</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">i</span><span class="p">):</span>
<span class="sd">""" Get a deep copy NDArray of the i-th aux data array associated with the</span>
<span class="sd"> BaseSparseNDArray.</span>
<span class="sd"> This function blocks. Do not use it in performance critical code.</span>
<span class="sd"> """</span>
<span class="bp">self</span><span class="o">.</span><span class="n">wait_to_read</span><span class="p">()</span>
<span class="n">hdl</span> <span class="o">=</span> <span class="n">NDArrayHandle</span><span class="p">()</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArrayGetAuxNDArray</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">i</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">byref</span><span class="p">(</span><span class="n">hdl</span><span class="p">)))</span>
<span class="k">return</span> <span class="n">NDArray</span><span class="p">(</span><span class="n">hdl</span><span class="p">)</span>
<span class="c1"># pylint: disable=abstract-method</span>
<div class="viewcode-block" id="CSRNDArray"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.CSRNDArray">[docs]</a><span class="k">class</span> <span class="nc">CSRNDArray</span><span class="p">(</span><span class="n">BaseSparseNDArray</span><span class="p">):</span>
<span class="sd">"""A sparse representation of 2D NDArray in the Compressed Sparse Row format.</span>
<span class="sd"> A CSRNDArray represents an NDArray as three separate arrays: `data`,</span>
<span class="sd"> `indptr` and `indices`. It uses the CSR representation where the column indices for</span>
<span class="sd"> row i are stored in ``indices[indptr[i]:indptr[i+1]]`` and their corresponding values are stored</span>
<span class="sd"> in ``data[indptr[i]:indptr[i+1]]``.</span>
<span class="sd"> The column indices for a given row are expected to be sorted in ascending order.</span>
<span class="sd"> Duplicate column entries for the same row are not allowed.</span>
<span class="sd"> Example</span>
<span class="sd"> -------</span>
<span class="sd"> >>> a = mx.nd.array([[0, 1, 0], [2, 0, 0], [0, 0, 0], [0, 0, 3]])</span>
<span class="sd"> >>> a = a.tostype('csr')</span>
<span class="sd"> >>> a.data.asnumpy()</span>
<span class="sd"> array([ 1., 2., 3.], dtype=float32)</span>
<span class="sd"> >>> a.indices.asnumpy()</span>
<span class="sd"> array([1, 0, 2])</span>
<span class="sd"> >>> a.indptr.asnumpy()</span>
<span class="sd"> array([0, 1, 2, 2, 3])</span>
<span class="sd"> See Also</span>
<span class="sd"> --------</span>
<span class="sd"> csr_matrix: Several ways to construct a CSRNDArray</span>
<span class="sd"> """</span>
<span class="k">def</span> <span class="nf">__reduce__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="n">CSRNDArray</span><span class="p">,</span> <span class="p">(</span><span class="kc">None</span><span class="p">,),</span> <span class="nb">super</span><span class="p">(</span><span class="n">CSRNDArray</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">__getstate__</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">+</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__isub__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">-</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__imul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">*</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__idiv__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">/</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__itruediv__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">/</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<div class="viewcode-block" id="CSRNDArray.__getitem__"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.CSRNDArray.__getitem__">[docs]</a> <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
<span class="sd">"""x.__getitem__(i) <=> x[i]</span>
<span class="sd"> Returns a newly created NDArray based on the indexing key.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> key : int or mxnet.ndarray.NDArray.slice</span>
<span class="sd"> Indexing key.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> indptr = np.array([0, 2, 3, 6])</span>
<span class="sd"> >>> indices = np.array([0, 2, 2, 0, 1, 2])</span>
<span class="sd"> >>> data = np.array([1, 2, 3, 4, 5, 6])</span>
<span class="sd"> >>> a = mx.nd.sparse.csr_matrix((data, indices, indptr), shape=(3, 3))</span>
<span class="sd"> >>> a.asnumpy()</span>
<span class="sd"> array([[ 1., 0., 2.],</span>
<span class="sd"> [ 0., 0., 3.],</span>
<span class="sd"> [ 4., 5., 6.]], dtype=float32)</span>
<span class="sd"> >>> a[1:2].asnumpy()</span>
<span class="sd"> array([[ 0., 0., 3.]], dtype=float32)</span>
<span class="sd"> >>> a[1].asnumpy()</span>
<span class="sd"> array([[ 0., 0., 3.]], dtype=float32)</span>
<span class="sd"> >>> a[-1].asnumpy()</span>
<span class="sd"> array([[ 4., 5., 6.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="nb">int</span><span class="p">):</span>
<span class="k">if</span> <span class="n">key</span> <span class="o">==</span> <span class="o">-</span><span class="mi">1</span><span class="p">:</span>
<span class="n">begin</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">-</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">begin</span> <span class="o">=</span> <span class="n">key</span>
<span class="k">return</span> <span class="n">op</span><span class="o">.</span><span class="n">slice</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">begin</span><span class="o">=</span><span class="n">begin</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">begin</span><span class="o">+</span><span class="mi">1</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">py_slice</span><span class="p">):</span>
<span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">step</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'CSRNDArray only supports continuous slicing on axis 0'</span><span class="p">)</span>
<span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">start</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">key</span><span class="o">.</span><span class="n">stop</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">begin</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">start</span> <span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">start</span> <span class="k">else</span> <span class="mi">0</span>
<span class="n">end</span> <span class="o">=</span> <span class="n">key</span><span class="o">.</span><span class="n">stop</span> <span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">stop</span> <span class="k">else</span> <span class="bp">self</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">return</span> <span class="n">op</span><span class="o">.</span><span class="n">slice</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">begin</span><span class="o">=</span><span class="n">begin</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="n">end</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Multi-dimension indexing is not supported'</span><span class="p">)</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Undefined behaviour for </span><span class="si">{}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">key</span><span class="p">))</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="CSRNDArray.__setitem__"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.CSRNDArray.__setitem__">[docs]</a> <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="sd">"""x.__setitem__(i, y) <=> x[i]=y</span>
<span class="sd"> Set self[key] to value. Only slice key [:] is supported.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> key : mxnet.ndarray.NDArray.slice</span>
<span class="sd"> The indexing key.</span>
<span class="sd"> value : NDArray or CSRNDArray or numpy.ndarray</span>
<span class="sd"> The value to set.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> src = mx.nd.sparse.zeros('csr', (3,3))</span>
<span class="sd"> >>> src.asnumpy()</span>
<span class="sd"> array([[ 0., 0., 0.],</span>
<span class="sd"> [ 0., 0., 0.],</span>
<span class="sd"> [ 0., 0., 0.]], dtype=float32)</span>
<span class="sd"> >>> # assign CSRNDArray with same storage type</span>
<span class="sd"> >>> x = mx.nd.ones((3,3)).tostype('csr')</span>
<span class="sd"> >>> x[:] = src</span>
<span class="sd"> >>> x.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> # assign NDArray to CSRNDArray</span>
<span class="sd"> >>> x[:] = mx.nd.ones((3,3)) * 2</span>
<span class="sd"> >>> x.asnumpy()</span>
<span class="sd"> array([[ 2., 2., 2.],</span>
<span class="sd"> [ 2., 2., 2.],</span>
<span class="sd"> [ 2., 2., 2.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">writable</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Failed to assign to a readonly CSRNDArray'</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">py_slice</span><span class="p">):</span>
<span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">step</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">key</span><span class="o">.</span><span class="n">start</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">key</span><span class="o">.</span><span class="n">stop</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Assignment with slice for CSRNDArray is not '</span> \
<span class="s1">'implemented yet.'</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="c1"># avoid copying to itself</span>
<span class="k">if</span> <span class="n">value</span><span class="o">.</span><span class="n">handle</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">:</span>
<span class="n">value</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">numeric_types</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Assigning numeric types to CSRNDArray is "</span> \
<span class="s2">"not implemented yet."</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">generic</span><span class="p">)):</span>
<span class="c1"># TODO(haibin/anisub) check scipy.sparse and use _sync_copy_from to</span>
<span class="c1"># avoid the temporary copy</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s1">'Assigning non-NDArray object to CSRNDArray is not efficient'</span><span class="p">,</span>
<span class="ne">RuntimeWarning</span><span class="p">)</span>
<span class="n">tmp</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="n">tmp</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'type </span><span class="si">%s</span><span class="s1"> not supported'</span> <span class="o">%</span> <span class="nb">str</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">value</span><span class="p">)))</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">assert</span><span class="p">(</span><span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)))</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s1">'CSRNDArray only supports [:] for assignment'</span><span class="p">)</span></div>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">indices</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""A deep copy NDArray of the indices array of the CSRNDArray.</span>
<span class="sd"> This generates a deep copy of the column indices of the current `csr` matrix.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> This CSRNDArray's indices array.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_aux_data</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">indptr</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""A deep copy NDArray of the indptr array of the CSRNDArray.</span>
<span class="sd"> This generates a deep copy of the `indptr` of the current `csr` matrix.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> This CSRNDArray's indptr array.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_aux_data</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">data</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""A deep copy NDArray of the data array of the CSRNDArray.</span>
<span class="sd"> This generates a deep copy of the `data` of the current `csr` matrix.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> This CSRNDArray's data array.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_data</span><span class="p">()</span>
<span class="nd">@indices</span><span class="o">.</span><span class="n">setter</span>
<span class="k">def</span> <span class="nf">indices</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">indices</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="nd">@indptr</span><span class="o">.</span><span class="n">setter</span>
<span class="k">def</span> <span class="nf">indptr</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">indptr</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="nd">@data</span><span class="o">.</span><span class="n">setter</span>
<span class="k">def</span> <span class="nf">data</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<div class="viewcode-block" id="CSRNDArray.tostype"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.CSRNDArray.tostype">[docs]</a> <span class="k">def</span> <span class="nf">tostype</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stype</span><span class="p">):</span>
<span class="sd">"""Return a copy of the array with chosen storage type.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray or CSRNDArray</span>
<span class="sd"> A copy of the array with the chosen storage stype</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="n">stype</span> <span class="o">==</span> <span class="s1">'row_sparse'</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"cast_storage from csr to row_sparse is not supported"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">op</span><span class="o">.</span><span class="n">cast_storage</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stype</span><span class="o">=</span><span class="n">stype</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="CSRNDArray.copyto"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.CSRNDArray.copyto">[docs]</a> <span class="k">def</span> <span class="nf">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="sd">"""Copies the value of this array to another array.</span>
<span class="sd"> If ``other`` is a ``NDArray`` or ``CSRNDArray`` object, then ``other.shape`` and</span>
<span class="sd"> ``self.shape`` should be the same. This function copies the value from</span>
<span class="sd"> ``self`` to ``other``.</span>
<span class="sd"> If ``other`` is a context, a new ``CSRNDArray`` will be first created on</span>
<span class="sd"> the target context, and the value of ``self`` is copied.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> other : NDArray or CSRNDArray or Context</span>
<span class="sd"> The destination array or context.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray or CSRNDArray</span>
<span class="sd"> The copied array. If ``other`` is an ``NDArray`` or ``CSRNDArray``, then the return</span>
<span class="sd"> value and ``other`` will point to the same ``NDArray`` or ``CSRNDArray``.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">Context</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">super</span><span class="p">(</span><span class="n">CSRNDArray</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">stype</span> <span class="o">=</span> <span class="n">other</span><span class="o">.</span><span class="n">stype</span>
<span class="k">if</span> <span class="n">stype</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'default'</span><span class="p">,</span> <span class="s1">'csr'</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">super</span><span class="p">(</span><span class="n">CSRNDArray</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'copyto does not support destination NDArray stype '</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">stype</span><span class="p">))</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'copyto does not support type '</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">other</span><span class="p">)))</span></div>
<div class="viewcode-block" id="CSRNDArray.asscipy"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.CSRNDArray.asscipy">[docs]</a> <span class="k">def</span> <span class="nf">asscipy</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""Returns a ``scipy.sparse.csr.csr_matrix`` object with value copied from this array</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> x = mx.nd.sparse.zeros('csr', (2,3))</span>
<span class="sd"> >>> y = x.asscipy()</span>
<span class="sd"> >>> type(y)</span>
<span class="sd"> <type 'scipy.sparse.csr.csr_matrix'></span>
<span class="sd"> >>> y</span>
<span class="sd"> <2x3 sparse matrix of type '<type 'numpy.float32'>'</span>
<span class="sd"> with 0 stored elements in Compressed Sparse Row format></span>
<span class="sd"> """</span>
<span class="n">data</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
<span class="n">indices</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">indices</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
<span class="n">indptr</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">indptr</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">spsp</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"scipy is not available. </span><span class="se">\</span>
<span class="s2"> Please check if the scipy python bindings are installed."</span><span class="p">)</span>
<span class="k">return</span> <span class="n">spsp</span><span class="o">.</span><span class="n">csr_matrix</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">indptr</span><span class="p">),</span> <span class="n">shape</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">dtype</span><span class="p">)</span></div></div>
<span class="c1"># pylint: disable=abstract-method</span>
<div class="viewcode-block" id="RowSparseNDArray"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.RowSparseNDArray">[docs]</a><span class="k">class</span> <span class="nc">RowSparseNDArray</span><span class="p">(</span><span class="n">BaseSparseNDArray</span><span class="p">):</span>
<span class="sd">"""A sparse representation of a set of NDArray row slices at given indices.</span>
<span class="sd"> A RowSparseNDArray represents a multidimensional NDArray using two separate arrays: `data` and</span>
<span class="sd"> `indices`. The number of dimensions has to be at least 2.</span>
<span class="sd"> - data: an NDArray of any dtype with shape [D0, D1, ..., Dn].</span>
<span class="sd"> - indices: a 1-D int64 NDArray with shape [D0] with values sorted in ascending order.</span>
<span class="sd"> The `indices` stores the indices of the row slices with non-zeros,</span>
<span class="sd"> while the values are stored in `data`. The corresponding NDArray ``dense``</span>
<span class="sd"> represented by RowSparseNDArray ``rsp`` has</span>
<span class="sd"> ``dense[rsp.indices[i], :, :, :, ...] = rsp.data[i, :, :, :, ...]``</span>
<span class="sd"> >>> dense.asnumpy()</span>
<span class="sd"> array([[ 1., 2., 3.],</span>
<span class="sd"> [ 0., 0., 0.],</span>
<span class="sd"> [ 4., 0., 5.],</span>
<span class="sd"> [ 0., 0., 0.],</span>
<span class="sd"> [ 0., 0., 0.]], dtype=float32)</span>
<span class="sd"> >>> rsp = dense.tostype('row_sparse')</span>
<span class="sd"> >>> rsp.indices.asnumpy()</span>
<span class="sd"> array([0, 2], dtype=int64)</span>
<span class="sd"> >>> rsp.data.asnumpy()</span>
<span class="sd"> array([[ 1., 2., 3.],</span>
<span class="sd"> [ 4., 0., 5.]], dtype=float32)</span>
<span class="sd"> A RowSparseNDArray is typically used to represent non-zero row slices of a large NDArray</span>
<span class="sd"> of shape [LARGE0, D1, .. , Dn] where LARGE0 >> D0 and most row slices are zeros.</span>
<span class="sd"> RowSparseNDArray is used principally in the definition of gradients for operations</span>
<span class="sd"> that have sparse gradients (e.g. sparse dot and sparse embedding).</span>
<span class="sd"> See Also</span>
<span class="sd"> --------</span>
<span class="sd"> row_sparse_array: Several ways to construct a RowSparseNDArray</span>
<span class="sd"> """</span>
<span class="k">def</span> <span class="nf">__reduce__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="k">return</span> <span class="n">RowSparseNDArray</span><span class="p">,</span> <span class="p">(</span><span class="kc">None</span><span class="p">,),</span> <span class="nb">super</span><span class="p">(</span><span class="n">RowSparseNDArray</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">__getstate__</span><span class="p">()</span>
<span class="k">def</span> <span class="nf">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">+</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__isub__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">-</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__imul__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">*</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__idiv__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">/</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">def</span> <span class="nf">__itruediv__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="p">(</span><span class="bp">self</span> <span class="o">/</span> <span class="n">other</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">return</span> <span class="bp">self</span>
<div class="viewcode-block" id="RowSparseNDArray.__getitem__"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.RowSparseNDArray.__getitem__">[docs]</a> <span class="k">def</span> <span class="nf">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">):</span>
<span class="sd">"""x.__getitem__(i) <=> x[i]</span>
<span class="sd"> Returns a sliced view of this array.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> key : mxnet.ndarray.NDArray.slice</span>
<span class="sd"> Indexing key.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> x = mx.nd.sparse.zeros('row_sparse', (2, 3))</span>
<span class="sd"> >>> x[:].asnumpy()</span>
<span class="sd"> array([[ 0., 0., 0.],</span>
<span class="sd"> [ 0., 0., 0.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="nb">int</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">"__getitem__ with int key is not implemented for RowSparseNDArray yet"</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">py_slice</span><span class="p">):</span>
<span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">step</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">key</span><span class="o">.</span><span class="n">start</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">key</span><span class="o">.</span><span class="n">stop</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s1">'RowSparseNDArray only supports [:] for __getitem__'</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="bp">self</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Multi-dimension indexing is not supported'</span><span class="p">)</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Undefined behaviour for </span><span class="si">{}</span><span class="s1">'</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">key</span><span class="p">))</span></div>
<div class="viewcode-block" id="RowSparseNDArray.__setitem__"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.RowSparseNDArray.__setitem__">[docs]</a> <span class="k">def</span> <span class="nf">__setitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span><span class="p">):</span>
<span class="sd">"""x.__setitem__(i, y) <=> x[i]=y</span>
<span class="sd"> Set self[key] to value. Only slice key [:] is supported.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> key : mxnet.ndarray.NDArray.slice</span>
<span class="sd"> The indexing key.</span>
<span class="sd"> value : NDArray or numpy.ndarray</span>
<span class="sd"> The value to set.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> src = mx.nd.row_sparse([[1, 0, 2], [4, 5, 6]], [0, 2], (3,3))</span>
<span class="sd"> >>> src.asnumpy()</span>
<span class="sd"> array([[ 1., 0., 2.],</span>
<span class="sd"> [ 0., 0., 0.],</span>
<span class="sd"> [ 4., 5., 6.]], dtype=float32)</span>
<span class="sd"> >>> # assign RowSparseNDArray with same storage type</span>
<span class="sd"> >>> x = mx.nd.sparse.zeros('row_sparse', (3,3))</span>
<span class="sd"> >>> x[:] = src</span>
<span class="sd"> >>> x.asnumpy()</span>
<span class="sd"> array([[ 1., 0., 2.],</span>
<span class="sd"> [ 0., 0., 0.],</span>
<span class="sd"> [ 4., 5., 6.]], dtype=float32)</span>
<span class="sd"> >>> # assign NDArray to RowSparseNDArray</span>
<span class="sd"> >>> x[:] = mx.nd.ones((3,3))</span>
<span class="sd"> >>> x.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">writable</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Failed to assign to a readonly RowSparseNDArray'</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="n">py_slice</span><span class="p">):</span>
<span class="k">if</span> <span class="n">key</span><span class="o">.</span><span class="n">step</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">key</span><span class="o">.</span><span class="n">start</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">or</span> <span class="n">key</span><span class="o">.</span><span class="n">stop</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'Assignment with slice for RowSparseNDArray '</span> \
<span class="s1">'is not implmented yet.'</span><span class="p">)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="c1"># avoid copying to itself</span>
<span class="k">if</span> <span class="n">value</span><span class="o">.</span><span class="n">handle</span> <span class="ow">is</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">handle</span><span class="p">:</span>
<span class="n">value</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">numeric_types</span><span class="p">):</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_set_value</span><span class="p">(</span><span class="nb">float</span><span class="p">(</span><span class="n">value</span><span class="p">),</span> <span class="n">out</span><span class="o">=</span><span class="bp">self</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">generic</span><span class="p">)):</span>
<span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">(</span><span class="s1">'Assigning non-NDArray object to RowSparseNDArray is not efficient'</span><span class="p">,</span>
<span class="ne">RuntimeWarning</span><span class="p">)</span>
<span class="n">tmp</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">value</span><span class="p">)</span>
<span class="n">tmp</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'type </span><span class="si">%s</span><span class="s1"> not supported'</span> <span class="o">%</span> <span class="nb">str</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">value</span><span class="p">)))</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">assert</span><span class="p">(</span><span class="nb">isinstance</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">)))</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'RowSparseNDArray only supports [:] for assignment'</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">indices</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""A deep copy NDArray of the indices array of the RowSparseNDArray.</span>
<span class="sd"> This generates a deep copy of the row indices of the current `row_sparse` matrix.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> This RowSparseNDArray's indices array.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_aux_data</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
<span class="nd">@property</span>
<span class="k">def</span> <span class="nf">data</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
<span class="sd">"""A deep copy NDArray of the data array of the RowSparseNDArray.</span>
<span class="sd"> This generates a deep copy of the `data` of the current `row_sparse` matrix.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> This RowSparseNDArray's data array.</span>
<span class="sd"> """</span>
<span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_data</span><span class="p">()</span>
<span class="nd">@indices</span><span class="o">.</span><span class="n">setter</span>
<span class="k">def</span> <span class="nf">indices</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">indices</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<span class="nd">@data</span><span class="o">.</span><span class="n">setter</span>
<span class="k">def</span> <span class="nf">data</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">()</span>
<div class="viewcode-block" id="RowSparseNDArray.tostype"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.RowSparseNDArray.tostype">[docs]</a> <span class="k">def</span> <span class="nf">tostype</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stype</span><span class="p">):</span>
<span class="sd">"""Return a copy of the array with chosen storage type.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray or RowSparseNDArray</span>
<span class="sd"> A copy of the array with the chosen storage stype</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="n">stype</span> <span class="o">==</span> <span class="s1">'csr'</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"cast_storage from row_sparse to csr is not supported"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">op</span><span class="o">.</span><span class="n">cast_storage</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">stype</span><span class="o">=</span><span class="n">stype</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="RowSparseNDArray.copyto"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.RowSparseNDArray.copyto">[docs]</a> <span class="k">def</span> <span class="nf">copyto</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<span class="sd">"""Copies the value of this array to another array.</span>
<span class="sd"> If ``other`` is a ``NDArray`` or ``RowSparseNDArray`` object, then ``other.shape``</span>
<span class="sd"> and ``self.shape`` should be the same. This function copies the value from</span>
<span class="sd"> ``self`` to ``other``.</span>
<span class="sd"> If ``other`` is a context, a new ``RowSparseNDArray`` will be first created on</span>
<span class="sd"> the target context, and the value of ``self`` is copied.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> other : NDArray or RowSparseNDArray or Context</span>
<span class="sd"> The destination array or context.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray or RowSparseNDArray</span>
<span class="sd"> The copied array. If ``other`` is an ``NDArray`` or ``RowSparseNDArray``, then the</span>
<span class="sd"> return value and ``other`` will point to the same ``NDArray`` or ``RowSparseNDArray``.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">Context</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">super</span><span class="p">(</span><span class="n">RowSparseNDArray</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">stype</span> <span class="o">=</span> <span class="n">other</span><span class="o">.</span><span class="n">stype</span>
<span class="k">if</span> <span class="n">stype</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'default'</span><span class="p">,</span> <span class="s1">'row_sparse'</span><span class="p">):</span>
<span class="k">return</span> <span class="nb">super</span><span class="p">(</span><span class="n">RowSparseNDArray</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="n">copyto</span><span class="p">(</span><span class="n">other</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'copyto does not support destination NDArray stype '</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">stype</span><span class="p">))</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'copyto does not support type '</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">other</span><span class="p">)))</span></div>
<div class="viewcode-block" id="RowSparseNDArray.retain"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.RowSparseNDArray.retain">[docs]</a> <span class="k">def</span> <span class="nf">retain</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="sd">"""Convenience fluent method for :py:func:`retain`.</span>
<span class="sd"> The arguments are the same as for :py:func:`retain`, with</span>
<span class="sd"> this array as data.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="n">gs_retain</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="s2">"gen_sparse could not be imported"</span><span class="p">)</span>
<span class="k">return</span> <span class="n">gs_retain</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span></div></div>
<span class="k">def</span> <span class="nf">_prepare_src_array</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">dtype</span><span class="p">):</span>
<span class="sd">"""Prepare `source_array` so that it can be used to construct NDArray.</span>
<span class="sd"> `source_array` is converted to a `np.ndarray` if it's neither an `NDArray` \</span>
<span class="sd"> nor an `np.ndarray`.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="p">):</span>
<span class="k">try</span><span class="p">:</span>
<span class="n">source_array</span> <span class="o">=</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">except</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">TypeError</span><span class="p">(</span><span class="s1">'values must be array like object'</span><span class="p">)</span>
<span class="k">return</span> <span class="n">source_array</span>
<span class="k">def</span> <span class="nf">_prepare_default_dtype</span><span class="p">(</span><span class="n">src_array</span><span class="p">,</span> <span class="n">dtype</span><span class="p">):</span>
<span class="sd">"""Prepare the value of dtype if `dtype` is None. If `src_array` is an NDArray, numpy.ndarray</span>
<span class="sd"> or scipy.sparse.csr.csr_matrix, return src_array.dtype. float32 is returned otherwise."""</span>
<span class="k">if</span> <span class="n">dtype</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">src_array</span><span class="p">,</span> <span class="p">(</span><span class="n">NDArray</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="p">)):</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">src_array</span><span class="o">.</span><span class="n">dtype</span>
<span class="k">elif</span> <span class="n">spsp</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">src_array</span><span class="p">,</span> <span class="n">spsp</span><span class="o">.</span><span class="n">csr</span><span class="o">.</span><span class="n">csr_matrix</span><span class="p">):</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">src_array</span><span class="o">.</span><span class="n">dtype</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">mx_real_t</span>
<span class="k">return</span> <span class="n">dtype</span>
<span class="k">def</span> <span class="nf">_check_shape</span><span class="p">(</span><span class="n">s1</span><span class="p">,</span> <span class="n">s2</span><span class="p">):</span>
<span class="sd">"""check s1 == s2 if both are not None"""</span>
<span class="k">if</span> <span class="n">s1</span> <span class="ow">and</span> <span class="n">s2</span> <span class="ow">and</span> <span class="n">s1</span> <span class="o">!=</span> <span class="n">s2</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Shape mismatch detected. "</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">s1</span><span class="p">)</span> <span class="o">+</span> <span class="s2">" v.s. "</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">s2</span><span class="p">))</span>
<div class="viewcode-block" id="csr_matrix"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.csr_matrix">[docs]</a><span class="k">def</span> <span class="nf">csr_matrix</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">shape</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""Creates a `CSRNDArray`, an 2D array with compressed sparse row (CSR) format.</span>
<span class="sd"> The CSRNDArray can be instantiated in several ways:</span>
<span class="sd"> - csr_matrix(D):</span>
<span class="sd"> to construct a CSRNDArray with a dense 2D array ``D``</span>
<span class="sd"> - **D** (*array_like*) - An object exposing the array interface, an object whose \</span>
<span class="sd"> `__array__` method returns an array, or any (nested) sequence.</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is ``D.dtype`` if ``D`` is an NDArray or numpy.ndarray, \</span>
<span class="sd"> float32 otherwise.</span>
<span class="sd"> - csr_matrix(S)</span>
<span class="sd"> to construct a CSRNDArray with a sparse 2D array ``S``</span>
<span class="sd"> - **S** (*CSRNDArray or scipy.sparse.csr.csr_matrix*) - A sparse matrix.</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is ``S.dtype``.</span>
<span class="sd"> - csr_matrix((M, N))</span>
<span class="sd"> to construct an empty CSRNDArray with shape ``(M, N)``</span>
<span class="sd"> - **M** (*int*) - Number of rows in the matrix</span>
<span class="sd"> - **N** (*int*) - Number of columns in the matrix</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is float32.</span>
<span class="sd"> - csr_matrix((data, indices, indptr))</span>
<span class="sd"> to construct a CSRNDArray based on the definition of compressed sparse row format \</span>
<span class="sd"> using three separate arrays, \</span>
<span class="sd"> where the column indices for row i are stored in ``indices[indptr[i]:indptr[i+1]]`` \</span>
<span class="sd"> and their corresponding values are stored in ``data[indptr[i]:indptr[i+1]]``. \</span>
<span class="sd"> The column indices for a given row are expected to be **sorted in ascending order.** \</span>
<span class="sd"> Duplicate column entries for the same row are not allowed.</span>
<span class="sd"> - **data** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> holds all the non-zero entries of the matrix in row-major order.</span>
<span class="sd"> - **indices** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> stores the column index for each non-zero element in ``data``.</span>
<span class="sd"> - **indptr** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> stores the offset into ``data`` of the first non-zero element number of each \</span>
<span class="sd"> row of the matrix.</span>
<span class="sd"> - **shape** (*tuple of int, optional*) - The shape of the array. The default \</span>
<span class="sd"> shape is inferred from the indices and indptr arrays.</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is ``data.dtype`` if ``data`` is an NDArray or numpy.ndarray, \</span>
<span class="sd"> float32 otherwise.</span>
<span class="sd"> - csr_matrix((data, (row, col)))</span>
<span class="sd"> to construct a CSRNDArray based on the COOrdinate format \</span>
<span class="sd"> using three seperate arrays, \</span>
<span class="sd"> where ``row[i]`` is the row index of the element, \</span>
<span class="sd"> ``col[i]`` is the column index of the element \</span>
<span class="sd"> and ``data[i]`` is the data corresponding to the element. All the missing \</span>
<span class="sd"> elements in the input are taken to be zeroes.</span>
<span class="sd"> - **data** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> holds all the non-zero entries of the matrix in COO format.</span>
<span class="sd"> - **row** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> stores the row index for each non zero element in ``data``.</span>
<span class="sd"> - **col** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> stores the col index for each non zero element in ``data``.</span>
<span class="sd"> - **shape** (*tuple of int, optional*) - The shape of the array. The default \</span>
<span class="sd"> shape is inferred from the ``row`` and ``col`` arrays.</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is float32.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> arg1: tuple of int, tuple of array_like, array_like, CSRNDArray, scipy.sparse.csr_matrix, \</span>
<span class="sd"> scipy.sparse.coo_matrix, tuple of int or tuple of array_like</span>
<span class="sd"> The argument to help instantiate the csr matrix. See above for further details.</span>
<span class="sd"> shape : tuple of int, optional</span>
<span class="sd"> The shape of the csr matrix.</span>
<span class="sd"> ctx: Context, optional</span>
<span class="sd"> Device context (default is the current default context).</span>
<span class="sd"> dtype: str or numpy.dtype, optional</span>
<span class="sd"> The data type of the output array.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> CSRNDArray</span>
<span class="sd"> A `CSRNDArray` with the `csr` storage representation.</span>
<span class="sd"> Example</span>
<span class="sd"> -------</span>
<span class="sd"> >>> a = mx.nd.sparse.csr_matrix(([1, 2, 3], [1, 0, 2], [0, 1, 2, 2, 3]), shape=(4, 3))</span>
<span class="sd"> >>> a.asnumpy()</span>
<span class="sd"> array([[ 0., 1., 0.],</span>
<span class="sd"> [ 2., 0., 0.],</span>
<span class="sd"> [ 0., 0., 0.],</span>
<span class="sd"> [ 0., 0., 3.]], dtype=float32)</span>
<span class="sd"> See Also</span>
<span class="sd"> --------</span>
<span class="sd"> CSRNDArray : MXNet NDArray in compressed sparse row format.</span>
<span class="sd"> """</span>
<span class="c1"># construct a csr matrix from (M, N) or (data, indices, indptr)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">arg_len</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">arg1</span><span class="p">)</span>
<span class="k">if</span> <span class="n">arg_len</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span>
<span class="c1"># construct a sparse csr matrix from</span>
<span class="c1"># scipy coo matrix if input format is coo</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="nb">tuple</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">len</span><span class="p">(</span><span class="n">arg1</span><span class="p">[</span><span class="mi">1</span><span class="p">])</span> <span class="o">==</span> <span class="mi">2</span><span class="p">:</span>
<span class="n">data</span><span class="p">,</span> <span class="p">(</span><span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="p">)</span> <span class="o">=</span> <span class="n">arg1</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">data</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">row</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">row</span> <span class="o">=</span> <span class="n">row</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">col</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">col</span> <span class="o">=</span> <span class="n">col</span><span class="o">.</span><span class="n">asnumpy</span><span class="p">()</span>
<span class="n">coo</span> <span class="o">=</span> <span class="n">spsp</span><span class="o">.</span><span class="n">coo_matrix</span><span class="p">((</span><span class="n">data</span><span class="p">,</span> <span class="p">(</span><span class="n">row</span><span class="p">,</span> <span class="n">col</span><span class="p">)),</span> <span class="n">shape</span><span class="o">=</span><span class="n">shape</span><span class="p">)</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">coo</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="n">csr</span> <span class="o">=</span> <span class="n">coo</span><span class="o">.</span><span class="n">tocsr</span><span class="p">()</span>
<span class="k">return</span> <span class="n">array</span><span class="p">(</span><span class="n">csr</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># empty matrix with shape</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="k">return</span> <span class="n">empty</span><span class="p">(</span><span class="s1">'csr'</span><span class="p">,</span> <span class="n">arg1</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">arg_len</span> <span class="o">==</span> <span class="mi">3</span><span class="p">:</span>
<span class="c1"># data, indices, indptr</span>
<span class="k">return</span> <span class="n">_csr_matrix_from_definition</span><span class="p">(</span><span class="n">arg1</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">arg1</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">arg1</span><span class="p">[</span><span class="mi">2</span><span class="p">],</span> <span class="n">shape</span><span class="o">=</span><span class="n">shape</span><span class="p">,</span>
<span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Unexpected length of input tuple: "</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">arg_len</span><span class="p">))</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># construct a csr matrix from a sparse / dense one</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">CSRNDArray</span><span class="p">)</span> <span class="ow">or</span> <span class="p">(</span><span class="n">spsp</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">spsp</span><span class="o">.</span><span class="n">csr</span><span class="o">.</span><span class="n">csr_matrix</span><span class="p">)):</span>
<span class="c1"># construct a csr matrix from scipy or CSRNDArray</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">arg1</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="k">return</span> <span class="n">array</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">RowSparseNDArray</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Unexpected input type: RowSparseNDArray"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># construct a csr matrix from a dense one</span>
<span class="c1"># prepare default ctx and dtype since mx.nd.array doesn't use default values</span>
<span class="c1"># based on source_array</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">_prepare_default_dtype</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="c1"># create dns array with provided dtype. ctx is not passed since copy across</span>
<span class="c1"># ctx requires dtype to be the same</span>
<span class="n">dns</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ctx</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">and</span> <span class="n">dns</span><span class="o">.</span><span class="n">context</span> <span class="o">!=</span> <span class="n">ctx</span><span class="p">:</span>
<span class="n">dns</span> <span class="o">=</span> <span class="n">dns</span><span class="o">.</span><span class="n">as_in_context</span><span class="p">(</span><span class="n">ctx</span><span class="p">)</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">dns</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="k">return</span> <span class="n">dns</span><span class="o">.</span><span class="n">tostype</span><span class="p">(</span><span class="s1">'csr'</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_csr_matrix_from_definition</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">indptr</span><span class="p">,</span> <span class="n">shape</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
<span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">indices_type</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">indptr_type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""Create a `CSRNDArray` based on data, indices and indptr"""</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="n">storage_type</span> <span class="o">=</span> <span class="s1">'csr'</span>
<span class="c1"># context</span>
<span class="n">ctx</span> <span class="o">=</span> <span class="n">current_context</span><span class="p">()</span> <span class="k">if</span> <span class="n">ctx</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">ctx</span>
<span class="c1"># types</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">_prepare_default_dtype</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="n">indptr_type</span> <span class="o">=</span> <span class="n">_STORAGE_AUX_TYPES</span><span class="p">[</span><span class="n">storage_type</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span> <span class="k">if</span> <span class="n">indptr_type</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">indptr_type</span>
<span class="n">indices_type</span> <span class="o">=</span> <span class="n">_STORAGE_AUX_TYPES</span><span class="p">[</span><span class="n">storage_type</span><span class="p">][</span><span class="mi">1</span><span class="p">]</span> <span class="k">if</span> <span class="n">indices_type</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">indices_type</span>
<span class="c1"># prepare src array and types</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">_prepare_src_array</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="n">indptr</span> <span class="o">=</span> <span class="n">_prepare_src_array</span><span class="p">(</span><span class="n">indptr</span><span class="p">,</span> <span class="n">indptr_type</span><span class="p">)</span>
<span class="n">indices</span> <span class="o">=</span> <span class="n">_prepare_src_array</span><span class="p">(</span><span class="n">indices</span><span class="p">,</span> <span class="n">indices_type</span><span class="p">)</span>
<span class="c1"># TODO(junwu): Convert data, indptr, and indices to mxnet NDArrays</span>
<span class="c1"># if they are not for now. In the future, we should provide a c-api</span>
<span class="c1"># to accept np.ndarray types to copy from to result.data and aux_data</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">indptr</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">indptr</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">indptr</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="n">indptr_type</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">indices</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">indices</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">indices</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="n">indices_type</span><span class="p">)</span>
<span class="k">if</span> <span class="n">shape</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="k">if</span> <span class="n">indices</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'invalid shape'</span><span class="p">)</span>
<span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">indptr</span><span class="p">)</span> <span class="o">-</span> <span class="mi">1</span><span class="p">,</span> <span class="n">op</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">indices</span><span class="p">)</span><span class="o">.</span><span class="n">asscalar</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
<span class="c1"># verify shapes</span>
<span class="n">aux_shapes</span> <span class="o">=</span> <span class="p">[</span><span class="n">indptr</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">indices</span><span class="o">.</span><span class="n">shape</span><span class="p">]</span>
<span class="k">if</span> <span class="n">data</span><span class="o">.</span><span class="n">ndim</span> <span class="o">!=</span> <span class="mi">1</span> <span class="ow">or</span> <span class="n">indptr</span><span class="o">.</span><span class="n">ndim</span> <span class="o">!=</span> <span class="mi">1</span> <span class="ow">or</span> <span class="n">indices</span><span class="o">.</span><span class="n">ndim</span> <span class="o">!=</span> <span class="mi">1</span> <span class="ow">or</span> \
<span class="n">indptr</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="mi">0</span> <span class="ow">or</span> <span class="nb">len</span><span class="p">(</span><span class="n">shape</span><span class="p">)</span> <span class="o">!=</span> <span class="mi">2</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'invalid shape'</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">CSRNDArray</span><span class="p">(</span><span class="n">_new_alloc_handle</span><span class="p">(</span><span class="n">storage_type</span><span class="p">,</span> <span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="kc">False</span><span class="p">,</span> <span class="n">dtype</span><span class="p">,</span>
<span class="p">[</span><span class="n">indptr_type</span><span class="p">,</span> <span class="n">indices_type</span><span class="p">],</span> <span class="n">aux_shapes</span><span class="p">))</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArraySyncCopyFromNDArray</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">data</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)))</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArraySyncCopyFromNDArray</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">indptr</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="mi">0</span><span class="p">)))</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArraySyncCopyFromNDArray</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">indices</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="mi">1</span><span class="p">)))</span>
<span class="k">return</span> <span class="n">result</span>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="row_sparse_array"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.row_sparse_array">[docs]</a><span class="k">def</span> <span class="nf">row_sparse_array</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">shape</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""Creates a `RowSparseNDArray`, a multidimensional row sparse array with a set of \</span>
<span class="sd"> tensor slices at given indices.</span>
<span class="sd"> The RowSparseNDArray can be instantiated in several ways:</span>
<span class="sd"> - row_sparse_array(D):</span>
<span class="sd"> to construct a RowSparseNDArray with a dense ndarray ``D``</span>
<span class="sd"> - **D** (*array_like*) - An object exposing the array interface, an object whose \</span>
<span class="sd"> `__array__` method returns an array, or any (nested) sequence.</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is ``D.dtype`` if ``D`` is an NDArray or numpy.ndarray, \</span>
<span class="sd"> float32 otherwise.</span>
<span class="sd"> - row_sparse_array(S)</span>
<span class="sd"> to construct a RowSparseNDArray with a sparse ndarray ``S``</span>
<span class="sd"> - **S** (*RowSparseNDArray*) - A sparse ndarray.</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is ``S.dtype``.</span>
<span class="sd"> - row_sparse_array((D0, D1 .. Dn))</span>
<span class="sd"> to construct an empty RowSparseNDArray with shape ``(D0, D1, ... Dn)``</span>
<span class="sd"> - **D0, D1 .. Dn** (*int*) - The shape of the ndarray</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is float32.</span>
<span class="sd"> - row_sparse_array((data, indices))</span>
<span class="sd"> to construct a RowSparseNDArray based on the definition of row sparse format \</span>
<span class="sd"> using two separate arrays, \</span>
<span class="sd"> where the `indices` stores the indices of the row slices with non-zeros,</span>
<span class="sd"> while the values are stored in `data`. The corresponding NDArray ``dense``</span>
<span class="sd"> represented by RowSparseNDArray ``rsp`` has \</span>
<span class="sd"> ``dense[rsp.indices[i], :, :, :, ...] = rsp.data[i, :, :, :, ...]``</span>
<span class="sd"> The row indices for are expected to be **sorted in ascending order.** \</span>
<span class="sd"> - **data** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> holds all the non-zero row slices of the array.</span>
<span class="sd"> - **indices** (*array_like*) - An object exposing the array interface, which \</span>
<span class="sd"> stores the row index for each row slice with non-zero elements.</span>
<span class="sd"> - **shape** (*tuple of int, optional*) - The shape of the array. The default \</span>
<span class="sd"> shape is inferred from the indices and indptr arrays.</span>
<span class="sd"> - **ctx** (*Context, optional*) - Device context \</span>
<span class="sd"> (default is the current default context).</span>
<span class="sd"> - **dtype** (*str or numpy.dtype, optional*) - The data type of the output array. \</span>
<span class="sd"> The default dtype is float32.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> arg1 : NDArray, numpy.ndarray, RowSparseNDArray, tuple of int or tuple of array_like</span>
<span class="sd"> The argument to help instantiate the row sparse ndarray. See above for further details.</span>
<span class="sd"> shape : tuple of int, optional</span>
<span class="sd"> The shape of the row sparse ndarray. (Default value = None)</span>
<span class="sd"> ctx : Context, optional</span>
<span class="sd"> Device context (default is the current default context).</span>
<span class="sd"> dtype : str or numpy.dtype, optional</span>
<span class="sd"> The data type of the output array. (Default value = None)</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> RowSparseNDArray</span>
<span class="sd"> An `RowSparseNDArray` with the `row_sparse` storage representation.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> a = mx.nd.sparse.row_sparse_array(([[1, 2], [3, 4]], [1, 4]), shape=(6, 2))</span>
<span class="sd"> >>> a.asnumpy()</span>
<span class="sd"> array([[ 0., 0.],</span>
<span class="sd"> [ 1., 2.],</span>
<span class="sd"> [ 0., 0.],</span>
<span class="sd"> [ 0., 0.],</span>
<span class="sd"> [ 3., 4.],</span>
<span class="sd"> [ 0., 0.]], dtype=float32)</span>
<span class="sd"> See Also</span>
<span class="sd"> --------</span>
<span class="sd"> RowSparseNDArray : MXNet NDArray in row sparse format.</span>
<span class="sd"> """</span>
<span class="c1"># construct a row sparse array from (D0, D1 ..) or (data, indices)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="nb">tuple</span><span class="p">):</span>
<span class="n">arg_len</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">arg1</span><span class="p">)</span>
<span class="k">if</span> <span class="n">arg_len</span> <span class="o"><</span> <span class="mi">2</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Unexpected length of input tuple: "</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">arg_len</span><span class="p">))</span>
<span class="k">elif</span> <span class="n">arg_len</span> <span class="o">></span> <span class="mi">2</span><span class="p">:</span>
<span class="c1"># empty ndarray with shape</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="k">return</span> <span class="n">empty</span><span class="p">(</span><span class="s1">'row_sparse'</span><span class="p">,</span> <span class="n">arg1</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># len(arg1) = 2, is either shape or (data, indices)</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">integer_types</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">integer_types</span><span class="p">):</span>
<span class="c1"># empty ndarray with shape</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="k">return</span> <span class="n">empty</span><span class="p">(</span><span class="s1">'row_sparse'</span><span class="p">,</span> <span class="n">arg1</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># data, indices, indptr</span>
<span class="k">return</span> <span class="n">_row_sparse_ndarray_from_definition</span><span class="p">(</span><span class="n">arg1</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">arg1</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">shape</span><span class="o">=</span><span class="n">shape</span><span class="p">,</span>
<span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># construct a row sparse ndarray from a dense / sparse array</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">RowSparseNDArray</span><span class="p">):</span>
<span class="c1"># construct a row sparse ndarray from RowSparseNDArray</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">arg1</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="k">return</span> <span class="n">array</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">CSRNDArray</span><span class="p">):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Unexpected input type: CSRNDArray"</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="c1"># construct a csr matrix from a dense one</span>
<span class="c1"># prepare default dtype since mx.nd.array doesn't use default values</span>
<span class="c1"># based on source_array</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">_prepare_default_dtype</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="c1"># create dns array with provided dtype. ctx is not passed since copy across</span>
<span class="c1"># ctx requires dtype to be the same</span>
<span class="n">dns</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">arg1</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ctx</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span> <span class="ow">and</span> <span class="n">dns</span><span class="o">.</span><span class="n">context</span> <span class="o">!=</span> <span class="n">ctx</span><span class="p">:</span>
<span class="n">dns</span> <span class="o">=</span> <span class="n">dns</span><span class="o">.</span><span class="n">as_in_context</span><span class="p">(</span><span class="n">ctx</span><span class="p">)</span>
<span class="n">_check_shape</span><span class="p">(</span><span class="n">dns</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">shape</span><span class="p">)</span>
<span class="k">return</span> <span class="n">dns</span><span class="o">.</span><span class="n">tostype</span><span class="p">(</span><span class="s1">'row_sparse'</span><span class="p">)</span></div>
<span class="k">def</span> <span class="nf">_row_sparse_ndarray_from_definition</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">shape</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span>
<span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">indices_type</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""Create a `RowSparseNDArray` based on data and indices"""</span>
<span class="n">storage_type</span> <span class="o">=</span> <span class="s1">'row_sparse'</span>
<span class="c1"># context</span>
<span class="n">ctx</span> <span class="o">=</span> <span class="n">current_context</span><span class="p">()</span> <span class="k">if</span> <span class="n">ctx</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">ctx</span>
<span class="c1"># types</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">_prepare_default_dtype</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="n">indices_type</span> <span class="o">=</span> <span class="n">_STORAGE_AUX_TYPES</span><span class="p">[</span><span class="n">storage_type</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span> <span class="k">if</span> <span class="n">indices_type</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">indices_type</span>
<span class="c1"># prepare src array and types</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">_prepare_src_array</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="n">indices</span> <span class="o">=</span> <span class="n">_prepare_src_array</span><span class="p">(</span><span class="n">indices</span><span class="p">,</span> <span class="n">indices_type</span><span class="p">)</span>
<span class="c1"># TODO(junwu): Convert data, indptr, and indices to mxnet NDArrays</span>
<span class="c1"># if they are not for now. In the future, we should provide a c-api</span>
<span class="c1"># to accept np.ndarray types to copy from to result.data and aux_data</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">data</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="k">if</span> <span class="ow">not</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">indices</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="n">indices</span> <span class="o">=</span> <span class="n">_array</span><span class="p">(</span><span class="n">indices</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="n">indices_type</span><span class="p">)</span>
<span class="k">if</span> <span class="n">shape</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">num_indices</span> <span class="o">=</span> <span class="n">indices</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
<span class="k">if</span> <span class="n">num_indices</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s1">'invalid shape'</span><span class="p">)</span>
<span class="n">dim0</span> <span class="o">=</span> <span class="n">indices</span><span class="p">[</span><span class="n">num_indices</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">asscalar</span><span class="p">()</span> <span class="o">+</span> <span class="mi">1</span>
<span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="n">dim0</span><span class="p">,</span> <span class="p">)</span> <span class="o">+</span> <span class="n">data</span><span class="o">.</span><span class="n">shape</span><span class="p">[</span><span class="mi">1</span><span class="p">:]</span>
<span class="c1"># verify shapes</span>
<span class="k">if</span> <span class="n">data</span><span class="o">.</span><span class="n">ndim</span> <span class="o">!=</span> <span class="nb">len</span><span class="p">(</span><span class="n">shape</span><span class="p">)</span> <span class="ow">or</span> <span class="n">indices</span><span class="o">.</span><span class="n">ndim</span> <span class="o">!=</span> <span class="mi">1</span> <span class="ow">or</span> <span class="n">np</span><span class="o">.</span><span class="n">prod</span><span class="p">(</span><span class="n">shape</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="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"invalid shape"</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">RowSparseNDArray</span><span class="p">(</span><span class="n">_new_alloc_handle</span><span class="p">(</span><span class="n">storage_type</span><span class="p">,</span> <span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="kc">False</span><span class="p">,</span> <span class="n">dtype</span><span class="p">,</span>
<span class="p">[</span><span class="n">indices_type</span><span class="p">],</span> <span class="p">[</span><span class="n">indices</span><span class="o">.</span><span class="n">shape</span><span class="p">]))</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArraySyncCopyFromNDArray</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">data</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">)))</span>
<span class="n">check_call</span><span class="p">(</span><span class="n">_LIB</span><span class="o">.</span><span class="n">MXNDArraySyncCopyFromNDArray</span><span class="p">(</span><span class="n">result</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">indices</span><span class="o">.</span><span class="n">handle</span><span class="p">,</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_int</span><span class="p">(</span><span class="mi">0</span><span class="p">)))</span>
<span class="k">return</span> <span class="n">result</span>
<span class="k">def</span> <span class="nf">_ndarray_cls</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">writable</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">stype</span><span class="o">=</span><span class="n">_STORAGE_TYPE_UNDEFINED</span><span class="p">):</span>
<span class="k">if</span> <span class="n">stype</span> <span class="o">==</span> <span class="n">_STORAGE_TYPE_UNDEFINED</span><span class="p">:</span>
<span class="n">stype</span> <span class="o">=</span> <span class="n">_storage_type</span><span class="p">(</span><span class="n">handle</span><span class="p">)</span>
<span class="k">if</span> <span class="n">stype</span> <span class="o">==</span> <span class="n">_STORAGE_TYPE_DEFAULT</span><span class="p">:</span>
<span class="k">return</span> <span class="n">NDArray</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">writable</span><span class="o">=</span><span class="n">writable</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">stype</span> <span class="o">==</span> <span class="n">_STORAGE_TYPE_CSR</span><span class="p">:</span>
<span class="k">return</span> <span class="n">CSRNDArray</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">writable</span><span class="o">=</span><span class="n">writable</span><span class="p">)</span>
<span class="k">elif</span> <span class="n">stype</span> <span class="o">==</span> <span class="n">_STORAGE_TYPE_ROW_SPARSE</span><span class="p">:</span>
<span class="k">return</span> <span class="n">RowSparseNDArray</span><span class="p">(</span><span class="n">handle</span><span class="p">,</span> <span class="n">writable</span><span class="o">=</span><span class="n">writable</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">"unknown storage type: </span><span class="si">%s</span><span class="s2">"</span><span class="o">%</span><span class="n">stype</span><span class="p">)</span>
<span class="n">_set_ndarray_class</span><span class="p">(</span><span class="n">_ndarray_cls</span><span class="p">)</span>
<div class="viewcode-block" id="add"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.add">[docs]</a><span class="k">def</span> <span class="nf">add</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">rhs</span><span class="p">):</span>
<span class="sd">"""Returns element-wise sum of the input arrays with broadcasting.</span>
<span class="sd"> Equivalent to ``lhs + rhs``, ``mx.nd.broadcast_add(lhs, rhs)`` and</span>
<span class="sd"> ``mx.nd.broadcast_plus(lhs, rhs)`` when shapes of lhs and rhs do not</span>
<span class="sd"> match. If lhs.shape == rhs.shape, this is equivalent to</span>
<span class="sd"> ``mx.nd.elemwise_add(lhs, rhs)``</span>
<span class="sd"> .. note::</span>
<span class="sd"> If the corresponding dimensions of two arrays have the same size or one of them has size 1,</span>
<span class="sd"> then the arrays are broadcastable to a common shape.abs</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> lhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> First array to be added.</span>
<span class="sd"> rhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> Second array to be added.</span>
<span class="sd"> If ``lhs.shape != rhs.shape``, they must be</span>
<span class="sd"> broadcastable to a common shape.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> The element-wise sum of the input arrays.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> a = mx.nd.ones((2,3)).tostype('csr')</span>
<span class="sd"> >>> b = mx.nd.ones((2,3)).tostype('csr')</span>
<span class="sd"> >>> a.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> b.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> (a+b).asnumpy()</span>
<span class="sd"> array([[ 2., 2., 2.],</span>
<span class="sd"> [ 2., 2., 2.]], dtype=float32)</span>
<span class="sd"> >>> c = mx.nd.ones((2,3)).tostype('row_sparse')</span>
<span class="sd"> >>> d = mx.nd.ones((2,3)).tostype('row_sparse')</span>
<span class="sd"> >>> c.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> d.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> (c+d).asnumpy()</span>
<span class="sd"> array([[ 2., 2., 2.],</span>
<span class="sd"> [ 2., 2., 2.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="n">lhs</span><span class="o">.</span><span class="n">shape</span> <span class="o">==</span> <span class="n">rhs</span><span class="o">.</span><span class="n">shape</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">elemwise_add</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_plus_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">broadcast_add</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">add</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_plus_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="subtract"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.subtract">[docs]</a><span class="k">def</span> <span class="nf">subtract</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">rhs</span><span class="p">):</span>
<span class="sd">"""Returns element-wise difference of the input arrays with broadcasting.</span>
<span class="sd"> Equivalent to ``lhs - rhs``, ``mx.nd.broadcast_sub(lhs, rhs)`` and</span>
<span class="sd"> ``mx.nd.broadcast_minus(lhs, rhs)`` when shapes of lhs and rhs do not</span>
<span class="sd"> match. If lhs.shape == rhs.shape, this is equivalent to</span>
<span class="sd"> ``mx.nd.elemwise_sub(lhs, rhs)``</span>
<span class="sd"> .. note::</span>
<span class="sd"> If the corresponding dimensions of two arrays have the same size or one of them has size 1,</span>
<span class="sd"> then the arrays are broadcastable to a common shape.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> lhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> First array to be subtracted.</span>
<span class="sd"> rhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> Second array to be subtracted.</span>
<span class="sd"> If ``lhs.shape != rhs.shape``, they must be</span>
<span class="sd"> broadcastable to a common shape.__spec__</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> The element-wise difference of the input arrays.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> a = mx.nd.ones((2,3)).tostype('csr')</span>
<span class="sd"> >>> b = mx.nd.ones((2,3)).tostype('csr')</span>
<span class="sd"> >>> a.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> b.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> (a-b).asnumpy()</span>
<span class="sd"> array([[ 0., 0., 0.],</span>
<span class="sd"> [ 0., 0., 0.]], dtype=float32)</span>
<span class="sd"> >>> c = mx.nd.ones((2,3)).tostype('row_sparse')</span>
<span class="sd"> >>> d = mx.nd.ones((2,3)).tostype('row_sparse')</span>
<span class="sd"> >>> c.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> d.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> (c-d).asnumpy()</span>
<span class="sd"> array([[ 0., 0., 0.],</span>
<span class="sd"> [ 0., 0., 0.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="n">lhs</span><span class="o">.</span><span class="n">shape</span> <span class="o">==</span> <span class="n">rhs</span><span class="o">.</span><span class="n">shape</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">elemwise_sub</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">sub</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_minus_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">broadcast_sub</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">sub</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_minus_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="multiply"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.multiply">[docs]</a><span class="k">def</span> <span class="nf">multiply</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">rhs</span><span class="p">):</span>
<span class="sd">"""Returns element-wise product of the input arrays with broadcasting.</span>
<span class="sd"> Equivalent to ``lhs * rhs`` and ``mx.nd.broadcast_mul(lhs, rhs)``</span>
<span class="sd"> when shapes of lhs and rhs do not match. If lhs.shape == rhs.shape,</span>
<span class="sd"> this is equivalent to ``mx.nd.elemwise_mul(lhs, rhs)``</span>
<span class="sd"> .. note::</span>
<span class="sd"> If the corresponding dimensions of two arrays have the same size or one of them has size 1,</span>
<span class="sd"> then the arrays are broadcastable to a common shape.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> lhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> First array to be multiplied.</span>
<span class="sd"> rhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> Second array to be multiplied.</span>
<span class="sd"> If ``lhs.shape != rhs.shape``, they must be</span>
<span class="sd"> broadcastable to a common shape.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> The element-wise multiplication of the input arrays.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> x = mx.nd.ones((2,3)).tostype('csr')</span>
<span class="sd"> >>> y = mx.nd.arange(2).reshape((2,1))</span>
<span class="sd"> >>> z = mx.nd.arange(3)</span>
<span class="sd"> >>> x.asnumpy()</span>
<span class="sd"> array([[ 1., 1., 1.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> y.asnumpy()</span>
<span class="sd"> array([[ 0.],</span>
<span class="sd"> [ 1.]], dtype=float32)</span>
<span class="sd"> >>> z.asnumpy()</span>
<span class="sd"> array([ 0., 1., 2.], dtype=float32)</span>
<span class="sd"> >>> (x*2).asnumpy()</span>
<span class="sd"> array([[ 2., 2., 2.],</span>
<span class="sd"> [ 2., 2., 2.]], dtype=float32)</span>
<span class="sd"> >>> (x*y).asnumpy()</span>
<span class="sd"> array([[ 0., 0., 0.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> mx.nd.sparse.multiply(x, y).asnumpy()</span>
<span class="sd"> array([[ 0., 0., 0.],</span>
<span class="sd"> [ 1., 1., 1.]], dtype=float32)</span>
<span class="sd"> >>> (x*z).asnumpy()</span>
<span class="sd"> array([[ 0., 1., 2.],</span>
<span class="sd"> [ 0., 1., 2.]], dtype=float32)</span>
<span class="sd"> >>> mx.nd.sparse.multiply(x, z).asnumpy()</span>
<span class="sd"> array([[ 0., 1., 2.],</span>
<span class="sd"> [ 0., 1., 2.]], dtype=float32)</span>
<span class="sd"> >>> z = z.reshape((1, 3))</span>
<span class="sd"> >>> z.asnumpy()</span>
<span class="sd"> array([[ 0., 1., 2.]], dtype=float32)</span>
<span class="sd"> >>> (x*z).asnumpy()</span>
<span class="sd"> array([[ 0., 1., 2.],</span>
<span class="sd"> [ 0., 1., 2.]], dtype=float32)</span>
<span class="sd"> >>> mx.nd.sparse.multiply(x, z).asnumpy()</span>
<span class="sd"> array([[ 0., 1., 2.],</span>
<span class="sd"> [ 0., 1., 2.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="n">lhs</span><span class="o">.</span><span class="n">shape</span> <span class="o">==</span> <span class="n">rhs</span><span class="o">.</span><span class="n">shape</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">elemwise_mul</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">mul</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_mul_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">broadcast_mul</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">mul</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_mul_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="divide"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.divide">[docs]</a><span class="k">def</span> <span class="nf">divide</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">rhs</span><span class="p">):</span>
<span class="sd">"""Returns element-wise division of the input arrays with broadcasting.</span>
<span class="sd"> Equivalent to ``lhs / rhs`` and ``mx.nd.broadcast_div(lhs, rhs)``</span>
<span class="sd"> when shapes of lhs and rhs do not match. If lhs.shape == rhs.shape,</span>
<span class="sd"> this is equivalent to ``mx.nd.elemwise_div(lhs, rhs)``</span>
<span class="sd"> .. note::</span>
<span class="sd"> If the corresponding dimensions of two arrays have the same size or one of them has size 1,</span>
<span class="sd"> then the arrays are broadcastable to a common shape.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> lhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> First array in division.</span>
<span class="sd"> rhs : scalar or mxnet.ndarray.sparse.array</span>
<span class="sd"> Second array in division.</span>
<span class="sd"> The arrays to be divided. If ``lhs.shape != rhs.shape``, they must be</span>
<span class="sd"> broadcastable to a common shape.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> NDArray</span>
<span class="sd"> The element-wise division of the input arrays.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> x = (mx.nd.ones((2,3))*6).tostype('csr')</span>
<span class="sd"> >>> y = mx.nd.arange(2).reshape((2,1)) + 1</span>
<span class="sd"> >>> z = mx.nd.arange(3) + 1</span>
<span class="sd"> >>> x.asnumpy()</span>
<span class="sd"> array([[ 6., 6., 6.],</span>
<span class="sd"> [ 6., 6., 6.]], dtype=float32)</span>
<span class="sd"> >>> y.asnumpy()</span>
<span class="sd"> array([[ 1.],</span>
<span class="sd"> [ 2.]], dtype=float32)</span>
<span class="sd"> >>> z.asnumpy()</span>
<span class="sd"> array([ 1., 2., 3.], dtype=float32)</span>
<span class="sd"> >>> x/2</span>
<span class="sd"> <NDArray 2x3 @cpu(0)></span>
<span class="sd"> >>> (x/3).asnumpy()</span>
<span class="sd"> array([[ 2., 2., 2.],</span>
<span class="sd"> [ 2., 2., 2.]], dtype=float32)</span>
<span class="sd"> >>> (x/y).asnumpy()</span>
<span class="sd"> array([[ 6., 6., 6.],</span>
<span class="sd"> [ 3., 3., 3.]], dtype=float32)</span>
<span class="sd"> >>> mx.nd.sparse.divide(x,y).asnumpy()</span>
<span class="sd"> array([[ 6., 6., 6.],</span>
<span class="sd"> [ 3., 3., 3.]], dtype=float32)</span>
<span class="sd"> >>> (x/z).asnumpy()</span>
<span class="sd"> array([[ 6., 3., 2.],</span>
<span class="sd"> [ 6., 3., 2.]], dtype=float32)</span>
<span class="sd"> >>> mx.nd.sprase.divide(x,z).asnumpy()</span>
<span class="sd"> array([[ 6., 3., 2.],</span>
<span class="sd"> [ 6., 3., 2.]], dtype=float32)</span>
<span class="sd"> >>> z = z.reshape((1,3))</span>
<span class="sd"> >>> z.asnumpy()</span>
<span class="sd"> array([[ 1., 2., 3.]], dtype=float32)</span>
<span class="sd"> >>> (x/z).asnumpy()</span>
<span class="sd"> array([[ 6., 3., 2.],</span>
<span class="sd"> [ 6., 3., 2.]], dtype=float32)</span>
<span class="sd"> >>> mx.nd.sparse.divide(x,z).asnumpy()</span>
<span class="sd"> array([[ 6., 3., 2.],</span>
<span class="sd"> [ 6., 3., 2.]], dtype=float32)</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">lhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">rhs</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">)</span> <span class="ow">and</span> <span class="n">lhs</span><span class="o">.</span><span class="n">shape</span> <span class="o">==</span> <span class="n">rhs</span><span class="o">.</span><span class="n">shape</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">elemwise_div</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">truediv</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_div_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span>
<span class="k">return</span> <span class="n">_ufunc_helper</span><span class="p">(</span>
<span class="n">lhs</span><span class="p">,</span>
<span class="n">rhs</span><span class="p">,</span>
<span class="n">op</span><span class="o">.</span><span class="n">broadcast_div</span><span class="p">,</span>
<span class="n">operator</span><span class="o">.</span><span class="n">truediv</span><span class="p">,</span>
<span class="n">_internal</span><span class="o">.</span><span class="n">_div_scalar</span><span class="p">,</span>
<span class="kc">None</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="zeros"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.zeros">[docs]</a><span class="k">def</span> <span class="nf">zeros</span><span class="p">(</span><span class="n">stype</span><span class="p">,</span> <span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">):</span>
<span class="sd">"""Return a new array of given shape and type, filled with zeros.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> stype: string</span>
<span class="sd"> The storage type of the empty array, such as 'row_sparse', 'csr', etc</span>
<span class="sd"> shape : int or tuple of int</span>
<span class="sd"> The shape of the empty array</span>
<span class="sd"> ctx : Context, optional</span>
<span class="sd"> An optional device context (default is the current default context)</span>
<span class="sd"> dtype : str or numpy.dtype, optional</span>
<span class="sd"> An optional value type (default is `float32`)</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> RowSparseNDArray or CSRNDArray</span>
<span class="sd"> A created array</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> mx.nd.sparse.zeros('csr', (1,2))</span>
<span class="sd"> <CSRNDArray 1x2 @cpu(0)></span>
<span class="sd"> >>> mx.nd.sparse.zeros('row_sparse', (1,2), ctx=mx.cpu(), dtype='float16').asnumpy()</span>
<span class="sd"> array([[ 0., 0.]], dtype=float16)</span>
<span class="sd"> """</span>
<span class="c1"># pylint: disable= no-member, protected-access</span>
<span class="k">if</span> <span class="n">stype</span> <span class="o">==</span> <span class="s1">'default'</span><span class="p">:</span>
<span class="k">return</span> <span class="n">_zeros_ndarray</span><span class="p">(</span><span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
<span class="k">if</span> <span class="n">ctx</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">ctx</span> <span class="o">=</span> <span class="n">current_context</span><span class="p">()</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">mx_real_t</span> <span class="k">if</span> <span class="n">dtype</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">dtype</span>
<span class="k">if</span> <span class="n">stype</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'row_sparse'</span><span class="p">,</span> <span class="s1">'csr'</span><span class="p">):</span>
<span class="n">aux_types</span> <span class="o">=</span> <span class="n">_STORAGE_AUX_TYPES</span><span class="p">[</span><span class="n">stype</span><span class="p">]</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"unknown storage type"</span> <span class="o">+</span> <span class="n">stype</span><span class="p">)</span>
<span class="n">out</span> <span class="o">=</span> <span class="n">_ndarray_cls</span><span class="p">(</span><span class="n">_new_alloc_handle</span><span class="p">(</span><span class="n">stype</span><span class="p">,</span> <span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="p">,</span> <span class="kc">True</span><span class="p">,</span> <span class="n">dtype</span><span class="p">,</span> <span class="n">aux_types</span><span class="p">))</span>
<span class="k">return</span> <span class="n">_internal</span><span class="o">.</span><span class="n">_zeros</span><span class="p">(</span><span class="n">shape</span><span class="o">=</span><span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">,</span> <span class="n">out</span><span class="o">=</span><span class="n">out</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span></div>
<span class="c1"># pylint: enable= no-member, protected-access</span>
<div class="viewcode-block" id="empty"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.empty">[docs]</a><span class="k">def</span> <span class="nf">empty</span><span class="p">(</span><span class="n">stype</span><span class="p">,</span> <span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""Returns a new array of given shape and type, without initializing entries.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> stype: string</span>
<span class="sd"> The storage type of the empty array, such as 'row_sparse', 'csr', etc</span>
<span class="sd"> shape : int or tuple of int</span>
<span class="sd"> The shape of the empty array.</span>
<span class="sd"> ctx : Context, optional</span>
<span class="sd"> An optional device context (default is the current default context).</span>
<span class="sd"> dtype : str or numpy.dtype, optional</span>
<span class="sd"> An optional value type (default is `float32`).</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> CSRNDArray or RowSparseNDArray</span>
<span class="sd"> A created array.</span>
<span class="sd"> """</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">shape</span><span class="p">,</span> <span class="nb">int</span><span class="p">):</span>
<span class="n">shape</span> <span class="o">=</span> <span class="p">(</span><span class="n">shape</span><span class="p">,</span> <span class="p">)</span>
<span class="k">if</span> <span class="n">ctx</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">ctx</span> <span class="o">=</span> <span class="n">current_context</span><span class="p">()</span>
<span class="k">if</span> <span class="n">dtype</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">mx_real_t</span>
<span class="k">assert</span><span class="p">(</span><span class="n">stype</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">)</span>
<span class="k">if</span> <span class="n">stype</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">'csr'</span><span class="p">,</span> <span class="s1">'row_sparse'</span><span class="p">):</span>
<span class="k">return</span> <span class="n">zeros</span><span class="p">(</span><span class="n">stype</span><span class="p">,</span> <span class="n">shape</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">"unknown stype : "</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="n">stype</span><span class="p">))</span></div>
<div class="viewcode-block" id="array"><a class="viewcode-back" href="../../../api/python/ndarray/sparse.html#mxnet.ndarray.sparse.array">[docs]</a><span class="k">def</span> <span class="nf">array</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
<span class="sd">"""Creates a sparse array from any object exposing the array interface.</span>
<span class="sd"> Parameters</span>
<span class="sd"> ----------</span>
<span class="sd"> source_array : RowSparseNDArray, CSRNDArray or scipy.sparse.csr.csr_matrix</span>
<span class="sd"> The source sparse array</span>
<span class="sd"> ctx : Context, optional</span>
<span class="sd"> The default context is ``source_array.context`` if ``source_array`` is an NDArray. \</span>
<span class="sd"> The current default context otherwise.</span>
<span class="sd"> dtype : str or numpy.dtype, optional</span>
<span class="sd"> The data type of the output array. The default dtype is ``source_array.dtype``</span>
<span class="sd"> if `source_array` is an `NDArray`, `numpy.ndarray` or `scipy.sparse.csr.csr_matrix`, \</span>
<span class="sd"> `float32` otherwise.</span>
<span class="sd"> Returns</span>
<span class="sd"> -------</span>
<span class="sd"> RowSparseNDArray or CSRNDArray</span>
<span class="sd"> An array with the same contents as the `source_array`.</span>
<span class="sd"> Examples</span>
<span class="sd"> --------</span>
<span class="sd"> >>> import scipy.sparse as spsp</span>
<span class="sd"> >>> csr = spsp.csr_matrix((2, 100))</span>
<span class="sd"> >>> mx.nd.sparse.array(csr)</span>
<span class="sd"> <CSRNDArray 2x100 @cpu(0)></span>
<span class="sd"> >>> mx.nd.sparse.array(mx.nd.sparse.zeros('csr', (3, 2)))</span>
<span class="sd"> <CSRNDArray 3x2 @cpu(0)></span>
<span class="sd"> >>> mx.nd.sparse.array(mx.nd.sparse.zeros('row_sparse', (3, 2)))</span>
<span class="sd"> <RowSparseNDArray 3x2 @cpu(0)></span>
<span class="sd"> """</span>
<span class="n">ctx</span> <span class="o">=</span> <span class="n">current_context</span><span class="p">()</span> <span class="k">if</span> <span class="n">ctx</span> <span class="ow">is</span> <span class="kc">None</span> <span class="k">else</span> <span class="n">ctx</span>
<span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">NDArray</span><span class="p">):</span>
<span class="k">assert</span><span class="p">(</span><span class="n">source_array</span><span class="o">.</span><span class="n">stype</span> <span class="o">!=</span> <span class="s1">'default'</span><span class="p">),</span> \
<span class="s2">"Please use `tostype` to create RowSparseNDArray or CSRNDArray from an NDArray"</span>
<span class="c1"># prepare dtype and ctx based on source_array, if not provided</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">_prepare_default_dtype</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="c1"># if both dtype and ctx are different from source_array, we cannot copy directly</span>
<span class="k">if</span> <span class="n">source_array</span><span class="o">.</span><span class="n">dtype</span> <span class="o">!=</span> <span class="n">dtype</span> <span class="ow">and</span> <span class="n">source_array</span><span class="o">.</span><span class="n">context</span> <span class="o">!=</span> <span class="n">ctx</span><span class="p">:</span>
<span class="n">arr</span> <span class="o">=</span> <span class="n">empty</span><span class="p">(</span><span class="n">source_array</span><span class="o">.</span><span class="n">stype</span><span class="p">,</span> <span class="n">source_array</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">)</span>
<span class="n">arr</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">source_array</span>
<span class="n">arr</span> <span class="o">=</span> <span class="n">arr</span><span class="o">.</span><span class="n">as_in_context</span><span class="p">(</span><span class="n">ctx</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="n">arr</span> <span class="o">=</span> <span class="n">empty</span><span class="p">(</span><span class="n">source_array</span><span class="o">.</span><span class="n">stype</span><span class="p">,</span> <span class="n">source_array</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">)</span>
<span class="n">arr</span><span class="p">[:]</span> <span class="o">=</span> <span class="n">source_array</span>
<span class="k">return</span> <span class="n">arr</span>
<span class="k">elif</span> <span class="n">spsp</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">spsp</span><span class="o">.</span><span class="n">csr</span><span class="o">.</span><span class="n">csr_matrix</span><span class="p">):</span>
<span class="c1"># TODO(haibin) implement `_sync_copy_from` with scipy csr object to reduce a copy</span>
<span class="c1"># preprocess scipy csr to canonical form</span>
<span class="n">csr</span> <span class="o">=</span> <span class="n">source_array</span><span class="o">.</span><span class="n">sorted_indices</span><span class="p">()</span>
<span class="n">csr</span><span class="o">.</span><span class="n">sum_duplicates</span><span class="p">()</span>
<span class="n">dtype</span> <span class="o">=</span> <span class="n">_prepare_default_dtype</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="n">dtype</span><span class="p">)</span>
<span class="k">return</span> <span class="n">csr_matrix</span><span class="p">((</span><span class="n">csr</span><span class="o">.</span><span class="n">data</span><span class="p">,</span> <span class="n">csr</span><span class="o">.</span><span class="n">indices</span><span class="p">,</span> <span class="n">csr</span><span class="o">.</span><span class="n">indptr</span><span class="p">),</span> <span class="n">shape</span><span class="o">=</span><span class="n">csr</span><span class="o">.</span><span class="n">shape</span><span class="p">,</span> \
<span class="n">dtype</span><span class="o">=</span><span class="n">dtype</span><span class="p">,</span> <span class="n">ctx</span><span class="o">=</span><span class="n">ctx</span><span class="p">)</span>
<span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">source_array</span><span class="p">,</span> <span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">ndarray</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">generic</span><span class="p">)):</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Please use mx.nd.array to create an NDArray with source_array of type "</span><span class="p">,</span>
<span class="nb">type</span><span class="p">(</span><span class="n">source_array</span><span class="p">))</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="s2">"Unexpected source_array type: "</span><span class="p">,</span> <span class="nb">type</span><span class="p">(</span><span class="n">source_array</span><span class="p">))</span></div>
</pre></div>
</div>
</div>
<div aria-label="main navigation" class="sphinxsidebar rightsidebar" role="navigation">
<div class="sphinxsidebarwrapper">
</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-2018, 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 src="../../../_static/js/docversion.js" type="text/javascript"></script>
<script type="text/javascript">
$('body').ready(function () {
$('body').css('visibility', 'visible');
});
</script>
</body>
</html>