1.1.0/torch.html



<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
  <meta name="robots" content="noindex">
  <meta charset="utf-8">
  
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  
  <title>torch &mdash; PyTorch master documentation</title>
  

    <link rel="canonical" href="https://pytorch.org/docs/stable/torch.html"/>
  

  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
  <!-- <link rel="stylesheet" href="_static/pygments.css" type="text/css" /> -->
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.0-beta/dist/katex.min.css" type="text/css" />
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css" type="text/css" />
  <link rel="stylesheet" href="_static/katex-math.css" type="text/css" />
    <link rel="index" title="Index" href="genindex.html" />
    <link rel="search" title="Search" href="search.html" />
    <link rel="next" title="torch.Tensor" href="tensors.html" />
    <link rel="prev" title="PyTorch Governance | Persons of Interest" href="community/persons_of_interest.html" /> 

  
  <script src="_static/js/modernizr.min.js"></script>
</head>

<div class="container-fluid header-holder tutorials-header" id="header-holder">
  <div class="container">
    <div class="header-container">
      <a class="header-logo" href="https://pytorch.org/" aria-label="PyTorch"></a>

      <div class="main-menu">
        <ul>
          <li>
            <a href="https://pytorch.org/get-started">Get Started</a>
          </li>

          <li>
            <a href="https://pytorch.org/features">Features</a>
          </li>

          <li>
            <a href="https://pytorch.org/ecosystem">Ecosystem</a>
          </li>

          <li>
            <a href="https://pytorch.org/blog/">Blog</a>
          </li>

          <li>
            <a href="https://pytorch.org/tutorials">Tutorials</a>
          </li>

          <li class="active">
            <a href="https://pytorch.org/docs/stable/index.html">Docs</a>
          </li>

          <li>
            <a href="https://pytorch.org/resources">Resources</a>
          </li>

          <li>
            <a href="https://github.com/pytorch/pytorch">Github</a>
          </li>
        </ul>
      </div>

      <a class="main-menu-open-button" href="#" data-behavior="open-mobile-menu"></a>
    </div>

  </div>
</div>


<body class="pytorch-body">

   
    <div class="table-of-contents-link-wrapper">
      <span>Table of Contents</span>
      <a href="#" class="toggle-table-of-contents" data-behavior="toggle-table-of-contents"></a>
    </div>

    <nav data-toggle="wy-nav-shift" class="pytorch-left-menu" id="pytorch-left-menu">
      <div class="pytorch-side-scroll">
        <div class="pytorch-menu pytorch-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          <div class="pytorch-left-menu-search">
            

                <div class="version">
                  <a href='http://pytorch.org/docs/versions.html'>1.1.0 &#x25BC</a>
                </div>
              
            
<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search Docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

            
          </div>

          
              <p class="caption"><span class="caption-text">Notes</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="notes/autograd.html">Autograd mechanics</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/broadcasting.html">Broadcasting semantics</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/cuda.html">CUDA semantics</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/extending.html">Extending PyTorch</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/faq.html">Frequently Asked Questions</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/multiprocessing.html">Multiprocessing best practices</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/randomness.html">Reproducibility</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/serialization.html">Serialization semantics</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/windows.html">Windows FAQ</a></li>
</ul>
<p class="caption"><span class="caption-text">Community</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="community/contribution_guide.html">PyTorch Contribution Guide</a></li>
<li class="toctree-l1"><a class="reference internal" href="community/governance.html">PyTorch Governance</a></li>
<li class="toctree-l1"><a class="reference internal" href="community/persons_of_interest.html">PyTorch Governance | Persons of Interest</a></li>
</ul>
<p class="caption"><span class="caption-text">Package Reference</span></p>
<ul class="current">
<li class="toctree-l1 current"><a class="current reference internal" href="#">torch</a></li>
<li class="toctree-l1"><a class="reference internal" href="tensors.html">torch.Tensor</a></li>
<li class="toctree-l1"><a class="reference internal" href="tensor_attributes.html">Tensor Attributes</a></li>
<li class="toctree-l1"><a class="reference internal" href="type_info.html">Type Info</a></li>
<li class="toctree-l1"><a class="reference internal" href="sparse.html">torch.sparse</a></li>
<li class="toctree-l1"><a class="reference internal" href="cuda.html">torch.cuda</a></li>
<li class="toctree-l1"><a class="reference internal" href="storage.html">torch.Storage</a></li>
<li class="toctree-l1"><a class="reference internal" href="nn.html">torch.nn</a></li>
<li class="toctree-l1"><a class="reference internal" href="nn.html#torch-nn-functional">torch.nn.functional</a></li>
<li class="toctree-l1"><a class="reference internal" href="nn.html#torch-nn-init">torch.nn.init</a></li>
<li class="toctree-l1"><a class="reference internal" href="optim.html">torch.optim</a></li>
<li class="toctree-l1"><a class="reference internal" href="autograd.html">torch.autograd</a></li>
<li class="toctree-l1"><a class="reference internal" href="distributed.html">torch.distributed</a></li>
<li class="toctree-l1"><a class="reference internal" href="distributions.html">torch.distributions</a></li>
<li class="toctree-l1"><a class="reference internal" href="hub.html">torch.hub</a></li>
<li class="toctree-l1"><a class="reference internal" href="jit.html">torch.jit</a></li>
<li class="toctree-l1"><a class="reference internal" href="multiprocessing.html">torch.multiprocessing</a></li>
<li class="toctree-l1"><a class="reference internal" href="bottleneck.html">torch.utils.bottleneck</a></li>
<li class="toctree-l1"><a class="reference internal" href="checkpoint.html">torch.utils.checkpoint</a></li>
<li class="toctree-l1"><a class="reference internal" href="cpp_extension.html">torch.utils.cpp_extension</a></li>
<li class="toctree-l1"><a class="reference internal" href="data.html">torch.utils.data</a></li>
<li class="toctree-l1"><a class="reference internal" href="dlpack.html">torch.utils.dlpack</a></li>
<li class="toctree-l1"><a class="reference internal" href="model_zoo.html">torch.utils.model_zoo</a></li>
<li class="toctree-l1"><a class="reference internal" href="tensorboard.html">torch.utils.tensorboard (experimental)</a></li>
<li class="toctree-l1"><a class="reference internal" href="onnx.html">torch.onnx</a></li>
<li class="toctree-l1"><a class="reference internal" href="__config__.html">torch.__config__</a></li>
<li class="toctree-l1"><a class="reference internal" href="distributed_deprecated.html">torch.distributed.deprecated</a></li>
</ul>
<p class="caption"><span class="caption-text">torchvision Reference</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="torchvision/index.html">torchvision</a></li>
</ul>

            
        </div>
      </div>
    </nav>

    <div class="pytorch-container">
      <div class="pytorch-page-level-bar" id="pytorch-page-level-bar">
        <div class="pytorch-breadcrumbs-wrapper">
          

<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="pytorch-breadcrumbs">
    
      <li>
        <a href="index.html">
          
            Docs
          
        </a> &gt;
      </li>

        
      <li>torch</li>
    
    
      <li class="pytorch-breadcrumbs-aside">
        
            
            <a href="_sources/torch.rst.txt" rel="nofollow"><img src="_static/images/view-page-source-icon.svg"></a>
          
        
      </li>
    
  </ul>

  
</div>
        </div>

        <div class="pytorch-shortcuts-wrapper" id="pytorch-shortcuts-wrapper">
          Shortcuts
        </div>
      </div>

      <section data-toggle="wy-nav-shift" id="pytorch-content-wrap" class="pytorch-content-wrap">
        <div class="pytorch-content-left">

        
          <div class="rst-content">
          
            <div role="main" class="main-content" itemscope="itemscope" itemtype="http://schema.org/Article">
             <article itemprop="articleBody" id="pytorch-article" class="pytorch-article">
              
  <div class="section" id="module-torch">
<span id="torch"></span><h1>torch<a class="headerlink" href="#module-torch" title="Permalink to this headline">¶</a></h1>
<p>The torch package contains data structures for multi-dimensional
tensors and mathematical operations over these are defined.
Additionally, it provides many utilities for efficient serializing of
Tensors and arbitrary types, and other useful utilities.</p>
<p>It has a CUDA counterpart, that enables you to run your tensor computations
on an NVIDIA GPU with compute capability &gt;= 3.0.</p>
<div class="section" id="tensors">
<h2>Tensors<a class="headerlink" href="#tensors" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="torch.is_tensor">
<code class="descclassname">torch.</code><code class="descname">is_tensor</code><span class="sig-paren">(</span><em>obj</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch.html#is_tensor"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.is_tensor" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns True if <cite>obj</cite> is a PyTorch tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>obj</strong> (<em>Object</em>) – Object to test</p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.is_storage">
<code class="descclassname">torch.</code><code class="descname">is_storage</code><span class="sig-paren">(</span><em>obj</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch.html#is_storage"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.is_storage" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns True if <cite>obj</cite> is a PyTorch storage object.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>obj</strong> (<em>Object</em>) – Object to test</p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.is_floating_point">
<code class="descclassname">torch.</code><code class="descname">is_floating_point</code><span class="sig-paren">(</span><em>tensor) -&gt; (bool</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.is_floating_point" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns True if the data type of <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a> is a floating point data type i.e.,
one of <code class="docutils literal notranslate"><span class="pre">torch.float64</span></code>, <code class="docutils literal notranslate"><span class="pre">torch.float32</span></code> and <code class="docutils literal notranslate"><span class="pre">torch.float16</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the PyTorch tensor to test</p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.set_default_dtype">
<code class="descclassname">torch.</code><code class="descname">set_default_dtype</code><span class="sig-paren">(</span><em>d</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch.html#set_default_dtype"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.set_default_dtype" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the default floating point dtype to <code class="xref py py-attr docutils literal notranslate"><span class="pre">d</span></code>. This type will be
used as default floating point type for type inference in
<a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.tensor()</span></code></a>.</p>
<p>The default floating point dtype is initially <code class="docutils literal notranslate"><span class="pre">torch.float32</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>d</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>) – the floating point dtype to make the default</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span><span class="o">.</span><span class="n">dtype</span>           <span class="c1"># initial default for floating point is torch.float32</span>
<span class="go">torch.float32</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_default_dtype</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float64</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span><span class="o">.</span><span class="n">dtype</span>           <span class="c1"># a new floating point tensor</span>
<span class="go">torch.float64</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.get_default_dtype">
<code class="descclassname">torch.</code><code class="descname">get_default_dtype</code><span class="sig-paren">(</span><span class="sig-paren">)</span> &#x2192; torch.dtype<a class="headerlink" href="#torch.get_default_dtype" title="Permalink to this definition">¶</a></dt>
<dd><p>Get the current default floating point <a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>.</p>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">get_default_dtype</span><span class="p">()</span>  <span class="c1"># initial default for floating point is torch.float32</span>
<span class="go">torch.float32</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_default_dtype</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float64</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">get_default_dtype</span><span class="p">()</span>  <span class="c1"># default is now changed to torch.float64</span>
<span class="go">torch.float64</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_default_tensor_type</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">FloatTensor</span><span class="p">)</span>  <span class="c1"># setting tensor type also affects this</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">get_default_dtype</span><span class="p">()</span>  <span class="c1"># changed to torch.float32, the dtype for torch.FloatTensor</span>
<span class="go">torch.float32</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.set_default_tensor_type">
<code class="descclassname">torch.</code><code class="descname">set_default_tensor_type</code><span class="sig-paren">(</span><em>t</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch.html#set_default_tensor_type"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.set_default_tensor_type" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the default <code class="docutils literal notranslate"><span class="pre">torch.Tensor</span></code> type to floating point tensor type
<a class="reference internal" href="#torch.t" title="torch.t"><code class="xref py py-attr docutils literal notranslate"><span class="pre">t</span></code></a>. This type will also be used as default floating point type for
type inference in <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.tensor()</span></code></a>.</p>
<p>The default floating point tensor type is initially <code class="docutils literal notranslate"><span class="pre">torch.FloatTensor</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>t</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#type" title="(in Python v3.7)"><em>type</em></a><em> or </em><em>string</em>) – the floating point tensor type or its name</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span><span class="o">.</span><span class="n">dtype</span>    <span class="c1"># initial default for floating point is torch.float32</span>
<span class="go">torch.float32</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_default_tensor_type</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">DoubleTensor</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span><span class="o">.</span><span class="n">dtype</span>    <span class="c1"># a new floating point tensor</span>
<span class="go">torch.float64</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.numel">
<code class="descclassname">torch.</code><code class="descname">numel</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; int<a class="headerlink" href="#torch.numel" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the total number of elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">numel</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">120</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">numel</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">16</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.set_printoptions">
<code class="descclassname">torch.</code><code class="descname">set_printoptions</code><span class="sig-paren">(</span><em>precision=None</em>, <em>threshold=None</em>, <em>edgeitems=None</em>, <em>linewidth=None</em>, <em>profile=None</em>, <em>sci_mode=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/_tensor_str.html#set_printoptions"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.set_printoptions" title="Permalink to this definition">¶</a></dt>
<dd><p>Set options for printing. Items shamelessly taken from NumPy</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>precision</strong> – Number of digits of precision for floating point output
(default = 4).</p></li>
<li><p><strong>threshold</strong> – Total number of array elements which trigger summarization
rather than full <cite>repr</cite> (default = 1000).</p></li>
<li><p><strong>edgeitems</strong> – Number of array items in summary at beginning and end of
each dimension (default = 3).</p></li>
<li><p><strong>linewidth</strong> – The number of characters per line for the purpose of
inserting line breaks (default = 80). Thresholded matrices will
ignore this parameter.</p></li>
<li><p><strong>profile</strong> – Sane defaults for pretty printing. Can override with any of
the above options. (any one of <cite>default</cite>, <cite>short</cite>, <cite>full</cite>)</p></li>
<li><p><strong>sci_mode</strong> – Enable (True) or disable (False) scientific notation. If
None (default) is specified, the value is defined by <cite>_Formatter</cite></p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.set_flush_denormal">
<code class="descclassname">torch.</code><code class="descname">set_flush_denormal</code><span class="sig-paren">(</span><em>mode</em><span class="sig-paren">)</span> &#x2192; bool<a class="headerlink" href="#torch.set_flush_denormal" title="Permalink to this definition">¶</a></dt>
<dd><p>Disables denormal floating numbers on CPU.</p>
<p>Returns <code class="docutils literal notranslate"><span class="pre">True</span></code> if your system supports flushing denormal numbers and it
successfully configures flush denormal mode.  <a class="reference internal" href="#torch.set_flush_denormal" title="torch.set_flush_denormal"><code class="xref py py-meth docutils literal notranslate"><span class="pre">set_flush_denormal()</span></code></a>
is only supported on x86 architectures supporting SSE3.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>mode</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – Controls whether to enable flush denormal mode or not</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_flush_denormal</span><span class="p">(</span><span class="kc">True</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1e-323</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">float64</span><span class="p">)</span>
<span class="go">tensor([ 0.], dtype=torch.float64)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_flush_denormal</span><span class="p">(</span><span class="kc">False</span><span class="p">)</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1e-323</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">float64</span><span class="p">)</span>
<span class="go">tensor(9.88131e-324 *</span>
<span class="go">       [ 1.0000], dtype=torch.float64)</span>
</pre></div>
</div>
</dd></dl>

<div class="section" id="creation-ops">
<span id="tensor-creation-ops"></span><h3>Creation Ops<a class="headerlink" href="#creation-ops" title="Permalink to this headline">¶</a></h3>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Random sampling creation ops are listed under <a class="reference internal" href="#random-sampling"><span class="std std-ref">Random sampling</span></a> and
include:
<a class="reference internal" href="#torch.rand" title="torch.rand"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.rand()</span></code></a>
<a class="reference internal" href="#torch.rand_like" title="torch.rand_like"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.rand_like()</span></code></a>
<a class="reference internal" href="#torch.randn" title="torch.randn"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.randn()</span></code></a>
<a class="reference internal" href="#torch.randn_like" title="torch.randn_like"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.randn_like()</span></code></a>
<a class="reference internal" href="#torch.randint" title="torch.randint"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.randint()</span></code></a>
<a class="reference internal" href="#torch.randint_like" title="torch.randint_like"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.randint_like()</span></code></a>
<a class="reference internal" href="#torch.randperm" title="torch.randperm"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.randperm()</span></code></a>
You may also use <a class="reference internal" href="#torch.empty" title="torch.empty"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.empty()</span></code></a> with the <a class="reference internal" href="#inplace-random-sampling"><span class="std std-ref">In-place random sampling</span></a>
methods to create <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.Tensor</span></code></a> s with values sampled from a broader
range of distributions.</p>
</div>
<dl class="function">
<dt id="torch.tensor">
<code class="descclassname">torch.</code><code class="descname">tensor</code><span class="sig-paren">(</span><em>data</em>, <em>dtype=None</em>, <em>device=None</em>, <em>requires_grad=False</em>, <em>pin_memory=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.tensor" title="Permalink to this definition">¶</a></dt>
<dd><p>Constructs a tensor with <code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.tensor()</span></code></a> always copies <code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code>. If you have a Tensor
<code class="docutils literal notranslate"><span class="pre">data</span></code> and want to avoid a copy, use <a class="reference internal" href="tensors.html#torch.Tensor.requires_grad_" title="torch.Tensor.requires_grad_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.requires_grad_()</span></code></a>
or <a class="reference internal" href="tensors.html#torch.Tensor.detach" title="torch.Tensor.detach"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.detach()</span></code></a>.
If you have a NumPy <code class="docutils literal notranslate"><span class="pre">ndarray</span></code> and want to avoid a copy, use
<a class="reference internal" href="#torch.as_tensor" title="torch.as_tensor"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.as_tensor()</span></code></a>.</p>
</div>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>When data is a tensor <cite>x</cite>, <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.tensor()</span></code></a> reads out ‘the data’ from whatever it is passed,
and constructs a leaf variable. Therefore <code class="docutils literal notranslate"><span class="pre">torch.tensor(x)</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">x.clone().detach()</span></code>
and <code class="docutils literal notranslate"><span class="pre">torch.tensor(x,</span> <span class="pre">requires_grad=True)</span></code> is equivalent to <code class="docutils literal notranslate"><span class="pre">x.clone().detach().requires_grad_(True)</span></code>.
The equivalents using <code class="docutils literal notranslate"><span class="pre">clone()</span></code> and <code class="docutils literal notranslate"><span class="pre">detach()</span></code> are recommended.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>data</strong> (<em>array_like</em>) – Initial data for the tensor. Can be a list, tuple,
NumPy <code class="docutils literal notranslate"><span class="pre">ndarray</span></code>, scalar, and other types.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, infers data type from <code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
<li><p><strong>pin_memory</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If set, returned tensor would be allocated in
the pinned memory. Works only for CPU tensors. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">0.1</span><span class="p">,</span> <span class="mf">1.2</span><span class="p">],</span> <span class="p">[</span><span class="mf">2.2</span><span class="p">,</span> <span class="mf">3.1</span><span class="p">],</span> <span class="p">[</span><span class="mf">4.9</span><span class="p">,</span> <span class="mf">5.2</span><span class="p">]])</span>
<span class="go">tensor([[ 0.1000,  1.2000],</span>
<span class="go">        [ 2.2000,  3.1000],</span>
<span class="go">        [ 4.9000,  5.2000]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>  <span class="c1"># Type inference on data</span>
<span class="go">tensor([ 0,  1])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">0.11111</span><span class="p">,</span> <span class="mf">0.222222</span><span class="p">,</span> <span class="mf">0.3333333</span><span class="p">]],</span>
<span class="go">                 dtype=torch.float64,</span>
<span class="go">                 device=torch.device(&#39;cuda:0&#39;))  # creates a torch.cuda.DoubleTensor</span>
<span class="go">tensor([[ 0.1111,  0.2222,  0.3333]], dtype=torch.float64, device=&#39;cuda:0&#39;)</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="mf">3.14159</span><span class="p">)</span>  <span class="c1"># Create a scalar (zero-dimensional tensor)</span>
<span class="go">tensor(3.1416)</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([])</span>  <span class="c1"># Create an empty tensor (of size (0,))</span>
<span class="go">tensor([])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sparse_coo_tensor">
<code class="descclassname">torch.</code><code class="descname">sparse_coo_tensor</code><span class="sig-paren">(</span><em>indices</em>, <em>values</em>, <em>size=None</em>, <em>dtype=None</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.sparse_coo_tensor" title="Permalink to this definition">¶</a></dt>
<dd><p>Constructs a sparse tensors in COO(rdinate) format with non-zero elements at the given <code class="xref py py-attr docutils literal notranslate"><span class="pre">indices</span></code>
with the given <code class="xref py py-attr docutils literal notranslate"><span class="pre">values</span></code>. A sparse tensor can be <cite>uncoalesced</cite>, in that case, there are duplicate
coordinates in the indices, and the value at that index is the sum of all duplicate value entries:
<a class="reference external" href="https://pytorch.org/docs/stable/sparse.html">torch.sparse</a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>indices</strong> (<em>array_like</em>) – Initial data for the tensor. Can be a list, tuple,
NumPy <code class="docutils literal notranslate"><span class="pre">ndarray</span></code>, scalar, and other types. Will be cast to a <code class="xref py py-class docutils literal notranslate"><span class="pre">torch.LongTensor</span></code>
internally. The indices are the coordinates of the non-zero values in the matrix, and thus
should be two-dimensional where the first dimension is the number of tensor dimensions and
the second dimension is the number of non-zero values.</p></li>
<li><p><strong>values</strong> (<em>array_like</em>) – Initial values for the tensor. Can be a list, tuple,
NumPy <code class="docutils literal notranslate"><span class="pre">ndarray</span></code>, scalar, and other types.</p></li>
<li><p><strong>size</strong> (list, tuple, or <code class="xref py py-class docutils literal notranslate"><span class="pre">torch.Size</span></code>, optional) – Size of the sparse tensor. If not
provided the size will be inferred as the minimum size big enough to hold all non-zero
elements.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if None, infers data type from <code class="xref py py-attr docutils literal notranslate"><span class="pre">values</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if None, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">i</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span>
<span class="go">                      [2, 0, 2]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">float32</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sparse_coo_tensor</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span>
<span class="go">tensor(indices=tensor([[0, 1, 1],</span>
<span class="go">                       [2, 0, 2]]),</span>
<span class="go">       values=tensor([3., 4., 5.]),</span>
<span class="go">       size=(2, 4), nnz=3, layout=torch.sparse_coo)</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sparse_coo_tensor</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">v</span><span class="p">)</span>  <span class="c1"># Shape inference</span>
<span class="go">tensor(indices=tensor([[0, 1, 1],</span>
<span class="go">                       [2, 0, 2]]),</span>
<span class="go">       values=tensor([3., 4., 5.]),</span>
<span class="go">       size=(2, 3), nnz=3, layout=torch.sparse_coo)</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sparse_coo_tensor</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">v</span><span class="p">,</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span>
<span class="go">                            dtype=torch.float64,</span>
<span class="go">                            device=torch.device(&#39;cuda:0&#39;))</span>
<span class="go">tensor(indices=tensor([[0, 1, 1],</span>
<span class="go">                       [2, 0, 2]]),</span>
<span class="go">       values=tensor([3., 4., 5.]),</span>
<span class="go">       device=&#39;cuda:0&#39;, size=(2, 4), nnz=3, dtype=torch.float64,</span>
<span class="go">       layout=torch.sparse_coo)</span>

<span class="go"># Create an empty sparse tensor with the following invariants:</span>
<span class="go">#   1. sparse_dim + dense_dim = len(SparseTensor.shape)</span>
<span class="go">#   2. SparseTensor._indices().shape = (sparse_dim, nnz)</span>
<span class="go">#   3. SparseTensor._values().shape = (nnz, SparseTensor.shape[sparse_dim:])</span>
<span class="go">#</span>
<span class="go"># For instance, to create an empty sparse tensor with nnz = 0, dense_dim = 0 and</span>
<span class="go"># sparse_dim = 1 (hence indices is a 2D tensor of shape = (1, 0))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">S</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">sparse_coo_tensor</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="p">[],</span> <span class="p">[</span><span class="mi">1</span><span class="p">])</span>
<span class="go">tensor(indices=tensor([], size=(1, 0)),</span>
<span class="go">       values=tensor([], size=(0,)),</span>
<span class="go">       size=(1,), nnz=0, layout=torch.sparse_coo)</span>

<span class="go"># and to create an empty sparse tensor with nnz = 0, dense_dim = 1 and</span>
<span class="go"># sparse_dim = 1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">S</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">sparse_coo_tensor</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">]),</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>
<span class="go">tensor(indices=tensor([], size=(1, 0)),</span>
<span class="go">       values=tensor([], size=(0, 2)),</span>
<span class="go">       size=(1, 2), nnz=0, layout=torch.sparse_coo)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.as_tensor">
<code class="descclassname">torch.</code><code class="descname">as_tensor</code><span class="sig-paren">(</span><em>data</em>, <em>dtype=None</em>, <em>device=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.as_tensor" title="Permalink to this definition">¶</a></dt>
<dd><p>Convert the data into a <cite>torch.Tensor</cite>. If the data is already a <cite>Tensor</cite> with the same <cite>dtype</cite> and <cite>device</cite>,
no copy will be performed, otherwise a new <cite>Tensor</cite> will be returned with computational graph retained if data
<cite>Tensor</cite> has <code class="docutils literal notranslate"><span class="pre">requires_grad=True</span></code>. Similarly, if the data is an <code class="docutils literal notranslate"><span class="pre">ndarray</span></code> of the corresponding <cite>dtype</cite> and
the <cite>device</cite> is the cpu, no copy will be performed.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>data</strong> (<em>array_like</em>) – Initial data for the tensor. Can be a list, tuple,
NumPy <code class="docutils literal notranslate"><span class="pre">ndarray</span></code>, scalar, and other types.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, infers data type from <code class="xref py py-attr docutils literal notranslate"><span class="pre">data</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">as_tensor</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span>
<span class="go">tensor([ 1,  2,  3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">array([-1,  2,  3])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">as_tensor</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">device</span><span class="p">(</span><span class="s1">&#39;cuda&#39;</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span>
<span class="go">tensor([ 1,  2,  3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">array([1,  2,  3])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.from_numpy">
<code class="descclassname">torch.</code><code class="descname">from_numpy</code><span class="sig-paren">(</span><em>ndarray</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.from_numpy" title="Permalink to this definition">¶</a></dt>
<dd><p>Creates a <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tensor</span></code></a> from a <a class="reference external" href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray" title="(in NumPy v1.16)"><code class="xref py py-class docutils literal notranslate"><span class="pre">numpy.ndarray</span></code></a>.</p>
<p>The returned tensor and <code class="xref py py-attr docutils literal notranslate"><span class="pre">ndarray</span></code> share the same memory. Modifications to
the tensor will be reflected in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">ndarray</span></code> and vice versa. The returned
tensor is not resizable.</p>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">numpy</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">from_numpy</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span>
<span class="go">tensor([ 1,  2,  3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">array([-1,  2,  3])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.zeros">
<code class="descclassname">torch.</code><code class="descname">zeros</code><span class="sig-paren">(</span><em>*sizes</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.zeros" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with the scalar value <cite>0</cite>, with the shape defined
by the variable argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">sizes</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>sizes</strong> (<em>int...</em>) – a sequence of integers defining the shape of the output tensor.
Can be a variable number of arguments or a collection like a list or tuple.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[ 0.,  0.,  0.],</span>
<span class="go">        [ 0.,  0.,  0.]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([ 0.,  0.,  0.,  0.,  0.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.zeros_like">
<code class="descclassname">torch.</code><code class="descname">zeros_like</code><span class="sig-paren">(</span><em>input</em>, <em>dtype=None</em>, <em>layout=None</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.zeros_like" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with the scalar value <cite>0</cite>, with the same size as
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>. <code class="docutils literal notranslate"><span class="pre">torch.zeros_like(input)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.zeros(input.size(),</span> <span class="pre">dtype=input.dtype,</span> <span class="pre">layout=input.layout,</span> <span class="pre">device=input.device)</span></code>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>As of 0.4, this function does not support an <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> keyword. As an alternative,
the old <code class="docutils literal notranslate"><span class="pre">torch.zeros_like(input,</span> <span class="pre">out=output)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.zeros(input.size(),</span> <span class="pre">out=output)</span></code>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will determine size of the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned Tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the dtype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the layout of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the device of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nb">input</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">zeros_like</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span>
<span class="go">tensor([[ 0.,  0.,  0.],</span>
<span class="go">        [ 0.,  0.,  0.]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.ones">
<code class="descclassname">torch.</code><code class="descname">ones</code><span class="sig-paren">(</span><em>*sizes</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ones" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with the scalar value <cite>1</cite>, with the shape defined
by the variable argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">sizes</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>sizes</strong> (<em>int...</em>) – a sequence of integers defining the shape of the output tensor.
Can be a variable number of arguments or a collection like a list or tuple.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[ 1.,  1.,  1.],</span>
<span class="go">        [ 1.,  1.,  1.]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([ 1.,  1.,  1.,  1.,  1.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.ones_like">
<code class="descclassname">torch.</code><code class="descname">ones_like</code><span class="sig-paren">(</span><em>input</em>, <em>dtype=None</em>, <em>layout=None</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ones_like" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with the scalar value <cite>1</cite>, with the same size as
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>. <code class="docutils literal notranslate"><span class="pre">torch.ones_like(input)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.ones(input.size(),</span> <span class="pre">dtype=input.dtype,</span> <span class="pre">layout=input.layout,</span> <span class="pre">device=input.device)</span></code>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>As of 0.4, this function does not support an <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> keyword. As an alternative,
the old <code class="docutils literal notranslate"><span class="pre">torch.ones_like(input,</span> <span class="pre">out=output)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.ones(input.size(),</span> <span class="pre">out=output)</span></code>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will determine size of the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned Tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the dtype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the layout of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the device of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nb">input</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ones_like</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span>
<span class="go">tensor([[ 1.,  1.,  1.],</span>
<span class="go">        [ 1.,  1.,  1.]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.arange">
<code class="descclassname">torch.</code><code class="descname">arange</code><span class="sig-paren">(</span><em>start=0</em>, <em>end</em>, <em>step=1</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.arange" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a 1-D tensor of size <span class="math">\(\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor\)</span>
with values from the interval <code class="docutils literal notranslate"><span class="pre">[start,</span> <span class="pre">end)</span></code> taken with common difference
<code class="xref py py-attr docutils literal notranslate"><span class="pre">step</span></code> beginning from <cite>start</cite>.</p>
<p>Note that non-integer <code class="xref py py-attr docutils literal notranslate"><span class="pre">step</span></code> is subject to floating point rounding errors when
comparing against <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code>; to avoid inconsistency, we advise adding a small epsilon to <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code>
in such cases.</p>
<div class="math">
\[\text{out}_{{i+1}} = \text{out}_{i} + \text{step}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>start</strong> (<em>Number</em>) – the starting value for the set of points. Default: <code class="docutils literal notranslate"><span class="pre">0</span></code>.</p></li>
<li><p><strong>end</strong> (<em>Number</em>) – the ending value for the set of points</p></li>
<li><p><strong>step</strong> (<em>Number</em>) – the gap between each pair of adjacent points. Default: <code class="docutils literal notranslate"><span class="pre">1</span></code>.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). If <cite>dtype</cite> is not given, infer the data type from the other input
arguments. If any of <cite>start</cite>, <cite>end</cite>, or <cite>stop</cite> are floating-point, the
<cite>dtype</cite> is inferred to be the default dtype, see
<a class="reference internal" href="#torch.get_default_dtype" title="torch.get_default_dtype"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_default_dtype()</span></code></a>. Otherwise, the <cite>dtype</cite> is inferred to
be <cite>torch.int64</cite>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([ 0,  1,  2,  3,  4])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">tensor([ 1,  2,  3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mf">2.5</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">)</span>
<span class="go">tensor([ 1.0000,  1.5000,  2.0000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.range">
<code class="descclassname">torch.</code><code class="descname">range</code><span class="sig-paren">(</span><em>start=0</em>, <em>end</em>, <em>step=1</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.range" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a 1-D tensor of size <span class="math">\(\left\lfloor \frac{\text{end} - \text{start}}{\text{step}} \right\rfloor + 1\)</span>
with values from <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code> to <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code> with step <code class="xref py py-attr docutils literal notranslate"><span class="pre">step</span></code>. Step is
the gap between two values in the tensor.</p>
<div class="math">
\[\text{out}_{i+1} = \text{out}_i + \text{step}.

\]</div>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This function is deprecated in favor of <a class="reference internal" href="#torch.arange" title="torch.arange"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.arange()</span></code></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>start</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the starting value for the set of points. Default: <code class="docutils literal notranslate"><span class="pre">0</span></code>.</p></li>
<li><p><strong>end</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the ending value for the set of points</p></li>
<li><p><strong>step</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the gap between each pair of adjacent points. Default: <code class="docutils literal notranslate"><span class="pre">1</span></code>.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). If <cite>dtype</cite> is not given, infer the data type from the other input
arguments. If any of <cite>start</cite>, <cite>end</cite>, or <cite>stop</cite> are floating-point, the
<cite>dtype</cite> is inferred to be the default dtype, see
<a class="reference internal" href="#torch.get_default_dtype" title="torch.get_default_dtype"><code class="xref py py-meth docutils literal notranslate"><span class="pre">get_default_dtype()</span></code></a>. Otherwise, the <cite>dtype</cite> is inferred to
be <cite>torch.int64</cite>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">tensor([ 1.,  2.,  3.,  4.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">range</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">)</span>
<span class="go">tensor([ 1.0000,  1.5000,  2.0000,  2.5000,  3.0000,  3.5000,  4.0000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.linspace">
<code class="descclassname">torch.</code><code class="descname">linspace</code><span class="sig-paren">(</span><em>start</em>, <em>end</em>, <em>steps=100</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.linspace" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a one-dimensional tensor of <code class="xref py py-attr docutils literal notranslate"><span class="pre">steps</span></code>
equally spaced points between <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code>.</p>
<p>The output tensor is 1-D of size <code class="xref py py-attr docutils literal notranslate"><span class="pre">steps</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>start</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the starting value for the set of points</p></li>
<li><p><strong>end</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the ending value for the set of points</p></li>
<li><p><strong>steps</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – number of points to sample between <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code>. Default: <code class="docutils literal notranslate"><span class="pre">100</span></code>.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([  3.0000,   4.7500,   6.5000,   8.2500,  10.0000])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="o">-</span><span class="mi">10</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([-10.,  -5.,   0.,   5.,  10.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="n">start</span><span class="o">=-</span><span class="mi">10</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([-10.,  -5.,   0.,   5.,  10.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="n">start</span><span class="o">=-</span><span class="mi">10</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([-10.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.logspace">
<code class="descclassname">torch.</code><code class="descname">logspace</code><span class="sig-paren">(</span><em>start</em>, <em>end</em>, <em>steps=100</em>, <em>base=10.0</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.logspace" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a one-dimensional tensor of <code class="xref py py-attr docutils literal notranslate"><span class="pre">steps</span></code> points
logarithmically spaced with base <code class="xref py py-attr docutils literal notranslate"><span class="pre">base</span></code> between
<span class="math">\({\text{base}}^{\text{start}}\)</span> and <span class="math">\({\text{base}}^{\text{end}}\)</span>.</p>
<p>The output tensor is 1-D of size <code class="xref py py-attr docutils literal notranslate"><span class="pre">steps</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>start</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the starting value for the set of points</p></li>
<li><p><strong>end</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the ending value for the set of points</p></li>
<li><p><strong>steps</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – number of points to sample between <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code>. Default: <code class="docutils literal notranslate"><span class="pre">100</span></code>.</p></li>
<li><p><strong>base</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – base of the logarithm function. Default: <code class="docutils literal notranslate"><span class="pre">10.0</span></code>.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">logspace</span><span class="p">(</span><span class="n">start</span><span class="o">=-</span><span class="mi">10</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">10</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([ 1.0000e-10,  1.0000e-05,  1.0000e+00,  1.0000e+05,  1.0000e+10])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">logspace</span><span class="p">(</span><span class="n">start</span><span class="o">=</span><span class="mf">0.1</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([  1.2589,   2.1135,   3.5481,   5.9566,  10.0000])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">logspace</span><span class="p">(</span><span class="n">start</span><span class="o">=</span><span class="mf">0.1</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([1.2589])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">logspace</span><span class="p">(</span><span class="n">start</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">base</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([4.0])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.eye">
<code class="descclassname">torch.</code><code class="descname">eye</code><span class="sig-paren">(</span><em>n</em>, <em>m=None</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.eye" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a 2-D tensor with ones on the diagonal and zeros elsewhere.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>n</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the number of rows</p></li>
<li><p><strong>m</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the number of columns with default being <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code></p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A 2-D tensor with ones on the diagonal and zeros elsewhere</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[ 1.,  0.,  0.],</span>
<span class="go">        [ 0.,  1.,  0.],</span>
<span class="go">        [ 0.,  0.,  1.]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.empty">
<code class="descclassname">torch.</code><code class="descname">empty</code><span class="sig-paren">(</span><em>*sizes</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em>, <em>pin_memory=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.empty" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with uninitialized data. The shape of the tensor is
defined by the variable argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">sizes</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>sizes</strong> (<em>int...</em>) – a sequence of integers defining the shape of the output tensor.
Can be a variable number of arguments or a collection like a list or tuple.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
<li><p><strong>pin_memory</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If set, returned tensor would be allocated in
the pinned memory. Works only for CPU tensors. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">tensor(1.00000e-08 *</span>
<span class="go">       [[ 6.3984,  0.0000,  0.0000],</span>
<span class="go">        [ 0.0000,  0.0000,  0.0000]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.empty_like">
<code class="descclassname">torch.</code><code class="descname">empty_like</code><span class="sig-paren">(</span><em>input</em>, <em>dtype=None</em>, <em>layout=None</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.empty_like" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns an uninitialized tensor with the same size as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.
<code class="docutils literal notranslate"><span class="pre">torch.empty_like(input)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.empty(input.size(),</span> <span class="pre">dtype=input.dtype,</span> <span class="pre">layout=input.layout,</span> <span class="pre">device=input.device)</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will determine size of the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned Tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the dtype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the layout of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the device of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">),</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">int64</span><span class="p">)</span>
<span class="go">tensor([[ 9.4064e+13,  2.8000e+01,  9.3493e+13],</span>
<span class="go">        [ 7.5751e+18,  7.1428e+18,  7.5955e+18]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.full">
<code class="descclassname">torch.</code><code class="descname">full</code><span class="sig-paren">(</span><em>size</em>, <em>fill_value</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.full" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor of size <code class="xref py py-attr docutils literal notranslate"><span class="pre">size</span></code> filled with <code class="xref py py-attr docutils literal notranslate"><span class="pre">fill_value</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>size</strong> (<em>int...</em>) – a list, tuple, or <code class="xref py py-class docutils literal notranslate"><span class="pre">torch.Size</span></code> of integers defining the
shape of the output tensor.</p></li>
<li><p><strong>fill_value</strong> – the number to fill the output tensor with.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">full</span><span class="p">((</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">),</span> <span class="mf">3.141592</span><span class="p">)</span>
<span class="go">tensor([[ 3.1416,  3.1416,  3.1416],</span>
<span class="go">        [ 3.1416,  3.1416,  3.1416]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.full_like">
<code class="descclassname">torch.</code><code class="descname">full_like</code><span class="sig-paren">(</span><em>input</em>, <em>fill_value</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.full_like" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor with the same size as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> filled with <code class="xref py py-attr docutils literal notranslate"><span class="pre">fill_value</span></code>.
<code class="docutils literal notranslate"><span class="pre">torch.full_like(input,</span> <span class="pre">fill_value)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.full(input.size(),</span> <span class="pre">fill_value,</span> <span class="pre">dtype=input.dtype,</span> <span class="pre">layout=input.layout,</span> <span class="pre">device=input.device)</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will determine size of the output tensor</p></li>
<li><p><strong>fill_value</strong> – the number to fill the output tensor with.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned Tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the dtype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the layout of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the device of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

</div>
<div class="section" id="indexing-slicing-joining-mutating-ops">
<h3>Indexing, Slicing, Joining, Mutating Ops<a class="headerlink" href="#indexing-slicing-joining-mutating-ops" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="torch.cat">
<code class="descclassname">torch.</code><code class="descname">cat</code><span class="sig-paren">(</span><em>tensors</em>, <em>dim=0</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cat" title="Permalink to this definition">¶</a></dt>
<dd><p>Concatenates the given sequence of <code class="xref py py-attr docutils literal notranslate"><span class="pre">seq</span></code> tensors in the given dimension.
All tensors must either have the same shape (except in the concatenating
dimension) or be empty.</p>
<p><a class="reference internal" href="#torch.cat" title="torch.cat"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cat()</span></code></a> can be seen as an inverse operation for <a class="reference internal" href="#torch.split" title="torch.split"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.split()</span></code></a>
and <a class="reference internal" href="#torch.chunk" title="torch.chunk"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.chunk()</span></code></a>.</p>
<p><a class="reference internal" href="#torch.cat" title="torch.cat"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cat()</span></code></a> can be best understood via examples.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensors</strong> (<em>sequence of Tensors</em>) – any python sequence of tensors of the same type.
Non-empty tensors provided must have the same shape, except in the
cat dimension.</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the dimension over which the tensors are concatenated</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 0.6580, -1.0969, -0.4614],</span>
<span class="go">        [-0.1034, -0.5790,  0.1497]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cat</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="p">),</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([[ 0.6580, -1.0969, -0.4614],</span>
<span class="go">        [-0.1034, -0.5790,  0.1497],</span>
<span class="go">        [ 0.6580, -1.0969, -0.4614],</span>
<span class="go">        [-0.1034, -0.5790,  0.1497],</span>
<span class="go">        [ 0.6580, -1.0969, -0.4614],</span>
<span class="go">        [-0.1034, -0.5790,  0.1497]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cat</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">x</span><span class="p">),</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.6580, -1.0969, -0.4614,  0.6580, -1.0969, -0.4614,  0.6580,</span>
<span class="go">         -1.0969, -0.4614],</span>
<span class="go">        [-0.1034, -0.5790,  0.1497, -0.1034, -0.5790,  0.1497, -0.1034,</span>
<span class="go">         -0.5790,  0.1497]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.chunk">
<code class="descclassname">torch.</code><code class="descname">chunk</code><span class="sig-paren">(</span><em>tensor</em>, <em>chunks</em>, <em>dim=0</em><span class="sig-paren">)</span> &#x2192; List of Tensors<a class="headerlink" href="#torch.chunk" title="Permalink to this definition">¶</a></dt>
<dd><p>Splits a tensor into a specific number of chunks.</p>
<p>Last chunk will be smaller if the tensor size along the given dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is not divisible by <code class="xref py py-attr docutils literal notranslate"><span class="pre">chunks</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to split</p></li>
<li><p><strong>chunks</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – number of chunks to return</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – dimension along which to split the tensor</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.gather">
<code class="descclassname">torch.</code><code class="descname">gather</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>index</em>, <em>out=None</em>, <em>sparse_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.gather" title="Permalink to this definition">¶</a></dt>
<dd><p>Gathers values along an axis specified by <cite>dim</cite>.</p>
<p>For a 3-D tensor the output is specified by:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">out</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="o">=</span> <span class="nb">input</span><span class="p">[</span><span class="n">index</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span>  <span class="c1"># if dim == 0</span>
<span class="n">out</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="o">=</span> <span class="nb">input</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">index</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]][</span><span class="n">k</span><span class="p">]</span>  <span class="c1"># if dim == 1</span>
<span class="n">out</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]</span> <span class="o">=</span> <span class="nb">input</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">index</span><span class="p">[</span><span class="n">i</span><span class="p">][</span><span class="n">j</span><span class="p">][</span><span class="n">k</span><span class="p">]]</span>  <span class="c1"># if dim == 2</span>
</pre></div>
</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is an n-dimensional tensor with size
<span class="math">\((x_0, x_1..., x_{i-1}, x_i, x_{i+1}, ..., x_{n-1})\)</span>
and <code class="docutils literal notranslate"><span class="pre">dim</span> <span class="pre">=</span> <span class="pre">i</span></code>, then <code class="xref py py-attr docutils literal notranslate"><span class="pre">index</span></code> must be an <span class="math">\(n\)</span>-dimensional tensor with
size <span class="math">\((x_0, x_1, ..., x_{i-1}, y, x_{i+1}, ..., x_{n-1})\)</span> where <span class="math">\(y \geq 1\)</span>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will have the same size as <code class="xref py py-attr docutils literal notranslate"><span class="pre">index</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the source tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the axis along which to index</p></li>
<li><p><strong>index</strong> (<em>LongTensor</em>) – the indices of elements to gather</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the destination tensor</p></li>
<li><p><strong>sparse_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>,</em><em>optional</em>) – If <code class="docutils literal notranslate"><span class="pre">True</span></code>, gradient w.r.t. <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will be a sparse tensor.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">],[</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">gather</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">]]))</span>
<span class="go">tensor([[ 1,  1],</span>
<span class="go">        [ 4,  3]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.index_select">
<code class="descclassname">torch.</code><code class="descname">index_select</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>index</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.index_select" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor which indexes the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor along dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> using the entries in <code class="xref py py-attr docutils literal notranslate"><span class="pre">index</span></code> which is a <cite>LongTensor</cite>.</p>
<p>The returned tensor has the same number of dimensions as the original tensor
(<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>).  The <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>th dimension has the same size as the length
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">index</span></code>; other dimensions have the same size as in the original tensor.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The returned tensor does <strong>not</strong> use the same storage as the original
tensor.  If <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> has a different shape than expected, we
silently change it to the correct shape, reallocating the underlying
storage if necessary.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension in which we index</p></li>
<li><p><strong>index</strong> (<em>LongTensor</em>) – the 1-D tensor containing the indices to index</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 0.1427,  0.0231, -0.5414, -1.0009],</span>
<span class="go">        [-0.4664,  0.2647, -0.1228, -1.1068],</span>
<span class="go">        [-1.1734, -0.6571,  0.7230, -0.6004]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">indices</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">index_select</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="n">indices</span><span class="p">)</span>
<span class="go">tensor([[ 0.1427,  0.0231, -0.5414, -1.0009],</span>
<span class="go">        [-1.1734, -0.6571,  0.7230, -0.6004]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">index_select</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">indices</span><span class="p">)</span>
<span class="go">tensor([[ 0.1427, -0.5414],</span>
<span class="go">        [-0.4664, -0.1228],</span>
<span class="go">        [-1.1734,  0.7230]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.masked_select">
<code class="descclassname">torch.</code><code class="descname">masked_select</code><span class="sig-paren">(</span><em>input</em>, <em>mask</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.masked_select" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new 1-D tensor which indexes the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor according to
the binary mask <code class="xref py py-attr docutils literal notranslate"><span class="pre">mask</span></code> which is a <cite>ByteTensor</cite>.</p>
<p>The shapes of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">mask</span></code> tensor and the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor don’t need
to match, but they must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The returned tensor does <strong>not</strong> use the same storage
as the original tensor</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input data</p></li>
<li><p><strong>mask</strong> (<a class="reference internal" href="tensors.html#torch.ByteTensor" title="torch.ByteTensor"><em>ByteTensor</em></a>) – the tensor containing the binary mask to index with</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 0.3552, -2.3825, -0.8297,  0.3477],</span>
<span class="go">        [-1.2035,  1.2252,  0.5002,  0.6248],</span>
<span class="go">        [ 0.1307, -2.0608,  0.1244,  2.0139]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">mask</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">ge</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">mask</span>
<span class="go">tensor([[ 0,  0,  0,  0],</span>
<span class="go">        [ 0,  1,  1,  1],</span>
<span class="go">        [ 0,  0,  0,  1]], dtype=torch.uint8)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">masked_select</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">mask</span><span class="p">)</span>
<span class="go">tensor([ 1.2252,  0.5002,  0.6248,  2.0139])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.narrow">
<code class="descclassname">torch.</code><code class="descname">narrow</code><span class="sig-paren">(</span><em>input</em>, <em>dimension</em>, <em>start</em>, <em>length</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.narrow" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor that is a narrowed version of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor. The
dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is input from <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code> to <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span> <span class="pre">+</span> <span class="pre">length</span></code>. The
returned tensor and <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor share the same underlying storage.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to narrow</p></li>
<li><p><strong>dimension</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension along which to narrow</p></li>
<li><p><strong>start</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the starting dimension</p></li>
<li><p><strong>length</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the distance to the ending dimension</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">],</span> <span class="p">[</span><span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">narrow</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([[ 1,  2,  3],</span>
<span class="go">        [ 4,  5,  6]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">narrow</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([[ 2,  3],</span>
<span class="go">        [ 5,  6],</span>
<span class="go">        [ 8,  9]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.nonzero">
<code class="descclassname">torch.</code><code class="descname">nonzero</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; LongTensor<a class="headerlink" href="#torch.nonzero" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor containing the indices of all non-zero elements of
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.  Each row in the result contains the indices of a non-zero
element in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>. The result is sorted lexicographically, with
the last index changing the fastest (C-style).</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> has <cite>n</cite> dimensions, then the resulting indices tensor
<code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> is of size <span class="math">\((z \times n)\)</span>, where <span class="math">\(z\)</span> is the total number of
non-zero elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<em>LongTensor</em><em>, </em><em>optional</em>) – the output tensor containing indices</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">nonzero</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]))</span>
<span class="go">tensor([[ 0],</span>
<span class="go">        [ 1],</span>
<span class="go">        [ 2],</span>
<span class="go">        [ 4]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">nonzero</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">0.6</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.0</span><span class="p">],</span>
<span class="go">                                [0.0, 0.4, 0.0, 0.0],</span>
<span class="go">                                [0.0, 0.0, 1.2, 0.0],</span>
<span class="go">                                [0.0, 0.0, 0.0,-0.4]]))</span>
<span class="go">tensor([[ 0,  0],</span>
<span class="go">        [ 1,  1],</span>
<span class="go">        [ 2,  2],</span>
<span class="go">        [ 3,  3]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.reshape">
<code class="descclassname">torch.</code><code class="descname">reshape</code><span class="sig-paren">(</span><em>input</em>, <em>shape</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.reshape" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor with the same data and number of elements as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>,
but with the specified shape. When possible, the returned tensor will be a view
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>. Otherwise, it will be a copy. Contiguous inputs and inputs
with compatible strides can be reshaped without copying, but you should not
depend on the copying vs. viewing behavior.</p>
<p>See <a class="reference internal" href="tensors.html#torch.Tensor.view" title="torch.Tensor.view"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.Tensor.view()</span></code></a> on when it is possible to return a view.</p>
<p>A single dimension may be -1, in which case it’s inferred from the remaining
dimensions and the number of elements in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to be reshaped</p></li>
<li><p><strong>shape</strong> (<em>tuple of python:ints</em>) – the new shape</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">4.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
<span class="go">tensor([[ 0.,  1.],</span>
<span class="go">        [ 2.,  3.]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span><span class="p">,))</span>
<span class="go">tensor([ 0,  1,  2,  3])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.split">
<code class="descclassname">torch.</code><code class="descname">split</code><span class="sig-paren">(</span><em>tensor</em>, <em>split_size_or_sections</em>, <em>dim=0</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#split"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.split" title="Permalink to this definition">¶</a></dt>
<dd><p>Splits the tensor into chunks.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">split_size_or_sections</span></code> is an integer type, then <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a> will
be split into equally sized chunks (if possible). Last chunk will be smaller if
the tensor size along the given dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is not divisible by
<code class="xref py py-attr docutils literal notranslate"><span class="pre">split_size</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">split_size_or_sections</span></code> is a list, then <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a> will be split
into <code class="docutils literal notranslate"><span class="pre">len(split_size_or_sections)</span></code> chunks with sizes in <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> according
to <code class="xref py py-attr docutils literal notranslate"><span class="pre">split_size_or_sections</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – tensor to split.</p></li>
<li><p><strong>split_size_or_sections</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>) or </em><em>(</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#list" title="(in Python v3.7)"><em>list</em></a><em>(</em><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>)</em>) – size of a single chunk or
list of sizes for each chunk</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – dimension along which to split the tensor.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.squeeze">
<code class="descclassname">torch.</code><code class="descname">squeeze</code><span class="sig-paren">(</span><em>input</em>, <em>dim=None</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.squeeze" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor with all the dimensions of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> of size <cite>1</cite> removed.</p>
<p>For example, if <cite>input</cite> is of shape:
<span class="math">\((A \times 1 \times B \times C \times 1 \times D)\)</span> then the <cite>out</cite> tensor
will be of shape: <span class="math">\((A \times B \times C \times D)\)</span>.</p>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is given, a squeeze operation is done only in the given
dimension. If <cite>input</cite> is of shape: <span class="math">\((A \times 1 \times B)\)</span>,
<code class="docutils literal notranslate"><span class="pre">squeeze(input,</span> <span class="pre">0)</span></code> leaves the tensor unchanged, but <code class="docutils literal notranslate"><span class="pre">squeeze(input,</span> <span class="pre">1)</span></code>
will squeeze the tensor to the shape <span class="math">\((A \times B)\)</span>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The returned tensor shares the storage with the input tensor,
so changing the contents of one will change the contents of the other.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – if given, the input will be squeezed only in
this dimension</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([2, 1, 2, 1, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">squeeze</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([2, 2, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">squeeze</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([2, 1, 2, 1, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">squeeze</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([2, 2, 1, 2])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.stack">
<code class="descclassname">torch.</code><code class="descname">stack</code><span class="sig-paren">(</span><em>seq</em>, <em>dim=0</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.stack" title="Permalink to this definition">¶</a></dt>
<dd><p>Concatenates sequence of tensors along a new dimension.</p>
<p>All tensors need to be of the same size.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>seq</strong> (<em>sequence of Tensors</em>) – sequence of tensors to concatenate</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – dimension to insert. Has to be between 0 and the number
of dimensions of concatenated tensors (inclusive)</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.t">
<code class="descclassname">torch.</code><code class="descname">t</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.t" title="Permalink to this definition">¶</a></dt>
<dd><p>Expects <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> to be &lt;= 2-D tensor and transposes dimensions 0
and 1.</p>
<p>0-D and 1-D tensors are returned as it is and
2-D tensor can be seen as a short-hand function for <code class="docutils literal notranslate"><span class="pre">transpose(input,</span> <span class="pre">0,</span> <span class="pre">1)</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(())</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor(0.1995)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">t</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="go">tensor(0.1995)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([ 2.4320, -0.4608,  0.7702])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">t</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="go">tensor([.2.4320,.-0.4608,..0.7702])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 0.4875,  0.9158, -0.5872],</span>
<span class="go">        [ 0.3938, -0.6929,  0.6932]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">t</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="go">tensor([[ 0.4875,  0.3938],</span>
<span class="go">        [ 0.9158, -0.6929],</span>
<span class="go">        [-0.5872,  0.6932]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.take">
<code class="descclassname">torch.</code><code class="descname">take</code><span class="sig-paren">(</span><em>input</em>, <em>indices</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.take" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> at the given indices.
The input tensor is treated as if it were viewed as a 1-D tensor. The result
takes the same shape as the indices.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>indices</strong> (<em>LongTensor</em>) – the indices into tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">src</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">],</span>
<span class="go">                        [6, 7, 8]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">take</span><span class="p">(</span><span class="n">src</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">5</span><span class="p">]))</span>
<span class="go">tensor([ 4,  5,  8])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.transpose">
<code class="descclassname">torch.</code><code class="descname">transpose</code><span class="sig-paren">(</span><em>input</em>, <em>dim0</em>, <em>dim1</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.transpose" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor that is a transposed version of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.
The given dimensions <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim0</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim1</span></code> are swapped.</p>
<p>The resulting <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> tensor shares it’s underlying storage with the
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor, so changing the content of one would change the content
of the other.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim0</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the first dimension to be transposed</p></li>
<li><p><strong>dim1</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the second dimension to be transposed</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 1.0028, -0.9893,  0.5809],</span>
<span class="go">        [-0.1669,  0.7299,  0.4942]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 1.0028, -0.1669],</span>
<span class="go">        [-0.9893,  0.7299],</span>
<span class="go">        [ 0.5809,  0.4942]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.unbind">
<code class="descclassname">torch.</code><code class="descname">unbind</code><span class="sig-paren">(</span><em>tensor</em>, <em>dim=0</em><span class="sig-paren">)</span> &#x2192; seq<a class="headerlink" href="#torch.unbind" title="Permalink to this definition">¶</a></dt>
<dd><p>Removes a tensor dimension.</p>
<p>Returns a tuple of all slices along a given dimension, already without it.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to unbind</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – dimension to remove</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">unbind</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span>
<span class="gp">&gt;&gt;&gt; </span>                           <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">],</span>
<span class="gp">&gt;&gt;&gt; </span>                           <span class="p">[</span><span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">9</span><span class="p">]]))</span>
<span class="go">(tensor([1, 2, 3]), tensor([4, 5, 6]), tensor([7, 8, 9]))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.unsqueeze">
<code class="descclassname">torch.</code><code class="descname">unsqueeze</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.unsqueeze" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with a dimension of size one inserted at the
specified position.</p>
<p>The returned tensor shares the same underlying data with this tensor.</p>
<p>A <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> value within the range <code class="docutils literal notranslate"><span class="pre">[-input.dim()</span> <span class="pre">-</span> <span class="pre">1,</span> <span class="pre">input.dim()</span> <span class="pre">+</span> <span class="pre">1)</span></code>
can be used. Negative <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> will correspond to <a class="reference internal" href="#torch.unsqueeze" title="torch.unsqueeze"><code class="xref py py-meth docutils literal notranslate"><span class="pre">unsqueeze()</span></code></a>
applied at <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> = <code class="docutils literal notranslate"><span class="pre">dim</span> <span class="pre">+</span> <span class="pre">input.dim()</span> <span class="pre">+</span> <span class="pre">1</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the index at which to insert the singleton dimension</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">unsqueeze</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([[ 1,  2,  3,  4]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">unsqueeze</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 1],</span>
<span class="go">        [ 2],</span>
<span class="go">        [ 3],</span>
<span class="go">        [ 4]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.where">
<code class="descclassname">torch.</code><code class="descname">where</code><span class="sig-paren">(</span><em>condition</em>, <em>x</em>, <em>y</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.where" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a tensor of elements selected from either <code class="xref py py-attr docutils literal notranslate"><span class="pre">x</span></code> or <code class="xref py py-attr docutils literal notranslate"><span class="pre">y</span></code>, depending on <code class="xref py py-attr docutils literal notranslate"><span class="pre">condition</span></code>.</p>
<p>The operation is defined as:</p>
<div class="math">
\[out_i = \begin{cases}
    x_i & \text{if } \text{condition}_i \\
    y_i & \text{otherwise} \\
\end{cases}

\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The tensors <code class="xref py py-attr docutils literal notranslate"><span class="pre">condition</span></code>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">x</span></code>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">y</span></code> must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>condition</strong> (<a class="reference internal" href="tensors.html#torch.ByteTensor" title="torch.ByteTensor"><em>ByteTensor</em></a>) – When True (nonzero), yield x, otherwise yield y</p></li>
<li><p><strong>x</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – values selected at indices where <code class="xref py py-attr docutils literal notranslate"><span class="pre">condition</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code></p></li>
<li><p><strong>y</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – values selected at indices where <code class="xref py py-attr docutils literal notranslate"><span class="pre">condition</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tensor of shape equal to the broadcasted shape of <code class="xref py py-attr docutils literal notranslate"><span class="pre">condition</span></code>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">x</span></code>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">y</span></code></p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[-0.4620,  0.3139],</span>
<span class="go">        [ 0.3898, -0.7197],</span>
<span class="go">        [ 0.0478, -0.1657]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">x</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="go">tensor([[ 1.0000,  0.3139],</span>
<span class="go">        [ 0.3898,  1.0000],</span>
<span class="go">        [ 0.0478,  1.0000]])</span>
</pre></div>
</div>
</dd></dl>

</div>
</div>
<div class="section" id="random-sampling">
<span id="id1"></span><h2>Random sampling<a class="headerlink" href="#random-sampling" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="torch.manual_seed">
<code class="descclassname">torch.</code><code class="descname">manual_seed</code><span class="sig-paren">(</span><em>seed</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/random.html#manual_seed"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.manual_seed" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the seed for generating random numbers. Returns a
<cite>torch._C.Generator</cite> object.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>seed</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – The desired seed.</p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.initial_seed">
<code class="descclassname">torch.</code><code class="descname">initial_seed</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/random.html#initial_seed"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.initial_seed" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the initial seed for generating random numbers as a
Python <cite>long</cite>.</p>
</dd></dl>

<dl class="function">
<dt id="torch.get_rng_state">
<code class="descclassname">torch.</code><code class="descname">get_rng_state</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/random.html#get_rng_state"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.get_rng_state" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the random number generator state as a <cite>torch.ByteTensor</cite>.</p>
</dd></dl>

<dl class="function">
<dt id="torch.set_rng_state">
<code class="descclassname">torch.</code><code class="descname">set_rng_state</code><span class="sig-paren">(</span><em>new_state</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/random.html#set_rng_state"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.set_rng_state" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the random number generator state.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>new_state</strong> (<a class="reference internal" href="tensors.html#torch.ByteTensor" title="torch.ByteTensor"><em>torch.ByteTensor</em></a>) – The desired state</p>
</dd>
</dl>
</dd></dl>

<dl class="data">
<dt id="torch.default_generator">
<code class="descclassname">torch.</code><code class="descname">default_generator</code><em class="property"> = &lt;torch._C.Generator object&gt;</em><a class="headerlink" href="#torch.default_generator" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="torch.bernoulli">
<code class="descclassname">torch.</code><code class="descname">bernoulli</code><span class="sig-paren">(</span><em>input</em>, <em>*</em>, <em>generator=None</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.bernoulli" title="Permalink to this definition">¶</a></dt>
<dd><p>Draws binary random numbers (0 or 1) from a Bernoulli distribution.</p>
<p>The <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor should be a tensor containing probabilities
to be used for drawing the binary random number.
Hence, all values in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> have to be in the range:
<span class="math">\(0 \leq \text{input}_i \leq 1\)</span>.</p>
<p>The <span class="math">\(\text{i}^{th}\)</span> element of the output tensor will draw a
value <span class="math">\(1\)</span> according to the <span class="math">\(\text{i}^{th}\)</span> probability value given
in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} \sim \mathrm{Bernoulli}(p = \text{input}_{i})

\]</div>
<p>The returned <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> tensor only has values 0 or 1 and is of the same
shape as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> can have integral <code class="docutils literal notranslate"><span class="pre">dtype</span></code>, but <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> must have floating
point <code class="docutils literal notranslate"><span class="pre">dtype</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor of probability values for the Bernoulli distribution</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span><span class="o">.</span><span class="n">uniform_</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>  <span class="c1"># generate a uniform random matrix with range [0, 1]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.1737,  0.0950,  0.3609],</span>
<span class="go">        [ 0.7148,  0.0289,  0.2676],</span>
<span class="go">        [ 0.9456,  0.8937,  0.7202]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">bernoulli</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[ 1.,  0.,  0.],</span>
<span class="go">        [ 0.,  0.,  0.],</span>
<span class="go">        [ 1.,  1.,  1.]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span> <span class="c1"># probability of drawing &quot;1&quot; is 1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">bernoulli</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[ 1.,  1.,  1.],</span>
<span class="go">        [ 1.,  1.,  1.],</span>
<span class="go">        [ 1.,  1.,  1.]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span> <span class="c1"># probability of drawing &quot;1&quot; is 0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">bernoulli</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[ 0.,  0.,  0.],</span>
<span class="go">        [ 0.,  0.,  0.],</span>
<span class="go">        [ 0.,  0.,  0.]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.multinomial">
<code class="descclassname">torch.</code><code class="descname">multinomial</code><span class="sig-paren">(</span><em>input</em>, <em>num_samples</em>, <em>replacement=False</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; LongTensor<a class="headerlink" href="#torch.multinomial" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor where each row contains <code class="xref py py-attr docutils literal notranslate"><span class="pre">num_samples</span></code> indices sampled
from the multinomial probability distribution located in the corresponding row
of tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The rows of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> do not need to sum to one (in which case we use
the values as weights), but must be non-negative, finite and have
a non-zero sum.</p>
</div>
<p>Indices are ordered from left to right according to when each was sampled
(first samples are placed in first column).</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a vector, <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> is a vector of size <code class="xref py py-attr docutils literal notranslate"><span class="pre">num_samples</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a matrix with <cite>m</cite> rows, <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> is an matrix of shape
<span class="math">\((m \times \text{num\_samples})\)</span>.</p>
<p>If replacement is <code class="docutils literal notranslate"><span class="pre">True</span></code>, samples are drawn with replacement.</p>
<p>If not, they are drawn without replacement, which means that when a
sample index is drawn for a row, it cannot be drawn again for that row.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When drawn without replacement, <code class="xref py py-attr docutils literal notranslate"><span class="pre">num_samples</span></code> must be lower than
number of non-zero elements in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> (or the min number of non-zero
elements in each row of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> if it is a matrix).</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor containing probabilities</p></li>
<li><p><strong>num_samples</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – number of samples to draw</p></li>
<li><p><strong>replacement</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether to draw with replacement or not</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">weights</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">float</span><span class="p">)</span> <span class="c1"># create a tensor of weights</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">multinomial</span><span class="p">(</span><span class="n">weights</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([1, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">multinomial</span><span class="p">(</span><span class="n">weights</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span> <span class="c1"># ERROR!</span>
<span class="go">RuntimeError: invalid argument 2: invalid multinomial distribution (with replacement=False,</span>
<span class="go">not enough non-negative category to sample) at ../aten/src/TH/generic/THTensorRandom.cpp:320</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">multinomial</span><span class="p">(</span><span class="n">weights</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="n">replacement</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="go">tensor([ 2,  1,  1,  1])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.normal">
<code class="descclassname">torch.</code><code class="descname">normal</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.normal" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">normal</code><span class="sig-paren">(</span><em>mean</em>, <em>std</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns a tensor of random numbers drawn from separate normal distributions
whose mean and standard deviation are given.</p>
<p>The <a class="reference internal" href="#torch.mean" title="torch.mean"><code class="xref py py-attr docutils literal notranslate"><span class="pre">mean</span></code></a> is a tensor with the mean of
each output element’s normal distribution</p>
<p>The <a class="reference internal" href="#torch.std" title="torch.std"><code class="xref py py-attr docutils literal notranslate"><span class="pre">std</span></code></a> is a tensor with the standard deviation of
each output element’s normal distribution</p>
<p>The shapes of <a class="reference internal" href="#torch.mean" title="torch.mean"><code class="xref py py-attr docutils literal notranslate"><span class="pre">mean</span></code></a> and <a class="reference internal" href="#torch.std" title="torch.std"><code class="xref py py-attr docutils literal notranslate"><span class="pre">std</span></code></a> don’t need to match, but the
total number of elements in each tensor need to be the same.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When the shapes do not match, the shape of <a class="reference internal" href="#torch.mean" title="torch.mean"><code class="xref py py-attr docutils literal notranslate"><span class="pre">mean</span></code></a>
is used as the shape for the returned output tensor</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>mean</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor of per-element means</p></li>
<li><p><strong>std</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor of per-element standard deviations</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">normal</span><span class="p">(</span><span class="n">mean</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">11.</span><span class="p">),</span> <span class="n">std</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mf">0.1</span><span class="p">))</span>
<span class="go">tensor([  1.0425,   3.5672,   2.7969,   4.2925,   4.7229,   6.2134,</span>
<span class="go">          8.0505,   8.1408,   9.0563,  10.0566])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">normal</code><span class="sig-paren">(</span><em>mean=0.0</em>, <em>std</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Similar to the function above, but the means are shared among all drawn
elements.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>mean</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>optional</em>) – the mean for all distributions</p></li>
<li><p><strong>std</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor of per-element standard deviations</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">normal</span><span class="p">(</span><span class="n">mean</span><span class="o">=</span><span class="mf">0.5</span><span class="p">,</span> <span class="n">std</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">6.</span><span class="p">))</span>
<span class="go">tensor([-1.2793, -1.0732, -2.0687,  5.1177, -1.2303])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">normal</code><span class="sig-paren">(</span><em>mean</em>, <em>std=1.0</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Similar to the function above, but the standard-deviations are shared among
all drawn elements.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>mean</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor of per-element means</p></li>
<li><p><strong>std</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>optional</em>) – the standard deviation for all distributions</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">normal</span><span class="p">(</span><span class="n">mean</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">6.</span><span class="p">))</span>
<span class="go">tensor([ 1.1552,  2.6148,  2.6535,  5.8318,  4.2361])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.rand">
<code class="descclassname">torch.</code><code class="descname">rand</code><span class="sig-paren">(</span><em>*sizes</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.rand" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with random numbers from a uniform distribution
on the interval <span class="math">\([0, 1)\)</span></p>
<p>The shape of the tensor is defined by the variable argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">sizes</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>sizes</strong> (<em>int...</em>) – a sequence of integers defining the shape of the output tensor.
Can be a variable number of arguments or a collection like a list or tuple.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rand</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="go">tensor([ 0.5204,  0.2503,  0.3525,  0.5673])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rand</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[ 0.8237,  0.5781,  0.6879],</span>
<span class="go">        [ 0.3816,  0.7249,  0.0998]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.rand_like">
<code class="descclassname">torch.</code><code class="descname">rand_like</code><span class="sig-paren">(</span><em>input</em>, <em>dtype=None</em>, <em>layout=None</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.rand_like" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor with the same size as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> that is filled with
random numbers from a uniform distribution on the interval <span class="math">\([0, 1)\)</span>.
<code class="docutils literal notranslate"><span class="pre">torch.rand_like(input)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.rand(input.size(),</span> <span class="pre">dtype=input.dtype,</span> <span class="pre">layout=input.layout,</span> <span class="pre">device=input.device)</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will determine size of the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned Tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the dtype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the layout of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the device of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.randint">
<code class="descclassname">torch.</code><code class="descname">randint</code><span class="sig-paren">(</span><em>low=0</em>, <em>high</em>, <em>size</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.randint" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with random integers generated uniformly
between <code class="xref py py-attr docutils literal notranslate"><span class="pre">low</span></code> (inclusive) and <code class="xref py py-attr docutils literal notranslate"><span class="pre">high</span></code> (exclusive).</p>
<p>The shape of the tensor is defined by the variable argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">size</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>low</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – Lowest integer to be drawn from the distribution. Default: 0.</p></li>
<li><p><strong>high</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – One above the highest integer to be drawn from the distribution.</p></li>
<li><p><strong>size</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a>) – a tuple defining the shape of the output tensor.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="p">(</span><span class="mi">3</span><span class="p">,))</span>
<span class="go">tensor([4, 3, 4])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
<span class="go">tensor([[0, 2],</span>
<span class="go">        [5, 5]])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">))</span>
<span class="go">tensor([[4, 5],</span>
<span class="go">        [6, 7]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.randint_like">
<code class="descclassname">torch.</code><code class="descname">randint_like</code><span class="sig-paren">(</span><em>input</em>, <em>low=0</em>, <em>high</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.randint_like" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor with the same shape as Tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> filled with
random integers generated uniformly between <code class="xref py py-attr docutils literal notranslate"><span class="pre">low</span></code> (inclusive) and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">high</span></code> (exclusive).</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will determine size of the output tensor</p></li>
<li><p><strong>low</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – Lowest integer to be drawn from the distribution. Default: 0.</p></li>
<li><p><strong>high</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – One above the highest integer to be drawn from the distribution.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned Tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the dtype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the layout of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the device of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.randn">
<code class="descclassname">torch.</code><code class="descname">randn</code><span class="sig-paren">(</span><em>*sizes</em>, <em>out=None</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.randn" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor filled with random numbers from a normal distribution
with mean <cite>0</cite> and variance <cite>1</cite> (also called the standard normal
distribution).</p>
<div class="math">
\[\text{out}_{i} \sim \mathcal{N}(0, 1)

\]</div>
<p>The shape of the tensor is defined by the variable argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">sizes</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>sizes</strong> (<em>int...</em>) – a sequence of integers defining the shape of the output tensor.
Can be a variable number of arguments or a collection like a list or tuple.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>).</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="go">tensor([-2.1436,  0.9966,  2.3426, -0.6366])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[ 1.5954,  2.8929, -1.0923],</span>
<span class="go">        [ 1.1719, -0.4709, -0.1996]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.randn_like">
<code class="descclassname">torch.</code><code class="descname">randn_like</code><span class="sig-paren">(</span><em>input</em>, <em>dtype=None</em>, <em>layout=None</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.randn_like" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor with the same size as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> that is filled with
random numbers from a normal distribution with mean 0 and variance 1.
<code class="docutils literal notranslate"><span class="pre">torch.randn_like(input)</span></code> is equivalent to
<code class="docutils literal notranslate"><span class="pre">torch.randn(input.size(),</span> <span class="pre">dtype=input.dtype,</span> <span class="pre">layout=input.layout,</span> <span class="pre">device=input.device)</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will determine size of the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned Tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the dtype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the layout of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, defaults to the device of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.randperm">
<code class="descclassname">torch.</code><code class="descname">randperm</code><span class="sig-paren">(</span><em>n</em>, <em>out=None</em>, <em>dtype=torch.int64</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; LongTensor<a class="headerlink" href="#torch.randperm" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a random permutation of integers from <code class="docutils literal notranslate"><span class="pre">0</span></code> to <code class="docutils literal notranslate"><span class="pre">n</span> <span class="pre">-</span> <span class="pre">1</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>n</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the upper bound (exclusive)</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.int64</span></code>.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned Tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">randperm</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="go">tensor([2, 1, 0, 3])</span>
</pre></div>
</div>
</dd></dl>

<div class="section" id="in-place-random-sampling">
<span id="inplace-random-sampling"></span><h3>In-place random sampling<a class="headerlink" href="#in-place-random-sampling" title="Permalink to this headline">¶</a></h3>
<p>There are a few more in-place random sampling functions defined on Tensors as well. Click through to refer to their documentation:</p>
<ul class="simple">
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.bernoulli_" title="torch.Tensor.bernoulli_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.bernoulli_()</span></code></a> - in-place version of <a class="reference internal" href="#torch.bernoulli" title="torch.bernoulli"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.bernoulli()</span></code></a></p></li>
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.cauchy_" title="torch.Tensor.cauchy_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.cauchy_()</span></code></a> - numbers drawn from the Cauchy distribution</p></li>
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.exponential_" title="torch.Tensor.exponential_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.exponential_()</span></code></a> - numbers drawn from the exponential distribution</p></li>
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.geometric_" title="torch.Tensor.geometric_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.geometric_()</span></code></a> - elements drawn from the geometric distribution</p></li>
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.log_normal_" title="torch.Tensor.log_normal_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.log_normal_()</span></code></a> - samples from the log-normal distribution</p></li>
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.normal_" title="torch.Tensor.normal_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.normal_()</span></code></a> - in-place version of <a class="reference internal" href="#torch.normal" title="torch.normal"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.normal()</span></code></a></p></li>
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.random_" title="torch.Tensor.random_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.random_()</span></code></a> - numbers sampled from the discrete uniform distribution</p></li>
<li><p><a class="reference internal" href="tensors.html#torch.Tensor.uniform_" title="torch.Tensor.uniform_"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.Tensor.uniform_()</span></code></a> - numbers sampled from the continuous uniform distribution</p></li>
</ul>
</div>
<div class="section" id="quasi-random-sampling">
<h3>Quasi-random sampling<a class="headerlink" href="#quasi-random-sampling" title="Permalink to this headline">¶</a></h3>
<dl class="class">
<dt id="torch.quasirandom.SobolEngine">
<em class="property">class </em><code class="descclassname">torch.quasirandom.</code><code class="descname">SobolEngine</code><span class="sig-paren">(</span><em>dimension</em>, <em>scramble=False</em>, <em>seed=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/quasirandom.html#SobolEngine"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.quasirandom.SobolEngine" title="Permalink to this definition">¶</a></dt>
<dd><p>The <a class="reference internal" href="#torch.quasirandom.SobolEngine" title="torch.quasirandom.SobolEngine"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.quasirandom.SobolEngine</span></code></a> is an engine for generating
(scrambled) Sobol sequences. Sobol sequences are an example of low
discrepancy quasi-random sequences.</p>
<p>This implementation of an engine for Sobol sequences is capable of
sampling sequences up to a maximum dimension of 1111. It uses direction
numbers to generate these sequences, and these numbers have been adapted
from <a class="reference external" href="http://web.maths.unsw.edu.au/~fkuo/sobol/joe-kuo-old.1111">here</a>.</p>
<p class="rubric">References</p>
<ul class="simple">
<li><p>Art B. Owen. Scrambling Sobol and Niederreiter-Xing points.
Journal of Complexity, 14(4):466-489, December 1998.</p></li>
<li><p>I. M. Sobol. The distribution of points in a cube and the accurate
evaluation of integrals.
Zh. Vychisl. Mat. i Mat. Phys., 7:784-802, 1967.</p></li>
</ul>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>dimension</strong> (<em>Int</em>) – The dimensionality of the sequence to be drawn</p></li>
<li><p><strong>scramble</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – Setting this to <code class="docutils literal notranslate"><span class="pre">True</span></code> will produce
scrambled Sobol sequences. Scrambling is
capable of producing better Sobol
sequences. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
<li><p><strong>seed</strong> (<em>Int</em><em>, </em><em>optional</em>) – This is the seed for the scrambling. The seed
of the random number generator is set to this,
if specified. Default: <code class="docutils literal notranslate"><span class="pre">None</span></code></p></li>
</ul>
</dd>
</dl>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">soboleng</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">quasirandom</span><span class="o">.</span><span class="n">SobolEngine</span><span class="p">(</span><span class="n">dimension</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">soboleng</span><span class="o">.</span><span class="n">draw</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[0.5000, 0.5000, 0.5000, 0.5000, 0.5000],</span>
<span class="go">        [0.7500, 0.2500, 0.7500, 0.2500, 0.7500],</span>
<span class="go">        [0.2500, 0.7500, 0.2500, 0.7500, 0.2500]])</span>
</pre></div>
</div>
<dl class="method">
<dt id="torch.quasirandom.SobolEngine.draw">
<code class="descname">draw</code><span class="sig-paren">(</span><em>n=1</em>, <em>out=None</em>, <em>dtype=torch.float32</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/quasirandom.html#SobolEngine.draw"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.quasirandom.SobolEngine.draw" title="Permalink to this definition">¶</a></dt>
<dd><p>Function to draw a sequence of <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code> points from a Sobol sequence.
Note that the samples are dependent on the previous samples. The size
of the result is <span class="math">\((n, dimension)\)</span>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>n</strong> (<em>Int</em><em>, </em><em>optional</em>) – The length of sequence of points to draw.
Default: 1</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – The output tensor</p></li>
<li><p><strong>dtype</strong> (<code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code>, optional) – the desired data type of the
returned tensor.
Default: <code class="docutils literal notranslate"><span class="pre">torch.float32</span></code></p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="torch.quasirandom.SobolEngine.fast_forward">
<code class="descname">fast_forward</code><span class="sig-paren">(</span><em>n</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/quasirandom.html#SobolEngine.fast_forward"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.quasirandom.SobolEngine.fast_forward" title="Permalink to this definition">¶</a></dt>
<dd><p>Function to fast-forward the state of the <code class="docutils literal notranslate"><span class="pre">SobolEngine</span></code> by
<code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code> steps. This is equivalent to drawing <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code> samples
without using the samples.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>n</strong> (<em>Int</em>) – The number of steps to fast-forward by.</p>
</dd>
</dl>
</dd></dl>

<dl class="method">
<dt id="torch.quasirandom.SobolEngine.reset">
<code class="descname">reset</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/quasirandom.html#SobolEngine.reset"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.quasirandom.SobolEngine.reset" title="Permalink to this definition">¶</a></dt>
<dd><p>Function to reset the <code class="docutils literal notranslate"><span class="pre">SobolEngine</span></code> to base state.</p>
</dd></dl>

</dd></dl>

</div>
</div>
<div class="section" id="serialization">
<h2>Serialization<a class="headerlink" href="#serialization" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="torch.save">
<code class="descclassname">torch.</code><code class="descname">save</code><span class="sig-paren">(</span><em>obj</em>, <em>f</em>, <em>pickle_module=pickle</em>, <em>pickle_protocol=2</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/serialization.html#save"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.save" title="Permalink to this definition">¶</a></dt>
<dd><p>Saves an object to a disk file.</p>
<p>See also: <a class="reference internal" href="notes/serialization.html#recommend-saving-models"><span class="std std-ref">Recommended approach for saving a model</span></a></p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>obj</strong> – saved object</p></li>
<li><p><strong>f</strong> – a file-like object (has to implement write and flush) or a string
containing a file name</p></li>
<li><p><strong>pickle_module</strong> – module used for pickling metadata and objects</p></li>
<li><p><strong>pickle_protocol</strong> – can be specified to override the default protocol</p></li>
</ul>
</dd>
</dl>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>If you are using Python 2, torch.save does NOT support StringIO.StringIO
as a valid file-like object. This is because the write method should return
the number of bytes written; StringIO.write() does not do this.</p>
<p>Please use something like io.BytesIO instead.</p>
</div>
<p class="rubric">Example</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># Save to file</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">save</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="s1">&#39;tensor.pt&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Save to io.BytesIO buffer</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">buffer</span> <span class="o">=</span> <span class="n">io</span><span class="o">.</span><span class="n">BytesIO</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">save</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">buffer</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.load">
<code class="descclassname">torch.</code><code class="descname">load</code><span class="sig-paren">(</span><em>f</em>, <em>map_location=None</em>, <em>pickle_module=pickle</em>, <em>**pickle_load_args</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/serialization.html#load"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.load" title="Permalink to this definition">¶</a></dt>
<dd><p>Loads an object saved with <a class="reference internal" href="#torch.save" title="torch.save"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.save()</span></code></a> from a file.</p>
<p><a class="reference internal" href="#torch.load" title="torch.load"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.load()</span></code></a> uses Python’s unpickling facilities but treats storages,
which underlie tensors, specially. They are first deserialized on the
CPU and are then moved to the device they were saved from. If this fails
(e.g. because the run time system doesn’t have certain devices), an exception
is raised. However, storages can be dynamically remapped to an alternative
set of devices using the <cite>map_location</cite> argument.</p>
<p>If <cite>map_location</cite> is a callable, it will be called once for each serialized
storage with two arguments: storage and location. The storage argument
will be the initial deserialization of the storage, residing on the CPU.
Each serialized storage has a location tag associated with it which
identifies the device it was saved from, and this tag is the second
argument passed to map_location. The builtin location tags are <cite>‘cpu’</cite> for
CPU tensors and <cite>‘cuda:device_id’</cite> (e.g. <cite>‘cuda:2’</cite>) for CUDA tensors.
<cite>map_location</cite> should return either None or a storage. If <cite>map_location</cite> returns
a storage, it will be used as the final deserialized object, already moved to
the right device. Otherwise, <span class="math">\(torch.load\)</span> will fall back to the default
behavior, as if <cite>map_location</cite> wasn’t specified.</p>
<p>If <cite>map_location</cite> is a string, it should be a device tag, where all tensors
should be loaded.</p>
<p>Otherwise, if <cite>map_location</cite> is a dict, it will be used to remap location tags
appearing in the file (keys), to ones that specify where to put the
storages (values).</p>
<p>User extensions can register their own location tags and tagging and
deserialization methods using <cite>register_package</cite>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>f</strong> – a file-like object (has to implement read, readline, tell, and seek),
or a string containing a file name</p></li>
<li><p><strong>map_location</strong> – a function, torch.device, string or a dict specifying how to remap storage
locations</p></li>
<li><p><strong>pickle_module</strong> – module used for unpickling metadata and objects (has to
match the pickle_module used to serialize file)</p></li>
<li><p><strong>pickle_load_args</strong> – optional keyword arguments passed over to
<code class="docutils literal notranslate"><span class="pre">pickle_module.load</span></code> and <code class="docutils literal notranslate"><span class="pre">pickle_module.Unpickler</span></code>, e.g.,
<code class="docutils literal notranslate"><span class="pre">encoding=...</span></code>.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When you call <a class="reference internal" href="#torch.load" title="torch.load"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.load()</span></code></a> on a file which contains GPU tensors, those tensors
will be loaded to GPU by default. You can call <cite>torch.load(.., map_location=’cpu’)</cite>
and then <code class="xref py py-meth docutils literal notranslate"><span class="pre">load_state_dict()</span></code> to avoid GPU RAM surge when loading a model checkpoint.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>In Python 3, when loading files saved by Python 2, you may encounter
<code class="docutils literal notranslate"><span class="pre">UnicodeDecodeError:</span> <span class="pre">'ascii'</span> <span class="pre">codec</span> <span class="pre">can't</span> <span class="pre">decode</span> <span class="pre">byte</span> <span class="pre">0x...</span></code>. This is
caused by the difference of handling in byte strings in Python2 and
Python 3. You may use extra <code class="docutils literal notranslate"><span class="pre">encoding</span></code> keyword argument to specify how
these objects should be loaded, e.g., <code class="docutils literal notranslate"><span class="pre">encoding='latin1'</span></code> decodes them
to strings using <code class="docutils literal notranslate"><span class="pre">latin1</span></code> encoding, and <code class="docutils literal notranslate"><span class="pre">encoding='bytes'</span></code> keeps them
as byte arrays which can be decoded later with <code class="docutils literal notranslate"><span class="pre">byte_array.decode(...)</span></code>.</p>
</div>
<p class="rubric">Example</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;tensors.pt&#39;</span><span class="p">)</span>
<span class="go"># Load all tensors onto the CPU</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;tensors.pt&#39;</span><span class="p">,</span> <span class="n">map_location</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">device</span><span class="p">(</span><span class="s1">&#39;cpu&#39;</span><span class="p">))</span>
<span class="go"># Load all tensors onto the CPU, using a function</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;tensors.pt&#39;</span><span class="p">,</span> <span class="n">map_location</span><span class="o">=</span><span class="k">lambda</span> <span class="n">storage</span><span class="p">,</span> <span class="n">loc</span><span class="p">:</span> <span class="n">storage</span><span class="p">)</span>
<span class="go"># Load all tensors onto GPU 1</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;tensors.pt&#39;</span><span class="p">,</span> <span class="n">map_location</span><span class="o">=</span><span class="k">lambda</span> <span class="n">storage</span><span class="p">,</span> <span class="n">loc</span><span class="p">:</span> <span class="n">storage</span><span class="o">.</span><span class="n">cuda</span><span class="p">(</span><span class="mi">1</span><span class="p">))</span>
<span class="go"># Map tensors from GPU 1 to GPU 0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;tensors.pt&#39;</span><span class="p">,</span> <span class="n">map_location</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;cuda:1&#39;</span><span class="p">:</span><span class="s1">&#39;cuda:0&#39;</span><span class="p">})</span>
<span class="go"># Load tensor from io.BytesIO object</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="s1">&#39;tensor.pt&#39;</span><span class="p">,</span> <span class="s1">&#39;rb&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
<span class="go">        buffer = io.BytesIO(f.read())</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="n">buffer</span><span class="p">)</span>
</pre></div>
</div>
</dd></dl>

</div>
<div class="section" id="parallelism">
<h2>Parallelism<a class="headerlink" href="#parallelism" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="torch.get_num_threads">
<code class="descclassname">torch.</code><code class="descname">get_num_threads</code><span class="sig-paren">(</span><span class="sig-paren">)</span> &#x2192; int<a class="headerlink" href="#torch.get_num_threads" title="Permalink to this definition">¶</a></dt>
<dd><p>Gets the number of threads used for parallelizing CPU operations</p>
</dd></dl>

<dl class="function">
<dt id="torch.set_num_threads">
<code class="descclassname">torch.</code><code class="descname">set_num_threads</code><span class="sig-paren">(</span><em>int</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.set_num_threads" title="Permalink to this definition">¶</a></dt>
<dd><p>Sets the number of threads used for parallelizing CPU operations.
WARNING:
To ensure that the correct number of threads is used, set_num_threads
must be called before running eager, JIT or autograd code.</p>
</dd></dl>

</div>
<div class="section" id="locally-disabling-gradient-computation">
<h2>Locally disabling gradient computation<a class="headerlink" href="#locally-disabling-gradient-computation" title="Permalink to this headline">¶</a></h2>
<p>The context managers <code class="xref py py-func docutils literal notranslate"><span class="pre">torch.no_grad()</span></code>, <code class="xref py py-func docutils literal notranslate"><span class="pre">torch.enable_grad()</span></code>, and
<code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_grad_enabled()</span></code> are helpful for locally disabling and enabling
gradient computation. See <a class="reference internal" href="autograd.html#locally-disable-grad"><span class="std std-ref">Locally disabling gradient computation</span></a> for more details on
their usage.</p>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">requires_grad</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">with</span> <span class="n">torch</span><span class="o">.</span><span class="n">no_grad</span><span class="p">():</span>
<span class="gp">... </span>    <span class="n">y</span> <span class="o">=</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">requires_grad</span>
<span class="go">False</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">is_train</span> <span class="o">=</span> <span class="kc">False</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">with</span> <span class="n">torch</span><span class="o">.</span><span class="n">set_grad_enabled</span><span class="p">(</span><span class="n">is_train</span><span class="p">):</span>
<span class="gp">... </span>    <span class="n">y</span> <span class="o">=</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">requires_grad</span>
<span class="go">False</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_grad_enabled</span><span class="p">(</span><span class="kc">True</span><span class="p">)</span>  <span class="c1"># this can also be used as a function</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">requires_grad</span>
<span class="go">True</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">set_grad_enabled</span><span class="p">(</span><span class="kc">False</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">x</span> <span class="o">*</span> <span class="mi">2</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">requires_grad</span>
<span class="go">False</span>
</pre></div>
</div>
</div>
<div class="section" id="math-operations">
<h2>Math operations<a class="headerlink" href="#math-operations" title="Permalink to this headline">¶</a></h2>
<div class="section" id="pointwise-ops">
<h3>Pointwise Ops<a class="headerlink" href="#pointwise-ops" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="torch.abs">
<code class="descclassname">torch.</code><code class="descname">abs</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.abs" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the element-wise absolute value of the given <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<div class="math">
\[\text{out}_{i} = |\text{input}_{i}|

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">abs</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="o">-</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="mi">3</span><span class="p">]))</span>
<span class="go">tensor([ 1,  2,  3])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.acos">
<code class="descclassname">torch.</code><code class="descname">acos</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.acos" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the arccosine  of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \cos^{-1}(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.3348, -0.5889,  0.2005, -0.1584])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">acos</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 1.2294,  2.2004,  1.3690,  1.7298])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.add">
<code class="descclassname">torch.</code><code class="descname">add</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.add" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">add</code><span class="sig-paren">(</span><em>input</em>, <em>value</em>, <em>out=None</em><span class="sig-paren">)</span></dt>
<dd></dd></dl>

<p>Adds the scalar <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> to each element of the input <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>
and returns a new resulting tensor.</p>
<div class="math">
\[\text{out} = \text{input} + \text{value}

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is of type FloatTensor or DoubleTensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> must be
a real number, otherwise it should be an integer.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>value</strong> (<em>Number</em>) – the number to be added to each element of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Keyword Arguments</dt>
<dd class="field-even"><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.0202,  1.0985,  1.3506, -0.6056])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">20</span><span class="p">)</span>
<span class="go">tensor([ 20.0202,  21.0985,  21.3506,  19.3944])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">add</code><span class="sig-paren">(</span><em>input</em>, <em>value=1</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span></dt>
<dd></dd></dl>

<p>Each element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> is multiplied by the scalar
<code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> and added to each element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.
The resulting tensor is returned.</p>
<p>The shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<div class="math">
\[\text{out} = \text{input} + \text{value} \times \text{other}

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> is of type FloatTensor or DoubleTensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> must be
a real number, otherwise it should be an integer.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first input tensor</p></li>
<li><p><strong>value</strong> (<em>Number</em>) – the scalar multiplier for <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code></p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second input tensor</p></li>
</ul>
</dd>
<dt class="field-even">Keyword Arguments</dt>
<dd class="field-even"><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.9732, -0.3497,  0.6245,  0.4022])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([[ 0.3743],</span>
<span class="go">        [-1.7724],</span>
<span class="go">        [-0.5811],</span>
<span class="go">        [-0.8017]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">10</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="go">tensor([[  2.7695,   3.3930,   4.3672,   4.1450],</span>
<span class="go">        [-18.6971, -18.0736, -17.0994, -17.3216],</span>
<span class="go">        [ -6.7845,  -6.1610,  -5.1868,  -5.4090],</span>
<span class="go">        [ -8.9902,  -8.3667,  -7.3925,  -7.6147]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.addcdiv">
<code class="descclassname">torch.</code><code class="descname">addcdiv</code><span class="sig-paren">(</span><em>tensor</em>, <em>value=1</em>, <em>tensor1</em>, <em>tensor2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.addcdiv" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs the element-wise division of <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor1</span></code> by <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor2</span></code>,
multiply the result by the scalar <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> and add it to <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a>.</p>
<div class="math">
\[\text{out}_i = \text{tensor}_i + \text{value} \times \frac{\text{tensor1}_i}{\text{tensor2}_i}

\]</div>
<p>The shapes of <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor1</span></code>, and <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor2</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<p>For inputs of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> must be
a real number, otherwise an integer.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to be added</p></li>
<li><p><strong>value</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <span class="math">\(\text{tensor1} / \text{tensor2}\)</span></p></li>
<li><p><strong>tensor1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the numerator tensor</p></li>
<li><p><strong>tensor2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the denominator tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">addcdiv</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="mf">0.1</span><span class="p">,</span> <span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">)</span>
<span class="go">tensor([[-0.2312, -3.6496,  0.1312],</span>
<span class="go">        [-1.0428,  3.4292, -0.1030],</span>
<span class="go">        [-0.5369, -0.9829,  0.0430]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.addcmul">
<code class="descclassname">torch.</code><code class="descname">addcmul</code><span class="sig-paren">(</span><em>tensor</em>, <em>value=1</em>, <em>tensor1</em>, <em>tensor2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.addcmul" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs the element-wise multiplication of <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor1</span></code>
by <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor2</span></code>, multiply the result by the scalar <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code>
and add it to <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a>.</p>
<div class="math">
\[\text{out}_i = \text{tensor}_i + \text{value} \times \text{tensor1}_i \times \text{tensor2}_i

\]</div>
<p>The shapes of <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor1</span></code>, and <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor2</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<p>For inputs of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> must be
a real number, otherwise an integer.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to be added</p></li>
<li><p><strong>value</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <span class="math">\(tensor1 .* tensor2\)</span></p></li>
<li><p><strong>tensor1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to be multiplied</p></li>
<li><p><strong>tensor2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">t2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">addcmul</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="mf">0.1</span><span class="p">,</span> <span class="n">t1</span><span class="p">,</span> <span class="n">t2</span><span class="p">)</span>
<span class="go">tensor([[-0.8635, -0.6391,  1.6174],</span>
<span class="go">        [-0.7617, -0.5879,  1.7388],</span>
<span class="go">        [-0.8353, -0.6249,  1.6511]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.asin">
<code class="descclassname">torch.</code><code class="descname">asin</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.asin" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the arcsine  of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \sin^{-1}(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.5962,  1.4985, -0.4396,  1.4525])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">asin</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-0.6387,     nan, -0.4552,     nan])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.atan">
<code class="descclassname">torch.</code><code class="descname">atan</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.atan" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the arctangent  of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \tan^{-1}(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.2341,  0.2539, -0.6256, -0.6448])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">atan</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 0.2299,  0.2487, -0.5591, -0.5727])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.atan2">
<code class="descclassname">torch.</code><code class="descname">atan2</code><span class="sig-paren">(</span><em>input1</em>, <em>input2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.atan2" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the arctangent of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input1</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">input2</span></code>.</p>
<p>The shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">input2</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first input tensor</p></li>
<li><p><strong>input2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.9041,  0.0196, -0.3108, -2.4423])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">atan2</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">))</span>
<span class="go">tensor([ 0.9833,  0.0811, -1.9743, -1.4151])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.ceil">
<code class="descclassname">torch.</code><code class="descname">ceil</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ceil" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the ceil of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>,
the smallest integer greater than or equal to each element.</p>
<div class="math">
\[\text{out}_{i} = \left\lceil \text{input}_{i} \right\rceil = \left\lfloor \text{input}_{i} \right\rfloor + 1

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.6341, -1.4208, -1.0900,  0.5826])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ceil</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-0., -1., -1.,  1.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.clamp">
<code class="descclassname">torch.</code><code class="descname">clamp</code><span class="sig-paren">(</span><em>input</em>, <em>min</em>, <em>max</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.clamp" title="Permalink to this definition">¶</a></dt>
<dd><p>Clamp all elements in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> into the range <cite>[</cite> <a class="reference internal" href="#torch.min" title="torch.min"><code class="xref py py-attr docutils literal notranslate"><span class="pre">min</span></code></a>, <a class="reference internal" href="#torch.max" title="torch.max"><code class="xref py py-attr docutils literal notranslate"><span class="pre">max</span></code></a> <cite>]</cite> and return
a resulting tensor:</p>
<div class="math">
\[y_i = \begin{cases}
    \text{min} & \text{if } x_i < \text{min} \\
    x_i & \text{if } \text{min} \leq x_i \leq \text{max} \\
    \text{max} & \text{if } x_i > \text{max}
\end{cases}

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, args <a class="reference internal" href="#torch.min" title="torch.min"><code class="xref py py-attr docutils literal notranslate"><span class="pre">min</span></code></a>
and <a class="reference internal" href="#torch.max" title="torch.max"><code class="xref py py-attr docutils literal notranslate"><span class="pre">max</span></code></a> must be real numbers, otherwise they should be integers.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>min</strong> (<em>Number</em>) – lower-bound of the range to be clamped to</p></li>
<li><p><strong>max</strong> (<em>Number</em>) – upper-bound of the range to be clamped to</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-1.7120,  0.1734, -0.0478, -0.0922])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">clamp</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="nb">min</span><span class="o">=-</span><span class="mf">0.5</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">tensor([-0.5000,  0.1734, -0.0478, -0.0922])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">clamp</code><span class="sig-paren">(</span><em>input</em>, <em>*</em>, <em>min</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Clamps all elements in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> to be larger or equal <a class="reference internal" href="#torch.min" title="torch.min"><code class="xref py py-attr docutils literal notranslate"><span class="pre">min</span></code></a>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code>
should be a real number, otherwise it should be an integer.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>value</strong> (<em>Number</em>) – minimal value of each element in the output</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.0299, -2.3184,  2.1593, -0.8883])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">clamp</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="nb">min</span><span class="o">=</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">tensor([ 0.5000,  0.5000,  2.1593,  0.5000])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">clamp</code><span class="sig-paren">(</span><em>input</em>, <em>*</em>, <em>max</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Clamps all elements in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> to be smaller or equal <a class="reference internal" href="#torch.max" title="torch.max"><code class="xref py py-attr docutils literal notranslate"><span class="pre">max</span></code></a>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code>
should be a real number, otherwise it should be an integer.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>value</strong> (<em>Number</em>) – maximal value of each element in the output</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.7753, -0.4702, -0.4599,  1.1899])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">clamp</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mf">0.5</span><span class="p">)</span>
<span class="go">tensor([ 0.5000, -0.4702, -0.4599,  0.5000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cos">
<code class="descclassname">torch.</code><code class="descname">cos</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cos" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the cosine  of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \cos(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 1.4309,  1.2706, -0.8562,  0.9796])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cos</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 0.1395,  0.2957,  0.6553,  0.5574])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cosh">
<code class="descclassname">torch.</code><code class="descname">cosh</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cosh" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the hyperbolic cosine  of the elements of
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \cosh(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.1632,  1.1835, -0.6979, -0.7325])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cosh</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 1.0133,  1.7860,  1.2536,  1.2805])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.div">
<code class="descclassname">torch.</code><code class="descname">div</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.div" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">div</code><span class="sig-paren">(</span><em>input</em>, <em>value</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Divides each element of the input <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> with the scalar <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code>
and returns a new resulting tensor.</p>
<div class="math">
\[\text{out}_i = \frac{\text{input}_i}{\text{value}}

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code>
should be a real number, otherwise it should be an integer</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>value</strong> (<em>Number</em>) – the number to be divided to each element of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code></p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.3810,  1.2774, -0.2972, -0.3719,  0.4637])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">div</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">)</span>
<span class="go">tensor([ 0.7620,  2.5548, -0.5944, -0.7439,  0.9275])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">div</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Each element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is divided by each element
of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code>. The resulting tensor is returned. The shapes of
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<div class="math">
\[\text{out}_i = \frac{\text{input}_i}{\text{other}_i}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the numerator tensor</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the denominator tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.3711, -1.9353, -0.4605, -0.2917],</span>
<span class="go">        [ 0.1815, -1.0111,  0.9805, -1.5923],</span>
<span class="go">        [ 0.1062,  1.4581,  0.7759, -1.2344],</span>
<span class="go">        [-0.1830, -0.0313,  1.1908, -1.4757]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([ 0.8032,  0.2930, -0.8113, -0.2308])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">div</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="go">tensor([[-0.4620, -6.6051,  0.5676,  1.2637],</span>
<span class="go">        [ 0.2260, -3.4507, -1.2086,  6.8988],</span>
<span class="go">        [ 0.1322,  4.9764, -0.9564,  5.3480],</span>
<span class="go">        [-0.2278, -0.1068, -1.4678,  6.3936]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.digamma">
<code class="descclassname">torch.</code><code class="descname">digamma</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.digamma" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the logarithmic derivative of the gamma function on <cite>input</cite>.</p>
<div class="math">
\[\psi(x) = \frac{d}{dx} \ln\left(\Gamma\left(x\right)\right) = \frac{\Gamma'(x)}{\Gamma(x)}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compute the digamma function on</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">digamma</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-0.5772, -1.9635])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.erf">
<code class="descclassname">torch.</code><code class="descname">erf</code><span class="sig-paren">(</span><em>tensor</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.erf" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the error function of each element. The error function is defined as follows:</p>
<div class="math">
\[\mathrm{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">erf</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">10.</span><span class="p">]))</span>
<span class="go">tensor([ 0.0000, -0.8427,  1.0000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.erfc">
<code class="descclassname">torch.</code><code class="descname">erfc</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.erfc" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the complementary error function of each element of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.
The complementary error function is defined as follows:</p>
<div class="math">
\[\mathrm{erfc}(x) = 1 - \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} dt

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">erfc</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">10.</span><span class="p">]))</span>
<span class="go">tensor([ 1.0000, 1.8427,  0.0000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.erfinv">
<code class="descclassname">torch.</code><code class="descname">erfinv</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.erfinv" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the inverse error function of each element of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.
The inverse error function is defined in the range <span class="math">\((-1, 1)\)</span> as:</p>
<div class="math">
\[\mathrm{erfinv}(\mathrm{erf}(x)) = x

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">erfinv</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.</span><span class="p">]))</span>
<span class="go">tensor([ 0.0000,  0.4769,    -inf])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.exp">
<code class="descclassname">torch.</code><code class="descname">exp</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.exp" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the exponential of the elements
of the input tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[y_{i} = e^{x_{i}}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">exp</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="n">math</span><span class="o">.</span><span class="n">log</span><span class="p">(</span><span class="mf">2.</span><span class="p">)]))</span>
<span class="go">tensor([ 1.,  2.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.expm1">
<code class="descclassname">torch.</code><code class="descname">expm1</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.expm1" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the exponential of the elements minus 1
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[y_{i} = e^{x_{i}} - 1

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">expm1</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">0</span><span class="p">,</span> <span class="n">math</span><span class="o">.</span><span class="n">log</span><span class="p">(</span><span class="mf">2.</span><span class="p">)]))</span>
<span class="go">tensor([ 0.,  1.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.floor">
<code class="descclassname">torch.</code><code class="descname">floor</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.floor" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the floor of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>,
the largest integer less than or equal to each element.</p>
<div class="math">
\[\text{out}_{i} = \left\lfloor \text{input}_{i} \right\rfloor

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.8166,  1.5308, -0.2530, -0.2091])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">floor</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-1.,  1., -1., -1.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.fmod">
<code class="descclassname">torch.</code><code class="descname">fmod</code><span class="sig-paren">(</span><em>input</em>, <em>divisor</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.fmod" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the element-wise remainder of division.</p>
<p>The dividend and divisor may contain both for integer and floating point
numbers. The remainder has the same sign as the dividend <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">divisor</span></code> is a tensor, the shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">divisor</span></code> must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the dividend</p></li>
<li><p><strong>divisor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the divisor, which may be either a number or a tensor of the same shape as the dividend</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">fmod</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="o">-</span><span class="mf">3.</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]),</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([-1., -0., -1.,  1.,  0.,  1.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">fmod</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]),</span> <span class="mf">1.5</span><span class="p">)</span>
<span class="go">tensor([ 1.0000,  0.5000,  0.0000,  1.0000,  0.5000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.frac">
<code class="descclassname">torch.</code><code class="descname">frac</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.frac" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the fractional portion of each element in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \text{input}_{i} - \left\lfloor \text{input}_{i} \right\rfloor

\]</div>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">frac</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mf">2.5</span><span class="p">,</span> <span class="o">-</span><span class="mf">3.2</span><span class="p">]))</span>
<span class="go">tensor([ 0.0000,  0.5000, -0.2000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.lerp">
<code class="descclassname">torch.</code><code class="descname">lerp</code><span class="sig-paren">(</span><em>start</em>, <em>end</em>, <em>weight</em>, <em>out=None</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.lerp" title="Permalink to this definition">¶</a></dt>
<dd><p>Does a linear interpolation of two tensors <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code> based
on a scalar or tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">weight</span></code> and returns the resulting <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> tensor.</p>
<div class="math">
\[\text{out}_i = \text{start}_i + \text{weight}_i \times (\text{end}_i - \text{start}_i)

\]</div>
<p>The shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">weight</span></code> is a tensor, then
the shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">start</span></code>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">end</span></code> must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>start</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor with the starting points</p></li>
<li><p><strong>end</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor with the ending points</p></li>
<li><p><strong>weight</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em> or </em><em>tensor</em>) – the weight for the interpolation formula</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">start</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">5.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">end</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span><span class="o">.</span><span class="n">fill_</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">start</span>
<span class="go">tensor([ 1.,  2.,  3.,  4.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">end</span>
<span class="go">tensor([ 10.,  10.,  10.,  10.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">lerp</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">)</span>
<span class="go">tensor([ 5.5000,  6.0000,  6.5000,  7.0000])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">lerp</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="n">end</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">full_like</span><span class="p">(</span><span class="n">start</span><span class="p">,</span> <span class="mf">0.5</span><span class="p">))</span>
<span class="go">tensor([ 5.5000,  6.0000,  6.5000,  7.0000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.log">
<code class="descclassname">torch.</code><code class="descname">log</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.log" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the natural logarithm of the elements
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[y_{i} = \log_{e} (x_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.7168, -0.5471, -0.8933, -1.4428, -0.1190])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">log</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ nan,  nan,  nan,  nan,  nan])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.log10">
<code class="descclassname">torch.</code><code class="descname">log10</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.log10" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the logarithm to the base 10 of the elements
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[y_{i} = \log_{10} (x_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">rand</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.5224,  0.9354,  0.7257,  0.1301,  0.2251])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">log10</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-0.2820, -0.0290, -0.1392, -0.8857, -0.6476])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.log1p">
<code class="descclassname">torch.</code><code class="descname">log1p</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.log1p" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the natural logarithm of (1 + <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>).</p>
<div class="math">
\[y_i = \log_{e} (x_i + 1)

\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function is more accurate than <a class="reference internal" href="#torch.log" title="torch.log"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.log()</span></code></a> for small
values of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-1.0090, -0.9923,  1.0249, -0.5372,  0.2492])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">log1p</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([    nan, -4.8653,  0.7055, -0.7705,  0.2225])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.log2">
<code class="descclassname">torch.</code><code class="descname">log2</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.log2" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the logarithm to the base 2 of the elements
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[y_{i} = \log_{2} (x_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">rand</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.8419,  0.8003,  0.9971,  0.5287,  0.0490])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">log2</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-0.2483, -0.3213, -0.0042, -0.9196, -4.3504])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.mul">
<code class="descclassname">torch.</code><code class="descname">mul</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.mul" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">mul</code><span class="sig-paren">(</span><em>input</em>, <em>value</em>, <em>out=None</em><span class="sig-paren">)</span></dt>
<dd></dd></dl>

<p>Multiplies each element of the input <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> with the scalar
<code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code> and returns a new resulting tensor.</p>
<div class="math">
\[\text{out}_i = \text{value} \times \text{input}_i

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">value</span></code>
should be a real number, otherwise it should be an integer</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>value</strong> (<em>Number</em>) – the number to be multiplied to each element of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code></p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.2015, -0.4255,  2.6087])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mul</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">100</span><span class="p">)</span>
<span class="go">tensor([  20.1494,  -42.5491,  260.8663])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">mul</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span></dt>
<dd></dd></dl>

<p>Each element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is multiplied by the corresponding
element of the Tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code>. The resulting tensor is returned.</p>
<p>The shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<div class="math">
\[\text{out}_i = \text{input}_i \times \text{other}_i

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first multiplicand tensor</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second multiplicand tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 1.1207],</span>
<span class="go">        [-0.3137],</span>
<span class="go">        [ 0.0700],</span>
<span class="go">        [ 0.8378]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([[ 0.5146,  0.1216, -0.5244,  2.2382]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mul</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="go">tensor([[ 0.5767,  0.1363, -0.5877,  2.5083],</span>
<span class="go">        [-0.1614, -0.0382,  0.1645, -0.7021],</span>
<span class="go">        [ 0.0360,  0.0085, -0.0367,  0.1567],</span>
<span class="go">        [ 0.4312,  0.1019, -0.4394,  1.8753]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.mvlgamma">
<code class="descclassname">torch.</code><code class="descname">mvlgamma</code><span class="sig-paren">(</span><em>input</em>, <em>p</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.mvlgamma" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the multivariate log-gamma function (<a class="reference external" href="https://en.wikipedia.org/wiki/Multivariate_gamma_function">[reference]</a>) with dimension <span class="math">\(p\)</span> element-wise, given by</p>
<div class="math">
\[\log(\Gamma_{p}(a)) = C + \displaystyle \sum_{i=1}^{p} \log\left(\Gamma\left(a - \frac{i - 1}{2}\right)\right)

\]</div>
<p>where <span class="math">\(C = \log(\pi) \times \frac{p (p - 1)}{4}\)</span> and <span class="math">\(\Gamma(\cdot)\)</span> is the Gamma function.</p>
<p>If any of the elements are less than or equal to <span class="math">\(\frac{p - 1}{2}\)</span>, then an error
is thrown.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compute the multivariate log-gamma function</p></li>
<li><p><strong>p</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the number of dimensions</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">empty</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span><span class="o">.</span><span class="n">uniform_</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[1.6835, 1.8474, 1.1929],</span>
<span class="go">        [1.0475, 1.7162, 1.4180]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mvlgamma</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([[0.3928, 0.4007, 0.7586],</span>
<span class="go">        [1.0311, 0.3901, 0.5049]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.neg">
<code class="descclassname">torch.</code><code class="descname">neg</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.neg" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the negative of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out} = -1 \times \text{input}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.0090, -0.2262, -0.0682, -0.2866,  0.3940])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-0.0090,  0.2262,  0.0682,  0.2866, -0.3940])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.pow">
<code class="descclassname">torch.</code><code class="descname">pow</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.pow" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">pow</code><span class="sig-paren">(</span><em>input</em>, <em>exponent</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Takes the power of each element in <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> with <code class="xref py py-attr docutils literal notranslate"><span class="pre">exponent</span></code> and
returns a tensor with the result.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">exponent</span></code> can be either a single <code class="docutils literal notranslate"><span class="pre">float</span></code> number or a <cite>Tensor</cite>
with the same number of elements as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">exponent</span></code> is a scalar value, the operation applied is:</p>
<div class="math">
\[\text{out}_i = x_i ^ \text{exponent}

\]</div>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">exponent</span></code> is a tensor, the operation applied is:</p>
<div class="math">
\[\text{out}_i = x_i ^ {\text{exponent}_i}

\]</div>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">exponent</span></code> is a tensor, the shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">exponent</span></code> must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>exponent</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em> or </em><em>tensor</em>) – the exponent value</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.4331,  1.2475,  0.6834, -0.2791])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">pow</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([ 0.1875,  1.5561,  0.4670,  0.0779])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">exp</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">5.</span><span class="p">)</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">5.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 1.,  2.,  3.,  4.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">exp</span>
<span class="go">tensor([ 1.,  2.,  3.,  4.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">pow</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">exp</span><span class="p">)</span>
<span class="go">tensor([   1.,    4.,   27.,  256.])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">pow</code><span class="sig-paren">(</span><em>base</em>, <em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">base</span></code> is a scalar <code class="docutils literal notranslate"><span class="pre">float</span></code> value, and <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a tensor.
The returned tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> is of the same shape as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code></p>
<p>The operation applied is:</p>
<div class="math">
\[out_i = base ^ {input_i}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>base</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the scalar base value for the power operation</p></li>
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the exponent tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">exp</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">5.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">base</span> <span class="o">=</span> <span class="mi">2</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">pow</span><span class="p">(</span><span class="n">base</span><span class="p">,</span> <span class="n">exp</span><span class="p">)</span>
<span class="go">tensor([  2.,   4.,   8.,  16.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.reciprocal">
<code class="descclassname">torch.</code><code class="descname">reciprocal</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.reciprocal" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the reciprocal of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code></p>
<div class="math">
\[\text{out}_{i} = \frac{1}{\text{input}_{i}}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.4595, -2.1219, -1.4314,  0.7298])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">reciprocal</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-2.1763, -0.4713, -0.6986,  1.3702])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.remainder">
<code class="descclassname">torch.</code><code class="descname">remainder</code><span class="sig-paren">(</span><em>input</em>, <em>divisor</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.remainder" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the element-wise remainder of division.</p>
<p>The divisor and dividend may contain both for integer and floating point
numbers. The remainder has the same sign as the divisor.</p>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">divisor</span></code> is a tensor, the shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">divisor</span></code> must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the dividend</p></li>
<li><p><strong>divisor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the divisor that may be either a number or a
Tensor of the same shape as the dividend</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">remainder</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="o">-</span><span class="mf">3.</span><span class="p">,</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]),</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([ 1.,  0.,  1.,  1.,  0.,  1.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">remainder</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]),</span> <span class="mf">1.5</span><span class="p">)</span>
<span class="go">tensor([ 1.0000,  0.5000,  0.0000,  1.0000,  0.5000])</span>
</pre></div>
</div>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#torch.fmod" title="torch.fmod"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.fmod()</span></code></a>, which computes the element-wise remainder of
division equivalently to the C library function <code class="docutils literal notranslate"><span class="pre">fmod()</span></code>.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.round">
<code class="descclassname">torch.</code><code class="descname">round</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.round" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with each of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> rounded
to the closest integer.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.9920,  0.6077,  0.9734, -1.0362])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">round</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 1.,  1.,  1., -1.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.rsqrt">
<code class="descclassname">torch.</code><code class="descname">rsqrt</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.rsqrt" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the reciprocal of the square-root of each of
the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \frac{1}{\sqrt{\text{input}_{i}}}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.0370,  0.2970,  1.5420, -0.9105])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rsqrt</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([    nan,  1.8351,  0.8053,     nan])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sigmoid">
<code class="descclassname">torch.</code><code class="descname">sigmoid</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.sigmoid" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the sigmoid of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \frac{1}{1 + e^{-\text{input}_{i}}}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.9213,  1.0887, -0.8858, -1.7683])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 0.7153,  0.7481,  0.2920,  0.1458])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sign">
<code class="descclassname">torch.</code><code class="descname">sign</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.sign" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the sign of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">0.7</span><span class="p">,</span> <span class="o">-</span><span class="mf">1.2</span><span class="p">,</span> <span class="mf">0.</span><span class="p">,</span> <span class="mf">2.3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.7000, -1.2000,  0.0000,  2.3000])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sign</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 1., -1.,  0.,  1.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sin">
<code class="descclassname">torch.</code><code class="descname">sin</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.sin" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the sine of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \sin(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.5461,  0.1347, -2.7266, -0.2746])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-0.5194,  0.1343, -0.4032, -0.2711])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sinh">
<code class="descclassname">torch.</code><code class="descname">sinh</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.sinh" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the hyperbolic sine of the elements of
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \sinh(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.5380, -0.8632, -0.1265,  0.9399])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sinh</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 0.5644, -0.9744, -0.1268,  1.0845])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sqrt">
<code class="descclassname">torch.</code><code class="descname">sqrt</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.sqrt" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the square-root of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \sqrt{\text{input}_{i}}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-2.0755,  1.0226,  0.0831,  0.4806])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sqrt</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([    nan,  1.0112,  0.2883,  0.6933])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.tan">
<code class="descclassname">torch.</code><code class="descname">tan</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.tan" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the tangent of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \tan(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-1.2027, -1.7687,  0.4412, -1.3856])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tan</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([-2.5930,  4.9859,  0.4722, -5.3366])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.tanh">
<code class="descclassname">torch.</code><code class="descname">tanh</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.tanh" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the hyperbolic tangent of the elements
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="math">
\[\text{out}_{i} = \tanh(\text{input}_{i})

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.8986, -0.7279,  1.1745,  0.2611])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tanh</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 0.7156, -0.6218,  0.8257,  0.2553])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.trunc">
<code class="descclassname">torch.</code><code class="descname">trunc</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.trunc" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with the truncated integer values of
the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 3.4742,  0.5466, -0.8008, -0.9079])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">trunc</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([ 3.,  0., -0., -0.])</span>
</pre></div>
</div>
</dd></dl>

</div>
<div class="section" id="reduction-ops">
<h3>Reduction Ops<a class="headerlink" href="#reduction-ops" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="torch.argmax">
<code class="descclassname">torch.</code><code class="descname">argmax</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.argmax" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">argmax</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; LongTensor</dt>
<dd></dd></dl>

<p>Returns the indices of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<p>This is the second value returned by <a class="reference internal" href="#torch.max" title="torch.max"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.max()</span></code></a>. See its
documentation for the exact semantics of this method.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 1.3398,  0.2663, -0.2686,  0.2450],</span>
<span class="go">        [-0.7401, -0.8805, -0.3402, -1.1936],</span>
<span class="go">        [ 0.4907, -1.3948, -1.0691, -0.3132],</span>
<span class="go">        [-1.6092,  0.5419, -0.2993,  0.3195]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">argmax</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">argmax</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em><span class="sig-paren">)</span> &#x2192; LongTensor</dt>
<dd></dd></dl>

<p>Returns the indices of the maximum values of a tensor across a dimension.</p>
<p>This is the second value returned by <a class="reference internal" href="#torch.max" title="torch.max"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.max()</span></code></a>. See its
documentation for the exact semantics of this method.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to reduce. If <code class="docutils literal notranslate"><span class="pre">None</span></code>, the argmax of the
flattened input is returned.</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>
retained or not. Ignored if <code class="docutils literal notranslate"><span class="pre">dim=None</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 1.3398,  0.2663, -0.2686,  0.2450],</span>
<span class="go">        [-0.7401, -0.8805, -0.3402, -1.1936],</span>
<span class="go">        [ 0.4907, -1.3948, -1.0691, -0.3132],</span>
<span class="go">        [-1.6092,  0.5419, -0.2993,  0.3195]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">argmax</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([ 0,  2,  0,  1])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.argmin">
<code class="descclassname">torch.</code><code class="descname">argmin</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.argmin" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">argmin</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; LongTensor</dt>
<dd></dd></dl>

<p>Returns the indices of the minimum value of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<p>This is the second value returned by <a class="reference internal" href="#torch.min" title="torch.min"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.min()</span></code></a>. See its
documentation for the exact semantics of this method.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.1139,  0.2254, -0.1381,  0.3687],</span>
<span class="go">        [ 1.0100, -1.1975, -0.0102, -0.4732],</span>
<span class="go">        [-0.9240,  0.1207, -0.7506, -1.0213],</span>
<span class="go">        [ 1.7809, -1.2960,  0.9384,  0.1438]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">argmin</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(13)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">argmin</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; LongTensor</dt>
<dd></dd></dl>

<p>Returns the indices of the minimum values of a tensor across a dimension.</p>
<p>This is the second value returned by <a class="reference internal" href="#torch.min" title="torch.min"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.min()</span></code></a>. See its
documentation for the exact semantics of this method.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to reduce. If <code class="docutils literal notranslate"><span class="pre">None</span></code>, the argmin of the
flattened input is returned.</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>
retained or not. Ignored if <code class="docutils literal notranslate"><span class="pre">dim=None</span></code>.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.1139,  0.2254, -0.1381,  0.3687],</span>
<span class="go">        [ 1.0100, -1.1975, -0.0102, -0.4732],</span>
<span class="go">        [-0.9240,  0.1207, -0.7506, -1.0213],</span>
<span class="go">        [ 1.7809, -1.2960,  0.9384,  0.1438]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">argmin</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([ 2,  1,  3,  1])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cumprod">
<code class="descclassname">torch.</code><code class="descname">cumprod</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>out=None</em>, <em>dtype=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cumprod" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the cumulative product of elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> in the dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>.</p>
<p>For example, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a vector of size N, the result will also be
a vector of size N, with elements.</p>
<div class="math">
\[y_i = x_1 \times x_2\times x_3\times \dots \times x_i

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to do the operation over</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
If specified, the input tensor is casted to <code class="xref py py-attr docutils literal notranslate"><span class="pre">dtype</span></code> before the operation
is performed. This is useful for preventing data type overflows. Default: None.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.6001,  0.2069, -0.1919,  0.9792,  0.6727,  1.0062,  0.4126,</span>
<span class="go">        -0.2129, -0.4206,  0.1968])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cumprod</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([ 0.6001,  0.1241, -0.0238, -0.0233, -0.0157, -0.0158, -0.0065,</span>
<span class="go">         0.0014, -0.0006, -0.0001])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="o">=</span> <span class="mf">0.0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cumprod</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([ 0.6001,  0.1241, -0.0238, -0.0233, -0.0157, -0.0000, -0.0000,</span>
<span class="go">         0.0000, -0.0000, -0.0000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cumsum">
<code class="descclassname">torch.</code><code class="descname">cumsum</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>out=None</em>, <em>dtype=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cumsum" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the cumulative sum of elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> in the dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>.</p>
<p>For example, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a vector of size N, the result will also be
a vector of size N, with elements.</p>
<div class="math">
\[y_i = x_1 + x_2 + x_3 + \dots + x_i

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to do the operation over</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
If specified, the input tensor is casted to <code class="xref py py-attr docutils literal notranslate"><span class="pre">dtype</span></code> before the operation
is performed. This is useful for preventing data type overflows. Default: None.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.8286, -0.4890,  0.5155,  0.8443,  0.1865, -0.1752, -2.0595,</span>
<span class="go">         0.1850, -1.1571, -0.4243])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cumsum</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([-0.8286, -1.3175, -0.8020,  0.0423,  0.2289,  0.0537, -2.0058,</span>
<span class="go">        -1.8209, -2.9780, -3.4022])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.dist">
<code class="descclassname">torch.</code><code class="descname">dist</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>p=2</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.dist" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the p-norm of (<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> - <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code>)</p>
<p>The shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the Right-hand-side input tensor</p></li>
<li><p><strong>p</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>optional</em>) – the norm to be computed</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([-1.5393, -0.8675,  0.5916,  1.6321])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span>
<span class="go">tensor([ 0.0967, -1.0511,  0.6295,  0.8360])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dist</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="mf">3.5</span><span class="p">)</span>
<span class="go">tensor(1.6727)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dist</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">tensor(1.6973)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dist</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">tensor(inf)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dist</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor(2.6537)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.logsumexp">
<code class="descclassname">torch.</code><code class="descname">logsumexp</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>out=None</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.logsumexp" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the log of summed exponentials of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>
tensor in the given dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. The computation is numerically
stabilized.</p>
<p>For summation index <span class="math">\(j\)</span> given by <cite>dim</cite> and other indices <span class="math">\(i\)</span>, the result is</p>
<blockquote>
<div><div class="math">
\[\text{logsumexp}(x)_{i} = \log \sum_j \exp(x_{ij})

\]</div>
</div></blockquote>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensor is of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension(s) <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where it is of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in the
output tensor having 1 (or <code class="docutils literal notranslate"><span class="pre">len(dim)</span></code>) fewer dimension(s).</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of python:ints</em>) – the dimension or dimensions to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensor has <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<dl>
<dt>Example::</dt><dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">logsumexp</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([ 0.8442,  1.4322,  0.8711])</span>
</pre></div>
</div>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.mean">
<code class="descclassname">torch.</code><code class="descname">mean</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.mean" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">mean</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the mean value of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.2294, -0.5481,  1.3288]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mean</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0.3367)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">mean</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the mean value of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given
dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is a list of dimensions,
reduce over all of them.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensor is of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension(s) <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where it is of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in the
output tensor having 1 (or <code class="docutils literal notranslate"><span class="pre">len(dim)</span></code>) fewer dimension(s).</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of python:ints</em>) – the dimension or dimensions to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensor has <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.3841,  0.6320,  0.4254, -0.7384],</span>
<span class="go">        [-0.9644,  1.0131, -0.6549, -1.4279],</span>
<span class="go">        [-0.2951, -1.3350, -0.7694,  0.5600],</span>
<span class="go">        [ 1.0842, -0.9580,  0.3623,  0.2343]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mean</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([-0.0163, -0.5085, -0.4599,  0.1807])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mean</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="kc">True</span><span class="p">)</span>
<span class="go">tensor([[-0.0163],</span>
<span class="go">        [-0.5085],</span>
<span class="go">        [-0.4599],</span>
<span class="go">        [ 0.1807]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.median">
<code class="descclassname">torch.</code><code class="descname">median</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.median" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">median</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the median value of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 1.5219, -1.5212,  0.2202]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">median</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0.2202)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">median</code><span class="sig-paren">(</span><em>input</em>, <em>dim=-1</em>, <em>keepdim=False</em>, <em>values=None</em>, <em>indices=None) -&gt; (Tensor</em>, <em>LongTensor</em><span class="sig-paren">)</span></dt>
<dd></dd></dl>

<p>Returns a namedtuple <code class="docutils literal notranslate"><span class="pre">(values,</span> <span class="pre">indices)</span></code> where <code class="docutils literal notranslate"><span class="pre">values</span></code> is the median
value of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. And <code class="docutils literal notranslate"><span class="pre">indices</span></code> is the index location of each median value found.</p>
<p>By default, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is the last dimension of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensors are of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where they are of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in
the outputs tensor having 1 fewer dimension than <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>values</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>indices</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output index tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.2505, -0.3982, -0.9948,  0.3518, -1.3131],</span>
<span class="go">        [ 0.3180, -0.6993,  1.0436,  0.0438,  0.2270],</span>
<span class="go">        [-0.2751,  0.7303,  0.2192,  0.3321,  0.2488],</span>
<span class="go">        [ 1.0778, -1.9510,  0.7048,  0.4742, -0.7125]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">median</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">torch.return_types.median(values=tensor([-0.3982,  0.2270,  0.2488,  0.4742]), indices=tensor([1, 4, 4, 3]))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.mode">
<code class="descclassname">torch.</code><code class="descname">mode</code><span class="sig-paren">(</span><em>input</em>, <em>dim=-1</em>, <em>keepdim=False</em>, <em>values=None</em>, <em>indices=None) -&gt; (Tensor</em>, <em>LongTensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.mode" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a namedtuple <code class="docutils literal notranslate"><span class="pre">(values,</span> <span class="pre">indices)</span></code> where <code class="docutils literal notranslate"><span class="pre">values</span></code> is the mode
value of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>, i.e. a value which appears most often
in that row, and <code class="docutils literal notranslate"><span class="pre">indices</span></code> is the index location of each mode value found.</p>
<p>By default, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is the last dimension of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensors are of the same size as
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where they are of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting
in the output tensors having 1 fewer dimension than <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function is not defined for <code class="docutils literal notranslate"><span class="pre">torch.cuda.Tensor</span></code> yet.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>values</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
<li><p><strong>indices</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output index tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([6, 5, 1, 0, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">a</span> <span class="o">+</span> <span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">50</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span> <span class="o">*</span> <span class="mi">5</span><span class="p">)</span><span class="o">.</span><span class="n">long</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mode</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">torch.return_types.mode(values=tensor([6, 5, 1, 0, 2]), indices=tensor([2, 2, 2, 2, 2]))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.norm">
<code class="descclassname">torch.</code><code class="descname">norm</code><span class="sig-paren">(</span><em>input</em>, <em>p='fro'</em>, <em>dim=None</em>, <em>keepdim=False</em>, <em>out=None</em>, <em>dtype=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#norm"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.norm" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the matrix norm or vector norm of a given tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>p</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>inf</em><em>, </em><em>-inf</em><em>, </em><em>'fro'</em><em>, </em><em>'nuc'</em><em>, </em><em>optional</em>) – <p>the order of norm. Default: <code class="docutils literal notranslate"><span class="pre">'fro'</span></code>
The following norms can be calculated:</p>
<table class="docutils align-center">
<colgroup>
<col style="width: 8%" />
<col style="width: 47%" />
<col style="width: 44%" />
</colgroup>
<thead>
<tr class="row-odd"><th class="head"><p>ord</p></th>
<th class="head"><p>matrix norm</p></th>
<th class="head"><p>vector norm</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p>None</p></td>
<td><p>Frobenius norm</p></td>
<td><p>2-norm</p></td>
</tr>
<tr class="row-odd"><td><p>’fro’</p></td>
<td><p>Frobenius norm</p></td>
<td><p>–</p></td>
</tr>
<tr class="row-even"><td><p>‘nuc’</p></td>
<td><p>nuclear norm</p></td>
<td><p>–</p></td>
</tr>
<tr class="row-odd"><td><p>Other</p></td>
<td><p>as vec norm when dim is None</p></td>
<td><p>sum(abs(x)**ord)**(1./ord)</p></td>
</tr>
</tbody>
</table>
</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>2-tuple of python:ints</em><em>, </em><em>2-list of python:ints</em><em>, </em><em>optional</em>) – If it is an int,
vector norm will be calculated, if it is 2-tuple of ints, matrix norm
will be calculated. If the value is None, matrix norm will be calculated
when the input tensor only has two dimensions, vector norm will be
calculated when the input tensor only has one dimension. If the input
tensor has more than two dimensions, the vector norm will be applied to
last dimension.</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>
retained or not. Ignored if <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> = <code class="docutils literal notranslate"><span class="pre">None</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> = <code class="docutils literal notranslate"><span class="pre">None</span></code>. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor. Ignored if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> = <code class="docutils literal notranslate"><span class="pre">None</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> = <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of
returned tensor. If specified, the input tensor is casted to
:attr:’dtype’ while performing the operation. Default: None.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">import</span> <span class="nn">torch</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">9</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">float</span><span class="p">)</span> <span class="o">-</span> <span class="mi">4</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">a</span><span class="o">.</span><span class="n">reshape</span><span class="p">((</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(7.7460)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="go">tensor(7.7460)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;inf&#39;</span><span class="p">))</span>
<span class="go">tensor(4.)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;inf&#39;</span><span class="p">))</span>
<span class="go">tensor(4.)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]</span> <span class="p">,</span> <span class="n">dtype</span><span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">float</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([1.4142, 2.2361, 5.0000])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([3.7417, 4.2426])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">c</span><span class="p">,</span> <span class="n">p</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([6., 6.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="n">dtype</span><span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">float</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">d</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">))</span>
<span class="go">tensor([ 3.7417, 11.2250])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">d</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="p">:,</span> <span class="p">:]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">d</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="p">:,</span> <span class="p">:])</span>
<span class="go">(tensor(3.7417), tensor(11.2250))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.prod">
<code class="descclassname">torch.</code><code class="descname">prod</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.prod" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">prod</code><span class="sig-paren">(</span><em>input</em>, <em>dtype=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the product of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
If specified, the input tensor is casted to <code class="xref py py-attr docutils literal notranslate"><span class="pre">dtype</span></code> before the operation
is performed. This is useful for preventing data type overflows. Default: None.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.8020,  0.5428, -1.5854]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">prod</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0.6902)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">prod</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>dtype=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the product of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given
dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensor is of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where it is of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in
the output tensor having 1 fewer dimension than <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensor has <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
If specified, the input tensor is casted to <code class="xref py py-attr docutils literal notranslate"><span class="pre">dtype</span></code> before the operation
is performed. This is useful for preventing data type overflows. Default: None.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.5261, -0.3837],</span>
<span class="go">        [ 1.1857, -0.2498],</span>
<span class="go">        [-1.1646,  0.0705],</span>
<span class="go">        [ 1.1131, -1.0629]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">prod</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([-0.2018, -0.2962, -0.0821, -1.1831])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.std">
<code class="descclassname">torch.</code><code class="descname">std</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.std" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">std</code><span class="sig-paren">(</span><em>input</em>, <em>unbiased=True</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the standard-deviation of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">unbiased</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, then the standard-deviation will be calculated
via the biased estimator. Otherwise, Bessel’s correction will be used.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>unbiased</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether to use the unbiased estimation or not</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.8166, -1.3802, -0.3560]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">std</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0.5130)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">std</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>unbiased=True</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the standard-deviation of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the
dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is a list of dimensions,
reduce over all of them.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensor is of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension(s) <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where it is of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in the
output tensor having 1 (or <code class="docutils literal notranslate"><span class="pre">len(dim)</span></code>) fewer dimension(s).</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">unbiased</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, then the standard-deviation will be calculated
via the biased estimator. Otherwise, Bessel’s correction will be used.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of python:ints</em>) – the dimension or dimensions to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensor has <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>unbiased</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether to use the unbiased estimation or not</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.2035,  1.2959,  1.8101, -0.4644],</span>
<span class="go">        [ 1.5027, -0.3270,  0.5905,  0.6538],</span>
<span class="go">        [-1.5745,  1.3330, -0.5596, -0.6548],</span>
<span class="go">        [ 0.1264, -0.5080,  1.6420,  0.1992]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">std</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([ 1.0311,  0.7477,  1.2204,  0.9087])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sum">
<code class="descclassname">torch.</code><code class="descname">sum</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.sum" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">sum</code><span class="sig-paren">(</span><em>input</em>, <em>dtype=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the sum of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
If specified, the input tensor is casted to <code class="xref py py-attr docutils literal notranslate"><span class="pre">dtype</span></code> before the operation
is performed. This is useful for preventing data type overflows. Default: None.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.1133, -0.9567,  0.2958]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(-0.5475)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">sum</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>dtype=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the sum of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given
dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is a list of dimensions,
reduce over all of them.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensor is of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension(s) <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where it is of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in the
output tensor having 1 (or <code class="docutils literal notranslate"><span class="pre">len(dim)</span></code>) fewer dimension(s).</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of python:ints</em>) – the dimension or dimensions to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensor has <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
If specified, the input tensor is casted to <code class="xref py py-attr docutils literal notranslate"><span class="pre">dtype</span></code> before the operation
is performed. This is useful for preventing data type overflows. Default: None.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.0569, -0.2475,  0.0737, -0.3429],</span>
<span class="go">        [-0.2993,  0.9138,  0.9337, -1.6864],</span>
<span class="go">        [ 0.1132,  0.7892, -0.1003,  0.5688],</span>
<span class="go">        [ 0.3637, -0.9906, -0.4752, -1.5197]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([-0.4598, -0.1381,  1.3708, -2.6217])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">4</span> <span class="o">*</span> <span class="mi">5</span> <span class="o">*</span> <span class="mi">6</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span>
<span class="go">tensor([  435.,  1335.,  2235.,  3135.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.unique">
<code class="descclassname">torch.</code><code class="descname">unique</code><span class="sig-paren">(</span><em>input</em>, <em>sorted=True</em>, <em>return_inverse=False</em>, <em>return_counts=False</em>, <em>dim=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#unique"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.unique" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the unique elements of the input tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>sorted</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – Whether to sort the unique elements in ascending order
before returning as output.</p></li>
<li><p><strong>return_inverse</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – Whether to also return the indices for where
elements in the original input ended up in the returned unique list.</p></li>
<li><p><strong>return_counts</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – Whether to also return the counts for each unique
element.</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to apply unique. If <code class="docutils literal notranslate"><span class="pre">None</span></code>, the unique of the
flattened input is returned. default: <code class="docutils literal notranslate"><span class="pre">None</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><dl>
<dt>(Tensor, Tensor (optional) Tensor (optional))::</dt><dd><p>A tensor or a tuple of tensors containing</p>
<blockquote>
<div><ul class="simple">
<li><p><strong>output</strong> (<em>Tensor</em>): the output list of unique scalar elements.</p></li>
<li><p><strong>inverse_indices</strong> (<em>Tensor</em>): (optional) if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">return_inverse</span></code> is True, there will be an additional
returned tensor (same shape as input) representing the indices
for where elements in the original input map to in the output;
otherwise, this function will only return a single tensor.</p></li>
<li><p><strong>counts</strong> (<em>Tensor</em>): (optional) if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">return_counts</span></code> is True, there will be an additional
returned tensor (same shape as output or output.size(dim),
if dim was specified) representing the number of occurrences
for each unique value or tensor.</p></li>
</ul>
</div></blockquote>
</dd>
</dl>
</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">output</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">unique</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">],</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">long</span><span class="p">))</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span>
<span class="go">tensor([ 2,  3,  1])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span><span class="p">,</span> <span class="n">inverse_indices</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">unique</span><span class="p">(</span>
<span class="go">        torch.tensor([1, 3, 2, 3], dtype=torch.long), sorted=True, return_inverse=True)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span>
<span class="go">tensor([ 1,  2,  3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">inverse_indices</span>
<span class="go">tensor([ 0,  2,  1,  2])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span><span class="p">,</span> <span class="n">inverse_indices</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">unique</span><span class="p">(</span>
<span class="go">        torch.tensor([[1, 3], [2, 3]], dtype=torch.long), sorted=True, return_inverse=True)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span>
<span class="go">tensor([ 1,  2,  3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">inverse_indices</span>
<span class="go">tensor([[ 0,  2],</span>
<span class="go">        [ 1,  2]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.unique_consecutive">
<code class="descclassname">torch.</code><code class="descname">unique_consecutive</code><span class="sig-paren">(</span><em>input</em>, <em>return_inverse=False</em>, <em>return_counts=False</em>, <em>dim=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#unique_consecutive"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.unique_consecutive" title="Permalink to this definition">¶</a></dt>
<dd><p>Eliminates all but the first element from every consecutive group of equivalent elements.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function is different from <a class="reference internal" href="#torch.unique" title="torch.unique"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.unique()</span></code></a> in the sense that this function
only eliminates consecutive duplicate values. This semantics is similar to <cite>std::unique</cite>
in C++.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>return_inverse</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – Whether to also return the indices for where
elements in the original input ended up in the returned unique list.</p></li>
<li><p><strong>return_counts</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – Whether to also return the counts for each unique
element.</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to apply unique. If <code class="docutils literal notranslate"><span class="pre">None</span></code>, the unique of the
flattened input is returned. default: <code class="docutils literal notranslate"><span class="pre">None</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><p>A tensor or a tuple of tensors containing</p>
<blockquote>
<div><ul class="simple">
<li><p><strong>output</strong> (<em>Tensor</em>): the output list of unique scalar elements.</p></li>
<li><p><strong>inverse_indices</strong> (<em>Tensor</em>): (optional) if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">return_inverse</span></code> is True, there will be an additional
returned tensor (same shape as input) representing the indices
for where elements in the original input map to in the output;
otherwise, this function will only return a single tensor.</p></li>
<li><p><strong>counts</strong> (<em>Tensor</em>): (optional) if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">return_counts</span></code> is True, there will be an additional
returned tensor (same shape as output or output.size(dim),
if dim was specified) representing the number of occurrences
for each unique value or tensor.</p></li>
</ul>
</div></blockquote>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>(<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>, <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a> (optional), <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a> (optional))</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">unique_consecutive</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span>
<span class="go">tensor([1, 2, 3, 1, 2])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span><span class="p">,</span> <span class="n">inverse_indices</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">unique_consecutive</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">return_inverse</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span>
<span class="go">tensor([1, 2, 3, 1, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">inverse_indices</span>
<span class="go">tensor([0, 0, 1, 1, 2, 3, 3, 4])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span><span class="p">,</span> <span class="n">counts</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">unique_consecutive</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">return_counts</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">output</span>
<span class="go">tensor([1, 2, 3, 1, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">counts</span>
<span class="go">tensor([2, 2, 1, 2, 1])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.var">
<code class="descclassname">torch.</code><code class="descname">var</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.var" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">var</code><span class="sig-paren">(</span><em>input</em>, <em>unbiased=True</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the variance of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">unbiased</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, then the variance will be calculated via the
biased estimator. Otherwise, Bessel’s correction will be used.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>unbiased</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether to use the unbiased estimation or not</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.3425, -1.2636, -0.4864]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">var</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0.2455)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">var</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>unbiased=True</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the variance of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given
dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensor is of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension(s) <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where it is of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in the
output tensor having 1 (or <code class="docutils literal notranslate"><span class="pre">len(dim)</span></code>) fewer dimension(s).</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">unbiased</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, then the variance will be calculated via the
biased estimator. Otherwise, Bessel’s correction will be used.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of python:ints</em>) – the dimension or dimensions to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensor has <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>unbiased</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether to use the unbiased estimation or not</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.3567,  1.7385, -1.3042,  0.7423],</span>
<span class="go">        [ 1.3436, -0.1015, -0.9834, -0.8438],</span>
<span class="go">        [ 0.6056,  0.1089, -0.3112, -1.4085],</span>
<span class="go">        [-0.7700,  0.6074, -0.1469,  0.7777]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">var</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([ 1.7444,  1.1363,  0.7356,  0.5112])</span>
</pre></div>
</div>
</dd></dl>

</div>
<div class="section" id="comparison-ops">
<h3>Comparison Ops<a class="headerlink" href="#comparison-ops" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="torch.allclose">
<code class="descclassname">torch.</code><code class="descname">allclose</code><span class="sig-paren">(</span><em>self</em>, <em>other</em>, <em>rtol=1e-05</em>, <em>atol=1e-08</em>, <em>equal_nan=False</em><span class="sig-paren">)</span> &#x2192; bool<a class="headerlink" href="#torch.allclose" title="Permalink to this definition">¶</a></dt>
<dd><p>This function checks if all <code class="xref py py-attr docutils literal notranslate"><span class="pre">self</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> satisfy the condition:</p>
<div class="math">
\[\lvert \text{self} - \text{other} \rvert \leq \texttt{atol} + \texttt{rtol} \times \lvert \text{other} \rvert

\]</div>
<p>elementwise, for all elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">self</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code>. The behaviour of this function is analogous to
<a class="reference external" href="https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html">numpy.allclose</a></p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>self</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – first tensor to compare</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – second tensor to compare</p></li>
<li><p><strong>atol</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>optional</em>) – absolute tolerance. Default: 1e-08</p></li>
<li><p><strong>rtol</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>optional</em>) – relative tolerance. Default: 1e-05</p></li>
<li><p><strong>equal_nan</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>optional</em>) – if <code class="docutils literal notranslate"><span class="pre">True</span></code>, then two <code class="docutils literal notranslate"><span class="pre">NaN</span></code> s will be compared as equal. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">10000.</span><span class="p">,</span> <span class="mf">1e-07</span><span class="p">]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">10000.1</span><span class="p">,</span> <span class="mf">1e-08</span><span class="p">]))</span>
<span class="go">False</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">10000.</span><span class="p">,</span> <span class="mf">1e-08</span><span class="p">]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">10000.1</span><span class="p">,</span> <span class="mf">1e-09</span><span class="p">]))</span>
<span class="go">True</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;nan&#39;</span><span class="p">)]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;nan&#39;</span><span class="p">)]))</span>
<span class="go">False</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;nan&#39;</span><span class="p">)]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.0</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;nan&#39;</span><span class="p">)]),</span> <span class="n">equal_nan</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.argsort">
<code class="descclassname">torch.</code><code class="descname">argsort</code><span class="sig-paren">(</span><em>input</em>, <em>dim=-1</em>, <em>descending=False</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; LongTensor<a class="headerlink" href="#torch.argsort" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the indices that sort a tensor along a given dimension in ascending
order by value.</p>
<p>This is the second value returned by <a class="reference internal" href="#torch.sort" title="torch.sort"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.sort()</span></code></a>.  See its documentation
for the exact semantics of this method.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the dimension to sort along</p></li>
<li><p><strong>descending</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls the sorting order (ascending or descending)</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.0785,  1.5267, -0.8521,  0.4065],</span>
<span class="go">        [ 0.1598,  0.0788, -0.0745, -1.2700],</span>
<span class="go">        [ 1.2208,  1.0722, -0.7064,  1.2564],</span>
<span class="go">        [ 0.0669, -0.2318, -0.8229, -0.9280]])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">argsort</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[2, 0, 3, 1],</span>
<span class="go">        [3, 2, 1, 0],</span>
<span class="go">        [2, 1, 0, 3],</span>
<span class="go">        [3, 2, 1, 0]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.eq">
<code class="descclassname">torch.</code><code class="descname">eq</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.eq" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes element-wise equality</p>
<p>The second argument can be a number or a tensor whose shape is
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with the first argument.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compare</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the tensor or value to compare</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor. Must be a <cite>ByteTensor</cite></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location where comparison is true</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">eq</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]))</span>
<span class="go">tensor([[ 1,  0],</span>
<span class="go">        [ 0,  1]], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.equal">
<code class="descclassname">torch.</code><code class="descname">equal</code><span class="sig-paren">(</span><em>tensor1</em>, <em>tensor2</em><span class="sig-paren">)</span> &#x2192; bool<a class="headerlink" href="#torch.equal" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">True</span></code> if two tensors have the same size and elements, <code class="docutils literal notranslate"><span class="pre">False</span></code> otherwise.</p>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">equal</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]))</span>
<span class="go">True</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.ge">
<code class="descclassname">torch.</code><code class="descname">ge</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ge" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <span class="math">\(\text{input} \geq \text{other}\)</span> element-wise.</p>
<p>The second argument can be a number or a tensor whose shape is
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with the first argument.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compare</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the tensor or value to compare</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor that must be a <cite>ByteTensor</cite></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location where comparison is true</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ge</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]))</span>
<span class="go">tensor([[ 1,  1],</span>
<span class="go">        [ 0,  1]], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.gt">
<code class="descclassname">torch.</code><code class="descname">gt</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.gt" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <span class="math">\(\text{input} &gt; \text{other}\)</span> element-wise.</p>
<p>The second argument can be a number or a tensor whose shape is
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with the first argument.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compare</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the tensor or value to compare</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor that must be a <cite>ByteTensor</cite></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location where comparison is true</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">gt</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]))</span>
<span class="go">tensor([[ 0,  1],</span>
<span class="go">        [ 0,  0]], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.isfinite">
<code class="descclassname">torch.</code><code class="descname">isfinite</code><span class="sig-paren">(</span><em>tensor</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#isfinite"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.isfinite" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with boolean elements representing if each element is <cite>Finite</cite> or not.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – A tensor to check</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location of finite elements and 0 otherwise</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">isfinite</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;inf&#39;</span><span class="p">),</span> <span class="mi">2</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;-inf&#39;</span><span class="p">),</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;nan&#39;</span><span class="p">)]))</span>
<span class="go">tensor([ 1,  0,  1,  0,  0], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.isinf">
<code class="descclassname">torch.</code><code class="descname">isinf</code><span class="sig-paren">(</span><em>tensor</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#isinf"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.isinf" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with boolean elements representing if each element is <cite>+/-INF</cite> or not.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – A tensor to check</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location of <cite>+/-INF</cite> elements and 0 otherwise</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">isinf</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;inf&#39;</span><span class="p">),</span> <span class="mi">2</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;-inf&#39;</span><span class="p">),</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;nan&#39;</span><span class="p">)]))</span>
<span class="go">tensor([ 0,  1,  0,  1,  0], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.isnan">
<code class="descclassname">torch.</code><code class="descname">isnan</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.isnan" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a new tensor with boolean elements representing if each element is <cite>NaN</cite> or not.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – A tensor to check</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location of <cite>NaN</cite> elements.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">isnan</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="nb">float</span><span class="p">(</span><span class="s1">&#39;nan&#39;</span><span class="p">),</span> <span class="mi">2</span><span class="p">]))</span>
<span class="go">tensor([ 0,  1,  0], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.kthvalue">
<code class="descclassname">torch.</code><code class="descname">kthvalue</code><span class="sig-paren">(</span><em>input</em>, <em>k</em>, <em>dim=None</em>, <em>keepdim=False</em>, <em>out=None) -&gt; (Tensor</em>, <em>LongTensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.kthvalue" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a namedtuple <code class="docutils literal notranslate"><span class="pre">(values,</span> <span class="pre">indices)</span></code> where <code class="docutils literal notranslate"><span class="pre">values</span></code> is the <code class="xref py py-attr docutils literal notranslate"><span class="pre">k</span></code> th
smallest element of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. And <code class="docutils literal notranslate"><span class="pre">indices</span></code> is the index location of each element found.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is not given, the last dimension of the <cite>input</cite> is chosen.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, both the <code class="xref py py-attr docutils literal notranslate"><span class="pre">values</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">indices</span></code> tensors
are the same size as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, except in the dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where
they are of size 1. Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed
(see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in both the <code class="xref py py-attr docutils literal notranslate"><span class="pre">values</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">indices</span></code> tensors having 1 fewer dimension than the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>k</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – k for the k-th smallest element</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the dimension to find the kth value along</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the output tuple of (Tensor, LongTensor)
can be optionally given to be used as output buffers</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">6.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([ 1.,  2.,  3.,  4.,  5.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">kthvalue</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="go">torch.return_types.kthvalue(values=tensor(4.), indices=tensor(3))</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span><span class="mf">7.</span><span class="p">)</span><span class="o">.</span><span class="n">resize_</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 1.,  2.,  3.],</span>
<span class="go">        [ 4.,  5.,  6.]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">kthvalue</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="kc">True</span><span class="p">)</span>
<span class="go">torch.return_types.kthvalue(values=tensor([[4., 5., 6.]]), indices=tensor([[1, 1, 1]]))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.le">
<code class="descclassname">torch.</code><code class="descname">le</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.le" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <span class="math">\(\text{input} \leq \text{other}\)</span> element-wise.</p>
<p>The second argument can be a number or a tensor whose shape is
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with the first argument.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compare</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the tensor or value to compare</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor that must be a <cite>ByteTensor</cite></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location where comparison is true</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">le</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]))</span>
<span class="go">tensor([[ 1,  0],</span>
<span class="go">        [ 1,  1]], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.lt">
<code class="descclassname">torch.</code><code class="descname">lt</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.lt" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <span class="math">\(\text{input} &lt; \text{other}\)</span> element-wise.</p>
<p>The second argument can be a number or a tensor whose shape is
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with the first argument.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compare</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the tensor or value to compare</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor that must be a <cite>ByteTensor</cite></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <cite>torch.ByteTensor</cite> containing a 1 at each location where comparison is true</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">lt</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]))</span>
<span class="go">tensor([[ 0,  0],</span>
<span class="go">        [ 1,  0]], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.max">
<code class="descclassname">torch.</code><code class="descname">max</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.max" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">max</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the maximum value of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.6763,  0.7445, -2.2369]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0.7445)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">max</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>out=None) -&gt; (Tensor</em>, <em>LongTensor</em><span class="sig-paren">)</span></dt>
<dd></dd></dl>

<p>Returns a namedtuple <code class="docutils literal notranslate"><span class="pre">(values,</span> <span class="pre">indices)</span></code> where <code class="docutils literal notranslate"><span class="pre">values</span></code> is the maximum
value of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. And <code class="docutils literal notranslate"><span class="pre">indices</span></code> is the index location of each maximum value found
(argmax).</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensors are of the same size
as <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where they are of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting
in the output tensors having 1 fewer dimension than <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the result tuple of two output tensors (max, max_indices)</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-1.2360, -0.2942, -0.1222,  0.8475],</span>
<span class="go">        [ 1.1949, -1.1127, -2.2379, -0.6702],</span>
<span class="go">        [ 1.5717, -0.9207,  0.1297, -1.8768],</span>
<span class="go">        [-0.6172,  1.0036, -0.6060, -0.2432]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">torch.return_types.max(values=tensor([0.8475, 1.1949, 1.5717, 1.0036]), indices=tensor([3, 0, 0, 1]))</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">max</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Each element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is compared with the corresponding
element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> and an element-wise maximum is taken.</p>
<p>The shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> don’t need to match,
but they must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<div class="math">
\[\text{out}_i = \max(\text{tensor}_i, \text{other}_i)

\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When the shapes do not match, the shape of the returned output tensor
follows the <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcasting rules</span></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.2942, -0.7416,  0.2653, -0.1584])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([ 0.8722, -1.7421, -0.4141, -0.5055])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="go">tensor([ 0.8722, -0.7416,  0.2653, -0.1584])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.min">
<code class="descclassname">torch.</code><code class="descname">min</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.min" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">min</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Returns the minimum value of all elements in the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.6750,  1.0857,  1.7197]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">min</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(0.6750)</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">min</code><span class="sig-paren">(</span><em>input</em>, <em>dim</em>, <em>keepdim=False</em>, <em>out=None) -&gt; (Tensor</em>, <em>LongTensor</em><span class="sig-paren">)</span></dt>
<dd></dd></dl>

<p>Returns a namedtuple <code class="docutils literal notranslate"><span class="pre">(values,</span> <span class="pre">indices)</span></code> where <code class="docutils literal notranslate"><span class="pre">values</span></code> is the minimum
value of each row of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor in the given dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code>. And <code class="docutils literal notranslate"><span class="pre">indices</span></code> is the index location of each minimum value found
(argmin).</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">keepdim</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the output tensors are of the same size as
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> except in the dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> where they are of size 1.
Otherwise, <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is squeezed (see <a class="reference internal" href="#torch.squeeze" title="torch.squeeze"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.squeeze()</span></code></a>), resulting in
the output tensors having 1 fewer dimension than <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to reduce</p></li>
<li><p><strong>keepdim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – whether the output tensors have <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> retained or not</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the tuple of two output tensors (min, min_indices)</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.6248,  1.1334, -1.1899, -0.2803],</span>
<span class="go">        [-1.4644, -0.2635, -0.3651,  0.6134],</span>
<span class="go">        [ 0.2457,  0.0384,  1.0128,  0.7015],</span>
<span class="go">        [-0.1153,  2.9849,  2.1458,  0.5788]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">min</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">torch.return_types.min(values=tensor([-1.1899, -1.4644,  0.0384, -0.1153]), indices=tensor([2, 0, 1, 0]))</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">min</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Each element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is compared with the corresponding
element of the tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> and an element-wise minimum is taken.
The resulting tensor is returned.</p>
<p>The shapes of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> don’t need to match,
but they must be <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a>.</p>
<div class="math">
\[\text{out}_i = \min(\text{tensor}_i, \text{other}_i)

\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When the shapes do not match, the shape of the returned output tensor
follows the <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcasting rules</span></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second input tensor</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.8137, -1.1740, -0.6460,  0.6308])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([-0.1369,  0.1555,  0.4019, -0.1929])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">min</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="go">tensor([-0.1369, -1.1740, -0.6460, -0.1929])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.ne">
<code class="descclassname">torch.</code><code class="descname">ne</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ne" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes <span class="math">\(input \neq other\)</span> element-wise.</p>
<p>The second argument can be a number or a tensor whose shape is
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with the first argument.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to compare</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the tensor or value to compare</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor that must be a <cite>ByteTensor</cite></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">torch.ByteTensor</span></code> containing a 1 at each location where comparison is true.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ne</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">]]))</span>
<span class="go">tensor([[ 0,  1],</span>
<span class="go">        [ 1,  0]], dtype=torch.uint8)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.sort">
<code class="descclassname">torch.</code><code class="descname">sort</code><span class="sig-paren">(</span><em>input</em>, <em>dim=-1</em>, <em>descending=False</em>, <em>out=None) -&gt; (Tensor</em>, <em>LongTensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.sort" title="Permalink to this definition">¶</a></dt>
<dd><p>Sorts the elements of the <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor along a given dimension
in ascending order by value.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is not given, the last dimension of the <cite>input</cite> is chosen.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">descending</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> then the elements are sorted in descending
order by value.</p>
<p>A namedtuple of (values, indices) is returned, where the <cite>values</cite> are the
sorted values and <cite>indices</cite> are the indices of the elements in the original
<cite>input</cite> tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the dimension to sort along</p></li>
<li><p><strong>descending</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls the sorting order (ascending or descending)</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the output tuple of (<cite>Tensor</cite>, <cite>LongTensor</cite>) that can
be optionally given to be used as output buffers</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span><span class="p">,</span> <span class="n">indices</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span>
<span class="go">tensor([[-0.2162,  0.0608,  0.6719,  2.3332],</span>
<span class="go">        [-0.5793,  0.0061,  0.6058,  0.9497],</span>
<span class="go">        [-0.5071,  0.3343,  0.9553,  1.0960]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">indices</span>
<span class="go">tensor([[ 1,  0,  2,  3],</span>
<span class="go">        [ 3,  1,  0,  2],</span>
<span class="go">        [ 0,  3,  1,  2]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span><span class="p">,</span> <span class="n">indices</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">sort</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">sorted</span>
<span class="go">tensor([[-0.5071, -0.2162,  0.6719, -0.5793],</span>
<span class="go">        [ 0.0608,  0.0061,  0.9497,  0.3343],</span>
<span class="go">        [ 0.6058,  0.9553,  1.0960,  2.3332]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">indices</span>
<span class="go">tensor([[ 2,  0,  0,  1],</span>
<span class="go">        [ 0,  1,  1,  2],</span>
<span class="go">        [ 1,  2,  2,  0]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.topk">
<code class="descclassname">torch.</code><code class="descname">topk</code><span class="sig-paren">(</span><em>input</em>, <em>k</em>, <em>dim=None</em>, <em>largest=True</em>, <em>sorted=True</em>, <em>out=None) -&gt; (Tensor</em>, <em>LongTensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.topk" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the <code class="xref py py-attr docutils literal notranslate"><span class="pre">k</span></code> largest elements of the given <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> tensor along
a given dimension.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is not given, the last dimension of the <cite>input</cite> is chosen.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">largest</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code> then the <cite>k</cite> smallest elements are returned.</p>
<p>A namedtuple of <cite>(values, indices)</cite> is returned, where the <cite>indices</cite> are the indices
of the elements in the original <cite>input</cite> tensor.</p>
<p>The boolean option <code class="xref py py-attr docutils literal notranslate"><span class="pre">sorted</span></code> if <code class="docutils literal notranslate"><span class="pre">True</span></code>, will make sure that the returned
<cite>k</cite> elements are themselves sorted</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>k</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the k in “top-k”</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the dimension to sort along</p></li>
<li><p><strong>largest</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return largest or
smallest elements</p></li>
<li><p><strong>sorted</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return the elements
in sorted order</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the output tuple of (Tensor, LongTensor) that can be
optionally given to be used as output buffers</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">6.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([ 1.,  2.,  3.,  4.,  5.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">topk</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">torch.return_types.topk(values=tensor([5., 4., 3.]), indices=tensor([4, 3, 2]))</span>
</pre></div>
</div>
</dd></dl>

</div>
<div class="section" id="spectral-ops">
<h3>Spectral Ops<a class="headerlink" href="#spectral-ops" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="torch.fft">
<code class="descclassname">torch.</code><code class="descname">fft</code><span class="sig-paren">(</span><em>input</em>, <em>signal_ndim</em>, <em>normalized=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.fft" title="Permalink to this definition">¶</a></dt>
<dd><p>Complex-to-complex Discrete Fourier Transform</p>
<p>This method computes the complex-to-complex discrete Fourier transform.
Ignoring the batch dimensions, it computes the following expression:</p>
<div class="math">
\[X[\omega_1, \dots, \omega_d] =
    \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
     e^{-j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},

\]</div>
<p>where <span class="math">\(d\)</span> = <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> is number of dimensions for the
signal, and <span class="math">\(N_i\)</span> is the size of signal dimension <span class="math">\(i\)</span>.</p>
<p>This method supports 1D, 2D and 3D complex-to-complex transforms, indicated
by <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code>. <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> must be a tensor with last dimension
of size 2, representing the real and imaginary components of complex
numbers, and should have at least <code class="docutils literal notranslate"><span class="pre">signal_ndim</span> <span class="pre">+</span> <span class="pre">1</span></code> dimensions with optionally
arbitrary number of leading batch dimensions. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">normalized</span></code> is set to
<code class="docutils literal notranslate"><span class="pre">True</span></code>, this normalizes the result by dividing it with
<span class="math">\(\sqrt{\prod_{i=1}^K N_i}\)</span> so that the operator is unitary.</p>
<p>Returns the real and the imaginary parts together as one tensor of the same
shape of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<p>The inverse of this function is <a class="reference internal" href="#torch.ifft" title="torch.ifft"><code class="xref py py-func docutils literal notranslate"><span class="pre">ifft()</span></code></a>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>For CUDA tensors, an LRU cache is used for cuFFT plans to speed up
repeatedly running FFT methods on tensors of same geometry with same
configuration. See <a class="reference internal" href="notes/cuda.html#cufft-plan-cache"><span class="std std-ref">cuFFT plan cache</span></a> for more details on how to
monitor and control the cache.</p>
</div>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>For CPU tensors, this method is currently only available with MKL. Use
<code class="xref py py-func docutils literal notranslate"><span class="pre">torch.backends.mkl.is_available()</span></code> to check if MKL is installed.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor of at least <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> <code class="docutils literal notranslate"><span class="pre">+</span> <span class="pre">1</span></code>
dimensions</p></li>
<li><p><strong>signal_ndim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the number of dimensions in each signal.
<code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> can only be 1, 2 or 3</p></li>
<li><p><strong>normalized</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return normalized results.
Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tensor containing the complex-to-complex Fourier transform result</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># unbatched 2D FFT</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">fft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([[[-0.0876,  1.7835],</span>
<span class="go">         [-2.0399, -2.9754],</span>
<span class="go">         [ 4.4773, -5.0119]],</span>

<span class="go">        [[-1.5716,  2.7631],</span>
<span class="go">         [-3.8846,  5.2652],</span>
<span class="go">         [ 0.2046, -0.7088]],</span>

<span class="go">        [[ 1.9938, -0.5901],</span>
<span class="go">         [ 6.5637,  6.4556],</span>
<span class="go">         [ 2.9865,  4.9318]],</span>

<span class="go">        [[ 7.0193,  1.1742],</span>
<span class="go">         [-1.3717, -2.1084],</span>
<span class="go">         [ 2.0289,  2.9357]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># batched 1D FFT</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">fft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[[ 1.8385,  1.2827],</span>
<span class="go">         [-0.1831,  1.6593],</span>
<span class="go">         [ 2.4243,  0.5367]],</span>

<span class="go">        [[-0.9176, -1.5543],</span>
<span class="go">         [-3.9943, -2.9860],</span>
<span class="go">         [ 1.2838, -2.9420]],</span>

<span class="go">        [[-0.8854, -0.6860],</span>
<span class="go">         [ 2.4450,  0.0808],</span>
<span class="go">         [ 1.3076, -0.5768]],</span>

<span class="go">        [[-0.1231,  2.7411],</span>
<span class="go">         [-0.3075, -1.7295],</span>
<span class="go">         [-0.5384, -2.0299]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># arbitrary number of batch dimensions, 2D FFT</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span><span class="o">.</span><span class="n">shape</span>
<span class="go">torch.Size([3, 3, 5, 5, 2])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.ifft">
<code class="descclassname">torch.</code><code class="descname">ifft</code><span class="sig-paren">(</span><em>input</em>, <em>signal_ndim</em>, <em>normalized=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ifft" title="Permalink to this definition">¶</a></dt>
<dd><p>Complex-to-complex Inverse Discrete Fourier Transform</p>
<p>This method computes the complex-to-complex inverse discrete Fourier
transform. Ignoring the batch dimensions, it computes the following
expression:</p>
<div class="math">
\[X[\omega_1, \dots, \omega_d] =
    \frac{1}{\prod_{i=1}^d N_i} \sum_{n_1=0}^{N_1-1} \dots \sum_{n_d=0}^{N_d-1} x[n_1, \dots, n_d]
     e^{\ j\ 2 \pi \sum_{i=0}^d \frac{\omega_i n_i}{N_i}},

\]</div>
<p>where <span class="math">\(d\)</span> = <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> is number of dimensions for the
signal, and <span class="math">\(N_i\)</span> is the size of signal dimension <span class="math">\(i\)</span>.</p>
<p>The argument specifications are almost identical with <a class="reference internal" href="#torch.fft" title="torch.fft"><code class="xref py py-func docutils literal notranslate"><span class="pre">fft()</span></code></a>.
However, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">normalized</span></code> is set to <code class="docutils literal notranslate"><span class="pre">True</span></code>, this instead returns the
results multiplied by <span class="math">\(\sqrt{\prod_{i=1}^d N_i}\)</span>, to become a unitary
operator. Therefore, to invert a <a class="reference internal" href="#torch.fft" title="torch.fft"><code class="xref py py-func docutils literal notranslate"><span class="pre">fft()</span></code></a>, the <code class="xref py py-attr docutils literal notranslate"><span class="pre">normalized</span></code>
argument should be set identically for <a class="reference internal" href="#torch.fft" title="torch.fft"><code class="xref py py-func docutils literal notranslate"><span class="pre">fft()</span></code></a>.</p>
<p>Returns the real and the imaginary parts together as one tensor of the same
shape of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<p>The inverse of this function is <a class="reference internal" href="#torch.fft" title="torch.fft"><code class="xref py py-func docutils literal notranslate"><span class="pre">fft()</span></code></a>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>For CUDA tensors, an LRU cache is used for cuFFT plans to speed up
repeatedly running FFT methods on tensors of same geometry with same
configuration. See <a class="reference internal" href="notes/cuda.html#cufft-plan-cache"><span class="std std-ref">cuFFT plan cache</span></a> for more details on how to
monitor and control the cache.</p>
</div>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>For CPU tensors, this method is currently only available with MKL. Use
<code class="xref py py-func docutils literal notranslate"><span class="pre">torch.backends.mkl.is_available()</span></code> to check if MKL is installed.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor of at least <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> <code class="docutils literal notranslate"><span class="pre">+</span> <span class="pre">1</span></code>
dimensions</p></li>
<li><p><strong>signal_ndim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the number of dimensions in each signal.
<code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> can only be 1, 2 or 3</p></li>
<li><p><strong>normalized</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return normalized results.
Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tensor containing the complex-to-complex inverse Fourier transform result</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[[ 1.2766,  1.3680],</span>
<span class="go">         [-0.8337,  2.0251],</span>
<span class="go">         [ 0.9465, -1.4390]],</span>

<span class="go">        [[-0.1890,  1.6010],</span>
<span class="go">         [ 1.1034, -1.9230],</span>
<span class="go">         [-0.9482,  1.0775]],</span>

<span class="go">        [[-0.7708, -0.8176],</span>
<span class="go">         [-0.1843, -0.2287],</span>
<span class="go">         [-1.9034, -0.2196]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ifft</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>  <span class="c1"># recover x</span>
<span class="go">tensor([[[ 1.2766,  1.3680],</span>
<span class="go">         [-0.8337,  2.0251],</span>
<span class="go">         [ 0.9465, -1.4390]],</span>

<span class="go">        [[-0.1890,  1.6010],</span>
<span class="go">         [ 1.1034, -1.9230],</span>
<span class="go">         [-0.9482,  1.0775]],</span>

<span class="go">        [[-0.7708, -0.8176],</span>
<span class="go">         [-0.1843, -0.2287],</span>
<span class="go">         [-1.9034, -0.2196]]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.rfft">
<code class="descclassname">torch.</code><code class="descname">rfft</code><span class="sig-paren">(</span><em>input</em>, <em>signal_ndim</em>, <em>normalized=False</em>, <em>onesided=True</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.rfft" title="Permalink to this definition">¶</a></dt>
<dd><p>Real-to-complex Discrete Fourier Transform</p>
<p>This method computes the real-to-complex discrete Fourier transform. It is
mathematically equivalent with <a class="reference internal" href="#torch.fft" title="torch.fft"><code class="xref py py-func docutils literal notranslate"><span class="pre">fft()</span></code></a> with differences only in
formats of the input and output.</p>
<p>This method supports 1D, 2D and 3D real-to-complex transforms, indicated
by <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code>. <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> must be a tensor with at least
<code class="docutils literal notranslate"><span class="pre">signal_ndim</span></code> dimensions with optionally arbitrary number of leading batch
dimensions. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">normalized</span></code> is set to <code class="docutils literal notranslate"><span class="pre">True</span></code>, this normalizes the result
by dividing it with <span class="math">\(\sqrt{\prod_{i=1}^K N_i}\)</span> so that the operator is
unitary, where <span class="math">\(N_i\)</span> is the size of signal dimension <span class="math">\(i\)</span>.</p>
<p>The real-to-complex Fourier transform results follow conjugate symmetry:</p>
<div class="math">
\[X[\omega_1, \dots, \omega_d] = X^*[N_1 - \omega_1, \dots, N_d - \omega_d],

\]</div>
<p>where the index arithmetic is computed modulus the size of the corresponding
dimension, <span class="math">\(\ ^*\)</span> is the conjugate operator, and
<span class="math">\(d\)</span> = <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code>. <code class="xref py py-attr docutils literal notranslate"><span class="pre">onesided</span></code> flag controls whether to avoid
redundancy in the output results. If set to <code class="docutils literal notranslate"><span class="pre">True</span></code> (default), the output will
not be full complex result of shape <span class="math">\((*, 2)\)</span>, where <span class="math">\(*\)</span> is the shape
of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, but instead the last dimension will be halfed as of size
<span class="math">\(\lfloor \frac{N_d}{2} \rfloor + 1\)</span>.</p>
<p>The inverse of this function is <a class="reference internal" href="#torch.irfft" title="torch.irfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">irfft()</span></code></a>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>For CUDA tensors, an LRU cache is used for cuFFT plans to speed up
repeatedly running FFT methods on tensors of same geometry with same
configuration. See <a class="reference internal" href="notes/cuda.html#cufft-plan-cache"><span class="std std-ref">cuFFT plan cache</span></a> for more details on how to
monitor and control the cache.</p>
</div>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>For CPU tensors, this method is currently only available with MKL. Use
<code class="xref py py-func docutils literal notranslate"><span class="pre">torch.backends.mkl.is_available()</span></code> to check if MKL is installed.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor of at least <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> dimensions</p></li>
<li><p><strong>signal_ndim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the number of dimensions in each signal.
<code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> can only be 1, 2 or 3</p></li>
<li><p><strong>normalized</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return normalized results.
Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
<li><p><strong>onesided</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return half of results to
avoid redundancy. Default: <code class="docutils literal notranslate"><span class="pre">True</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tensor containing the real-to-complex Fourier transform result</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rfft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">shape</span>
<span class="go">torch.Size([5, 3, 2])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rfft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">onesided</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span><span class="o">.</span><span class="n">shape</span>
<span class="go">torch.Size([5, 5, 2])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.irfft">
<code class="descclassname">torch.</code><code class="descname">irfft</code><span class="sig-paren">(</span><em>input</em>, <em>signal_ndim</em>, <em>normalized=False</em>, <em>onesided=True</em>, <em>signal_sizes=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.irfft" title="Permalink to this definition">¶</a></dt>
<dd><p>Complex-to-real Inverse Discrete Fourier Transform</p>
<p>This method computes the complex-to-real inverse discrete Fourier transform.
It is mathematically equivalent with <a class="reference internal" href="#torch.ifft" title="torch.ifft"><code class="xref py py-func docutils literal notranslate"><span class="pre">ifft()</span></code></a> with differences only in
formats of the input and output.</p>
<p>The argument specifications are almost identical with <a class="reference internal" href="#torch.ifft" title="torch.ifft"><code class="xref py py-func docutils literal notranslate"><span class="pre">ifft()</span></code></a>.
Similar to <a class="reference internal" href="#torch.ifft" title="torch.ifft"><code class="xref py py-func docutils literal notranslate"><span class="pre">ifft()</span></code></a>, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">normalized</span></code> is set to <code class="docutils literal notranslate"><span class="pre">True</span></code>,
this normalizes the result by multiplying it with
<span class="math">\(\sqrt{\prod_{i=1}^K N_i}\)</span> so that the operator is unitary, where
<span class="math">\(N_i\)</span> is the size of signal dimension <span class="math">\(i\)</span>.</p>
<p>Due to the conjugate symmetry, <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> do not need to contain the full
complex frequency values. Roughly half of the values will be sufficient, as
is the case when <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is given by <a class="reference internal" href="#torch.rfft" title="torch.rfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">rfft()</span></code></a> with
<code class="docutils literal notranslate"><span class="pre">rfft(signal,</span> <span class="pre">onesided=True)</span></code>. In such case, set the <code class="xref py py-attr docutils literal notranslate"><span class="pre">onesided</span></code>
argument of this method to <code class="docutils literal notranslate"><span class="pre">True</span></code>. Moreover, the original signal shape
information can sometimes be lost, optionally set <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_sizes</span></code> to be
the size of the original signal (without the batch dimensions if in batched
mode) to recover it with correct shape.</p>
<p>Therefore, to invert an <a class="reference internal" href="#torch.rfft" title="torch.rfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">rfft()</span></code></a>, the <code class="xref py py-attr docutils literal notranslate"><span class="pre">normalized</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">onesided</span></code> arguments should be set identically for <a class="reference internal" href="#torch.irfft" title="torch.irfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">irfft()</span></code></a>,
and preferrably a <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_sizes</span></code> is given to avoid size mismatch. See the
example below for a case of size mismatch.</p>
<p>See <a class="reference internal" href="#torch.rfft" title="torch.rfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">rfft()</span></code></a> for details on conjugate symmetry.</p>
<p>The inverse of this function is <a class="reference internal" href="#torch.rfft" title="torch.rfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">rfft()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>Generally speaking, the input of this function should contain values
following conjugate symmetry. Note that even if <code class="xref py py-attr docutils literal notranslate"><span class="pre">onesided</span></code> is
<code class="docutils literal notranslate"><span class="pre">True</span></code>, often symmetry on some part is still needed. When this
requirement is not satisfied, the behavior of <a class="reference internal" href="#torch.irfft" title="torch.irfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">irfft()</span></code></a> is
undefined. Since <a class="reference internal" href="autograd.html#torch.autograd.gradcheck" title="torch.autograd.gradcheck"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.autograd.gradcheck()</span></code></a> estimates numerical
Jacobian with point perturbations, <a class="reference internal" href="#torch.irfft" title="torch.irfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">irfft()</span></code></a> will almost
certainly fail the check.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>For CUDA tensors, an LRU cache is used for cuFFT plans to speed up
repeatedly running FFT methods on tensors of same geometry with same
configuration. See <a class="reference internal" href="notes/cuda.html#cufft-plan-cache"><span class="std std-ref">cuFFT plan cache</span></a> for more details on how to
monitor and control the cache.</p>
</div>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>For CPU tensors, this method is currently only available with MKL. Use
<code class="xref py py-func docutils literal notranslate"><span class="pre">torch.backends.mkl.is_available()</span></code> to check if MKL is installed.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor of at least <code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> <code class="docutils literal notranslate"><span class="pre">+</span> <span class="pre">1</span></code>
dimensions</p></li>
<li><p><strong>signal_ndim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the number of dimensions in each signal.
<code class="xref py py-attr docutils literal notranslate"><span class="pre">signal_ndim</span></code> can only be 1, 2 or 3</p></li>
<li><p><strong>normalized</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return normalized results.
Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
<li><p><strong>onesided</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> was halfed to avoid
redundancy, e.g., by <a class="reference internal" href="#torch.rfft" title="torch.rfft"><code class="xref py py-func docutils literal notranslate"><span class="pre">rfft()</span></code></a>. Default: <code class="docutils literal notranslate"><span class="pre">True</span></code></p></li>
<li><p><strong>signal_sizes</strong> (list or <code class="xref py py-class docutils literal notranslate"><span class="pre">torch.Size</span></code>, optional) – the size of the original
signal (without batch dimension). Default: <code class="docutils literal notranslate"><span class="pre">None</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tensor containing the complex-to-real inverse Fourier transform result</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rfft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">onesided</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span><span class="o">.</span><span class="n">shape</span>
<span class="go">torch.Size([4, 3, 2])</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># notice that with onesided=True, output size does not determine the original signal size</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rfft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">onesided</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span><span class="o">.</span><span class="n">shape</span>
<span class="go">torch.Size([4, 3, 2])</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># now we use the original shape to recover x</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[-0.8992,  0.6117, -1.6091, -0.4155, -0.8346],</span>
<span class="go">        [-2.1596, -0.0853,  0.7232,  0.1941, -0.0789],</span>
<span class="go">        [-2.0329,  1.1031,  0.6869, -0.5042,  0.9895],</span>
<span class="go">        [-0.1884,  0.2858, -1.5831,  0.9917, -0.8356]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">rfft</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">onesided</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">irfft</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="n">onesided</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">signal_sizes</span><span class="o">=</span><span class="n">x</span><span class="o">.</span><span class="n">shape</span><span class="p">)</span>  <span class="c1"># recover x</span>
<span class="go">tensor([[-0.8992,  0.6117, -1.6091, -0.4155, -0.8346],</span>
<span class="go">        [-2.1596, -0.0853,  0.7232,  0.1941, -0.0789],</span>
<span class="go">        [-2.0329,  1.1031,  0.6869, -0.5042,  0.9895],</span>
<span class="go">        [-0.1884,  0.2858, -1.5831,  0.9917, -0.8356]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.stft">
<code class="descclassname">torch.</code><code class="descname">stft</code><span class="sig-paren">(</span><em>input</em>, <em>n_fft</em>, <em>hop_length=None</em>, <em>win_length=None</em>, <em>window=None</em>, <em>center=True</em>, <em>pad_mode='reflect'</em>, <em>normalized=False</em>, <em>onesided=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#stft"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.stft" title="Permalink to this definition">¶</a></dt>
<dd><p>Short-time Fourier transform (STFT).</p>
<p>Ignoring the optional batch dimension, this method computes the following
expression:</p>
<div class="math">
\[X[m, \omega] = \sum_{k = 0}^{\text{win\_length-1}}%
                    \text{window}[k]\ \text{input}[m \times \text{hop\_length} + k]\ %
                    \exp\left(- j \frac{2 \pi \cdot \omega k}{\text{win\_length}}\right),

\]</div>
<p>where <span class="math">\(m\)</span> is the index of the sliding window, and <span class="math">\(\omega\)</span> is
the frequency that <span class="math">\(0 \leq \omega &lt; \text{n\_fft}\)</span>. When
<code class="xref py py-attr docutils literal notranslate"><span class="pre">onesided</span></code> is the default value <code class="docutils literal notranslate"><span class="pre">True</span></code>,</p>
<ul class="simple">
<li><p><code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> must be either a 1-D time sequence or a 2-D batch of time
sequences.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">hop_length</span></code> is <code class="docutils literal notranslate"><span class="pre">None</span></code> (default), it is treated as equal to
<code class="docutils literal notranslate"><span class="pre">floor(n_fft</span> <span class="pre">/</span> <span class="pre">4)</span></code>.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">win_length</span></code> is <code class="docutils literal notranslate"><span class="pre">None</span></code> (default), it is treated as equal to
<code class="xref py py-attr docutils literal notranslate"><span class="pre">n_fft</span></code>.</p></li>
<li><p><code class="xref py py-attr docutils literal notranslate"><span class="pre">window</span></code> can be a 1-D tensor of size <code class="xref py py-attr docutils literal notranslate"><span class="pre">win_length</span></code>, e.g., from
<a class="reference internal" href="#torch.hann_window" title="torch.hann_window"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.hann_window()</span></code></a>. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">window</span></code> is <code class="docutils literal notranslate"><span class="pre">None</span></code> (default), it is
treated as if having <span class="math">\(1\)</span> everywhere in the window. If
<span class="math">\(\text{win\_length} &lt; \text{n\_fft}\)</span>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">window</span></code> will be padded on
both sides to length <code class="xref py py-attr docutils literal notranslate"><span class="pre">n_fft</span></code> before being applied.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">center</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> (default), <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> will be padded on
both sides so that the <span class="math">\(t\)</span>-th frame is centered at time
<span class="math">\(t \times \text{hop\_length}\)</span>. Otherwise, the <span class="math">\(t\)</span>-th frame
begins at time  <span class="math">\(t \times \text{hop\_length}\)</span>.</p></li>
<li><p><code class="xref py py-attr docutils literal notranslate"><span class="pre">pad_mode</span></code> determines the padding method used on <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> when
<code class="xref py py-attr docutils literal notranslate"><span class="pre">center</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>. See <a class="reference internal" href="nn.html#torch.nn.functional.pad" title="torch.nn.functional.pad"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.nn.functional.pad()</span></code></a> for
all available options. Default is <code class="docutils literal notranslate"><span class="pre">&quot;reflect&quot;</span></code>.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">onesided</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> (default), only values for <span class="math">\(\omega\)</span>
in <span class="math">\(\left[0, 1, 2, \dots, \left\lfloor \frac{\text{n\_fft}}{2} \right\rfloor + 1\right]\)</span>
are returned because the real-to-complex Fourier transform satisfies the
conjugate symmetry, i.e., <span class="math">\(X[m, \omega] = X[m, \text{n\_fft} - \omega]^*\)</span>.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">normalized</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> (default is <code class="docutils literal notranslate"><span class="pre">False</span></code>), the function
returns the normalized STFT results, i.e., multiplied by <span class="math">\((\text{frame\_length})^{-0.5}\)</span>.</p></li>
</ul>
<p>Returns the real and the imaginary parts together as one tensor of size
<span class="math">\((* \times N \times T \times 2)\)</span>, where <span class="math">\(*\)</span> is the optional
batch size of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, <span class="math">\(N\)</span> is the number of frequencies where
STFT is applied, <span class="math">\(T\)</span> is the total number of frames used, and each pair
in the last dimension represents a complex number as the real part and the
imaginary part.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This function changed signature at version 0.4.1. Calling with the
previous signature may cause error or return incorrect result.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>n_fft</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – size of Fourier transform</p></li>
<li><p><strong>hop_length</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the distance between neighboring sliding window
frames. Default: <code class="docutils literal notranslate"><span class="pre">None</span></code> (treated as equal to <code class="docutils literal notranslate"><span class="pre">floor(n_fft</span> <span class="pre">/</span> <span class="pre">4)</span></code>)</p></li>
<li><p><strong>win_length</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the size of window frame and STFT filter.
Default: <code class="docutils literal notranslate"><span class="pre">None</span></code>  (treated as equal to <code class="xref py py-attr docutils literal notranslate"><span class="pre">n_fft</span></code>)</p></li>
<li><p><strong>window</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the optional window function.
Default: <code class="docutils literal notranslate"><span class="pre">None</span></code> (treated as window of all <span class="math">\(1\)</span> s)</p></li>
<li><p><strong>center</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether to pad <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> on both sides so
that the <span class="math">\(t\)</span>-th frame is centered at time <span class="math">\(t \times \text{hop\_length}\)</span>.
Default: <code class="docutils literal notranslate"><span class="pre">True</span></code></p></li>
<li><p><strong>pad_mode</strong> (<em>string</em><em>, </em><em>optional</em>) – controls the padding method used when
<code class="xref py py-attr docutils literal notranslate"><span class="pre">center</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>. Default: <code class="docutils literal notranslate"><span class="pre">&quot;reflect&quot;</span></code></p></li>
<li><p><strong>normalized</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return the normalized STFT results
Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
<li><p><strong>onesided</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether to return half of results to
avoid redundancy Default: <code class="docutils literal notranslate"><span class="pre">True</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tensor containing the STFT result with shape described above</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.bartlett_window">
<code class="descclassname">torch.</code><code class="descname">bartlett_window</code><span class="sig-paren">(</span><em>window_length</em>, <em>periodic=True</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.bartlett_window" title="Permalink to this definition">¶</a></dt>
<dd><p>Bartlett window function.</p>
<div class="math">
\[w[n] = 1 - \left| \frac{2n}{N-1} - 1 \right| = \begin{cases}
    \frac{2n}{N - 1} & \text{if } 0 \leq n \leq \frac{N - 1}{2} \\
    2 - \frac{2n}{N - 1} & \text{if } \frac{N - 1}{2} < n < N \\
\end{cases},

\]</div>
<p>where <span class="math">\(N\)</span> is the full window size.</p>
<p>The input <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> is a positive integer controlling the
returned window size. <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> flag determines whether the returned
window trims off the last duplicate value from the symmetric window and is
ready to be used as a periodic window with functions like
<a class="reference internal" href="#torch.stft" title="torch.stft"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.stft()</span></code></a>. Therefore, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> is true, the <span class="math">\(N\)</span> in
above formula is in fact <span class="math">\(\text{window\_length} + 1\)</span>. Also, we always have
<code class="docutils literal notranslate"><span class="pre">torch.bartlett_window(L,</span> <span class="pre">periodic=True)</span></code> equal to
<code class="docutils literal notranslate"><span class="pre">torch.bartlett_window(L</span> <span class="pre">+</span> <span class="pre">1,</span> <span class="pre">periodic=False)[:-1])</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> <span class="math">\(=1\)</span>, the returned window contains a single value 1.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>window_length</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the size of returned window</p></li>
<li><p><strong>periodic</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If True, returns a window to be used as periodic
function. If False, return a symmetric window.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). Only floating point types are supported.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned window tensor. Only
<code class="docutils literal notranslate"><span class="pre">torch.strided</span></code> (dense layout) is supported.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A 1-D tensor of size <span class="math">\((\text{window\_length},)\)</span> containing the window</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.blackman_window">
<code class="descclassname">torch.</code><code class="descname">blackman_window</code><span class="sig-paren">(</span><em>window_length</em>, <em>periodic=True</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.blackman_window" title="Permalink to this definition">¶</a></dt>
<dd><p>Blackman window function.</p>
<div class="math">
\[w[n] = 0.42 - 0.5 \cos \left( \frac{2 \pi n}{N - 1} \right) + 0.08 \cos \left( \frac{4 \pi n}{N - 1} \right)

\]</div>
<p>where <span class="math">\(N\)</span> is the full window size.</p>
<p>The input <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> is a positive integer controlling the
returned window size. <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> flag determines whether the returned
window trims off the last duplicate value from the symmetric window and is
ready to be used as a periodic window with functions like
<a class="reference internal" href="#torch.stft" title="torch.stft"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.stft()</span></code></a>. Therefore, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> is true, the <span class="math">\(N\)</span> in
above formula is in fact <span class="math">\(\text{window\_length} + 1\)</span>. Also, we always have
<code class="docutils literal notranslate"><span class="pre">torch.blackman_window(L,</span> <span class="pre">periodic=True)</span></code> equal to
<code class="docutils literal notranslate"><span class="pre">torch.blackman_window(L</span> <span class="pre">+</span> <span class="pre">1,</span> <span class="pre">periodic=False)[:-1])</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> <span class="math">\(=1\)</span>, the returned window contains a single value 1.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>window_length</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the size of returned window</p></li>
<li><p><strong>periodic</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If True, returns a window to be used as periodic
function. If False, return a symmetric window.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). Only floating point types are supported.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned window tensor. Only
<code class="docutils literal notranslate"><span class="pre">torch.strided</span></code> (dense layout) is supported.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A 1-D tensor of size <span class="math">\((\text{window\_length},)\)</span> containing the window</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.hamming_window">
<code class="descclassname">torch.</code><code class="descname">hamming_window</code><span class="sig-paren">(</span><em>window_length</em>, <em>periodic=True</em>, <em>alpha=0.54</em>, <em>beta=0.46</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.hamming_window" title="Permalink to this definition">¶</a></dt>
<dd><p>Hamming window function.</p>
<div class="math">
\[w[n] = \alpha - \beta\ \cos \left( \frac{2 \pi n}{N - 1} \right),

\]</div>
<p>where <span class="math">\(N\)</span> is the full window size.</p>
<p>The input <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> is a positive integer controlling the
returned window size. <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> flag determines whether the returned
window trims off the last duplicate value from the symmetric window and is
ready to be used as a periodic window with functions like
<a class="reference internal" href="#torch.stft" title="torch.stft"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.stft()</span></code></a>. Therefore, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> is true, the <span class="math">\(N\)</span> in
above formula is in fact <span class="math">\(\text{window\_length} + 1\)</span>. Also, we always have
<code class="docutils literal notranslate"><span class="pre">torch.hamming_window(L,</span> <span class="pre">periodic=True)</span></code> equal to
<code class="docutils literal notranslate"><span class="pre">torch.hamming_window(L</span> <span class="pre">+</span> <span class="pre">1,</span> <span class="pre">periodic=False)[:-1])</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> <span class="math">\(=1\)</span>, the returned window contains a single value 1.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This is a generalized version of <a class="reference internal" href="#torch.hann_window" title="torch.hann_window"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.hann_window()</span></code></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>window_length</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the size of returned window</p></li>
<li><p><strong>periodic</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If True, returns a window to be used as periodic
function. If False, return a symmetric window.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). Only floating point types are supported.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned window tensor. Only
<code class="docutils literal notranslate"><span class="pre">torch.strided</span></code> (dense layout) is supported.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A 1-D tensor of size <span class="math">\((\text{window\_length},)\)</span> containing the window</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.hann_window">
<code class="descclassname">torch.</code><code class="descname">hann_window</code><span class="sig-paren">(</span><em>window_length</em>, <em>periodic=True</em>, <em>dtype=None</em>, <em>layout=torch.strided</em>, <em>device=None</em>, <em>requires_grad=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.hann_window" title="Permalink to this definition">¶</a></dt>
<dd><p>Hann window function.</p>
<div class="math">
\[w[n] = \frac{1}{2}\ \left[1 - \cos \left( \frac{2 \pi n}{N - 1} \right)\right] =
        \sin^2 \left( \frac{\pi n}{N - 1} \right),

\]</div>
<p>where <span class="math">\(N\)</span> is the full window size.</p>
<p>The input <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> is a positive integer controlling the
returned window size. <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> flag determines whether the returned
window trims off the last duplicate value from the symmetric window and is
ready to be used as a periodic window with functions like
<a class="reference internal" href="#torch.stft" title="torch.stft"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.stft()</span></code></a>. Therefore, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">periodic</span></code> is true, the <span class="math">\(N\)</span> in
above formula is in fact <span class="math">\(\text{window\_length} + 1\)</span>. Also, we always have
<code class="docutils literal notranslate"><span class="pre">torch.hann_window(L,</span> <span class="pre">periodic=True)</span></code> equal to
<code class="docutils literal notranslate"><span class="pre">torch.hann_window(L</span> <span class="pre">+</span> <span class="pre">1,</span> <span class="pre">periodic=False)[:-1])</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">window_length</span></code> <span class="math">\(=1\)</span>, the returned window contains a single value 1.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>window_length</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the size of returned window</p></li>
<li><p><strong>periodic</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If True, returns a window to be used as periodic
function. If False, return a symmetric window.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses a global default (see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). Only floating point types are supported.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – the desired layout of returned window tensor. Only
<code class="docutils literal notranslate"><span class="pre">torch.strided</span></code> (dense layout) is supported.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>requires_grad</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – If autograd should record operations on the
returned tensor. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A 1-D tensor of size <span class="math">\((\text{window\_length},)\)</span> containing the window</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
</dd></dl>

</div>
<div class="section" id="other-operations">
<h3>Other Operations<a class="headerlink" href="#other-operations" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="torch.bincount">
<code class="descclassname">torch.</code><code class="descname">bincount</code><span class="sig-paren">(</span><em>self</em>, <em>weights=None</em>, <em>minlength=0</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.bincount" title="Permalink to this definition">¶</a></dt>
<dd><p>Count the frequency of each value in an array of non-negative ints.</p>
<p>The number of bins (size 1) is one larger than the largest value in
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> unless <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is empty, in which case the result is a
tensor of size 0. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">minlength</span></code> is specified, the number of bins is at least
<code class="xref py py-attr docutils literal notranslate"><span class="pre">minlength</span></code> and if <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is empty, then the result is tensor of size
<code class="xref py py-attr docutils literal notranslate"><span class="pre">minlength</span></code> filled with zeros. If <code class="docutils literal notranslate"><span class="pre">n</span></code> is the value at position <code class="docutils literal notranslate"><span class="pre">i</span></code>,
<code class="docutils literal notranslate"><span class="pre">out[n]</span> <span class="pre">+=</span> <span class="pre">weights[i]</span></code> if <code class="xref py py-attr docutils literal notranslate"><span class="pre">weights</span></code> is specified else
<code class="docutils literal notranslate"><span class="pre">out[n]</span> <span class="pre">+=</span> <span class="pre">1</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When using the CUDA backend, this operation may induce nondeterministic
behaviour that is not easily switched off.
Please see the notes on <a class="reference internal" href="notes/randomness.html"><span class="doc">Reproducibility</span></a> for background.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – 1-d int tensor</p></li>
<li><p><strong>weights</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – optional, weight for each value in the input tensor.
Should be of same size as input tensor.</p></li>
<li><p><strong>minlength</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – optional, minimum number of bins. Should be non-negative.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>a tensor of shape <code class="docutils literal notranslate"><span class="pre">Size([max(input)</span> <span class="pre">+</span> <span class="pre">1])</span></code> if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is non-empty, else <code class="docutils literal notranslate"><span class="pre">Size(0)</span></code></p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>output (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>)</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nb">input</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randint</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="p">(</span><span class="mi">5</span><span class="p">,),</span> <span class="n">dtype</span><span class="o">=</span><span class="n">torch</span><span class="o">.</span><span class="n">int64</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">weights</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">linspace</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="n">steps</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">input</span><span class="p">,</span> <span class="n">weights</span>
<span class="go">(tensor([4, 3, 6, 3, 4]),</span>
<span class="go"> tensor([ 0.0000,  0.2500,  0.5000,  0.7500,  1.0000])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">bincount</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span>
<span class="go">tensor([0, 0, 0, 2, 2, 0, 1])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="nb">input</span><span class="o">.</span><span class="n">bincount</span><span class="p">(</span><span class="n">weights</span><span class="p">)</span>
<span class="go">tensor([0.0000, 0.0000, 0.0000, 1.0000, 1.0000, 0.0000, 0.5000])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.broadcast_tensors">
<code class="descclassname">torch.</code><code class="descname">broadcast_tensors</code><span class="sig-paren">(</span><em>*tensors</em><span class="sig-paren">)</span> &#x2192; List of Tensors<a class="reference internal" href="_modules/torch/functional.html#broadcast_tensors"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.broadcast_tensors" title="Permalink to this definition">¶</a></dt>
<dd><p>Broadcasts the given tensors according to <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">Broadcasting semantics</span></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>*tensors</strong> – any number of tensors of the same type</p>
</dd>
</dl>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>More than one element of a broadcasted tensor may refer to a single
memory location. As a result, in-place operations (especially ones that
are vectorized) may result in incorrect behavior. If you need to write
to the tensors, please clone them first.</p>
</div>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="p">,</span> <span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">broadcast_tensors</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([2, 3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[0, 1, 2],</span>
<span class="go">        [0, 1, 2]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cartesian_prod">
<code class="descclassname">torch.</code><code class="descname">cartesian_prod</code><span class="sig-paren">(</span><em>*tensors</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#cartesian_prod"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.cartesian_prod" title="Permalink to this definition">¶</a></dt>
<dd><p>Do cartesian product of the given sequence of tensors. The behavior is similar to
python’s <cite>itertools.product</cite>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>*tensors</strong> – any number of 1 dimensional tensors.</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><dl class="simple">
<dt>A tensor equivalent to converting all the input tensors into lists,</dt><dd><p>do <cite>itertools.product</cite> on these lists, and finally convert the resulting list
into tensor.</p>
</dd>
</dl>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="n">itertools</span><span class="o">.</span><span class="n">product</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">))</span>
<span class="go">[(1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor_a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor_b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cartesian_prod</span><span class="p">(</span><span class="n">tensor_a</span><span class="p">,</span> <span class="n">tensor_b</span><span class="p">)</span>
<span class="go">tensor([[1, 4],</span>
<span class="go">        [1, 5],</span>
<span class="go">        [2, 4],</span>
<span class="go">        [2, 5],</span>
<span class="go">        [3, 4],</span>
<span class="go">        [3, 5]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.combinations">
<code class="descclassname">torch.</code><code class="descname">combinations</code><span class="sig-paren">(</span><em>tensor</em>, <em>r=2</em>, <em>with_replacement=False</em><span class="sig-paren">)</span> &#x2192; seq<a class="headerlink" href="#torch.combinations" title="Permalink to this definition">¶</a></dt>
<dd><p>Compute combinations of length <span class="math">\(r\)</span> of the given tensor. The behavior is similar to
python’s <cite>itertools.combinations</cite> when <cite>with_replacement</cite> is set to <cite>False</cite>, and
<cite>itertools.combinations_with_replacement</cite> when <cite>with_replacement</cite> is set to <cite>True</cite>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – 1D vector.</p></li>
<li><p><strong>r</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – number of elements to combine</p></li>
<li><p><strong>with_replacement</strong> (<em>boolean</em><em>, </em><em>optional</em>) – whether to allow duplication in combination</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A tensor equivalent to converting all the input tensors into lists, do
<cite>itertools.combinations</cite> or <cite>itertools.combinations_with_replacement</cite> on these
lists, and finally convert the resulting list into tensor.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="n">itertools</span><span class="o">.</span><span class="n">combinations</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">r</span><span class="o">=</span><span class="mi">2</span><span class="p">))</span>
<span class="go">[(1, 2), (1, 3), (2, 3)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="n">itertools</span><span class="o">.</span><span class="n">combinations</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">r</span><span class="o">=</span><span class="mi">3</span><span class="p">))</span>
<span class="go">[(1, 2, 3)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">list</span><span class="p">(</span><span class="n">itertools</span><span class="o">.</span><span class="n">combinations_with_replacement</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">r</span><span class="o">=</span><span class="mi">2</span><span class="p">))</span>
<span class="go">[(1, 1), (1, 2), (1, 3), (2, 2), (2, 3), (3, 3)]</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor_a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">combinations</span><span class="p">(</span><span class="n">tensor_a</span><span class="p">)</span>
<span class="go">tensor([[1, 2],</span>
<span class="go">        [1, 3],</span>
<span class="go">        [2, 3]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">combinations</span><span class="p">(</span><span class="n">tensor_a</span><span class="p">,</span> <span class="n">r</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[1, 2, 3]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">combinations</span><span class="p">(</span><span class="n">tensor_a</span><span class="p">,</span> <span class="n">with_replacement</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="go">tensor([[1, 1],</span>
<span class="go">        [1, 2],</span>
<span class="go">        [1, 3],</span>
<span class="go">        [2, 2],</span>
<span class="go">        [2, 3],</span>
<span class="go">        [3, 3]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cross">
<code class="descclassname">torch.</code><code class="descname">cross</code><span class="sig-paren">(</span><em>input</em>, <em>other</em>, <em>dim=-1</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cross" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the cross product of vectors in dimension <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code>.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">other</span></code> must have the same size, and the size of their
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> dimension should be 3.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is not given, it defaults to the first dimension found with the
size 3.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>other</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second input tensor</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the dimension to take the cross-product in.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.3956,  1.1455,  1.6895],</span>
<span class="go">        [-0.5849,  1.3672,  0.3599],</span>
<span class="go">        [-1.1626,  0.7180, -0.0521],</span>
<span class="go">        [-0.1339,  0.9902, -2.0225]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([[-0.0257, -1.4725, -1.2251],</span>
<span class="go">        [-1.1479, -0.7005, -1.9757],</span>
<span class="go">        [-1.3904,  0.3726, -1.1836],</span>
<span class="go">        [-0.9688, -0.7153,  0.2159]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cross</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 1.0844, -0.5281,  0.6120],</span>
<span class="go">        [-2.4490, -1.5687,  1.9792],</span>
<span class="go">        [-0.8304, -1.3037,  0.5650],</span>
<span class="go">        [-1.2329,  1.9883,  1.0551]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cross</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">)</span>
<span class="go">tensor([[ 1.0844, -0.5281,  0.6120],</span>
<span class="go">        [-2.4490, -1.5687,  1.9792],</span>
<span class="go">        [-0.8304, -1.3037,  0.5650],</span>
<span class="go">        [-1.2329,  1.9883,  1.0551]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.diag">
<code class="descclassname">torch.</code><code class="descname">diag</code><span class="sig-paren">(</span><em>input</em>, <em>diagonal=0</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.diag" title="Permalink to this definition">¶</a></dt>
<dd><ul class="simple">
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a vector (1-D tensor), then returns a 2-D square tensor
with the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> as the diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a matrix (2-D tensor), then returns a 1-D tensor with
the diagonal elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
</ul>
<p>The argument <a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> controls which diagonal to consider:</p>
<ul class="simple">
<li><p>If <a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> = 0, it is the main diagonal.</p></li>
<li><p>If <a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> &gt; 0, it is above the main diagonal.</p></li>
<li><p>If <a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> &lt; 0, it is below the main diagonal.</p></li>
</ul>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>diagonal</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the diagonal to consider</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<div class="admonition seealso">
<p class="admonition-title">See also</p>
<p><a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.diagonal()</span></code></a> always returns the diagonal of its input.</p>
<p><a class="reference internal" href="#torch.diagflat" title="torch.diagflat"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.diagflat()</span></code></a> always constructs a tensor with diagonal elements
specified by the input.</p>
</div>
<p>Examples:</p>
<p>Get the square matrix where the input vector is the diagonal:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([ 0.5950,-0.0872, 2.3298])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diag</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[ 0.5950, 0.0000, 0.0000],</span>
<span class="go">        [ 0.0000,-0.0872, 0.0000],</span>
<span class="go">        [ 0.0000, 0.0000, 2.3298]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diag</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.0000, 0.5950, 0.0000, 0.0000],</span>
<span class="go">        [ 0.0000, 0.0000,-0.0872, 0.0000],</span>
<span class="go">        [ 0.0000, 0.0000, 0.0000, 2.3298],</span>
<span class="go">        [ 0.0000, 0.0000, 0.0000, 0.0000]])</span>
</pre></div>
</div>
<p>Get the k-th diagonal of a given matrix:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-0.4264, 0.0255,-0.1064],</span>
<span class="go">        [ 0.8795,-0.2429, 0.1374],</span>
<span class="go">        [ 0.1029,-0.6482,-1.6300]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diag</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([-0.4264,-0.2429,-1.6300])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diag</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([ 0.0255, 0.1374])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.diag_embed">
<code class="descclassname">torch.</code><code class="descname">diag_embed</code><span class="sig-paren">(</span><em>input</em>, <em>offset=0</em>, <em>dim1=-2</em>, <em>dim2=-1</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.diag_embed" title="Permalink to this definition">¶</a></dt>
<dd><p>Creates a tensor whose diagonals of certain 2D planes (specified by
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim2</span></code>) are filled by <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.
To facilitate creating batched diagonal matrices, the 2D planes formed by
the last two dimensions of the returned tensor are chosen by default.</p>
<p>The argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> controls which diagonal to consider:</p>
<ul class="simple">
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> = 0, it is the main diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> &gt; 0, it is above the main diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> &lt; 0, it is below the main diagonal.</p></li>
</ul>
<p>The size of the new matrix will be calculated to make the specified diagonal
of the size of the last input dimension.
Note that for <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> other than <span class="math">\(0\)</span>, the order of <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim1</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim2</span></code> matters. Exchanging them is equivalent to changing the
sign of <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code>.</p>
<p>Applying <a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.diagonal()</span></code></a> to the output of this function with
the same arguments yields a matrix identical to input. However,
<a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.diagonal()</span></code></a> has different default dimensions, so those
need to be explicitly specified.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor. Must be at least 1-dimensional.</p></li>
<li><p><strong>offset</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – which diagonal to consider. Default: 0
(main diagonal).</p></li>
<li><p><strong>dim1</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – first dimension with respect to which to
take diagonal. Default: -2.</p></li>
<li><p><strong>dim2</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – second dimension with respect to which to
take diagonal. Default: -1.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diag_embed</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[[ 1.5410,  0.0000,  0.0000],</span>
<span class="go">         [ 0.0000, -0.2934,  0.0000],</span>
<span class="go">         [ 0.0000,  0.0000, -2.1788]],</span>

<span class="go">        [[ 0.5684,  0.0000,  0.0000],</span>
<span class="go">         [ 0.0000, -1.0845,  0.0000],</span>
<span class="go">         [ 0.0000,  0.0000, -1.3986]]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diag_embed</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">offset</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">dim1</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="n">dim2</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([[[ 0.0000,  1.5410,  0.0000,  0.0000],</span>
<span class="go">         [ 0.0000,  0.5684,  0.0000,  0.0000]],</span>

<span class="go">        [[ 0.0000,  0.0000, -0.2934,  0.0000],</span>
<span class="go">         [ 0.0000,  0.0000, -1.0845,  0.0000]],</span>

<span class="go">        [[ 0.0000,  0.0000,  0.0000, -2.1788],</span>
<span class="go">         [ 0.0000,  0.0000,  0.0000, -1.3986]],</span>

<span class="go">        [[ 0.0000,  0.0000,  0.0000,  0.0000],</span>
<span class="go">         [ 0.0000,  0.0000,  0.0000,  0.0000]]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.diagflat">
<code class="descclassname">torch.</code><code class="descname">diagflat</code><span class="sig-paren">(</span><em>input</em>, <em>diagonal=0</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.diagflat" title="Permalink to this definition">¶</a></dt>
<dd><ul class="simple">
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a vector (1-D tensor), then returns a 2-D square tensor
with the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> as the diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is a tensor with more than one dimension, then returns a
2-D tensor with diagonal elements equal to a flattened <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
</ul>
<p>The argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> controls which diagonal to consider:</p>
<ul class="simple">
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> = 0, it is the main diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> &gt; 0, it is above the main diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> &lt; 0, it is below the main diagonal.</p></li>
</ul>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>offset</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the diagonal to consider. Default: 0 (main
diagonal).</p></li>
</ul>
</dd>
</dl>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([-0.2956, -0.9068,  0.1695])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diagflat</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[-0.2956,  0.0000,  0.0000],</span>
<span class="go">        [ 0.0000, -0.9068,  0.0000],</span>
<span class="go">        [ 0.0000,  0.0000,  0.1695]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diagflat</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.0000, -0.2956,  0.0000,  0.0000],</span>
<span class="go">        [ 0.0000,  0.0000, -0.9068,  0.0000],</span>
<span class="go">        [ 0.0000,  0.0000,  0.0000,  0.1695],</span>
<span class="go">        [ 0.0000,  0.0000,  0.0000,  0.0000]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.2094, -0.3018],</span>
<span class="go">        [-0.1516,  1.9342]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diagflat</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[ 0.2094,  0.0000,  0.0000,  0.0000],</span>
<span class="go">        [ 0.0000, -0.3018,  0.0000,  0.0000],</span>
<span class="go">        [ 0.0000,  0.0000, -0.1516,  0.0000],</span>
<span class="go">        [ 0.0000,  0.0000,  0.0000,  1.9342]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.diagonal">
<code class="descclassname">torch.</code><code class="descname">diagonal</code><span class="sig-paren">(</span><em>input</em>, <em>offset=0</em>, <em>dim1=0</em>, <em>dim2=1</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.diagonal" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a partial view of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> with the its diagonal elements
with respect to <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">dim2</span></code> appended as a dimension
at the end of the shape.</p>
<p>The argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> controls which diagonal to consider:</p>
<ul class="simple">
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> = 0, it is the main diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> &gt; 0, it is above the main diagonal.</p></li>
<li><p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> &lt; 0, it is below the main diagonal.</p></li>
</ul>
<p>Applying <a class="reference internal" href="#torch.diag_embed" title="torch.diag_embed"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.diag_embed()</span></code></a> to the output of this function with
the same arguments yields a diagonal matrix with the diagonal entries
of the input. However, <a class="reference internal" href="#torch.diag_embed" title="torch.diag_embed"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.diag_embed()</span></code></a> has different default
dimensions, so those need to be explicitly specified.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor. Must be at least 2-dimensional.</p></li>
<li><p><strong>offset</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – which diagonal to consider. Default: 0
(main diagonal).</p></li>
<li><p><strong>dim1</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – first dimension with respect to which to
take diagonal. Default: 0.</p></li>
<li><p><strong>dim2</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – second dimension with respect to which to
take diagonal. Default: 1.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>To take a batch diagonal, pass in dim1=-2, dim2=-1.</p>
</div>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-1.0854,  1.1431, -0.1752],</span>
<span class="go">        [ 0.8536, -0.0905,  0.0360],</span>
<span class="go">        [ 0.6927, -0.3735, -0.4945]])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diagonal</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([-1.0854, -0.0905, -0.4945])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diagonal</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([ 1.1431,  0.0360])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">diagonal</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">offset</span><span class="o">=-</span><span class="mi">1</span><span class="p">,</span> <span class="n">dim1</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">dim2</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([[[-1.2631,  0.3755, -1.5977, -1.8172],</span>
<span class="go">         [-1.1065,  1.0401, -0.2235, -0.7938]],</span>

<span class="go">        [[-1.7325, -0.3081,  0.6166,  0.2335],</span>
<span class="go">         [ 1.0500,  0.7336, -0.3836, -1.1015]]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.einsum">
<code class="descclassname">torch.</code><code class="descname">einsum</code><span class="sig-paren">(</span><em>equation</em>, <em>*operands</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="reference internal" href="_modules/torch/functional.html#einsum"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.einsum" title="Permalink to this definition">¶</a></dt>
<dd><p>This function provides a way of computing multilinear expressions (i.e. sums of products) using the
Einstein summation convention.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>equation</strong> (<em>string</em>) – The equation is given in terms of lower case letters (indices) to be associated
with each dimension of the operands and result. The left hand side lists the operands
dimensions, separated by commas. There should be one index letter per tensor dimension.
The right hand side follows after <cite>-&gt;</cite> and gives the indices for the output.
If the <cite>-&gt;</cite> and right hand side are omitted, it implicitly defined as the alphabetically
sorted list of all indices appearing exactly once in the left hand side.
The indices not apprearing in the output are summed over after multiplying the operands
entries.
If an index appears several times for the same operand, a diagonal is taken.
Ellipses <cite>…</cite> represent a fixed number of dimensions. If the right hand side is inferred,
the ellipsis dimensions are at the beginning of the output.</p></li>
<li><p><strong>operands</strong> (<em>list of Tensors</em>) – The operands to compute the Einstein sum of.</p></li>
</ul>
</dd>
</dl>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">einsum</span><span class="p">(</span><span class="s1">&#39;i,j-&gt;ij&#39;</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>  <span class="c1"># outer product</span>
<span class="go">tensor([[-0.0570, -0.0286, -0.0231,  0.0197],</span>
<span class="go">        [ 1.2616,  0.6335,  0.5113, -0.4351],</span>
<span class="go">        [ 1.4452,  0.7257,  0.5857, -0.4984],</span>
<span class="go">        [-0.4647, -0.2333, -0.1883,  0.1603],</span>
<span class="go">        [-1.1130, -0.5588, -0.4510,  0.3838]])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">r</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">einsum</span><span class="p">(</span><span class="s1">&#39;bn,anm,bm-&gt;ba&#39;</span><span class="p">,</span> <span class="n">l</span><span class="p">,</span> <span class="n">A</span><span class="p">,</span> <span class="n">r</span><span class="p">)</span> <span class="c1"># compare torch.nn.functional.bilinear</span>
<span class="go">tensor([[-0.3430, -5.2405,  0.4494],</span>
<span class="go">        [ 0.3311,  5.5201, -3.0356]])</span>


<span class="gp">&gt;&gt;&gt; </span><span class="n">As</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">Bs</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">einsum</span><span class="p">(</span><span class="s1">&#39;bij,bjk-&gt;bik&#39;</span><span class="p">,</span> <span class="n">As</span><span class="p">,</span> <span class="n">Bs</span><span class="p">)</span> <span class="c1"># batch matrix multiplication</span>
<span class="go">tensor([[[-1.0564, -1.5904,  3.2023,  3.1271],</span>
<span class="go">         [-1.6706, -0.8097, -0.8025, -2.1183]],</span>

<span class="go">        [[ 4.2239,  0.3107, -0.5756, -0.2354],</span>
<span class="go">         [-1.4558, -0.3460,  1.5087, -0.8530]],</span>

<span class="go">        [[ 2.8153,  1.8787, -4.3839, -1.2112],</span>
<span class="go">         [ 0.3728, -2.1131,  0.0921,  0.8305]]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">einsum</span><span class="p">(</span><span class="s1">&#39;ii-&gt;i&#39;</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span> <span class="c1"># diagonal</span>
<span class="go">tensor([-0.7825,  0.8291, -0.1936])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">einsum</span><span class="p">(</span><span class="s1">&#39;...ii-&gt;...i&#39;</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span> <span class="c1"># batch diagonal</span>
<span class="go">tensor([[-1.0864,  0.7292,  0.0569],</span>
<span class="go">        [-0.9725, -1.0270,  0.6493],</span>
<span class="go">        [ 0.5832, -1.1716, -1.5084],</span>
<span class="go">        [ 0.4041, -1.1690,  0.8570]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">einsum</span><span class="p">(</span><span class="s1">&#39;...ij-&gt;...ji&#39;</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span><span class="o">.</span><span class="n">shape</span> <span class="c1"># batch permute</span>
<span class="go">torch.Size([2, 3, 5, 4])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.flatten">
<code class="descclassname">torch.</code><code class="descname">flatten</code><span class="sig-paren">(</span><em>input</em>, <em>start_dim=0</em>, <em>end_dim=-1</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.flatten" title="Permalink to this definition">¶</a></dt>
<dd><p>Flattens a contiguous range of dims in a tensor.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>start_dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the first dim to flatten</p></li>
<li><p><strong>end_dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the last dim to flatten</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">t</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span>
<span class="go">                       [3, 4]],</span>
<span class="go">                      [[5, 6],</span>
<span class="go">                       [7, 8]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">flatten</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
<span class="go">tensor([1, 2, 3, 4, 5, 6, 7, 8])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">flatten</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">start_dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[1, 2, 3, 4],</span>
<span class="go">        [5, 6, 7, 8]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.flip">
<code class="descclassname">torch.</code><code class="descname">flip</code><span class="sig-paren">(</span><em>input</em>, <em>dims</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.flip" title="Permalink to this definition">¶</a></dt>
<dd><p>Reverse the order of a n-D tensor along given axis in dims.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>dims</strong> (<em>a list</em><em> or </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a>) – axis to flip on</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[[ 0,  1],</span>
<span class="go">         [ 2,  3]],</span>

<span class="go">        [[ 4,  5],</span>
<span class="go">         [ 6,  7]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">flip</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="go">tensor([[[ 6,  7],</span>
<span class="go">         [ 4,  5]],</span>

<span class="go">        [[ 2,  3],</span>
<span class="go">         [ 0,  1]]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.rot90">
<code class="descclassname">torch.</code><code class="descname">rot90</code><span class="sig-paren">(</span><em>input</em>, <em>k</em>, <em>dims</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.rot90" title="Permalink to this definition">¶</a></dt>
<dd><p>Rotate a n-D tensor by 90 degrees in the plane specified by dims axis.
Rotation direction is from the first towards the second axis if k &gt; 0, and from the second towards the first for k &lt; 0.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>k</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – number of times to rotate</p></li>
<li><p><strong>dims</strong> (<em>a list</em><em> or </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a>) – axis to rotate</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[0, 1],</span>
<span class="go">        [2, 3]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rot90</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">])</span>
<span class="go">tensor([[1, 3],</span>
<span class="go">        [0, 2]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mi">8</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[[0, 1],</span>
<span class="go">         [2, 3]],</span>

<span class="go">        [[4, 5],</span>
<span class="go">         [6, 7]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">rot90</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span>
<span class="go">tensor([[[1, 3],</span>
<span class="go">         [0, 2]],</span>

<span class="go">        [[5, 7],</span>
<span class="go">         [4, 6]]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.histc">
<code class="descclassname">torch.</code><code class="descname">histc</code><span class="sig-paren">(</span><em>input</em>, <em>bins=100</em>, <em>min=0</em>, <em>max=0</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.histc" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the histogram of a tensor.</p>
<p>The elements are sorted into equal width bins between <a class="reference internal" href="#torch.min" title="torch.min"><code class="xref py py-attr docutils literal notranslate"><span class="pre">min</span></code></a> and
<a class="reference internal" href="#torch.max" title="torch.max"><code class="xref py py-attr docutils literal notranslate"><span class="pre">max</span></code></a>. If <a class="reference internal" href="#torch.min" title="torch.min"><code class="xref py py-attr docutils literal notranslate"><span class="pre">min</span></code></a> and <a class="reference internal" href="#torch.max" title="torch.max"><code class="xref py py-attr docutils literal notranslate"><span class="pre">max</span></code></a> are both zero, the minimum and
maximum values of the data are used.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>bins</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – number of histogram bins</p></li>
<li><p><strong>min</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – lower end of the range (inclusive)</p></li>
<li><p><strong>max</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – upper end of the range (inclusive)</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Histogram represented as a tensor</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">histc</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mf">1.</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">]),</span> <span class="n">bins</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span> <span class="nb">min</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([ 0.,  2.,  1.,  0.])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.meshgrid">
<code class="descclassname">torch.</code><code class="descname">meshgrid</code><span class="sig-paren">(</span><em>*tensors</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#meshgrid"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.meshgrid" title="Permalink to this definition">¶</a></dt>
<dd><p>Take <span class="math">\(N\)</span> tensors, each of which can be either scalar or 1-dimensional
vector, and create <span class="math">\(N\)</span> N-dimensional grids, where the <span class="math">\(i\)</span> <sup>th</sup> grid is defined by
expanding the <span class="math">\(i\)</span> <sup>th</sup> input over dimensions defined by other inputs.</p>
<blockquote>
<div><dl class="simple">
<dt>Args:</dt><dd><p>tensors (list of Tensor): list of scalars or 1 dimensional tensors. Scalars will be
treated as tensors of size <span class="math">\((1,)\)</span> automatically</p>
</dd>
<dt>Returns:</dt><dd><p>seq (sequence of Tensors): If the input has <span class="math">\(k\)</span> tensors of size
<span class="math">\((N_1,), (N_2,), \ldots , (N_k,)\)</span>, then the output would also has <span class="math">\(k\)</span> tensors,
where all tensors are of size <span class="math">\((N_1, N_2, \ldots , N_k)\)</span>.</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">grid_x</span><span class="p">,</span> <span class="n">grid_y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">meshgrid</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">grid_x</span>
<span class="go">tensor([[1, 1, 1],</span>
<span class="go">        [2, 2, 2],</span>
<span class="go">        [3, 3, 3]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">grid_y</span>
<span class="go">tensor([[4, 5, 6],</span>
<span class="go">        [4, 5, 6],</span>
<span class="go">        [4, 5, 6]])</span>
</pre></div>
</div>
</div></blockquote>
</dd></dl>

<dl class="function">
<dt id="torch.renorm">
<code class="descclassname">torch.</code><code class="descname">renorm</code><span class="sig-paren">(</span><em>input</em>, <em>p</em>, <em>dim</em>, <em>maxnorm</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.renorm" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tensor where each sub-tensor of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> along dimension
<code class="xref py py-attr docutils literal notranslate"><span class="pre">dim</span></code> is normalized such that the <cite>p</cite>-norm of the sub-tensor is lower
than the value <code class="xref py py-attr docutils literal notranslate"><span class="pre">maxnorm</span></code></p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>If the norm of a row is lower than <cite>maxnorm</cite>, the row is unchanged</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>p</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the power for the norm computation</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the dimension to slice over to get the sub-tensors</p></li>
<li><p><strong>maxnorm</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – the maximum norm to keep each sub-tensor under</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">fill_</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([ 2.,  2.,  2.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="o">.</span><span class="n">fill_</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([ 3.,  3.,  3.])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 1.,  1.,  1.],</span>
<span class="go">        [ 2.,  2.,  2.],</span>
<span class="go">        [ 3.,  3.,  3.]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">renorm</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="go">tensor([[ 1.0000,  1.0000,  1.0000],</span>
<span class="go">        [ 1.6667,  1.6667,  1.6667],</span>
<span class="go">        [ 1.6667,  1.6667,  1.6667]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.repeat_interleave">
<code class="descclassname">torch.</code><code class="descname">repeat_interleave</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#torch.repeat_interleave" title="Permalink to this definition">¶</a></dt>
<dd><dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">repeat_interleave</code><span class="sig-paren">(</span><em>input</em>, <em>repeats</em>, <em>dim=None</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>Repeat elements of a tensor.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This is different from <code class="xref py py-func docutils literal notranslate"><span class="pre">torch.repeat()</span></code> but similar to <cite>numpy.repeat</cite>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – The input tensor</p></li>
<li><p><strong>repeats</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em> or </em><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – The number of repetitions for each element.
repeats is broadcasted to fit the shape of the given axis.</p></li>
<li><p><strong>dim</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – The dimension along which to repeat values.
By default, use the flattened input array, and return a flat output
array.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><dl class="simple">
<dt>Repeated tensor which has the same shape as input, except along the</dt><dd><p>given axis.</p>
</dd>
</dl>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span><span class="o">.</span><span class="n">repeat_interleave</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([1, 1, 2, 2, 3, 3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">repeat_interleave</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="go">tensor([1, 1, 2, 2, 3, 3, 4, 4])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">repeat_interleave</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="n">dim</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[1, 1, 1, 2, 2, 2],</span>
<span class="go">        [3, 3, 3, 4, 4, 4]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">repeat_interleave</span><span class="p">(</span><span class="n">y</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">]),</span> <span class="n">dim</span><span class="o">=</span><span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([[1, 2],</span>
<span class="go">        [3, 4],</span>
<span class="go">        [3, 4]])</span>
</pre></div>
</div>
<dl class="function">
<dt>
<code class="descclassname">torch.</code><code class="descname">repeat_interleave</code><span class="sig-paren">(</span><em>repeats</em><span class="sig-paren">)</span> &#x2192; Tensor</dt>
<dd></dd></dl>

<p>If the <cite>repeats</cite> is <cite>tensor([n1, n2, n3, …])</cite>, then the output will be
<cite>tensor([0, 0, …, 1, 1, …, 2, 2, …, …])</cite> where <cite>0</cite> appears <cite>n1</cite> times,
<cite>1</cite> appears <cite>n2</cite> times, <cite>2</cite> appears <cite>n3</cite> times, etc.</p>
</dd></dl>

<dl class="function">
<dt id="torch.roll">
<code class="descclassname">torch.</code><code class="descname">roll</code><span class="sig-paren">(</span><em>input</em>, <em>shifts</em>, <em>dims=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.roll" title="Permalink to this definition">¶</a></dt>
<dd><p>Roll the tensor along the given dimension(s). Elements that are shifted beyond the
last position are re-introduced at the first position. If a dimension is not
specified, the tensor will be flattened before rolling and then restored
to the original shape.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>shifts</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of python:ints</em>) – The number of places by which the elements
of the tensor are shifted. If shifts is a tuple, dims must be a tuple of
the same size, and each dimension will be rolled by the corresponding
value</p></li>
<li><p><strong>dims</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of python:ints</em>) – Axis along which to roll</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">8</span><span class="p">])</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[1, 2],</span>
<span class="go">        [3, 4],</span>
<span class="go">        [5, 6],</span>
<span class="go">        [7, 8]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">roll</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([[7, 8],</span>
<span class="go">        [1, 2],</span>
<span class="go">        [3, 4],</span>
<span class="go">        [5, 6]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">roll</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span>
<span class="go">tensor([[3, 4],</span>
<span class="go">        [5, 6],</span>
<span class="go">        [7, 8],</span>
<span class="go">        [1, 2]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">roll</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">shifts</span><span class="o">=</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">),</span> <span class="n">dims</span><span class="o">=</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">))</span>
<span class="go">tensor([[6, 5],</span>
<span class="go">        [8, 7],</span>
<span class="go">        [2, 1],</span>
<span class="go">        [4, 3]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.tensordot">
<code class="descclassname">torch.</code><code class="descname">tensordot</code><span class="sig-paren">(</span><em>a</em>, <em>b</em>, <em>dims=2</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#tensordot"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.tensordot" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a contraction of a and b over multiple dimensions.</p>
<p><a class="reference internal" href="#torch.tensordot" title="torch.tensordot"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensordot</span></code></a> implements a generalizes the matrix product.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>a</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – Left tensor to contract</p></li>
<li><p><strong>b</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – Right tensor to contract</p></li>
<li><p><strong>dims</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em> or </em><em>tuple of two lists of python:integers</em>) – number of dimensions to
contract or explicit lists of dimensions for <code class="xref py py-attr docutils literal notranslate"><span class="pre">a</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">b</span></code> respectively</p></li>
</ul>
</dd>
</dl>
<p>When called with an integer argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">dims</span></code> = <span class="math">\(d\)</span>, and the number of
dimensions of <code class="xref py py-attr docutils literal notranslate"><span class="pre">a</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">b</span></code> is <span class="math">\(m\)</span> and <span class="math">\(n\)</span>, respectively,
it computes</p>
<div class="math">
\[r_{i_0,...,i_{m-d}, i_d,...,i_n}
  = \sum_{k_0,...,k_{d-1}} a_{i_0,...,i_{m-d},k_0,...,k_{d-1}} \times b_{k_0,...,k_{d-1}, i_d,...,i_n}.

\]</div>
<p>When called with <code class="xref py py-attr docutils literal notranslate"><span class="pre">dims</span></code> of the list form, the given dimensions will be contracted
in place of the last <span class="math">\(d\)</span> of <code class="xref py py-attr docutils literal notranslate"><span class="pre">a</span></code> and the first <span class="math">\(d\)</span> of <span class="math">\(b\)</span>. The sizes
in these dimensions must match, but <a class="reference internal" href="#torch.tensordot" title="torch.tensordot"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensordot</span></code></a> will deal with broadcasted
dimensions.</p>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">60.</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">24.</span><span class="p">)</span><span class="o">.</span><span class="n">reshape</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tensordot</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">dims</span><span class="o">=</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">]))</span>
<span class="go">tensor([[4400., 4730.],</span>
<span class="go">        [4532., 4874.],</span>
<span class="go">        [4664., 5018.],</span>
<span class="go">        [4796., 5162.],</span>
<span class="go">        [4928., 5306.]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="s1">&#39;cuda&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="s1">&#39;cuda&#39;</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensordot</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">dims</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">cpu</span><span class="p">()</span>
<span class="go">tensor([[ 8.3504, -2.5436,  6.2922,  2.7556, -1.0732,  3.2741],</span>
<span class="go">        [ 3.3161,  0.0704,  5.0187, -0.4079, -4.3126,  4.8744],</span>
<span class="go">        [ 0.8223,  3.9445,  3.2168, -0.2400,  3.4117,  1.7780]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.trace">
<code class="descclassname">torch.</code><code class="descname">trace</code><span class="sig-paren">(</span><em>input</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.trace" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the sum of the elements of the diagonal of the input 2-D matrix.</p>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">10.</span><span class="p">)</span><span class="o">.</span><span class="n">view</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span>
<span class="go">tensor([[ 1.,  2.,  3.],</span>
<span class="go">        [ 4.,  5.,  6.],</span>
<span class="go">        [ 7.,  8.,  9.]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="go">tensor(15.)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.tril">
<code class="descclassname">torch.</code><code class="descname">tril</code><span class="sig-paren">(</span><em>input</em>, <em>diagonal=0</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.tril" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the lower triangular part of the matrix (2-D tensor) or batch of matrices
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, the other elements of the result tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> are set to 0.</p>
<p>The lower triangular part of the matrix is defined as the elements on and
below the diagonal.</p>
<p>The argument <a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> controls which diagonal to consider. If
<a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> = 0, all elements on and below the main diagonal are
retained. A positive value includes just as many diagonals above the main
diagonal, and similarly a negative value excludes just as many diagonals below
the main diagonal. The main diagonal are the set of indices
<span class="math">\(\lbrace (i, i) \rbrace\)</span> for <span class="math">\(i \in [0, \min\{d_{1}, d_{2}\} - 1]\)</span> where
<span class="math">\(d_{1}, d_{2}\)</span> are the dimensions of the matrix.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>diagonal</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the diagonal to consider</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[-1.0813, -0.8619,  0.7105],</span>
<span class="go">        [ 0.0935,  0.1380,  2.2112],</span>
<span class="go">        [-0.3409, -0.9828,  0.0289]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tril</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[-1.0813,  0.0000,  0.0000],</span>
<span class="go">        [ 0.0935,  0.1380,  0.0000],</span>
<span class="go">        [-0.3409, -0.9828,  0.0289]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([[ 1.2219,  0.5653, -0.2521, -0.2345,  1.2544,  0.3461],</span>
<span class="go">        [ 0.4785, -0.4477,  0.6049,  0.6368,  0.8775,  0.7145],</span>
<span class="go">        [ 1.1502,  3.2716, -1.1243, -0.5413,  0.3615,  0.6864],</span>
<span class="go">        [-0.0614, -0.7344, -1.3164, -0.7648, -1.4024,  0.0978]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tril</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">diagonal</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 1.2219,  0.5653,  0.0000,  0.0000,  0.0000,  0.0000],</span>
<span class="go">        [ 0.4785, -0.4477,  0.6049,  0.0000,  0.0000,  0.0000],</span>
<span class="go">        [ 1.1502,  3.2716, -1.1243, -0.5413,  0.0000,  0.0000],</span>
<span class="go">        [-0.0614, -0.7344, -1.3164, -0.7648, -1.4024,  0.0000]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">tril</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">diagonal</span><span class="o">=-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.0000,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000],</span>
<span class="go">        [ 0.4785,  0.0000,  0.0000,  0.0000,  0.0000,  0.0000],</span>
<span class="go">        [ 1.1502,  3.2716,  0.0000,  0.0000,  0.0000,  0.0000],</span>
<span class="go">        [-0.0614, -0.7344, -1.3164,  0.0000,  0.0000,  0.0000]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.tril_indices">
<code class="descclassname">torch.</code><code class="descname">tril_indices</code><span class="sig-paren">(</span><em>row</em>, <em>column</em>, <em>offset=0</em>, <em>dtype=torch.long</em>, <em>device='cpu'</em>, <em>layout=torch.strided</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.tril_indices" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the indices of the lower triangular part of a <code class="xref py py-attr docutils literal notranslate"><span class="pre">row</span></code>-by-
<code class="xref py py-attr docutils literal notranslate"><span class="pre">column</span></code> matrix in a 2-by-N Tensor, where the first row contains row
coordinates of all indices and the second row contains column coordinates.
Indices are ordered based on rows and then columns.</p>
<p>The lower triangular part of the matrix is defined as the elements on and
below the diagonal.</p>
<p>The argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> controls which diagonal to consider. If
<code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> = 0, all elements on and below the main diagonal are
retained. A positive value includes just as many diagonals above the main
diagonal, and similarly a negative value excludes just as many diagonals below
the main diagonal. The main diagonal are the set of indices
<span class="math">\(\lbrace (i, i) \rbrace\)</span> for <span class="math">\(i \in [0, \min\{d_{1}, d_{2}\} - 1]\)</span>
where <span class="math">\(d_{1}, d_{2}\)</span> are the dimensions of the matrix.</p>
<p>NOTE: when running on ‘cuda’, row * col must be less than <span class="math">\(2^{59}\)</span> to
prevent overflow during calculation.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>row</strong> (<code class="docutils literal notranslate"><span class="pre">int</span></code>) – number of rows in the 2-D matrix.</p></li>
<li><p><strong>column</strong> (<code class="docutils literal notranslate"><span class="pre">int</span></code>) – number of columns in the 2-D matrix.</p></li>
<li><p><strong>offset</strong> (<code class="docutils literal notranslate"><span class="pre">int</span></code>) – diagonal offset from the main diagonal.
Default: if not provided, 0.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, <code class="docutils literal notranslate"><span class="pre">torch.long</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – currently only support <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
</ul>
</dd>
</dl>
<dl>
<dt>Example::</dt><dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tril_indices</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[0, 1, 1, 2, 2, 2],</span>
<span class="go">        [0, 0, 1, 0, 1, 2]])</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tril_indices</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[1, 2, 2, 3, 3, 3],</span>
<span class="go">        [0, 0, 1, 0, 1, 2]])</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tril_indices</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3],</span>
<span class="go">        [0, 1, 0, 1, 2, 0, 1, 2, 0, 1, 2]])</span>
</pre></div>
</div>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.triu">
<code class="descclassname">torch.</code><code class="descname">triu</code><span class="sig-paren">(</span><em>input</em>, <em>diagonal=0</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.triu" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the upper triangular part of a matrix (2-D tensor) or batch of matrices
<code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, the other elements of the result tensor <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> are set to 0.</p>
<p>The upper triangular part of the matrix is defined as the elements on and
above the diagonal.</p>
<p>The argument <a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> controls which diagonal to consider. If
<a class="reference internal" href="#torch.diagonal" title="torch.diagonal"><code class="xref py py-attr docutils literal notranslate"><span class="pre">diagonal</span></code></a> = 0, all elements on and below the main diagonal are
retained. A positive value excludes just as many diagonals above the main
diagonal, and similarly a negative value includes just as many diagonals below
the main diagonal. The main diagonal are the set of indices
<span class="math">\(\lbrace (i, i) \rbrace\)</span> for <span class="math">\(i \in [0, \min\{d_{1}, d_{2}\} - 1]\)</span> where
<span class="math">\(d_{1}, d_{2}\)</span> are the dimensions of the matrix.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>diagonal</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a><em>, </em><em>optional</em>) – the diagonal to consider</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.2309,  0.5207,  2.0049],</span>
<span class="go">        [ 0.2072, -1.0680,  0.6602],</span>
<span class="go">        [ 0.3480, -0.5211, -0.4573]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">triu</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor([[ 0.2309,  0.5207,  2.0049],</span>
<span class="go">        [ 0.0000, -1.0680,  0.6602],</span>
<span class="go">        [ 0.0000,  0.0000, -0.4573]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">triu</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">diagonal</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.0000,  0.5207,  2.0049],</span>
<span class="go">        [ 0.0000,  0.0000,  0.6602],</span>
<span class="go">        [ 0.0000,  0.0000,  0.0000]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">triu</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">diagonal</span><span class="o">=-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.2309,  0.5207,  2.0049],</span>
<span class="go">        [ 0.2072, -1.0680,  0.6602],</span>
<span class="go">        [ 0.0000, -0.5211, -0.4573]])</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([[ 0.5876, -0.0794, -1.8373,  0.6654,  0.2604,  1.5235],</span>
<span class="go">        [-0.2447,  0.9556, -1.2919,  1.3378, -0.1768, -1.0857],</span>
<span class="go">        [ 0.4333,  0.3146,  0.6576, -1.0432,  0.9348, -0.4410],</span>
<span class="go">        [-0.9888,  1.0679, -1.3337, -1.6556,  0.4798,  0.2830]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">triu</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">diagonal</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.0000, -0.0794, -1.8373,  0.6654,  0.2604,  1.5235],</span>
<span class="go">        [ 0.0000,  0.0000, -1.2919,  1.3378, -0.1768, -1.0857],</span>
<span class="go">        [ 0.0000,  0.0000,  0.0000, -1.0432,  0.9348, -0.4410],</span>
<span class="go">        [ 0.0000,  0.0000,  0.0000,  0.0000,  0.4798,  0.2830]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">triu</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">diagonal</span><span class="o">=-</span><span class="mi">1</span><span class="p">)</span>
<span class="go">tensor([[ 0.5876, -0.0794, -1.8373,  0.6654,  0.2604,  1.5235],</span>
<span class="go">        [-0.2447,  0.9556, -1.2919,  1.3378, -0.1768, -1.0857],</span>
<span class="go">        [ 0.0000,  0.3146,  0.6576, -1.0432,  0.9348, -0.4410],</span>
<span class="go">        [ 0.0000,  0.0000, -1.3337, -1.6556,  0.4798,  0.2830]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.triu_indices">
<code class="descclassname">torch.</code><code class="descname">triu_indices</code><span class="sig-paren">(</span><em>row</em>, <em>column</em>, <em>offset=0</em>, <em>dtype=torch.long</em>, <em>device='cpu'</em>, <em>layout=torch.strided</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.triu_indices" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the indices of the upper triangular part of a <code class="xref py py-attr docutils literal notranslate"><span class="pre">row</span></code> by
<code class="xref py py-attr docutils literal notranslate"><span class="pre">column</span></code> matrix in a 2-by-N Tensor, where the first row contains row
coordinates of all indices and the second row contains column coordinates.
Indices are ordered based on rows and then columns.</p>
<p>The upper triangular part of the matrix is defined as the elements on and
above the diagonal.</p>
<p>The argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> controls which diagonal to consider. If
<code class="xref py py-attr docutils literal notranslate"><span class="pre">offset</span></code> = 0, all elements on and above the main diagonal are
retained. A positive value excludes just as many diagonals above the main
diagonal, and similarly a negative value includes just as many diagonals below
the main diagonal. The main diagonal are the set of indices
<span class="math">\(\lbrace (i, i) \rbrace\)</span> for <span class="math">\(i \in [0, \min\{d_{1}, d_{2}\} - 1]\)</span>
where <span class="math">\(d_{1}, d_{2}\)</span> are the dimensions of the matrix.</p>
<p>NOTE: when running on ‘cuda’, row * col must be less than <span class="math">\(2^{59}\)</span> to
prevent overflow during calculation.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>row</strong> (<code class="docutils literal notranslate"><span class="pre">int</span></code>) – number of rows in the 2-D matrix.</p></li>
<li><p><strong>column</strong> (<code class="docutils literal notranslate"><span class="pre">int</span></code>) – number of columns in the 2-D matrix.</p></li>
<li><p><strong>offset</strong> (<code class="docutils literal notranslate"><span class="pre">int</span></code>) – diagonal offset from the main diagonal.
Default: if not provided, 0.</p></li>
<li><p><strong>dtype</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.dtype" title="torch.torch.dtype"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.dtype</span></code></a>, optional) – the desired data type of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, <code class="docutils literal notranslate"><span class="pre">torch.long</span></code>.</p></li>
<li><p><strong>device</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.device" title="torch.torch.device"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.device</span></code></a>, optional) – the desired device of returned tensor.
Default: if <code class="docutils literal notranslate"><span class="pre">None</span></code>, uses the current device for the default tensor type
(see <a class="reference internal" href="#torch.set_default_tensor_type" title="torch.set_default_tensor_type"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.set_default_tensor_type()</span></code></a>). <code class="xref py py-attr docutils literal notranslate"><span class="pre">device</span></code> will be the CPU
for CPU tensor types and the current CUDA device for CUDA tensor types.</p></li>
<li><p><strong>layout</strong> (<a class="reference internal" href="tensor_attributes.html#torch.torch.layout" title="torch.torch.layout"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.layout</span></code></a>, optional) – currently only support <code class="docutils literal notranslate"><span class="pre">torch.strided</span></code>.</p></li>
</ul>
</dd>
</dl>
<dl>
<dt>Example::</dt><dd><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">triu_indices</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[0, 0, 0, 1, 1, 2],</span>
<span class="go">        [0, 1, 2, 1, 2, 2]])</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">triu_indices</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[0, 0, 0, 1, 1, 1, 2, 2, 3],</span>
<span class="go">        [0, 1, 2, 0, 1, 2, 1, 2, 2]])</span>
</pre></div>
</div>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">triu_indices</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[0, 0, 1],</span>
<span class="go">        [1, 2, 2]])</span>
</pre></div>
</div>
</dd>
</dl>
</dd></dl>

</div>
<div class="section" id="blas-and-lapack-operations">
<h3>BLAS and LAPACK Operations<a class="headerlink" href="#blas-and-lapack-operations" title="Permalink to this headline">¶</a></h3>
<dl class="function">
<dt id="torch.addbmm">
<code class="descclassname">torch.</code><code class="descname">addbmm</code><span class="sig-paren">(</span><em>beta=1</em>, <em>mat</em>, <em>alpha=1</em>, <em>batch1</em>, <em>batch2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.addbmm" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs a batch matrix-matrix product of matrices stored
in <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code>,
with a reduced add step (all matrix multiplications get accumulated
along the first dimension).
<code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> is added to the final result.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code> must be 3-D tensors each containing the
same number of matrices.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code> is a <span class="math">\((b \times n \times m)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code> is a
<span class="math">\((b \times m \times p)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with a <span class="math">\((n \times p)\)</span> tensor
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be a <span class="math">\((n \times p)\)</span> tensor.</p>
<div class="math">
\[out = \beta\ \text{mat} + \alpha\ (\sum_{i=0}^{b-1} \text{batch1}_i \mathbin{@} \text{batch2}_i)

\]</div>
<p>For inputs of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, arguments <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code>
must be real numbers, otherwise they should be integers.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>beta</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> (<span class="math">\(\beta\)</span>)</p></li>
<li><p><strong>mat</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – matrix to be added</p></li>
<li><p><strong>alpha</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <cite>batch1 &#64; batch2</cite> (<span class="math">\(\alpha\)</span>)</p></li>
<li><p><strong>batch1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first batch of matrices to be multiplied</p></li>
<li><p><strong>batch2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second batch of matrices to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">M</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">batch1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">batch2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">addbmm</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="n">batch1</span><span class="p">,</span> <span class="n">batch2</span><span class="p">)</span>
<span class="go">tensor([[  6.6311,   0.0503,   6.9768, -12.0362,  -2.1653],</span>
<span class="go">        [ -4.8185,  -1.4255,  -6.6760,   8.9453,   2.5743],</span>
<span class="go">        [ -3.8202,   4.3691,   1.0943,  -1.1109,   5.4730]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.addmm">
<code class="descclassname">torch.</code><code class="descname">addmm</code><span class="sig-paren">(</span><em>beta=1</em>, <em>mat</em>, <em>alpha=1</em>, <em>mat1</em>, <em>mat2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.addmm" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs a matrix multiplication of the matrices <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat2</span></code>.
The matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> is added to the final result.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat1</span></code> is a <span class="math">\((n \times m)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat2</span></code> is a
<span class="math">\((m \times p)\)</span> tensor, then <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with a <span class="math">\((n \times p)\)</span> tensor
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be a <span class="math">\((n \times p)\)</span> tensor.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> are scaling factors on matrix-vector product between
<code class="xref py py-attr docutils literal notranslate"><span class="pre">mat1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat2</span></code> and the added matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> respectively.</p>
<div class="math">
\[\text{out} = \beta\ \text{mat} + \alpha\ (\text{mat1}_i \mathbin{@} \text{mat2}_i)

\]</div>
<p>For inputs of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, arguments <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> must be real numbers, otherwise they should be integers.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>beta</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> (<span class="math">\(\beta\)</span>)</p></li>
<li><p><strong>mat</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – matrix to be added</p></li>
<li><p><strong>alpha</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <span class="math">\(mat1 &#64; mat2\)</span> (<span class="math">\(\alpha\)</span>)</p></li>
<li><p><strong>mat1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first matrix to be multiplied</p></li>
<li><p><strong>mat2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second matrix to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">M</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">mat1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">mat2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">addmm</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="n">mat1</span><span class="p">,</span> <span class="n">mat2</span><span class="p">)</span>
<span class="go">tensor([[-4.8716,  1.4671, -1.3746],</span>
<span class="go">        [ 0.7573, -3.9555, -2.8681]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.addmv">
<code class="descclassname">torch.</code><code class="descname">addmv</code><span class="sig-paren">(</span><em>beta=1</em>, <em>tensor</em>, <em>alpha=1</em>, <em>mat</em>, <em>vec</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.addmv" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs a matrix-vector product of the matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> and
the vector <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec</span></code>.
The vector <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a> is added to the final result.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> is a <span class="math">\((n \times m)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec</span></code> is a 1-D tensor of
size <cite>m</cite>, then <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with a 1-D tensor of size <cite>n</cite> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be 1-D tensor of size <cite>n</cite>.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> are scaling factors on matrix-vector product between
<code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec</span></code> and the added tensor <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a> respectively.</p>
<div class="math">
\[\text{out} = \beta\ \text{tensor} + \alpha\ (\text{mat} \mathbin{@} \text{vec})

\]</div>
<p>For inputs of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, arguments <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> must be real numbers, otherwise they should be integers</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>beta</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <a class="reference internal" href="#torch.tensor" title="torch.tensor"><code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor</span></code></a> (<span class="math">\(\beta\)</span>)</p></li>
<li><p><strong>tensor</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – vector to be added</p></li>
<li><p><strong>alpha</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <span class="math">\(mat &#64; vec\)</span> (<span class="math">\(\alpha\)</span>)</p></li>
<li><p><strong>mat</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – matrix to be multiplied</p></li>
<li><p><strong>vec</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – vector to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">M</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">mat</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vec</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">addmv</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="n">mat</span><span class="p">,</span> <span class="n">vec</span><span class="p">)</span>
<span class="go">tensor([-0.3768, -5.5565])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.addr">
<code class="descclassname">torch.</code><code class="descname">addr</code><span class="sig-paren">(</span><em>beta=1</em>, <em>mat</em>, <em>alpha=1</em>, <em>vec1</em>, <em>vec2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.addr" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs the outer-product of vectors <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec2</span></code>
and adds it to the matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code>.</p>
<p>Optional values <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> are scaling factors on the
outer product between <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec2</span></code> and the added matrix
<code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> respectively.</p>
<div class="math">
\[\text{out} = \beta\ \text{mat} + \alpha\ (\text{vec1} \otimes \text{vec2})

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec1</span></code> is a vector of size <cite>n</cite> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec2</span></code> is a vector
of size <cite>m</cite>, then <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with a matrix of size
<span class="math">\((n \times m)\)</span> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be a matrix of size
<span class="math">\((n \times m)\)</span>.</p>
<p>For inputs of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, arguments <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> must be real numbers, otherwise they should be integers</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>beta</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> (<span class="math">\(\beta\)</span>)</p></li>
<li><p><strong>mat</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – matrix to be added</p></li>
<li><p><strong>alpha</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <span class="math">\(\text{vec1} \otimes \text{vec2}\)</span> (<span class="math">\(\alpha\)</span>)</p></li>
<li><p><strong>vec1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first vector of the outer product</p></li>
<li><p><strong>vec2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second vector of the outer product</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">vec1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">4.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vec2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">3.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">M</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">zeros</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">addr</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="n">vec1</span><span class="p">,</span> <span class="n">vec2</span><span class="p">)</span>
<span class="go">tensor([[ 1.,  2.],</span>
<span class="go">        [ 2.,  4.],</span>
<span class="go">        [ 3.,  6.]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.baddbmm">
<code class="descclassname">torch.</code><code class="descname">baddbmm</code><span class="sig-paren">(</span><em>beta=1</em>, <em>mat</em>, <em>alpha=1</em>, <em>batch1</em>, <em>batch2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.baddbmm" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs a batch matrix-matrix product of matrices in <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code>.
<code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> is added to the final result.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code> must be 3-D tensors each containing the same
number of matrices.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code> is a <span class="math">\((b \times n \times m)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code> is a
<span class="math">\((b \times m \times p)\)</span> tensor, then <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> must be
<a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcastable</span></a> with a
<span class="math">\((b \times n \times p)\)</span> tensor and <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be a
<span class="math">\((b \times n \times p)\)</span> tensor. Both <code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> mean the
same as the scaling factors used in <a class="reference internal" href="#torch.addbmm" title="torch.addbmm"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.addbmm()</span></code></a>.</p>
<div class="math">
\[\text{out}_i = \beta\ \text{mat}_i + \alpha\ (\text{batch1}_i \mathbin{@} \text{batch2}_i)

\]</div>
<p>For inputs of type <cite>FloatTensor</cite> or <cite>DoubleTensor</cite>, arguments <code class="xref py py-attr docutils literal notranslate"><span class="pre">beta</span></code> and
<code class="xref py py-attr docutils literal notranslate"><span class="pre">alpha</span></code> must be real numbers, otherwise they should be integers.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>beta</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> (<span class="math">\(\beta\)</span>)</p></li>
<li><p><strong>mat</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to be added</p></li>
<li><p><strong>alpha</strong> (<em>Number</em><em>, </em><em>optional</em>) – multiplier for <span class="math">\(\text{batch1} \mathbin{&#64;} \text{batch2}\)</span> (<span class="math">\(\alpha\)</span>)</p></li>
<li><p><strong>batch1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first batch of matrices to be multiplied</p></li>
<li><p><strong>batch2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second batch of matrices to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">M</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">batch1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">batch2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">baddbmm</span><span class="p">(</span><span class="n">M</span><span class="p">,</span> <span class="n">batch1</span><span class="p">,</span> <span class="n">batch2</span><span class="p">)</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([10, 3, 5])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.bmm">
<code class="descclassname">torch.</code><code class="descname">bmm</code><span class="sig-paren">(</span><em>batch1</em>, <em>batch2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.bmm" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs a batch matrix-matrix product of matrices stored in <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code>
and <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code>.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code> must be 3-D tensors each containing
the same number of matrices.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch1</span></code> is a <span class="math">\((b \times n \times m)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">batch2</span></code> is a
<span class="math">\((b \times m \times p)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be a
<span class="math">\((b \times n \times p)\)</span> tensor.</p>
<div class="math">
\[\text{out}_i = \text{batch1}_i \mathbin{@} \text{batch2}_i

\]</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function does not <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcast</span></a>.
For broadcasting matrix products, see <a class="reference internal" href="#torch.matmul" title="torch.matmul"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.matmul()</span></code></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>batch1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first batch of matrices to be multiplied</p></li>
<li><p><strong>batch2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second batch of matrices to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">batch1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">batch2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">res</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">bmm</span><span class="p">(</span><span class="n">batch1</span><span class="p">,</span> <span class="n">batch2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">res</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([10, 3, 5])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.btrifact">
<code class="descclassname">torch.</code><code class="descname">btrifact</code><span class="sig-paren">(</span><em>A</em>, <em>pivot=True</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#btrifact"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.btrifact" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns a tuple containing the LU factorization and pivots of <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code>.
Pivoting is done if <code class="xref py py-attr docutils literal notranslate"><span class="pre">pivot</span></code> is set.</p>
<p>For more information regarding <a class="reference internal" href="#torch.btrifact" title="torch.btrifact"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btrifact()</span></code></a>, please check <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.btrifact" title="torch.btrifact"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btrifact()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu()</span></code></a> and will be
removed in the next release. Please use <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu()</span></code></a> instead.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.btrifact_with_info">
<code class="descclassname">torch.</code><code class="descname">btrifact_with_info</code><span class="sig-paren">(</span><em>A</em>, <em>pivot=True</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#btrifact_with_info"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.btrifact_with_info" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs LU factorization and returns additional status information along with the LU
factorization and pivots.</p>
<p>For more information regarding <a class="reference internal" href="#torch.btrifact_with_info" title="torch.btrifact_with_info"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btrifact_with_info()</span></code></a>, please check <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.btrifact_with_info" title="torch.btrifact_with_info"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btrifact_with_info()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu()</span></code></a> and will
be removed in the next release. Please use <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu()</span></code></a> with the <code class="xref py py-attr docutils literal notranslate"><span class="pre">get_infos</span></code>
argument set to <code class="docutils literal notranslate"><span class="pre">True</span></code> instead.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.btrisolve">
<code class="descclassname">torch.</code><code class="descname">btrisolve</code><span class="sig-paren">(</span><em>b</em>, <em>LU_data</em>, <em>LU_pivots</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#btrisolve"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.btrisolve" title="Permalink to this definition">¶</a></dt>
<dd><p>Solves the system of equations <span class="math">\(Ax = b\)</span> using the partially pivoted LU
factorization of <span class="math">\(A\)</span> given by <code class="xref py py-attr docutils literal notranslate"><span class="pre">LU_data</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">LU_pivots</span></code>.</p>
<p>For more information regarding <a class="reference internal" href="#torch.btrisolve" title="torch.btrisolve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btrisolve()</span></code></a>, please check
<a class="reference internal" href="#torch.lu_solve" title="torch.lu_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu_solve()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.btrisolve" title="torch.btrisolve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btrisolve()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.lu_solve" title="torch.lu_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu_solve()</span></code></a> and will be
removed in the next release. Please use <a class="reference internal" href="#torch.lu_solve" title="torch.lu_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu_solve()</span></code></a> instead.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.btriunpack">
<code class="descclassname">torch.</code><code class="descname">btriunpack</code><span class="sig-paren">(</span><em>LU_data</em>, <em>LU_pivots</em>, <em>unpack_data=True</em>, <em>unpack_pivots=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#btriunpack"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.btriunpack" title="Permalink to this definition">¶</a></dt>
<dd><p>Unpacks the data and pivots from a LU factorization of a tensor.</p>
<p>For more information regarding <a class="reference internal" href="#torch.btriunpack" title="torch.btriunpack"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btriunpack()</span></code></a>, please check <a class="reference internal" href="#torch.lu_unpack" title="torch.lu_unpack"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu_unpack()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.btriunpack" title="torch.btriunpack"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.btriunpack()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.lu_unpack" title="torch.lu_unpack"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu_unpack()</span></code></a> and will be
removed in the next release. Please use <a class="reference internal" href="#torch.lu_unpack" title="torch.lu_unpack"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.lu_unpack()</span></code></a> instead.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.chain_matmul">
<code class="descclassname">torch.</code><code class="descname">chain_matmul</code><span class="sig-paren">(</span><em>*matrices</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#chain_matmul"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.chain_matmul" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the matrix product of the <span class="math">\(N\)</span> 2-D tensors. This product is efficiently computed
using the matrix chain order algorithm which selects the order in which incurs the lowest cost in terms
of arithmetic operations (<a class="reference external" href="https://mitpress.mit.edu/books/introduction-algorithms-third-edition">[CLRS]</a>). Note that since this is a function to compute the product, <span class="math">\(N\)</span>
needs to be greater than or equal to 2; if equal to 2 then a trivial matrix-matrix product is returned.
If <span class="math">\(N\)</span> is 1, then this is a no-op - the original matrix is returned as is.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>matrices</strong> (<em>Tensors...</em>) – a sequence of 2 or more 2-D tensors whose product is to be determined.</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>if the <span class="math">\(i^{th}\)</span> tensor was of dimensions <span class="math">\(p_{i} \times p_{i + 1}\)</span>, then the product
would be of dimensions <span class="math">\(p_{1} \times p_{N + 1}\)</span>.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">d</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">6</span><span class="p">,</span> <span class="mi">7</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">chain_matmul</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">,</span> <span class="n">c</span><span class="p">,</span> <span class="n">d</span><span class="p">)</span>
<span class="go">tensor([[ -2.3375,  -3.9790,  -4.1119,  -6.6577,   9.5609, -11.5095,  -3.2614],</span>
<span class="go">        [ 21.4038,   3.3378,  -8.4982,  -5.2457, -10.2561,  -2.4684,   2.7163],</span>
<span class="go">        [ -0.9647,  -5.8917,  -2.3213,  -5.2284,  12.8615, -12.2816,  -2.5095]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cholesky">
<code class="descclassname">torch.</code><code class="descname">cholesky</code><span class="sig-paren">(</span><em>A</em>, <em>upper=False</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cholesky" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the Cholesky decomposition of a symmetric positive-definite
matrix <span class="math">\(A\)</span> or for batches of symmetric positive-definite matrices.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, the returned matrix <code class="docutils literal notranslate"><span class="pre">U</span></code> is upper-triangular, and
the decomposition has the form:</p>
<div class="math">
\[A = U^TU\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, the returned matrix <code class="docutils literal notranslate"><span class="pre">L</span></code> is lower-triangular, and
the decomposition has the form:</p>
<div class="math">
\[A = LL^T\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, and <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code> is a batch of symmetric positive-definite
matrices, then the returned tensor will be composed of upper-triangular Cholesky factors
of each of the individual matrices. Similarly, when <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, the returned
tensor will be composed of lower-triangular Cholesky factors of each of the individual
matrices.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>a</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor of size (<a href="#id2"><span class="problematic" id="id3">*</span></a>, n, n) where <cite>*</cite> is zero or more
batch dimensions consisting of symmetric positive-definite matrices.</p></li>
<li><p><strong>upper</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – flag that indicates whether to return a
upper or lower triangular matrix. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output matrix</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">a</span><span class="o">.</span><span class="n">t</span><span class="p">())</span> <span class="c1"># make symmetric positive-definite</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cholesky</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 2.4112, -0.7486,  1.4551],</span>
<span class="go">        [-0.7486,  1.3544,  0.1294],</span>
<span class="go">        [ 1.4551,  0.1294,  1.6724]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span>
<span class="go">tensor([[ 1.5528,  0.0000,  0.0000],</span>
<span class="go">        [-0.4821,  1.0592,  0.0000],</span>
<span class="go">        [ 0.9371,  0.5487,  0.7023]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">l</span><span class="o">.</span><span class="n">t</span><span class="p">())</span>
<span class="go">tensor([[ 2.4112, -0.7486,  1.4551],</span>
<span class="go">        [-0.7486,  1.3544,  0.1294],</span>
<span class="go">        [ 1.4551,  0.1294,  1.6724]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">a</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="o">-</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="o">+</span> <span class="mf">1e-03</span> <span class="c1"># make symmetric positive-definite</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">l</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cholesky</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">z</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">l</span><span class="p">,</span> <span class="n">l</span><span class="o">.</span><span class="n">transpose</span><span class="p">(</span><span class="o">-</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="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">abs</span><span class="p">(</span><span class="n">z</span> <span class="o">-</span> <span class="n">a</span><span class="p">))</span> <span class="c1"># Max non-zero</span>
<span class="go">tensor(2.3842e-07)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cholesky_inverse">
<code class="descclassname">torch.</code><code class="descname">cholesky_inverse</code><span class="sig-paren">(</span><em>u</em>, <em>upper=False</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cholesky_inverse" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the inverse of a symmetric positive-definite matrix <span class="math">\(A\)</span> using its
Cholesky factor <code class="xref py py-attr docutils literal notranslate"><span class="pre">u</span></code>: returns matrix <code class="docutils literal notranslate"><span class="pre">inv</span></code>. The inverse is computed using
LAPACK routines <code class="docutils literal notranslate"><span class="pre">dpotri</span></code> and <code class="docutils literal notranslate"><span class="pre">spotri</span></code> (and the corresponding MAGMA routines).</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">u</span></code> is lower triangular
such that the returned tensor is</p>
<div class="math">
\[inv = (uu^{T})^{-1}

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> or not provided, <code class="xref py py-attr docutils literal notranslate"><span class="pre">u</span></code> is upper
triangular such that the returned tensor is</p>
<div class="math">
\[inv = (u^T u)^{-1}

\]</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>u</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input 2-D tensor, a upper or lower triangular
Cholesky factor</p></li>
<li><p><strong>upper</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether to return a lower (default) or upper triangular matrix</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor for <cite>inv</cite></p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">a</span><span class="o">.</span><span class="n">t</span><span class="p">())</span> <span class="o">+</span> <span class="mf">1e-05</span> <span class="o">*</span> <span class="n">torch</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span> <span class="c1"># make symmetric positive definite</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">u</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cholesky</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[  0.9935,  -0.6353,   1.5806],</span>
<span class="go">        [ -0.6353,   0.8769,  -1.7183],</span>
<span class="go">        [  1.5806,  -1.7183,  10.6618]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cholesky_inverse</span><span class="p">(</span><span class="n">u</span><span class="p">)</span>
<span class="go">tensor([[ 1.9314,  1.2251, -0.0889],</span>
<span class="go">        [ 1.2251,  2.4439,  0.2122],</span>
<span class="go">        [-0.0889,  0.2122,  0.1412]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span><span class="o">.</span><span class="n">inverse</span><span class="p">()</span>
<span class="go">tensor([[ 1.9314,  1.2251, -0.0889],</span>
<span class="go">        [ 1.2251,  2.4439,  0.2122],</span>
<span class="go">        [-0.0889,  0.2122,  0.1412]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.cholesky_solve">
<code class="descclassname">torch.</code><code class="descname">cholesky_solve</code><span class="sig-paren">(</span><em>b</em>, <em>u</em>, <em>upper=False</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.cholesky_solve" title="Permalink to this definition">¶</a></dt>
<dd><p>Solves a linear system of equations with a positive semidefinite
matrix to be inverted given its Cholesky factor matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">u</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">u</span></code> is and lower triangular and <cite>c</cite> is
returned such that:</p>
<div class="math">
\[c = (u u^T)^{-1} b

\]</div>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> or not provided, <code class="xref py py-attr docutils literal notranslate"><span class="pre">u</span></code> is upper triangular
and <cite>c</cite> is returned such that:</p>
<div class="math">
\[c = (u^T u)^{-1} b

\]</div>
<p><cite>torch.cholesky_solve(b, u)</cite> can take in 2D inputs <cite>b, u</cite> or inputs that are
batches of 2D matrices. If the inputs are batches, then returns
batched outputs <cite>c</cite></p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> keyword only supports 2D matrix inputs, that is,
<cite>b, u</cite> must be 2D matrices.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>b</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – input matrix of size <span class="math">\((*, m, k)\)</span>,
where <span class="math">\(*\)</span> is zero or more batch dimensions</p></li>
<li><p><strong>u</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – input matrix of size <span class="math">\((*, m, m)\)</span>,
where <span class="math">\(*\)</span> is zero of more batch dimensions composed of
upper or lower triangular Cholesky factor</p></li>
<li><p><strong>upper</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether to consider the Cholesky factor as a
lower or upper triangular matrix. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor for <cite>c</cite></p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">a</span><span class="o">.</span><span class="n">t</span><span class="p">())</span> <span class="c1"># make symmetric positive definite</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">u</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cholesky</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 0.7747, -1.9549,  1.3086],</span>
<span class="go">        [-1.9549,  6.7546, -5.4114],</span>
<span class="go">        [ 1.3086, -5.4114,  4.8733]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([[-0.6355,  0.9891],</span>
<span class="go">        [ 0.1974,  1.4706],</span>
<span class="go">        [-0.4115, -0.6225]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">cholesky_solve</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">u</span><span class="p">)</span>
<span class="go">tensor([[ -8.1625,  19.6097],</span>
<span class="go">        [ -5.8398,  14.2387],</span>
<span class="go">        [ -4.3771,  10.4173]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">a</span><span class="o">.</span><span class="n">inverse</span><span class="p">(),</span> <span class="n">b</span><span class="p">)</span>
<span class="go">tensor([[ -8.1626,  19.6097],</span>
<span class="go">        [ -5.8398,  14.2387],</span>
<span class="go">        [ -4.3771,  10.4173]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.dot">
<code class="descclassname">torch.</code><code class="descname">dot</code><span class="sig-paren">(</span><em>tensor1</em>, <em>tensor2</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.dot" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the dot product (inner product) of two tensors.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function does not <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcast</span></a>.</p>
</div>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dot</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]),</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([</span><span class="mi">2</span><span class="p">,</span> <span class="mi">1</span><span class="p">]))</span>
<span class="go">tensor(7)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.eig">
<code class="descclassname">torch.</code><code class="descname">eig</code><span class="sig-paren">(</span><em>a</em>, <em>eigenvectors=False</em>, <em>out=None) -&gt; (Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.eig" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the eigenvalues and eigenvectors of a real square matrix.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Since eigenvalues and eigenvectors might be complex, backward pass is supported only</p>
</div>
<p>for <a class="reference internal" href="#torch.symeig" title="torch.symeig"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.symeig()</span></code></a></p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>a</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the square matrix of shape <span class="math">\((n \times n)\)</span> for which the eigenvalues and eigenvectors
will be computed</p></li>
<li><p><strong>eigenvectors</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – <code class="docutils literal notranslate"><span class="pre">True</span></code> to compute both eigenvalues and eigenvectors;
otherwise, only eigenvalues will be computed</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the output tensors</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><p>A namedtuple (eigenvalues, eigenvectors) containing</p>
<blockquote>
<div><ul class="simple">
<li><p><strong>eigenvalues</strong> (<em>Tensor</em>): Shape <span class="math">\((n \times 2)\)</span>. Each row is an eigenvalue of <code class="docutils literal notranslate"><span class="pre">a</span></code>,
where the first element is the real part and the second element is the imaginary part.
The eigenvalues are not necessarily ordered.</p></li>
<li><p><strong>eigenvectors</strong> (<em>Tensor</em>): If <code class="docutils literal notranslate"><span class="pre">eigenvectors=False</span></code>, it’s an empty tensor.
Otherwise, this tensor of shape <span class="math">\((n \times n)\)</span> can be used to compute normalized (unit length)
eigenvectors of corresponding eigenvalues as follows.
If the corresponding <cite>eigenvalues[j]</cite> is a real number, column <cite>eigenvectors[:, j]</cite> is the eigenvector
corresponding to <cite>eigenvalues[j]</cite>.
If the corresponding <cite>eigenvalues[j]</cite> and <cite>eigenvalues[j + 1]</cite> form a complex conjugate pair, then the
true eigenvectors can be computed as
<span class="math">\(\text{true eigenvector}[j] = eigenvectors[:, j] + i \times eigenvectors[:, j + 1]\)</span>,
<span class="math">\(\text{true eigenvector}[j + 1] = eigenvectors[:, j] - i \times eigenvectors[:, j + 1]\)</span>.</p></li>
</ul>
</div></blockquote>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>(<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>, <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>)</p>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.gels">
<code class="descclassname">torch.</code><code class="descname">gels</code><span class="sig-paren">(</span><em>B</em>, <em>A</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.gels" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the solution to the least squares and least norm problems for a full
rank matrix <span class="math">\(A\)</span> of size <span class="math">\((m \times n)\)</span> and a matrix <span class="math">\(B\)</span> of
size <span class="math">\((m \times k)\)</span>.</p>
<p>If <span class="math">\(m \geq n\)</span>, <a class="reference internal" href="#torch.gels" title="torch.gels"><code class="xref py py-func docutils literal notranslate"><span class="pre">gels()</span></code></a> solves the least-squares problem:</p>
<div class="math">
\[\begin{array}{ll}
\min_X & \|AX-B\|_2.
\end{array}\]</div>
<p>If <span class="math">\(m &lt; n\)</span>, <a class="reference internal" href="#torch.gels" title="torch.gels"><code class="xref py py-func docutils literal notranslate"><span class="pre">gels()</span></code></a> solves the least-norm problem:</p>
<div class="math">
\[\begin{array}{ll}
\min_X & \|X\|_2 & \text{subject to} & AX = B.
\end{array}\]</div>
<p>Returned tensor <span class="math">\(X\)</span> has shape <span class="math">\((\max(m, n) \times k)\)</span>. The first <span class="math">\(n\)</span>
rows of <span class="math">\(X\)</span> contains the solution. If <span class="math">\(m \geq n\)</span>, the residual sum of squares
for the solution in each column is given by the sum of squares of elements in the
remaining <span class="math">\(m - n\)</span> rows of that column.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>B</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the matrix <span class="math">\(B\)</span></p></li>
<li><p><strong>A</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the <span class="math">\(m\)</span> by <span class="math">\(n\)</span> matrix <span class="math">\(A\)</span></p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the optional destination tensor</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><p>A namedtuple (solution, QR) containing:</p>
<blockquote>
<div><ul class="simple">
<li><p><strong>solution</strong> (<em>Tensor</em>): the least squares solution</p></li>
<li><p><strong>QR</strong> (<em>Tensor</em>): the details of the QR factorization</p></li>
</ul>
</div></blockquote>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>(<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>, <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>)</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The returned matrices will always be transposed, irrespective of the strides
of the input matrices. That is, they will have stride <cite>(1, m)</cite> instead of
<cite>(m, 1)</cite>.</p>
</div>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">1.</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span>
<span class="go">                      [2, 3, 4],</span>
<span class="go">                      [3, 5, 2],</span>
<span class="go">                      [4, 2, 5],</span>
<span class="go">                      [5, 4, 3]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">B</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="o">-</span><span class="mf">10.</span><span class="p">,</span> <span class="o">-</span><span class="mi">3</span><span class="p">],</span>
<span class="go">                      [ 12, 14],</span>
<span class="go">                      [ 14, 12],</span>
<span class="go">                      [ 16, 16],</span>
<span class="go">                      [ 18, 16]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">X</span><span class="p">,</span> <span class="n">_</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">gels</span><span class="p">(</span><span class="n">B</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">X</span>
<span class="go">tensor([[  2.0000,   1.0000],</span>
<span class="go">        [  1.0000,   1.0000],</span>
<span class="go">        [  1.0000,   2.0000],</span>
<span class="go">        [ 10.9635,   4.8501],</span>
<span class="go">        [  8.9332,   5.2418]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.geqrf">
<code class="descclassname">torch.</code><code class="descname">geqrf</code><span class="sig-paren">(</span><em>input</em>, <em>out=None) -&gt; (Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.geqrf" title="Permalink to this definition">¶</a></dt>
<dd><p>This is a low-level function for calling LAPACK directly. This function
returns a namedtuple (a, tau) as defined in <a class="reference external" href="https://software.intel.com/en-us/node/521004">LAPACK documentation for geqrf</a> .</p>
<p>You’ll generally want to use <a class="reference internal" href="#torch.qr" title="torch.qr"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.qr()</span></code></a> instead.</p>
<p>Computes a QR decomposition of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, but without constructing
<span class="math">\(Q\)</span> and <span class="math">\(R\)</span> as explicit separate matrices.</p>
<p>Rather, this directly calls the underlying LAPACK function <cite>?geqrf</cite>
which produces a sequence of ‘elementary reflectors’.</p>
<p>See <a class="reference external" href="https://software.intel.com/en-us/node/521004">LAPACK documentation for geqrf</a> for further details.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input matrix</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the output tuple of (Tensor, Tensor)</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.ger">
<code class="descclassname">torch.</code><code class="descname">ger</code><span class="sig-paren">(</span><em>vec1</em>, <em>vec2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ger" title="Permalink to this definition">¶</a></dt>
<dd><p>Outer product of <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec2</span></code>.
If <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec1</span></code> is a vector of size <span class="math">\(n\)</span> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec2</span></code> is a vector of
size <span class="math">\(m\)</span>, then <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> must be a matrix of size <span class="math">\((n \times m)\)</span>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function does not <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcast</span></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>vec1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – 1-D input vector</p></li>
<li><p><strong>vec2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – 1-D input vector</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – optional output matrix</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">v1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">5.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">arange</span><span class="p">(</span><span class="mf">1.</span><span class="p">,</span> <span class="mf">4.</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">ger</span><span class="p">(</span><span class="n">v1</span><span class="p">,</span> <span class="n">v2</span><span class="p">)</span>
<span class="go">tensor([[  1.,   2.,   3.],</span>
<span class="go">        [  2.,   4.,   6.],</span>
<span class="go">        [  3.,   6.,   9.],</span>
<span class="go">        [  4.,   8.,  12.]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.gesv">
<code class="descclassname">torch.</code><code class="descname">gesv</code><span class="sig-paren">(</span><em>b</em>, <em>A</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#gesv"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.gesv" title="Permalink to this definition">¶</a></dt>
<dd><p>This function returns the solution to the system of linear equations represented
by <span class="math">\(AX = B\)</span> and the LU factorization of A, in order as a tuple <cite>X, LU</cite>.</p>
<p>For more information regarding <a class="reference internal" href="#torch.gesv" title="torch.gesv"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.gesv()</span></code></a>, please check <a class="reference internal" href="#torch.solve" title="torch.solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.solve()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.gesv" title="torch.gesv"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.gesv()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.solve" title="torch.solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.solve()</span></code></a> and will be removed in the
next release. Please use <a class="reference internal" href="#torch.solve" title="torch.solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.solve()</span></code></a> instead.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.inverse">
<code class="descclassname">torch.</code><code class="descname">inverse</code><span class="sig-paren">(</span><em>input</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.inverse" title="Permalink to this definition">¶</a></dt>
<dd><p>Takes the inverse of the square matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>. <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> can be batches
of 2D square tensors, in which case this function would return a tensor composed of
individual inverses.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Irrespective of the original strides, the returned tensors will be
transposed, i.e. with strides like <cite>input.contiguous().transpose(-2, -1).strides()</cite></p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor of size (<a href="#id4"><span class="problematic" id="id5">*</span></a>, n, n) where <cite>*</cite> is zero or more
batch dimensions</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the optional output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">rand</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">inverse</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">z</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">z</span>
<span class="go">tensor([[ 1.0000, -0.0000, -0.0000,  0.0000],</span>
<span class="go">        [ 0.0000,  1.0000,  0.0000,  0.0000],</span>
<span class="go">        [ 0.0000,  0.0000,  1.0000,  0.0000],</span>
<span class="go">        [ 0.0000, -0.0000, -0.0000,  1.0000]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">abs</span><span class="p">(</span><span class="n">z</span> <span class="o">-</span> <span class="n">torch</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">4</span><span class="p">)))</span> <span class="c1"># Max non-zero</span>
<span class="go">tensor(1.1921e-07)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Batched inverse example</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">y</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">inverse</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">z</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">abs</span><span class="p">(</span><span class="n">z</span> <span class="o">-</span> <span class="n">torch</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span><span class="o">.</span><span class="n">expand_as</span><span class="p">(</span><span class="n">x</span><span class="p">)))</span> <span class="c1"># Max non-zero</span>
<span class="go">tensor(1.9073e-06)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.det">
<code class="descclassname">torch.</code><code class="descname">det</code><span class="sig-paren">(</span><em>A</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.det" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculates determinant of a 2D square tensor.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backward through <a class="reference internal" href="#torch.det" title="torch.det"><code class="xref py py-meth docutils literal notranslate"><span class="pre">det()</span></code></a> internally uses SVD results when <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code> is
not invertible. In this case, double backward through <a class="reference internal" href="#torch.det" title="torch.det"><code class="xref py py-meth docutils literal notranslate"><span class="pre">det()</span></code></a> will be
unstable in when <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code> doesn’t have distinct singular values. See
<a class="reference internal" href="#torch.svd" title="torch.svd"><code class="xref py py-meth docutils literal notranslate"><span class="pre">svd()</span></code></a> for details.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>A</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – The input 2D square tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">det</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="go">tensor(3.7641)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.logdet">
<code class="descclassname">torch.</code><code class="descname">logdet</code><span class="sig-paren">(</span><em>A</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.logdet" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculates log determinant of a 2D square tensor.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Result is <code class="docutils literal notranslate"><span class="pre">-inf</span></code> if <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code> has zero log determinant, and is <code class="docutils literal notranslate"><span class="pre">nan</span></code> if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code> has negative determinant.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backward through <a class="reference internal" href="#torch.logdet" title="torch.logdet"><code class="xref py py-meth docutils literal notranslate"><span class="pre">logdet()</span></code></a> internally uses SVD results when <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code>
is not invertible. In this case, double backward through <a class="reference internal" href="#torch.logdet" title="torch.logdet"><code class="xref py py-meth docutils literal notranslate"><span class="pre">logdet()</span></code></a> will
be unstable in when <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code> doesn’t have distinct singular values. See
<a class="reference internal" href="#torch.svd" title="torch.svd"><code class="xref py py-meth docutils literal notranslate"><span class="pre">svd()</span></code></a> for details.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>A</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – The input 2D square tensor</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">det</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="go">tensor(0.2611)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">logdet</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="go">tensor(-1.3430)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.slogdet">
<code class="descclassname">torch.</code><code class="descname">slogdet</code><span class="sig-paren">(</span><em>A) -&gt; (Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.slogdet" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculates the sign and log value of a 2D square tensor’s determinant.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>If <code class="docutils literal notranslate"><span class="pre">A</span></code> has zero determinant, this returns <code class="docutils literal notranslate"><span class="pre">(0,</span> <span class="pre">-inf)</span></code>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backward through <a class="reference internal" href="#torch.slogdet" title="torch.slogdet"><code class="xref py py-meth docutils literal notranslate"><span class="pre">slogdet()</span></code></a> internally uses SVD results when <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code>
is not invertible. In this case, double backward through <a class="reference internal" href="#torch.slogdet" title="torch.slogdet"><code class="xref py py-meth docutils literal notranslate"><span class="pre">slogdet()</span></code></a>
will be unstable in when <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code> doesn’t have distinct singular values.
See <a class="reference internal" href="#torch.svd" title="torch.svd"><code class="xref py py-meth docutils literal notranslate"><span class="pre">svd()</span></code></a> for details.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>A</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – The input 2D square tensor</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A namedtuple (sign, logabsdet) containing the sign of the determinant, and the log
value of the absolute determinant.</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span>
<span class="go">tensor([[ 0.0032, -0.2239, -1.1219],</span>
<span class="go">        [-0.6690,  0.1161,  0.4053],</span>
<span class="go">        [-1.6218, -0.9273, -0.0082]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">det</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="go">tensor(-0.7576)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">logdet</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="go">tensor(nan)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">slogdet</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="go">torch.return_types.slogdet(sign=tensor(-1.), logabsdet=tensor(-0.2776))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.lu">
<code class="descclassname">torch.</code><code class="descname">lu</code><span class="sig-paren">(</span><em>A</em>, <em>pivot=True</em>, <em>get_infos=False</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#lu"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.lu" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the LU factorization of a square matrix or batches of square matrices
<code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code>. Returns a tuple containing the LU factorization and pivots of <code class="xref py py-attr docutils literal notranslate"><span class="pre">A</span></code>.
Pivoting is done if <code class="xref py py-attr docutils literal notranslate"><span class="pre">pivot</span></code> is set to <code class="docutils literal notranslate"><span class="pre">True</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The pivots returned by the function are 1-indexed. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">pivot</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>,
then the returned pivots is a tensor filled with zeros of the appropriate size.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>LU factorization with <code class="xref py py-attr docutils literal notranslate"><span class="pre">pivot</span></code> = <code class="docutils literal notranslate"><span class="pre">False</span></code> is not available for CPU, and attempting
to do so will throw an error. However, LU factorization with <code class="xref py py-attr docutils literal notranslate"><span class="pre">pivot</span></code> = <code class="docutils literal notranslate"><span class="pre">False</span></code> is
available for CUDA.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function does not check if the factorization was successful or not if
<code class="xref py py-attr docutils literal notranslate"><span class="pre">get_infos</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> since the status of the factorization is present in the
third element of the return tuple.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>A</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the tensor to factor of size <span class="math">\((*, m, m)\)</span></p></li>
<li><p><strong>pivot</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls whether pivoting is done. Default: <code class="docutils literal notranslate"><span class="pre">True</span></code></p></li>
<li><p><strong>get_infos</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – if set to <code class="docutils literal notranslate"><span class="pre">True</span></code>, returns an info IntTensor.
Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – optional output tuple. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">get_infos</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>,
then the elements in the tuple are Tensor, IntTensor,
and IntTensor. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">get_infos</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, then the
elements in the tuple are Tensor, IntTensor. Default: <code class="docutils literal notranslate"><span class="pre">None</span></code></p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><p>A tuple of tensors containing</p>
<blockquote>
<div><ul class="simple">
<li><p><strong>factorization</strong> (<em>Tensor</em>): the factorization of size <span class="math">\((*, m, m)\)</span></p></li>
<li><p><strong>pivots</strong> (<em>IntTensor</em>): the pivots of size <span class="math">\((*, m)\)</span></p></li>
<li><p><strong>infos</strong> (<em>IntTensor</em>, <em>optional</em>): if <code class="xref py py-attr docutils literal notranslate"><span class="pre">get_infos</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>, this is a tensor of
size <span class="math">\((*)\)</span> where non-zero values indicate whether factorization for the matrix or
each minibatch has succeeded or failed</p></li>
</ul>
</div></blockquote>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>(<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>, IntTensor, IntTensor (optional))</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A_LU</span><span class="p">,</span> <span class="n">pivots</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">lu</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A_LU</span>
<span class="go">tensor([[[ 1.3506,  2.5558, -0.0816],</span>
<span class="go">         [ 0.1684,  1.1551,  0.1940],</span>
<span class="go">         [ 0.1193,  0.6189, -0.5497]],</span>

<span class="go">        [[ 0.4526,  1.2526, -0.3285],</span>
<span class="go">         [-0.7988,  0.7175, -0.9701],</span>
<span class="go">         [ 0.2634, -0.9255, -0.3459]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">pivots</span>
<span class="go">tensor([[ 3,  3,  3],</span>
<span class="go">        [ 3,  3,  3]], dtype=torch.int32)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A_LU</span><span class="p">,</span> <span class="n">pivots</span><span class="p">,</span> <span class="n">info</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">lu</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="n">get_infos</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="k">if</span> <span class="n">info</span><span class="o">.</span><span class="n">nonzero</span><span class="p">()</span><span class="o">.</span><span class="n">size</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="gp">... </span>  <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;LU factorization succeeded for all samples!&#39;</span><span class="p">)</span>
<span class="go">LU factorization succeeded for all samples!</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.lu_solve">
<code class="descclassname">torch.</code><code class="descname">lu_solve</code><span class="sig-paren">(</span><em>b</em>, <em>LU_data</em>, <em>LU_pivots</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.lu_solve" title="Permalink to this definition">¶</a></dt>
<dd><p>Batch LU solve.</p>
<p>Returns the LU solve of the linear system <span class="math">\(Ax = b\)</span> using the partially pivoted
LU factorization of A from <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.lu()</span></code></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>b</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the RHS tensor</p></li>
<li><p><strong>LU_data</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the pivoted LU factorization of A from <a class="reference internal" href="#torch.lu" title="torch.lu"><code class="xref py py-meth docutils literal notranslate"><span class="pre">torch.lu()</span></code></a>.</p></li>
<li><p><strong>LU_pivots</strong> (<em>IntTensor</em>) – the pivots of the LU factorization</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the optional output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A_LU</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">lu</span><span class="p">(</span><span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">x</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">lu_solve</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="o">*</span><span class="n">A_LU</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">norm</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">bmm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="n">x</span><span class="o">.</span><span class="n">unsqueeze</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span> <span class="o">-</span> <span class="n">b</span><span class="o">.</span><span class="n">unsqueeze</span><span class="p">(</span><span class="mi">2</span><span class="p">))</span>
<span class="go">tensor(1.00000e-07 *</span>
<span class="go">       2.8312)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.lu_unpack">
<code class="descclassname">torch.</code><code class="descname">lu_unpack</code><span class="sig-paren">(</span><em>LU_data</em>, <em>LU_pivots</em>, <em>unpack_data=True</em>, <em>unpack_pivots=True</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#lu_unpack"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.lu_unpack" title="Permalink to this definition">¶</a></dt>
<dd><p>Unpacks the data and pivots from a LU factorization of a tensor.</p>
<p>Returns a tuple of tensors as <code class="docutils literal notranslate"><span class="pre">(the</span> <span class="pre">pivots,</span> <span class="pre">the</span> <span class="pre">L</span> <span class="pre">tensor,</span> <span class="pre">the</span> <span class="pre">U</span> <span class="pre">tensor)</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>LU_data</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the packed LU factorization data</p></li>
<li><p><strong>LU_pivots</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the packed LU factorization pivots</p></li>
<li><p><strong>unpack_data</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – flag indicating if the data should be unpacked</p></li>
<li><p><strong>unpack_pivots</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a>) – flag indicating if the pivots should be unpacked</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A_LU</span><span class="p">,</span> <span class="n">pivots</span> <span class="o">=</span> <span class="n">A</span><span class="o">.</span><span class="n">lu</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">P</span><span class="p">,</span> <span class="n">A_L</span><span class="p">,</span> <span class="n">A_U</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">lu_unpack</span><span class="p">(</span><span class="n">A_LU</span><span class="p">,</span> <span class="n">pivots</span><span class="p">)</span>
<span class="go">&gt;&gt;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># can recover A from factorization</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A_</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">bmm</span><span class="p">(</span><span class="n">P</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">bmm</span><span class="p">(</span><span class="n">A_L</span><span class="p">,</span> <span class="n">A_U</span><span class="p">))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.matmul">
<code class="descclassname">torch.</code><code class="descname">matmul</code><span class="sig-paren">(</span><em>tensor1</em>, <em>tensor2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.matmul" title="Permalink to this definition">¶</a></dt>
<dd><p>Matrix product of two tensors.</p>
<p>The behavior depends on the dimensionality of the tensors as follows:</p>
<ul class="simple">
<li><p>If both tensors are 1-dimensional, the dot product (scalar) is returned.</p></li>
<li><p>If both arguments are 2-dimensional, the matrix-matrix product is returned.</p></li>
<li><p>If the first argument is 1-dimensional and the second argument is 2-dimensional,
a 1 is prepended to its dimension for the purpose of the matrix multiply.
After the matrix multiply, the prepended dimension is removed.</p></li>
<li><p>If the first argument is 2-dimensional and the second argument is 1-dimensional,
the matrix-vector product is returned.</p></li>
<li><p>If both arguments are at least 1-dimensional and at least one argument is
N-dimensional (where N &gt; 2), then a batched matrix multiply is returned.  If the first
argument is 1-dimensional, a 1 is prepended to its dimension for the purpose of the
batched matrix multiply and removed after.  If the second argument is 1-dimensional, a
1 is appended to its dimension for the purpose of the batched matrix multiple and removed after.
The non-matrix (i.e. batch) dimensions are <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcasted</span></a> (and thus
must be broadcastable).  For example, if <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor1</span></code> is a
<span class="math">\((j \times 1 \times n \times m)\)</span> tensor and <code class="xref py py-attr docutils literal notranslate"><span class="pre">tensor2</span></code> is a <span class="math">\((k \times m \times p)\)</span>
tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be an <span class="math">\((j \times k \times n \times p)\)</span> tensor.</p></li>
</ul>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The 1-dimensional dot product version of this function does not support an <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> parameter.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>tensor1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first tensor to be multiplied</p></li>
<li><p><strong>tensor2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second tensor to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="c1"># vector x vector</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">tensor1</span><span class="p">,</span> <span class="n">tensor2</span><span class="p">)</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># matrix x vector</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">tensor1</span><span class="p">,</span> <span class="n">tensor2</span><span class="p">)</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># batched matrix x broadcasted vector</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">tensor1</span><span class="p">,</span> <span class="n">tensor2</span><span class="p">)</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([10, 3])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># batched matrix x batched matrix</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">tensor1</span><span class="p">,</span> <span class="n">tensor2</span><span class="p">)</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([10, 3, 5])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="c1"># batched matrix x broadcasted matrix</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">tensor2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">tensor1</span><span class="p">,</span> <span class="n">tensor2</span><span class="p">)</span><span class="o">.</span><span class="n">size</span><span class="p">()</span>
<span class="go">torch.Size([10, 3, 5])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.matrix_power">
<code class="descclassname">torch.</code><code class="descname">matrix_power</code><span class="sig-paren">(</span><em>input</em>, <em>n</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.matrix_power" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the matrix raised to the power <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code> for square matrices.
For batch of matrices, each individual matrix is raised to the power <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code> is negative, then the inverse of the matrix (if invertible) is
raised to the power <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code>.  For a batch of matrices, the batched inverse
(if invertible) is raised to the power <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code>. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">n</span></code> is 0, then an identity matrix
is returned.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input tensor</p></li>
<li><p><strong>n</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.7)"><em>int</em></a>) – the power to raise the matrix to</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[[-1.9975, -1.9610],</span>
<span class="go">         [ 0.9592, -2.3364]],</span>

<span class="go">        [[-1.2534, -1.3429],</span>
<span class="go">         [ 0.4153, -1.4664]]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matrix_power</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="go">tensor([[[  3.9392, -23.9916],</span>
<span class="go">         [ 11.7357,  -0.2070]],</span>

<span class="go">        [[  0.2468,  -6.7168],</span>
<span class="go">         [  2.0774,  -0.8187]]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.matrix_rank">
<code class="descclassname">torch.</code><code class="descname">matrix_rank</code><span class="sig-paren">(</span><em>input</em>, <em>tol=None</em>, <em>bool symmetric=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.matrix_rank" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the numerical rank of a 2-D tensor. The method to compute the
matrix rank is done using SVD by default. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">symmetric</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>,
then <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is assumed to be symmetric, and the computation of the
rank is done by obtaining the eigenvalues.</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">tol</span></code> is the threshold below which the singular values (or the eigenvalues
when <code class="xref py py-attr docutils literal notranslate"><span class="pre">symmetric</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>) are considered to be 0. If <code class="xref py py-attr docutils literal notranslate"><span class="pre">tol</span></code> is not
specified, <code class="xref py py-attr docutils literal notranslate"><span class="pre">tol</span></code> is set to <code class="docutils literal notranslate"><span class="pre">S.max()</span> <span class="pre">*</span> <span class="pre">max(S.size())</span> <span class="pre">*</span> <span class="pre">eps</span></code> where <cite>S</cite> is the
singular values (or the eigenvalues when <code class="xref py py-attr docutils literal notranslate"><span class="pre">symmetric</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code>), and <code class="docutils literal notranslate"><span class="pre">eps</span></code>
is the epsilon value for the datatype of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input 2-D tensor</p></li>
<li><p><strong>tol</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a><em>, </em><em>optional</em>) – the tolerance value. Default: <code class="docutils literal notranslate"><span class="pre">None</span></code></p></li>
<li><p><strong>symmetric</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – indicates whether <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is symmetric.
Default: <code class="docutils literal notranslate"><span class="pre">False</span></code></p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matrix_rank</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="go">tensor(10)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">matrix_rank</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>
<span class="go">tensor(9)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.mm">
<code class="descclassname">torch.</code><code class="descname">mm</code><span class="sig-paren">(</span><em>mat1</em>, <em>mat2</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.mm" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs a matrix multiplication of the matrices <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat1</span></code> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat2</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat1</span></code> is a <span class="math">\((n \times m)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat2</span></code> is a
<span class="math">\((m \times p)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be a <span class="math">\((n \times p)\)</span> tensor.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function does not <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcast</span></a>.
For broadcasting matrix products, see <a class="reference internal" href="#torch.matmul" title="torch.matmul"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.matmul()</span></code></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>mat1</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the first matrix to be multiplied</p></li>
<li><p><strong>mat2</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the second matrix to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">mat1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">mat2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">mat1</span><span class="p">,</span> <span class="n">mat2</span><span class="p">)</span>
<span class="go">tensor([[ 0.4851,  0.5037, -0.3633],</span>
<span class="go">        [-0.0760, -3.6705,  2.4784]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.mv">
<code class="descclassname">torch.</code><code class="descname">mv</code><span class="sig-paren">(</span><em>mat</em>, <em>vec</em>, <em>out=None</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.mv" title="Permalink to this definition">¶</a></dt>
<dd><p>Performs a matrix-vector product of the matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> and the vector
<code class="xref py py-attr docutils literal notranslate"><span class="pre">vec</span></code>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">mat</span></code> is a <span class="math">\((n \times m)\)</span> tensor, <code class="xref py py-attr docutils literal notranslate"><span class="pre">vec</span></code> is a 1-D tensor of
size <span class="math">\(m\)</span>, <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> will be 1-D of size <span class="math">\(n\)</span>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This function does not <a class="reference internal" href="notes/broadcasting.html#broadcasting-semantics"><span class="std std-ref">broadcast</span></a>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>mat</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – matrix to be multiplied</p></li>
<li><p><strong>vec</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – vector to be multiplied</p></li>
<li><p><strong>out</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><em>optional</em>) – the output tensor</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">mat</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">vec</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mv</span><span class="p">(</span><span class="n">mat</span><span class="p">,</span> <span class="n">vec</span><span class="p">)</span>
<span class="go">tensor([ 1.0404, -0.6361])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.orgqr">
<code class="descclassname">torch.</code><code class="descname">orgqr</code><span class="sig-paren">(</span><em>a</em>, <em>tau</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.orgqr" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the orthogonal matrix <cite>Q</cite> of a QR factorization, from the <cite>(a, tau)</cite>
tuple returned by <a class="reference internal" href="#torch.geqrf" title="torch.geqrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.geqrf()</span></code></a>.</p>
<p>This directly calls the underlying LAPACK function <cite>?orgqr</cite>.
See <a class="reference external" href="https://software.intel.com/en-us/mkl-developer-reference-c-orgqr">LAPACK documentation for orgqr</a> for further details.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>a</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the <cite>a</cite> from <a class="reference internal" href="#torch.geqrf" title="torch.geqrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.geqrf()</span></code></a>.</p></li>
<li><p><strong>tau</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the <cite>tau</cite> from <a class="reference internal" href="#torch.geqrf" title="torch.geqrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.geqrf()</span></code></a>.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.ormqr">
<code class="descclassname">torch.</code><code class="descname">ormqr</code><span class="sig-paren">(</span><em>a</em>, <em>tau</em>, <em>mat</em>, <em>left=True</em>, <em>transpose=False</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.ormqr" title="Permalink to this definition">¶</a></dt>
<dd><p>Multiplies <cite>mat</cite> by the orthogonal <cite>Q</cite> matrix of the QR factorization
formed by <a class="reference internal" href="#torch.geqrf" title="torch.geqrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.geqrf()</span></code></a> that is represented by <cite>(a, tau)</cite>.</p>
<p>This directly calls the underlying LAPACK function <cite>?ormqr</cite>.
See <a class="reference external" href="https://software.intel.com/en-us/mkl-developer-reference-c-ormqr">LAPACK documentation for ormqr</a> for further details.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>a</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the <cite>a</cite> from <a class="reference internal" href="#torch.geqrf" title="torch.geqrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.geqrf()</span></code></a>.</p></li>
<li><p><strong>tau</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the <cite>tau</cite> from <a class="reference internal" href="#torch.geqrf" title="torch.geqrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.geqrf()</span></code></a>.</p></li>
<li><p><strong>mat</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the matrix to be multiplied.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.pinverse">
<code class="descclassname">torch.</code><code class="descname">pinverse</code><span class="sig-paren">(</span><em>input</em>, <em>rcond=1e-15</em><span class="sig-paren">)</span> &#x2192; Tensor<a class="headerlink" href="#torch.pinverse" title="Permalink to this definition">¶</a></dt>
<dd><p>Calculates the pseudo-inverse (also known as the Moore-Penrose inverse) of a 2D tensor.
Please look at <a class="reference external" href="https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse">Moore-Penrose inverse</a> for more details</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>This method is implemented using the Singular Value Decomposition.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The pseudo-inverse is not necessarily a continuous function in the elements of the matrix <a class="reference external" href="https://epubs.siam.org/doi/10.1137/0117004">[1]</a>.
Therefore, derivatives are not always existent, and exist for a constant rank only <a class="reference external" href="https://www.jstor.org/stable/2156365">[2]</a>.
However, this method is backprop-able due to the implementation by using SVD results, and
could be unstable. Double-backward will also be unstable due to the usage of SVD internally.
See <a class="reference internal" href="#torch.svd" title="torch.svd"><code class="xref py py-meth docutils literal notranslate"><span class="pre">svd()</span></code></a> for more details.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – The input 2D tensor of dimensions <span class="math">\(m \times n\)</span></p></li>
<li><p><strong>rcond</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#float" title="(in Python v3.7)"><em>float</em></a>) – A floating point value to determine the cutoff for small singular values.
Default: 1e-15</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The pseudo-inverse of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> of dimensions <span class="math">\(n \times m\)</span></p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nb">input</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="nb">input</span>
<span class="go">tensor([[ 0.5495,  0.0979, -1.4092, -0.1128,  0.4132],</span>
<span class="go">        [-1.1143, -0.3662,  0.3042,  1.6374, -0.9294],</span>
<span class="go">        [-0.3269, -0.5745, -0.0382, -0.5922, -0.6759]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">pinverse</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span>
<span class="go">tensor([[ 0.0600, -0.1933, -0.2090],</span>
<span class="go">        [-0.0903, -0.0817, -0.4752],</span>
<span class="go">        [-0.7124, -0.1631, -0.2272],</span>
<span class="go">        [ 0.1356,  0.3933, -0.5023],</span>
<span class="go">        [-0.0308, -0.1725, -0.5216]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.potrf">
<code class="descclassname">torch.</code><code class="descname">potrf</code><span class="sig-paren">(</span><em>a</em>, <em>upper=True</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#potrf"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.potrf" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the Cholesky decomposition of a symmetric positive-definite
matrix <span class="math">\(A\)</span>.</p>
<p>For more information regarding <a class="reference internal" href="#torch.potrf" title="torch.potrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.potrf()</span></code></a>, please check <a class="reference internal" href="#torch.cholesky" title="torch.cholesky"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.potrf" title="torch.potrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.potrf()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.cholesky" title="torch.cholesky"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky()</span></code></a> and will be removed
in the next release. Please use <a class="reference internal" href="#torch.cholesky" title="torch.cholesky"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky()</span></code></a> instead and note that the <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code>
argument in <a class="reference internal" href="#torch.cholesky" title="torch.cholesky"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky()</span></code></a> defaults to <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.potri">
<code class="descclassname">torch.</code><code class="descname">potri</code><span class="sig-paren">(</span><em>a</em>, <em>upper=True</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#potri"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.potri" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the inverse of a symmetric positive-definite matrix <span class="math">\(A\)</span> using its
Cholesky factor.</p>
<p>For more information regarding <a class="reference internal" href="#torch.potri" title="torch.potri"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.potri()</span></code></a>, please check <a class="reference internal" href="#torch.cholesky_inverse" title="torch.cholesky_inverse"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_inverse()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.potri" title="torch.potri"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.potri()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.cholesky_inverse" title="torch.cholesky_inverse"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_inverse()</span></code></a> and will be removed
in the next release. Please use <a class="reference internal" href="#torch.cholesky_inverse" title="torch.cholesky_inverse"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_inverse()</span></code></a> instead and note that the <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code>
argument in <a class="reference internal" href="#torch.cholesky_inverse" title="torch.cholesky_inverse"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_inverse()</span></code></a> defaults to <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.potrs">
<code class="descclassname">torch.</code><code class="descname">potrs</code><span class="sig-paren">(</span><em>b</em>, <em>u</em>, <em>upper=True</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#potrs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.potrs" title="Permalink to this definition">¶</a></dt>
<dd><p>Solves a linear system of equations with a positive semidefinite
matrix to be inverted given its Cholesky factor matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">u</span></code>.</p>
<p>For more information regarding <a class="reference internal" href="#torch.potrs" title="torch.potrs"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.potrs()</span></code></a>, please check <a class="reference internal" href="#torch.cholesky_solve" title="torch.cholesky_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_solve()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.potrs" title="torch.potrs"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.potrs()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.cholesky_solve" title="torch.cholesky_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_solve()</span></code></a> and will be
removed in the next release. Please use <a class="reference internal" href="#torch.cholesky_solve" title="torch.cholesky_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_solve()</span></code></a> instead and note that
the <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> argument in <a class="reference internal" href="#torch.cholesky_solve" title="torch.cholesky_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky_solve()</span></code></a> defaults to <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.pstrf">
<code class="descclassname">torch.</code><code class="descname">pstrf</code><span class="sig-paren">(</span><em>a</em>, <em>upper=True</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#pstrf"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.pstrf" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the pivoted Cholesky decomposition of a symmetric positive-definite
matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">a</span></code>. returns a namedtuple (u, pivot) of matrice.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> or not provided, <cite>u</cite> is upper triangular
such that <span class="math">\(a = p^T u^T u p\)</span>, with <cite>p</cite> the permutation given by <cite>pivot</cite>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, <cite>u</cite> is lower triangular such that
<span class="math">\(a = p^T u u^T p\)</span>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.pstrf" title="torch.pstrf"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.pstrf()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.cholesky" title="torch.cholesky"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.cholesky()</span></code></a> and will
be removed in the next release.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>a</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input 2-D tensor</p></li>
<li><p><strong>upper</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether to return a upper (default) or lower triangular matrix</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – namedtuple of <cite>u</cite> and <cite>pivot</cite> tensors</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">a</span><span class="o">.</span><span class="n">t</span><span class="p">())</span> <span class="c1"># make symmetric positive definite</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">a</span>
<span class="go">tensor([[ 3.5405, -0.4577,  0.8342],</span>
<span class="go">        [-0.4577,  1.8244, -0.1996],</span>
<span class="go">        [ 0.8342, -0.1996,  3.7493]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">u</span><span class="p">,</span><span class="n">piv</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">pstrf</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">u</span>
<span class="go">tensor([[ 1.9363,  0.4308, -0.1031],</span>
<span class="go">        [ 0.0000,  1.8316, -0.2256],</span>
<span class="go">        [ 0.0000,  0.0000,  1.3277]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">piv</span>
<span class="go">tensor([ 2,  0,  1], dtype=torch.int32)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">p</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">eye</span><span class="p">(</span><span class="mi">3</span><span class="p">)</span><span class="o">.</span><span class="n">index_select</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="n">piv</span><span class="o">.</span><span class="n">long</span><span class="p">())</span><span class="o">.</span><span class="n">index_select</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="n">piv</span><span class="o">.</span><span class="n">long</span><span class="p">())</span><span class="o">.</span><span class="n">t</span><span class="p">()</span> <span class="c1"># make pivot permutation</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">p</span><span class="o">.</span><span class="n">t</span><span class="p">(),</span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">u</span><span class="o">.</span><span class="n">t</span><span class="p">(),</span><span class="n">u</span><span class="p">)),</span><span class="n">p</span><span class="p">)</span> <span class="c1"># reconstruct</span>
<span class="go">tensor([[ 3.5405, -0.4577,  0.8342],</span>
<span class="go">        [-0.4577,  1.8244, -0.1996],</span>
<span class="go">        [ 0.8342, -0.1996,  3.7493]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.qr">
<code class="descclassname">torch.</code><code class="descname">qr</code><span class="sig-paren">(</span><em>input</em>, <em>out=None) -&gt; (Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.qr" title="Permalink to this definition">¶</a></dt>
<dd><p>Computes the QR decomposition of a matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, and returns a namedtuple
(Q, R) of matrices such that <span class="math">\(\text{input} = Q R\)</span>, with <span class="math">\(Q\)</span> being an
orthogonal matrix and <span class="math">\(R\)</span> being an upper triangular matrix.</p>
<p>This returns the thin (reduced) QR factorization.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>precision may be lost if the magnitudes of the elements of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>
are large</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>While it should always give you a valid decomposition, it may not
give you the same one across platforms - it will depend on your
LAPACK implementation.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Irrespective of the original strides, the returned matrix <span class="math">\(Q\)</span> will be
transposed, i.e. with strides <cite>(1, m)</cite> instead of <cite>(m, 1)</cite>.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input 2-D tensor</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – tuple of <cite>Q</cite> and <cite>R</cite> tensors</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">12.</span><span class="p">,</span> <span class="o">-</span><span class="mi">51</span><span class="p">,</span> <span class="mi">4</span><span class="p">],</span> <span class="p">[</span><span class="mi">6</span><span class="p">,</span> <span class="mi">167</span><span class="p">,</span> <span class="o">-</span><span class="mi">68</span><span class="p">],</span> <span class="p">[</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span> <span class="mi">24</span><span class="p">,</span> <span class="o">-</span><span class="mi">41</span><span class="p">]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">q</span><span class="p">,</span> <span class="n">r</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">qr</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">q</span>
<span class="go">tensor([[-0.8571,  0.3943,  0.3314],</span>
<span class="go">        [-0.4286, -0.9029, -0.0343],</span>
<span class="go">        [ 0.2857, -0.1714,  0.9429]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">r</span>
<span class="go">tensor([[ -14.0000,  -21.0000,   14.0000],</span>
<span class="go">        [   0.0000, -175.0000,   70.0000],</span>
<span class="go">        [   0.0000,    0.0000,  -35.0000]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">q</span><span class="p">,</span> <span class="n">r</span><span class="p">)</span><span class="o">.</span><span class="n">round</span><span class="p">()</span>
<span class="go">tensor([[  12.,  -51.,    4.],</span>
<span class="go">        [   6.,  167.,  -68.],</span>
<span class="go">        [  -4.,   24.,  -41.]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">q</span><span class="o">.</span><span class="n">t</span><span class="p">(),</span> <span class="n">q</span><span class="p">)</span><span class="o">.</span><span class="n">round</span><span class="p">()</span>
<span class="go">tensor([[ 1.,  0.,  0.],</span>
<span class="go">        [ 0.,  1., -0.],</span>
<span class="go">        [ 0., -0.,  1.]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.solve">
<code class="descclassname">torch.</code><code class="descname">solve</code><span class="sig-paren">(</span><em>B</em>, <em>A</em>, <em>out=None) -&gt; (Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.solve" title="Permalink to this definition">¶</a></dt>
<dd><p>This function returns the solution to the system of linear
equations represented by <span class="math">\(AX = B\)</span> and the LU factorization of
A, in order as a namedtuple <cite>solution, LU</cite>.</p>
<p><cite>LU</cite> contains <cite>L</cite> and <cite>U</cite> factors for LU factorization of <cite>A</cite>.</p>
<p><cite>torch.solve(B, A)</cite> can take in 2D inputs <cite>B, A</cite> or inputs that are
batches of 2D matrices. If the inputs are batches, then returns
batched outputs <cite>solution, LU</cite>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Irrespective of the original strides, the returned matrices
<cite>solution</cite> and <cite>LU</cite> will be transposed, i.e. with strides like
<cite>B.contiguous().transpose(-1, -2).strides()</cite> and
<cite>A.contiguous().transpose(-1, -2).strides()</cite> respectively.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>B</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – input matrix of size <span class="math">\((*, m, k)\)</span> , where <span class="math">\(*\)</span>
is zero or more batch dimensions.</p></li>
<li><p><strong>A</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – input square matrix of size <span class="math">\((*, m, m)\)</span>, where
<span class="math">\(*\)</span> is zero or more batch dimensions.</p></li>
<li><p><strong>out</strong> (<em>(</em><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>, </em><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a><em>)</em><em>, </em><em>optional</em>) – optional output tuple.</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">6.80</span><span class="p">,</span> <span class="o">-</span><span class="mf">2.11</span><span class="p">,</span>  <span class="mf">5.66</span><span class="p">,</span>  <span class="mf">5.97</span><span class="p">,</span>  <span class="mf">8.23</span><span class="p">],</span>
<span class="go">                      [-6.05, -3.30,  5.36, -4.44,  1.08],</span>
<span class="go">                      [-0.45,  2.58, -2.70,  0.27,  9.04],</span>
<span class="go">                      [8.32,  2.71,  4.35,  -7.17,  2.14],</span>
<span class="go">                      [-9.67, -5.14, -7.26,  6.08, -6.87]]).t()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">B</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">4.02</span><span class="p">,</span>  <span class="mf">6.19</span><span class="p">,</span> <span class="o">-</span><span class="mf">8.22</span><span class="p">,</span> <span class="o">-</span><span class="mf">7.57</span><span class="p">,</span> <span class="o">-</span><span class="mf">3.03</span><span class="p">],</span>
<span class="go">                      [-1.56,  4.00, -8.67,  1.75,  2.86],</span>
<span class="go">                      [9.81, -4.09, -4.57, -8.61,  8.99]]).t()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">X</span><span class="p">,</span> <span class="n">LU</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">solve</span><span class="p">(</span><span class="n">B</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dist</span><span class="p">(</span><span class="n">B</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="n">X</span><span class="p">))</span>
<span class="go">tensor(1.00000e-06 *</span>
<span class="go">       7.0977)</span>

<span class="gp">&gt;&gt;&gt; </span><span class="c1"># Batched solver example</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">B</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">X</span><span class="p">,</span> <span class="n">LU</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">solve</span><span class="p">(</span><span class="n">B</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dist</span><span class="p">(</span><span class="n">B</span><span class="p">,</span> <span class="n">A</span><span class="o">.</span><span class="n">matmul</span><span class="p">(</span><span class="n">X</span><span class="p">))</span>
<span class="go">tensor(1.00000e-06 *</span>
<span class="go">   3.6386)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.svd">
<code class="descclassname">torch.</code><code class="descname">svd</code><span class="sig-paren">(</span><em>input</em>, <em>some=True</em>, <em>compute_uv=True</em>, <em>out=None) -&gt; (Tensor</em>, <em>Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.svd" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">svd(A)</span></code> returns a namedtuple <code class="docutils literal notranslate"><span class="pre">(U,</span> <span class="pre">S,</span> <span class="pre">V)</span></code> which the singular value
decomposition of a input real matrix <cite>A</cite> of size <cite>(n x m)</cite> such that
<span class="math">\(A = USV^T\)</span>.</p>
<p><cite>U</cite> is of shape <span class="math">\((n \times n)\)</span>.</p>
<p><cite>S</cite> is a diagonal matrix of shape <span class="math">\((n \times m)\)</span>, represented as a vector
of size <span class="math">\(\min(n, m)\)</span> containing the non-negative diagonal entries.</p>
<p><cite>V</cite> is of shape <span class="math">\((m \times m)\)</span>.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">some</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> (default), the returned <cite>U</cite> and <cite>V</cite> matrices will
contain only <span class="math">\(min(n, m)\)</span> orthonormal columns.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">compute_uv</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, the returned <cite>U</cite> and <cite>V</cite> matrices will be zero matrices
of shape <span class="math">\((n \times n)\)</span> and <span class="math">\((m \times m)\)</span> respectively. <code class="xref py py-attr docutils literal notranslate"><span class="pre">some</span></code> will be ignored here.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The implementation of SVD on CPU uses the LAPACK routine <cite>?gesdd</cite> (a divide-and-conquer
algorithm) instead of <cite>?gesvd</cite> for speed. Analogously, the SVD on GPU uses the MAGMA routine
<cite>gesdd</cite> as well.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Irrespective of the original strides, the returned matrix <cite>U</cite>
will be transposed, i.e. with strides <cite>(1, n)</cite> instead of <cite>(n, 1)</cite>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Extra care needs to be taken when backward through <cite>U</cite> and <cite>V</cite>
outputs. Such operation is really only stable when <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is
full rank with all distinct singular values. Otherwise, <code class="docutils literal notranslate"><span class="pre">NaN</span></code> can
appear as the gradients are not properly defined. Also, notice that
double backward will usually do an additional backward through <cite>U</cite> and
<cite>V</cite> even if the original backward is only on <cite>S</cite>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">some</span></code> = <code class="docutils literal notranslate"><span class="pre">False</span></code>, the gradients on <code class="docutils literal notranslate"><span class="pre">U[:,</span> <span class="pre">min(n,</span> <span class="pre">m):]</span></code>
and <code class="docutils literal notranslate"><span class="pre">V[:,</span> <span class="pre">min(n,</span> <span class="pre">m):]</span></code> will be ignored in backward as those vectors
can be arbitrary bases of the subspaces.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>When <code class="xref py py-attr docutils literal notranslate"><span class="pre">compute_uv</span></code> = <code class="docutils literal notranslate"><span class="pre">False</span></code>, backward cannot be performed since <code class="docutils literal notranslate"><span class="pre">U</span></code> and <code class="docutils literal notranslate"><span class="pre">V</span></code>
from the forward pass is required for the backward operation.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input 2-D tensor</p></li>
<li><p><strong>some</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – controls the shape of returned <cite>U</cite> and <cite>V</cite></p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the output tuple of tensors</p></li>
</ul>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span><span class="mf">8.79</span><span class="p">,</span>  <span class="mf">6.11</span><span class="p">,</span> <span class="o">-</span><span class="mf">9.15</span><span class="p">,</span>  <span class="mf">9.57</span><span class="p">,</span> <span class="o">-</span><span class="mf">3.49</span><span class="p">,</span>  <span class="mf">9.84</span><span class="p">],</span>
<span class="go">                      [9.93,  6.91, -7.93,  1.64,  4.02,  0.15],</span>
<span class="go">                      [9.83,  5.04,  4.86,  8.83,  9.80, -8.99],</span>
<span class="go">                      [5.45, -0.27,  4.85,  0.74, 10.00, -6.02],</span>
<span class="go">                      [3.16,  7.98,  3.01,  5.80,  4.27, -5.31]]).t()</span>

<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">svd</span><span class="p">(</span><span class="n">a</span><span class="p">)</span><span class="o">.</span><span class="vm">__class__</span>
<span class="go">&lt;class &#39;torch.return_types.svd&#39;&gt;</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">u</span><span class="p">,</span> <span class="n">s</span><span class="p">,</span> <span class="n">v</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">svd</span><span class="p">(</span><span class="n">a</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">u</span>
<span class="go">tensor([[-0.5911,  0.2632,  0.3554,  0.3143,  0.2299],</span>
<span class="go">        [-0.3976,  0.2438, -0.2224, -0.7535, -0.3636],</span>
<span class="go">        [-0.0335, -0.6003, -0.4508,  0.2334, -0.3055],</span>
<span class="go">        [-0.4297,  0.2362, -0.6859,  0.3319,  0.1649],</span>
<span class="go">        [-0.4697, -0.3509,  0.3874,  0.1587, -0.5183],</span>
<span class="go">        [ 0.2934,  0.5763, -0.0209,  0.3791, -0.6526]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">s</span>
<span class="go">tensor([ 27.4687,  22.6432,   8.5584,   5.9857,   2.0149])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span>
<span class="go">tensor([[-0.2514,  0.8148, -0.2606,  0.3967, -0.2180],</span>
<span class="go">        [-0.3968,  0.3587,  0.7008, -0.4507,  0.1402],</span>
<span class="go">        [-0.6922, -0.2489, -0.2208,  0.2513,  0.5891],</span>
<span class="go">        [-0.3662, -0.3686,  0.3859,  0.4342, -0.6265],</span>
<span class="go">        [-0.4076, -0.0980, -0.4933, -0.6227, -0.4396]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">dist</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">mm</span><span class="p">(</span><span class="n">u</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">diag</span><span class="p">(</span><span class="n">s</span><span class="p">)),</span> <span class="n">v</span><span class="o">.</span><span class="n">t</span><span class="p">()))</span>
<span class="go">tensor(1.00000e-06 *</span>
<span class="go">       9.3738)</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.symeig">
<code class="descclassname">torch.</code><code class="descname">symeig</code><span class="sig-paren">(</span><em>input</em>, <em>eigenvectors=False</em>, <em>upper=True</em>, <em>out=None) -&gt; (Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.symeig" title="Permalink to this definition">¶</a></dt>
<dd><p>This function returns eigenvalues and eigenvectors
of a real symmetric matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>, represented by a namedtuple
(eigenvalues, eigenvectors).</p>
<p><code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> and <span class="math">\(V\)</span> are <span class="math">\((m \times m)\)</span> matrices and <span class="math">\(e\)</span> is a
<span class="math">\(m\)</span> dimensional vector.</p>
<p>This function calculates all eigenvalues (and vectors) of <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code>
such that <span class="math">\(\text{input} = V \text{diag}(e) V^T\)</span>.</p>
<p>The boolean argument <code class="xref py py-attr docutils literal notranslate"><span class="pre">eigenvectors</span></code> defines computation of
eigenvectors or eigenvalues only.</p>
<p>If it is <code class="docutils literal notranslate"><span class="pre">False</span></code>, only eigenvalues are computed. If it is <code class="docutils literal notranslate"><span class="pre">True</span></code>,
both eigenvalues and eigenvectors are computed.</p>
<p>Since the input matrix <code class="xref py py-attr docutils literal notranslate"><span class="pre">input</span></code> is supposed to be symmetric,
only the upper triangular portion is used by default.</p>
<p>If <code class="xref py py-attr docutils literal notranslate"><span class="pre">upper</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>, then lower triangular portion is used.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Irrespective of the original strides, the returned matrix <cite>V</cite> will
be transposed, i.e. with strides <cite>(1, m)</cite> instead of <cite>(m, 1)</cite>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Extra care needs to be taken when backward through outputs. Such
operation is really only stable when all eigenvalues are distinct.
Otherwise, <code class="docutils literal notranslate"><span class="pre">NaN</span></code> can appear as the gradients are not properly defined.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>input</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input symmetric matrix</p></li>
<li><p><strong>eigenvectors</strong> (<em>boolean</em><em>, </em><em>optional</em>) – controls whether eigenvectors have to be computed</p></li>
<li><p><strong>upper</strong> (<em>boolean</em><em>, </em><em>optional</em>) – controls whether to consider upper-triangular or lower-triangular region</p></li>
<li><p><strong>out</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#tuple" title="(in Python v3.7)"><em>tuple</em></a><em>, </em><em>optional</em>) – the output tuple of (Tensor, Tensor)</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><p>A namedtuple (eigenvalues, eigenvectors) containing</p>
<blockquote>
<div><ul class="simple">
<li><p><strong>eigenvalues</strong> (<em>Tensor</em>): Shape <span class="math">\((m)\)</span>. Each element is an eigenvalue of <code class="docutils literal notranslate"><span class="pre">input</span></code>,
The eigenvalues are in ascending order.</p></li>
<li><p><strong>eigenvectors</strong> (<em>Tensor</em>): Shape <span class="math">\((m \times m)\)</span>.
If <code class="docutils literal notranslate"><span class="pre">eigenvectors=False</span></code>, it’s a tensor filled with zeros.
Otherwise, this tensor contains the orthonormal eigenvectors of the <code class="docutils literal notranslate"><span class="pre">input</span></code>.</p></li>
</ul>
</div></blockquote>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>(<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>, <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor">Tensor</a>)</p>
</dd>
</dl>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">a</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">tensor</span><span class="p">([[</span> <span class="mf">1.96</span><span class="p">,</span>  <span class="mf">0.00</span><span class="p">,</span>  <span class="mf">0.00</span><span class="p">,</span>  <span class="mf">0.00</span><span class="p">,</span>  <span class="mf">0.00</span><span class="p">],</span>
<span class="go">                      [-6.49,  3.80,  0.00,  0.00,  0.00],</span>
<span class="go">                      [-0.47, -6.39,  4.17,  0.00,  0.00],</span>
<span class="go">                      [-7.20,  1.50, -1.51,  5.70,  0.00],</span>
<span class="go">                      [-0.65, -6.34,  2.67,  1.80, -7.10]]).t()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">e</span><span class="p">,</span> <span class="n">v</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">symeig</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">eigenvectors</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">e</span>
<span class="go">tensor([-11.0656,  -6.2287,   0.8640,   8.8655,  16.0948])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">v</span>
<span class="go">tensor([[-0.2981, -0.6075,  0.4026, -0.3745,  0.4896],</span>
<span class="go">        [-0.5078, -0.2880, -0.4066, -0.3572, -0.6053],</span>
<span class="go">        [-0.0816, -0.3843, -0.6600,  0.5008,  0.3991],</span>
<span class="go">        [-0.0036, -0.4467,  0.4553,  0.6204, -0.4564],</span>
<span class="go">        [-0.8041,  0.4480,  0.1725,  0.3108,  0.1622]])</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.triangular_solve">
<code class="descclassname">torch.</code><code class="descname">triangular_solve</code><span class="sig-paren">(</span><em>b</em>, <em>A</em>, <em>upper=True</em>, <em>transpose=False</em>, <em>unitriangular=False) -&gt; (Tensor</em>, <em>Tensor</em><span class="sig-paren">)</span><a class="headerlink" href="#torch.triangular_solve" title="Permalink to this definition">¶</a></dt>
<dd><p>Solves a system of equations with a triangular coefficient matrix <span class="math">\(A\)</span>
and multiple right-hand sides <code class="xref py py-attr docutils literal notranslate"><span class="pre">b</span></code>.</p>
<p>In particular, solves <span class="math">\(AX = b\)</span> and assumes <span class="math">\(A\)</span> is upper-triangular
with the default keyword arguments.</p>
<p><cite>torch.triangular_solve(b, A)</cite> can take in 2D inputs <cite>b, A</cite> or inputs that are
batches of 2D matrices. If the inputs are batches, then returns
batched outputs <cite>X</cite></p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The <code class="xref py py-attr docutils literal notranslate"><span class="pre">out</span></code> keyword only supports 2D matrix inputs, that is,
<cite>b, A</cite> must be 2D matrices.</p>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>A</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – the input triangular coefficient matrix of size <span class="math">\((*, m, m)\)</span>
where <span class="math">\(*\)</span> is zero or more batch dimensions</p></li>
<li><p><strong>b</strong> (<a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>Tensor</em></a>) – multiple right-hand sides of size <span class="math">\((*, m, k)\)</span> where
<span class="math">\(*\)</span> is zero of more batch dimensions</p></li>
<li><p><strong>upper</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether to solve the upper-triangular system
of equations (default) or the lower-triangular system of equations. Default: <code class="docutils literal notranslate"><span class="pre">True</span></code>.</p></li>
<li><p><strong>transpose</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether <span class="math">\(A\)</span> should be transposed before
being sent into the solver. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
<li><p><strong>unitriangular</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.7)"><em>bool</em></a><em>, </em><em>optional</em>) – whether <span class="math">\(A\)</span> is unit triangular.
If True, the diagonal elements of <span class="math">\(A\)</span> are assumed to be
1 and not referenced from <span class="math">\(A\)</span>. Default: <code class="docutils literal notranslate"><span class="pre">False</span></code>.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A namedtuple <span class="math">\((solution, cloned_coefficient)\)</span> where <span class="math">\(cloned_coefficient\)</span>
is a clone of <span class="math">\(A\)</span> and <span class="math">\(solution\)</span> is the solution <span class="math">\(X\)</span> to <span class="math">\(AX = b\)</span>
(or whatever variant of the system of equations, depending on the keyword arguments.)</p>
</dd>
</dl>
<p>Examples:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">A</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">)</span><span class="o">.</span><span class="n">triu</span><span class="p">()</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">A</span>
<span class="go">tensor([[ 1.1527, -1.0753],</span>
<span class="go">        [ 0.0000,  0.7986]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">)</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">b</span>
<span class="go">tensor([[-0.0210,  2.3513, -1.5492],</span>
<span class="go">        [ 1.5429,  0.7403, -1.0243]])</span>
<span class="gp">&gt;&gt;&gt; </span><span class="n">torch</span><span class="o">.</span><span class="n">triangular_solve</span><span class="p">(</span><span class="n">b</span><span class="p">,</span> <span class="n">A</span><span class="p">)</span>
<span class="go">torch.return_types.triangular_solve(</span>
<span class="go">solution=tensor([[ 1.7841,  2.9046, -2.5405],</span>
<span class="go">        [ 1.9320,  0.9270, -1.2826]]),</span>
<span class="go">cloned_coefficient=tensor([[ 1.1527, -1.0753],</span>
<span class="go">        [ 0.0000,  0.7986]]))</span>
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="torch.trtrs">
<code class="descclassname">torch.</code><code class="descname">trtrs</code><span class="sig-paren">(</span><em>b</em>, <em>A</em>, <em>upper=True</em>, <em>transpose=False</em>, <em>unitriangular=False</em>, <em>out=None</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/functional.html#trtrs"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.trtrs" title="Permalink to this definition">¶</a></dt>
<dd><p>Solves a system of equations with a triangular coefficient matrix <span class="math">\(A\)</span>
and multiple right-hand sides <code class="xref py py-attr docutils literal notranslate"><span class="pre">b</span></code>.</p>
<p>In particular, solves <span class="math">\(AX = b\)</span> and assumes <span class="math">\(A\)</span> is upper-triangular
with the default keyword arguments.</p>
<p>For more information regarding <a class="reference internal" href="#torch.trtrs" title="torch.trtrs"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.trtrs()</span></code></a>, please check <a class="reference internal" href="#torch.triangular_solve" title="torch.triangular_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.triangular_solve()</span></code></a>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p><a class="reference internal" href="#torch.trtrs" title="torch.trtrs"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.trtrs()</span></code></a> is deprecated in favour of <a class="reference internal" href="#torch.triangular_solve" title="torch.triangular_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.triangular_solve()</span></code></a> and will be
removed in the next release. Please use <a class="reference internal" href="#torch.triangular_solve" title="torch.triangular_solve"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.triangular_solve()</span></code></a> instead.</p>
</div>
</dd></dl>

</div>
</div>
<div class="section" id="utilities">
<h2>Utilities<a class="headerlink" href="#utilities" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="torch.compiled_with_cxx11_abi">
<code class="descclassname">torch.</code><code class="descname">compiled_with_cxx11_abi</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch.html#compiled_with_cxx11_abi"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.compiled_with_cxx11_abi" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns whether PyTorch was built with _GLIBCXX_USE_CXX11_ABI=1</p>
</dd></dl>

</div>
</div>


             </article>
             
            </div>
            <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="tensors.html" class="btn btn-neutral float-right" title="torch.Tensor" accesskey="n" rel="next">Next <img src="_static/images/chevron-right-orange.svg" class="next-page"></a>
      
      
        <a href="community/persons_of_interest.html" class="btn btn-neutral" title="PyTorch Governance | Persons of Interest" accesskey="p" rel="prev"><img src="_static/images/chevron-right-orange.svg" class="previous-page"> Previous</a>
      
    </div>
  

    <hr>

  
  <div role="contentinfo">
    <p>
        &copy; Copyright 2018, Torch Contributors.

    </p>
  </div>
    
      <div>
        Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>.
      </div>
     

</footer>

          </div>
        </div>

        <div class="pytorch-content-right" id="pytorch-content-right">
          <div class="pytorch-right-menu" id="pytorch-right-menu">
            <div class="pytorch-side-scroll" id="pytorch-side-scroll-right">
              <ul>
<li><a class="reference internal" href="#">torch</a><ul>
<li><a class="reference internal" href="#tensors">Tensors</a><ul>
<li><a class="reference internal" href="#creation-ops">Creation Ops</a></li>
<li><a class="reference internal" href="#indexing-slicing-joining-mutating-ops">Indexing, Slicing, Joining, Mutating Ops</a></li>
</ul>
</li>
<li><a class="reference internal" href="#random-sampling">Random sampling</a><ul>
<li><a class="reference internal" href="#in-place-random-sampling">In-place random sampling</a></li>
<li><a class="reference internal" href="#quasi-random-sampling">Quasi-random sampling</a></li>
</ul>
</li>
<li><a class="reference internal" href="#serialization">Serialization</a></li>
<li><a class="reference internal" href="#parallelism">Parallelism</a></li>
<li><a class="reference internal" href="#locally-disabling-gradient-computation">Locally disabling gradient computation</a></li>
<li><a class="reference internal" href="#math-operations">Math operations</a><ul>
<li><a class="reference internal" href="#pointwise-ops">Pointwise Ops</a></li>
<li><a class="reference internal" href="#reduction-ops">Reduction Ops</a></li>
<li><a class="reference internal" href="#comparison-ops">Comparison Ops</a></li>
<li><a class="reference internal" href="#spectral-ops">Spectral Ops</a></li>
<li><a class="reference internal" href="#other-operations">Other Operations</a></li>
<li><a class="reference internal" href="#blas-and-lapack-operations">BLAS and LAPACK Operations</a></li>
</ul>
</li>
<li><a class="reference internal" href="#utilities">Utilities</a></li>
</ul>
</li>
</ul>

            </div>
          </div>
        </div>
      </section>
    </div>

  
       <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></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="_static/language_data.js"></script>
         <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.js"></script>
         <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/contrib/auto-render.min.js"></script>
         <script type="text/javascript" src="_static/katex_autorenderer.js"></script>
     

  <script type="text/javascript" src="_static/js/vendor/popper.min.js"></script>
  <script type="text/javascript" src="_static/js/vendor/bootstrap.min.js"></script>
  <script type="text/javascript" src="_static/js/theme.js"></script>

  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.Navigation.enable(true);
      });
  </script> 

  <!-- Begin Footer -->

  <div class="container-fluid docs-tutorials-resources" id="docs-tutorials-resources">
    <div class="container">
      <div class="row">
        <div class="col-md-4 text-center">
          <h2>Docs</h2>
          <p>Access comprehensive developer documentation for PyTorch</p>
          <a class="with-right-arrow" href="https://pytorch.org/docs/stable/index.html">View Docs</a>
        </div>

        <div class="col-md-4 text-center">
          <h2>Tutorials</h2>
          <p>Get in-depth tutorials for beginners and advanced developers</p>
          <a class="with-right-arrow" href="https://pytorch.org/tutorials">View Tutorials</a>
        </div>

        <div class="col-md-4 text-center">
          <h2>Resources</h2>
          <p>Find development resources and get your questions answered</p>
          <a class="with-right-arrow" href="https://pytorch.org/resources">View Resources</a>
        </div>
      </div>
    </div>
  </div>

  <footer class="site-footer">
    <div class="container footer-container">
      <div class="footer-logo-wrapper">
        <a href="https://pytorch.org/" class="footer-logo"></a>
      </div>

      <div class="footer-links-wrapper">
        <div class="footer-links-col">
          <ul>
            <li class="list-title"><a href="https://pytorch.org/">PyTorch</a></li>
            <li><a href="https://pytorch.org/get-started">Get Started</a></li>
            <li><a href="https://pytorch.org/features">Features</a></li>
            <li><a href="https://pytorch.org/ecosystem">Ecosystem</a></li>
            <li><a href="https://pytorch.org/blog/">Blog</a></li>
            <li><a href="https://pytorch.org/resources">Resources</a></li>
          </ul>
        </div>

        <div class="footer-links-col">
          <ul>
            <li class="list-title"><a href="https://pytorch.org/support">Support</a></li>
            <li><a href="https://pytorch.org/tutorials">Tutorials</a></li>
            <li><a href="https://pytorch.org/docs/stable/index.html">Docs</a></li>
            <li><a href="https://discuss.pytorch.org" target="_blank">Discuss</a></li>
            <li><a href="https://github.com/pytorch/pytorch/issues" target="_blank">Github Issues</a></li>
            <li><a href="https://pytorch.slack.com" target="_blank">Slack</a></li>
            <li><a href="https://github.com/pytorch/pytorch/blob/master/CONTRIBUTING.md" target="_blank">Contributing</a></li>
          </ul>
        </div>

        <div class="footer-links-col follow-us-col">
          <ul>
            <li class="list-title">Follow Us</li>
            <li>
              <div id="mc_embed_signup">
                <form
                  action="https://twitter.us14.list-manage.com/subscribe/post?u=75419c71fe0a935e53dfa4a3f&id=91d0dccd39"
                  method="post"
                  id="mc-embedded-subscribe-form"
                  name="mc-embedded-subscribe-form"
                  class="email-subscribe-form validate"
                  target="_blank"
                  novalidate>
                  <div id="mc_embed_signup_scroll" class="email-subscribe-form-fields-wrapper">
                    <div class="mc-field-group">
                      <label for="mce-EMAIL" style="display:none;">Email Address</label>
                      <input type="email" value="" name="EMAIL" class="required email" id="mce-EMAIL" placeholder="Email Address">
                    </div>

                    <div id="mce-responses" class="clear">
                      <div class="response" id="mce-error-response" style="display:none"></div>
                      <div class="response" id="mce-success-response" style="display:none"></div>
                    </div>    <!-- real people should not fill this in and expect good things - do not remove this or risk form bot signups-->

                    <div style="position: absolute; left: -5000px;" aria-hidden="true"><input type="text" name="b_75419c71fe0a935e53dfa4a3f_91d0dccd39" tabindex="-1" value=""></div>

                    <div class="clear">
                      <input type="submit" value="" name="subscribe" id="mc-embedded-subscribe" class="button email-subscribe-button">
                    </div>
                  </div>
                </form>
              </div>

            </li>
          </ul>

          <div class="footer-social-icons">
            <a href="https://www.facebook.com/pytorch" target="_blank" class="facebook"></a>
            <a href="https://twitter.com/pytorch" target="_blank" class="twitter"></a>
          </div>
        </div>
      </div>
    </div>
  </footer>

  <div class="cookie-banner-wrapper">
  <div class="container">
    <p class="gdpr-notice">To analyze traffic and optimize your experience, we serve cookies on this site. By clicking or navigating, you agree to allow our usage of cookies. As the current maintainers of this site, Facebook’s Cookies Policy applies. Learn more, including about available controls: <a href="https://www.facebook.com/policies/cookies/">Cookies Policy</a>.</p>
    <img class="close-button" src="_static/images/pytorch-x.svg">
  </div>
</div>

  <!-- End Footer -->

  <!-- Begin Mobile Menu -->

  <div class="mobile-main-menu">
    <div class="container-fluid">
      <div class="container">
        <div class="mobile-main-menu-header-container">
          <a class="header-logo" href="https://pytorch.org/" aria-label="PyTorch"></a>
          <a class="main-menu-close-button" href="#" data-behavior="close-mobile-menu"></a>
        </div>
      </div>
    </div>

    <div class="mobile-main-menu-links-container">
      <div class="main-menu">
        <ul>
          <li>
            <a href="#">Get Started</a>
          </li>

          <li>
            <a href="#">Features</a>
          </li>

          <li>
            <a href="#">Ecosystem</a>
          </li>

          <li>
            <a href="https://pytorch.org/blog/">Blog</a>
          </li>

          <li>
            <a href="https://pytorch.org/tutorials">Tutorials</a>
          </li>

          <li class="active">
            <a href="https://pytorch.org/docs/stable/index.html">Docs</a>
          </li>

          <li>
            <a href="https://pytorch.org/resources">Resources</a>
          </li>

          <li>
            <a href="https://github.com/pytorch/pytorch">Github</a>
          </li>
        </ul>
      </div>
    </div>
  </div>

  <!-- End Mobile Menu -->

  <script type="text/javascript" src="_static/js/vendor/anchor.min.js"></script>

  <script type="text/javascript">
    $(document).ready(function() {
      mobileMenu.bind();
      mobileTOC.bind();
      pytorchAnchors.bind();
      sideMenus.bind();
      scrollToAnchor.bind();
      highlightNavigation.bind();

      // Add class to links that have code blocks, since we cannot create links in code blocks
      $("article.pytorch-article a span.pre").each(function(e) {
        $(this).closest("a").addClass("has-code");
      });
    })
  </script>
</body>
</html>