1.8.1/onnx.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.onnx &mdash; PyTorch 1.8.1 documentation</title>
  

    <link rel="canonical" href="https://pytorch.org/docs/stable/onnx.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="_static/css/jit.css" type="text/css" />
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.12.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.optim" href="optim.html" />
    <link rel="prev" title="torch.nn.init" href="nn.init.html" /> 

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

  <!-- Preload the theme fonts -->

<link rel="preload" href="_static/fonts/FreightSans/freight-sans-book.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="_static/fonts/FreightSans/freight-sans-medium.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="_static/fonts/IBMPlexMono/IBMPlexMono-Medium.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="_static/fonts/FreightSans/freight-sans-bold.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="_static/fonts/FreightSans/freight-sans-medium-italic.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="_static/fonts/IBMPlexMono/IBMPlexMono-SemiBold.woff2" as="font" type="font/woff2" crossorigin="anonymous">

<!-- Preload the katex fonts -->

<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Math-Italic.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Main-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Main-Bold.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Size1-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Size4-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Size2-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Size3-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">
<link rel="preload" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/fonts/KaTeX_Caligraphic-Regular.woff2" as="font" type="font/woff2" crossorigin="anonymous">
  <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.15.2/css/all.css" integrity="sha384-vSIIfh2YWi9wW0r9iZe7RJPrKwp6bG+s9QZMoITbCckVJqGCCRhc+ccxNcdpHuYu" crossorigin="anonymous">
</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/ecosystem">Ecosystem</a>
          </li>

          <li>
            <a href="https://pytorch.org/mobile">Mobile</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">
            <div id="resourcesDropdownButton" data-toggle="resources-dropdown" class="resources-dropdown">
              <a class="resource-option with-down-orange-arrow">
                Docs
              </a>
              <div class="resources-dropdown-menu">
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/docs/stable/index.html">
                  <span class="dropdown-title">PyTorch</span>
                  <p></p>
                </a>
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/audio/stable/index.html">
                  <span class="dropdown-title">torchaudio</span>
                  <p></p>
                </a>
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/text/stable/index.html">
                  <span class="dropdown-title">torchtext</span>
                  <p></p>
                </a>
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/vision/stable/index.html">
                  <span class="dropdown-title">torchvision</span>
                  <p></p>
                </a>
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/elastic/">
                  <span class="dropdown-title">TorchElastic</span>
                  <p></p>
                </a>
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/serve/">
                  <span class="dropdown-title">TorchServe</span>
                  <p></p>
                </a>
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/xla">
                  <span class="dropdown-title">PyTorch on XLA Devices</span>
                  <p></p>
                </a>
            </div>
          </li>

          <li>
            <div id="resourcesDropdownButton" data-toggle="resources-dropdown" class="resources-dropdown">
              <a class="resource-option with-down-arrow">
                Resources
              </a>
              <div class="resources-dropdown-menu">
                <a class="nav-dropdown-item" href="https://pytorch.org/features">
                  <span class="dropdown-title">About</span>
                  <p>Learn about PyTorch’s features and capabilities</p>
                </a>
                <a class="nav-dropdown-item" href="https://pytorch.org/#community-module">
                  <span class="dropdown-title">Community</span>
                  <p>Join the PyTorch developer community to contribute, learn, and get your questions answered.</p>
                </a>
                <a class="nav-dropdown-item" href="https://pytorch.org/resources">
                  <span class="dropdown-title">Developer Resources</span>
                  <p>Find resources and get questions answered</p>
                </a>
                <a class="nav-dropdown-item" href="https://discuss.pytorch.org/" target="_blank">
                  <span class="dropdown-title">Forums</span>
                  <p>A place to discuss PyTorch code, issues, install, research</p>
                </a>
                <a class="nav-dropdown-item" href="https://pytorch.org/hub">
                  <span class="dropdown-title">Models (Beta)</span>
                  <p>Discover, publish, and reuse pre-trained models</p>
                </a>
              </div>
            </div>
          </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='https://pytorch.org/docs/versions.html'>1.8.1 &#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/amp_examples.html">Automatic Mixed Precision examples</a></li>
<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/cpu_threading_torchscript_inference.html">CPU threading and TorchScript inference</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/ddp.html">Distributed Data Parallel</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/large_scale_deployments.html">Features for large-scale deployments</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/modules.html">Modules</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">Language Bindings</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="cpp_index.html">C++</a></li>
<li class="toctree-l1"><a class="reference external" href="https://pytorch.org/javadoc/">Javadoc</a></li>
</ul>
<p class="caption"><span class="caption-text">Python API</span></p>
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="torch.html">torch</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.functional.html">torch.nn.functional</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="tensor_view.html">Tensor Views</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="cuda.html">torch.cuda</a></li>
<li class="toctree-l1"><a class="reference internal" href="amp.html">torch.cuda.amp</a></li>
<li class="toctree-l1"><a class="reference internal" href="backends.html">torch.backends</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="fft.html">torch.fft</a></li>
<li class="toctree-l1"><a class="reference internal" href="futures.html">torch.futures</a></li>
<li class="toctree-l1"><a class="reference internal" href="fx.html">torch.fx</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="linalg.html">torch.linalg</a></li>
<li class="toctree-l1"><a class="reference internal" href="torch.overrides.html">torch.overrides</a></li>
<li class="toctree-l1"><a class="reference internal" href="profiler.html">torch.profiler</a></li >
<li class="toctree-l1"><a class="reference internal" href="nn.init.html">torch.nn.init</a></li>
<li class="toctree-l1 current"><a class="current reference internal" href="#">torch.onnx</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="complex_numbers.html">Complex Numbers</a></li>
<li class="toctree-l1"><a class="reference internal" href="ddp_comm_hooks.html">DDP Communication Hooks</a></li>
<li class="toctree-l1"><a class="reference internal" href="pipeline.html">Pipeline Parallelism</a></li>
<li class="toctree-l1"><a class="reference internal" href="quantization.html">Quantization</a></li>
<li class="toctree-l1"><a class="reference internal" href="rpc.html">Distributed RPC Framework</a></li>
<li class="toctree-l1"><a class="reference internal" href="random.html">torch.random</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="storage.html">torch.Storage</a></li>
<li class="toctree-l1"><a class="reference internal" href="benchmark_utils.html">torch.utils.benchmark</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="mobile_optimizer.html">torch.utils.mobile_optimizer</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</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="named_tensor.html">Named Tensors</a></li>
<li class="toctree-l1"><a class="reference internal" href="name_inference.html">Named Tensors operator coverage</a></li>
<li class="toctree-l1"><a class="reference internal" href="__config__.html">torch.__config__</a></li>
</ul>
<p class="caption"><span class="caption-text">Libraries</span></p>
<ul>
<li class="toctree-l1"><a class="reference external" href="https://pytorch.org/audio/stable">torchaudio</a></li>
<li class="toctree-l1"><a class="reference external" href="https://pytorch.org/text/stable">torchtext</a></li>
<li class="toctree-l1"><a class="reference external" href="https://pytorch.org/vision/stable">torchvision</a></li>
<li class="toctree-l1"><a class="reference external" href="https://pytorch.org/elastic/">TorchElastic</a></li>
<li class="toctree-l1"><a class="reference external" href="https://pytorch.org/serve">TorchServe</a></li>
<li class="toctree-l1"><a class="reference external" href="http://pytorch.org/xla/">PyTorch on XLA Devices</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>

            
        </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.onnx</li>
    
    
      <li class="pytorch-breadcrumbs-aside">
        
            
            <a href="_sources/onnx.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="torch-onnx">
<h1>torch.onnx<a class="headerlink" href="#torch-onnx" title="Permalink to this headline">¶</a></h1>
<div class="contents local topic" id="contents">
<ul class="simple">
<li><p><a class="reference internal" href="#example-end-to-end-alexnet-from-pytorch-to-onnx" id="id3">Example: End-to-end AlexNet from PyTorch to ONNX</a></p></li>
<li><p><a class="reference internal" href="#tracing-vs-scripting" id="id4">Tracing vs Scripting</a></p></li>
<li><p><a class="reference internal" href="#write-pytorch-model-in-torch-way" id="id5">Write PyTorch model in Torch way</a></p></li>
<li><p><a class="reference internal" href="#using-dictionaries-to-handle-named-arguments-as-model-inputs" id="id6">Using dictionaries to handle Named Arguments as model inputs</a></p></li>
<li><p><a class="reference internal" href="#indexing" id="id7">Indexing</a></p>
<ul>
<li><p><a class="reference internal" href="#getter" id="id8">Getter</a></p></li>
<li><p><a class="reference internal" href="#setter" id="id9">Setter</a></p></li>
</ul>
</li>
<li><p><a class="reference internal" href="#torchvision-support" id="id10">TorchVision support</a></p></li>
<li><p><a class="reference internal" href="#limitations" id="id11">Limitations</a></p></li>
<li><p><a class="reference internal" href="#supported-operators" id="id12">Supported operators</a></p></li>
<li><p><a class="reference internal" href="#adding-support-for-operators" id="id13">Adding support for operators</a></p>
<ul>
<li><p><a class="reference internal" href="#aten-operators" id="id14">ATen operators</a></p></li>
<li><p><a class="reference internal" href="#non-aten-operators" id="id15">Non-ATen operators</a></p></li>
<li><p><a class="reference internal" href="#custom-operators" id="id16">Custom operators</a></p></li>
</ul>
</li>
<li><p><a class="reference internal" href="#operator-export-type" id="id17">Operator Export Type</a></p>
<ul>
<li><p><a class="reference internal" href="#id2" id="id18">ONNX</a></p></li>
<li><p><a class="reference internal" href="#onnx-aten" id="id19">ONNX_ATEN</a></p></li>
<li><p><a class="reference internal" href="#onnx-aten-fallback" id="id20">ONNX_ATEN_FALLBACK</a></p></li>
<li><p><a class="reference internal" href="#raw" id="id21">RAW</a></p></li>
<li><p><a class="reference internal" href="#onnx-fallthrough" id="id22">ONNX_FALLTHROUGH</a></p></li>
</ul>
</li>
<li><p><a class="reference internal" href="#frequently-asked-questions" id="id23">Frequently Asked Questions</a></p></li>
<li><p><a class="reference internal" href="#use-external-data-format" id="id24">Use external data format</a></p></li>
<li><p><a class="reference internal" href="#training" id="id25">Training</a></p></li>
<li><p><a class="reference internal" href="#functions" id="id26">Functions</a></p></li>
</ul>
</div>
<span class="target" id="module-torch.onnx"></span><div class="section" id="example-end-to-end-alexnet-from-pytorch-to-onnx">
<h2><a class="toc-backref" href="#id3">Example: End-to-end AlexNet from PyTorch to ONNX</a><a class="headerlink" href="#example-end-to-end-alexnet-from-pytorch-to-onnx" title="Permalink to this headline">¶</a></h2>
<p>Here is a simple script which exports a pretrained AlexNet as defined in
torchvision into ONNX.  It runs a single round of inference and then
saves the resulting traced model to <code class="docutils literal notranslate"><span class="pre">alexnet.onnx</span></code>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">torch</span>
<span class="kn">import</span> <span class="nn">torchvision</span>

<span class="n">dummy_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">10</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">224</span><span class="p">,</span> <span class="mi">224</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="n">model</span> <span class="o">=</span> <span class="n">torchvision</span><span class="o">.</span><span class="n">models</span><span class="o">.</span><span class="n">alexnet</span><span class="p">(</span><span class="n">pretrained</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span><span class="o">.</span><span class="n">cuda</span><span class="p">()</span>

<span class="c1"># Providing input and output names sets the display names for values</span>
<span class="c1"># within the model&#39;s graph. Setting these does not change the semantics</span>
<span class="c1"># of the graph; it is only for readability.</span>
<span class="c1">#</span>
<span class="c1"># The inputs to the network consist of the flat list of inputs (i.e.</span>
<span class="c1"># the values you would pass to the forward() method) followed by the</span>
<span class="c1"># flat list of parameters. You can partially specify names, i.e. provide</span>
<span class="c1"># a list here shorter than the number of inputs to the model, and we will</span>
<span class="c1"># only set that subset of names, starting from the beginning.</span>
<span class="n">input_names</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&quot;actual_input_1&quot;</span> <span class="p">]</span> <span class="o">+</span> <span class="p">[</span> <span class="s2">&quot;learned_</span><span class="si">%d</span><span class="s2">&quot;</span> <span class="o">%</span> <span class="n">i</span> <span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">16</span><span class="p">)</span> <span class="p">]</span>
<span class="n">output_names</span> <span class="o">=</span> <span class="p">[</span> <span class="s2">&quot;output1&quot;</span> <span class="p">]</span>

<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="n">dummy_input</span><span class="p">,</span> <span class="s2">&quot;alexnet.onnx&quot;</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">input_names</span><span class="o">=</span><span class="n">input_names</span><span class="p">,</span> <span class="n">output_names</span><span class="o">=</span><span class="n">output_names</span><span class="p">)</span>
</pre></div>
</div>
<p>The resulting <code class="docutils literal notranslate"><span class="pre">alexnet.onnx</span></code> is a binary protobuf file which contains both
the network structure and parameters of the model you exported
(in this case, AlexNet).  The keyword argument <code class="docutils literal notranslate"><span class="pre">verbose=True</span></code> causes the
exporter to print out a human-readable representation of the network:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># These are the inputs and parameters to the network, which have taken on</span>
<span class="c1"># the names we specified earlier.</span>
<span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="n">actual_input_1</span> <span class="p">:</span> <span class="n">Float</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">224</span><span class="p">,</span> <span class="mi">224</span><span class="p">)</span>
      <span class="o">%</span><span class="n">learned_0</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">64</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">11</span><span class="p">)</span>
      <span class="o">%</span><span class="n">learned_1</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">64</span><span class="p">)</span>
      <span class="o">%</span><span class="n">learned_2</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">192</span><span class="p">,</span> <span class="mi">64</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="o">%</span><span class="n">learned_3</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">192</span><span class="p">)</span>
      <span class="c1"># ---- omitted for brevity ----</span>
      <span class="o">%</span><span class="n">learned_14</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">1000</span><span class="p">,</span> <span class="mi">4096</span><span class="p">)</span>
      <span class="o">%</span><span class="n">learned_15</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">1000</span><span class="p">))</span> <span class="p">{</span>
  <span class="c1"># Every statement consists of some output tensors (and their types),</span>
  <span class="c1"># the operator to be run (with its attributes, e.g., kernels, strides,</span>
  <span class="c1"># etc.), its input tensors (%actual_input_1, %learned_0, %learned_1)</span>
  <span class="o">%</span><span class="mi">17</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">64</span><span class="p">,</span> <span class="mi">55</span><span class="p">,</span> <span class="mi">55</span><span class="p">)</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Conv</span><span class="p">[</span><span class="n">dilations</span><span class="o">=</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="n">group</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">kernel_shape</span><span class="o">=</span><span class="p">[</span><span class="mi">11</span><span class="p">,</span> <span class="mi">11</span><span class="p">],</span> <span class="n">pads</span><span class="o">=</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">],</span> <span class="n">strides</span><span class="o">=</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="o">%</span><span class="n">actual_input_1</span><span class="p">,</span> <span class="o">%</span><span class="n">learned_0</span><span class="p">,</span> <span class="o">%</span><span class="n">learned_1</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span><span class="o">/</span><span class="n">Sequential</span><span class="p">[</span><span class="n">features</span><span class="p">]</span><span class="o">/</span><span class="n">Conv2d</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
  <span class="o">%</span><span class="mi">18</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">64</span><span class="p">,</span> <span class="mi">55</span><span class="p">,</span> <span class="mi">55</span><span class="p">)</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Relu</span><span class="p">(</span><span class="o">%</span><span class="mi">17</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span><span class="o">/</span><span class="n">Sequential</span><span class="p">[</span><span class="n">features</span><span class="p">]</span><span class="o">/</span><span class="n">ReLU</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span>
  <span class="o">%</span><span class="mi">19</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">64</span><span class="p">,</span> <span class="mi">27</span><span class="p">,</span> <span class="mi">27</span><span class="p">)</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">MaxPool</span><span class="p">[</span><span class="n">kernel_shape</span><span class="o">=</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="n">pads</span><span class="o">=</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">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">]](</span><span class="o">%</span><span class="mi">18</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span><span class="o">/</span><span class="n">Sequential</span><span class="p">[</span><span class="n">features</span><span class="p">]</span><span class="o">/</span><span class="n">MaxPool2d</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span>
  <span class="c1"># ---- omitted for brevity ----</span>
  <span class="o">%</span><span class="mi">29</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">256</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">6</span><span class="p">)</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">MaxPool</span><span class="p">[</span><span class="n">kernel_shape</span><span class="o">=</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="n">pads</span><span class="o">=</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">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">2</span><span class="p">]](</span><span class="o">%</span><span class="mi">28</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span><span class="o">/</span><span class="n">Sequential</span><span class="p">[</span><span class="n">features</span><span class="p">]</span><span class="o">/</span><span class="n">MaxPool2d</span><span class="p">[</span><span class="mi">12</span><span class="p">]</span>
  <span class="c1"># Dynamic means that the shape is not known. This may be because of a</span>
  <span class="c1"># limitation of our implementation (which we would like to fix in a</span>
  <span class="c1"># future release) or shapes which are truly dynamic.</span>
  <span class="o">%</span><span class="mi">30</span> <span class="p">:</span> <span class="n">Dynamic</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Shape</span><span class="p">(</span><span class="o">%</span><span class="mi">29</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span>
  <span class="o">%</span><span class="mi">31</span> <span class="p">:</span> <span class="n">Dynamic</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Slice</span><span class="p">[</span><span class="n">axes</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="n">ends</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">starts</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">]](</span><span class="o">%</span><span class="mi">30</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span>
  <span class="o">%</span><span class="mi">32</span> <span class="p">:</span> <span class="n">Long</span><span class="p">()</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Squeeze</span><span class="p">[</span><span class="n">axes</span><span class="o">=</span><span class="p">[</span><span class="mi">0</span><span class="p">]](</span><span class="o">%</span><span class="mi">31</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span>
  <span class="o">%</span><span class="mi">33</span> <span class="p">:</span> <span class="n">Long</span><span class="p">()</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">9216</span><span class="p">}](),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span>
  <span class="c1"># ---- omitted for brevity ----</span>
  <span class="o">%</span><span class="n">output1</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">1000</span><span class="p">)</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Gemm</span><span class="p">[</span><span class="n">alpha</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">beta</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">broadcast</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span> <span class="n">transB</span><span class="o">=</span><span class="mi">1</span><span class="p">](</span><span class="o">%</span><span class="mi">45</span><span class="p">,</span> <span class="o">%</span><span class="n">learned_14</span><span class="p">,</span> <span class="o">%</span><span class="n">learned_15</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">AlexNet</span><span class="o">/</span><span class="n">Sequential</span><span class="p">[</span><span class="n">classifier</span><span class="p">]</span><span class="o">/</span><span class="n">Linear</span><span class="p">[</span><span class="mi">6</span><span class="p">]</span>
  <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="n">output1</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
</div>
<p>You can also verify the protobuf using the <a class="reference external" href="https://github.com/onnx/onnx/">ONNX</a> library.
You can install <code class="docutils literal notranslate"><span class="pre">ONNX</span></code> with conda:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">conda</span> <span class="n">install</span> <span class="o">-</span><span class="n">c</span> <span class="n">conda</span><span class="o">-</span><span class="n">forge</span> <span class="n">onnx</span>
</pre></div>
</div>
<p>Then, you can run:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">onnx</span>

<span class="c1"># Load the ONNX model</span>
<span class="n">model</span> <span class="o">=</span> <span class="n">onnx</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s2">&quot;alexnet.onnx&quot;</span><span class="p">)</span>

<span class="c1"># Check that the IR is well formed</span>
<span class="n">onnx</span><span class="o">.</span><span class="n">checker</span><span class="o">.</span><span class="n">check_model</span><span class="p">(</span><span class="n">model</span><span class="p">)</span>

<span class="c1"># Print a human readable representation of the graph</span>
<span class="n">onnx</span><span class="o">.</span><span class="n">helper</span><span class="o">.</span><span class="n">printable_graph</span><span class="p">(</span><span class="n">model</span><span class="o">.</span><span class="n">graph</span><span class="p">)</span>
</pre></div>
</div>
<p>To run the exported script with <a class="reference external" href="https://caffe2.ai/">caffe2</a>, you will need to install <cite>caffe2</cite>: If you don’t have one already, Please <a class="reference external" href="https://caffe2.ai/docs/getting-started.html">follow the install instructions</a>.</p>
<p>Once these are installed, you can use the backend for Caffe2:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># ...continuing from above</span>
<span class="kn">import</span> <span class="nn">caffe2.python.onnx.backend</span> <span class="k">as</span> <span class="nn">backend</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>

<span class="n">rep</span> <span class="o">=</span> <span class="n">backend</span><span class="o">.</span><span class="n">prepare</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="n">device</span><span class="o">=</span><span class="s2">&quot;CUDA:0&quot;</span><span class="p">)</span> <span class="c1"># or &quot;CPU&quot;</span>
<span class="c1"># For the Caffe2 backend:</span>
<span class="c1">#     rep.predict_net is the Caffe2 protobuf for the network</span>
<span class="c1">#     rep.workspace is the Caffe2 workspace for the network</span>
<span class="c1">#       (see the class caffe2.python.onnx.backend.Workspace)</span>
<span class="n">outputs</span> <span class="o">=</span> <span class="n">rep</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">random</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">224</span><span class="p">,</span> <span class="mi">224</span><span class="p">)</span><span class="o">.</span><span class="n">astype</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">float32</span><span class="p">))</span>
<span class="c1"># To run networks with more than one input, pass a tuple</span>
<span class="c1"># rather than a single numpy ndarray.</span>
<span class="nb">print</span><span class="p">(</span><span class="n">outputs</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
</pre></div>
</div>
<p>You can also run the exported model with <a class="reference external" href="https://github.com/microsoft/onnxruntime">ONNX Runtime</a>,
you will need to install <cite>ONNX Runtime</cite>: please <a class="reference external" href="https://github.com/microsoft/onnxruntime#installation">follow these instructions</a>.</p>
<p>Once these are installed, you can use the backend for ONNX Runtime:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># ...continuing from above</span>
<span class="kn">import</span> <span class="nn">onnxruntime</span> <span class="k">as</span> <span class="nn">ort</span>

<span class="n">ort_session</span> <span class="o">=</span> <span class="n">ort</span><span class="o">.</span><span class="n">InferenceSession</span><span class="p">(</span><span class="s1">&#39;alexnet.onnx&#39;</span><span class="p">)</span>

<span class="n">outputs</span> <span class="o">=</span> <span class="n">ort_session</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="p">{</span><span class="s1">&#39;actual_input_1&#39;</span><span class="p">:</span> <span class="n">np</span><span class="o">.</span><span class="n">random</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">224</span><span class="p">,</span> <span class="mi">224</span><span class="p">)</span><span class="o">.</span><span class="n">astype</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">float32</span><span class="p">)})</span>

<span class="nb">print</span><span class="p">(</span><span class="n">outputs</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
</pre></div>
</div>
<p>Here is another <a class="reference external" href="https://pytorch.org/tutorials/advanced/super_resolution_with_onnxruntime.html">tutorial of exporting the SuperResolution model to ONNX.</a>.</p>
<p>In the future, there will be backends for other frameworks as well.</p>
</div>
<div class="section" id="tracing-vs-scripting">
<h2><a class="toc-backref" href="#id4">Tracing vs Scripting</a><a class="headerlink" href="#tracing-vs-scripting" title="Permalink to this headline">¶</a></h2>
<p>The ONNX exporter can be both <em>trace-based</em> and <em>script-based</em> exporter.</p>
<ul class="simple">
<li><p><em>trace-based</em> means that it operates by executing your model once, and exporting the operators which
were actually run during this run.  This means that if your model is
dynamic, e.g., changes behavior depending on input data, the export
won’t be accurate.  Similarly, a trace is likely to be valid only
for a specific input size (which is one reason why we require explicit inputs
on tracing.)  We recommend examining the model trace and making sure
the traced operators look reasonable.  If your model contains control flows like
for loops and if conditions, <em>trace-based</em> exporter will unroll the loops and if conditions,
exporting a static graph that is exactly the same as this run.  If you want
to export your model with dynamic control flows, you will need to use the <em>script-based</em> exporter.</p></li>
<li><p><em>script-based</em> means that the model you are trying to export is a <a class="reference external" href="jit.html">ScriptModule</a>.
<cite>ScriptModule</cite> is the core data structure in <cite>TorchScript</cite>, and <cite>TorchScript</cite> is a subset of Python language,
that creates serializable and optimizable models from PyTorch code.</p></li>
</ul>
<p>We allow mixing tracing and scripting. You can compose tracing and scripting to suit the particular requirements
of a part of a model.  Checkout this example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">torch</span>

<span class="c1"># Trace-based only</span>

<span class="k">class</span> <span class="nc">LoopModel</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</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="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">y</span><span class="p">):</span>
            <span class="n">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">i</span>
        <span class="k">return</span> <span class="n">x</span>

<span class="n">model</span> <span class="o">=</span> <span class="n">LoopModel</span><span class="p">()</span>
<span class="n">dummy_input</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">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="n">loop_count</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">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">long</span><span class="p">)</span>

<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="p">(</span><span class="n">dummy_input</span><span class="p">,</span> <span class="n">loop_count</span><span class="p">),</span> <span class="s1">&#39;loop.onnx&#39;</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</pre></div>
</div>
<p>With <em>trace-based</em> exporter, we get the result ONNX graph which unrolls the for loop:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Long</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="n">Long</span><span class="p">()):</span>
  <span class="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">1</span><span class="p">}]()</span>
  <span class="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Add</span><span class="p">(</span><span class="o">%</span><span class="mi">0</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">4</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">2</span><span class="p">}]()</span>
  <span class="o">%</span><span class="mi">5</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Add</span><span class="p">(</span><span class="o">%</span><span class="mi">3</span><span class="p">,</span> <span class="o">%</span><span class="mi">4</span><span class="p">)</span>
  <span class="o">%</span><span class="mi">6</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">3</span><span class="p">}]()</span>
  <span class="o">%</span><span class="mi">7</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Add</span><span class="p">(</span><span class="o">%</span><span class="mi">5</span><span class="p">,</span> <span class="o">%</span><span class="mi">6</span><span class="p">)</span>
  <span class="o">%</span><span class="mi">8</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">4</span><span class="p">}]()</span>
  <span class="o">%</span><span class="mi">9</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Add</span><span class="p">(</span><span class="o">%</span><span class="mi">7</span><span class="p">,</span> <span class="o">%</span><span class="mi">8</span><span class="p">)</span>
  <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">9</span><span class="p">)</span>
</pre></div>
</div>
<p>To utilize <em>script-based</em> exporter for capturing the dynamic loop,
we can write the loop in script, and call it from the regular nn.Module:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Mixing tracing and scripting</span>

<span class="nd">@torch</span><span class="o">.</span><span class="n">jit</span><span class="o">.</span><span class="n">script</span>
<span class="k">def</span> <span class="nf">loop</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="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">y</span><span class="p">)):</span>
        <span class="n">x</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">i</span>
    <span class="k">return</span> <span class="n">x</span>

<span class="k">class</span> <span class="nc">LoopModel2</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</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="k">return</span> <span class="n">loop</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>

<span class="n">model</span> <span class="o">=</span> <span class="n">LoopModel2</span><span class="p">()</span>
<span class="n">dummy_input</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">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="n">loop_count</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">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">long</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="p">(</span><span class="n">dummy_input</span><span class="p">,</span> <span class="n">loop_count</span><span class="p">),</span> <span class="s1">&#39;loop.onnx&#39;</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span>
                  <span class="n">input_names</span><span class="o">=</span><span class="p">[</span><span class="s1">&#39;input_data&#39;</span><span class="p">,</span> <span class="s1">&#39;loop_range&#39;</span><span class="p">])</span>
</pre></div>
</div>
<p>Now the exported ONNX graph becomes:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="n">input_data</span> <span class="p">:</span> <span class="n">Long</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">loop_range</span> <span class="p">:</span> <span class="n">Long</span><span class="p">()):</span>
  <span class="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Long</span><span class="p">()</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">1</span><span class="p">}](),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">LoopModel2</span><span class="o">/</span><span class="n">loop</span>
  <span class="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Cast</span><span class="p">[</span><span class="n">to</span><span class="o">=</span><span class="mi">9</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">4</span> <span class="p">:</span> <span class="n">Long</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">onnx</span><span class="p">::</span><span class="n">Loop</span><span class="p">(</span><span class="o">%</span><span class="n">loop_range</span><span class="p">,</span> <span class="o">%</span><span class="mi">3</span><span class="p">,</span> <span class="o">%</span><span class="n">input_data</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">LoopModel2</span><span class="o">/</span><span class="n">loop</span> <span class="c1"># custom_loop.py:240:5</span>
    <span class="n">block0</span><span class="p">(</span><span class="o">%</span><span class="n">i</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Long</span><span class="p">(),</span> <span class="o">%</span><span class="n">cond</span> <span class="p">:</span> <span class="nb">bool</span><span class="p">,</span> <span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">6</span> <span class="p">:</span> <span class="n">Long</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">8</span> <span class="p">:</span> <span class="n">Long</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">onnx</span><span class="p">::</span><span class="n">Add</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">6</span><span class="p">,</span> <span class="o">%</span><span class="n">i</span><span class="o">.</span><span class="mi">1</span><span class="p">),</span> <span class="n">scope</span><span class="p">:</span> <span class="n">LoopModel2</span><span class="o">/</span><span class="n">loop</span> <span class="c1"># custom_loop.py:241:13</span>
      <span class="o">%</span><span class="mi">9</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Cast</span><span class="p">[</span><span class="n">to</span><span class="o">=</span><span class="mi">9</span><span class="p">](</span><span class="o">%</span><span class="mi">2</span><span class="p">)</span>
      <span class="o">-&gt;</span> <span class="p">(</span><span class="o">%</span><span class="mi">9</span><span class="p">,</span> <span class="o">%</span><span class="mi">8</span><span class="p">)</span>
  <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">4</span><span class="p">)</span>
</pre></div>
</div>
<p>The dynamic control flow is captured correctly. We can verify in backends with different loop range.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">caffe2.python.onnx.backend</span> <span class="k">as</span> <span class="nn">backend</span>
<span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
<span class="kn">import</span> <span class="nn">onnx</span>
<span class="n">model</span> <span class="o">=</span> <span class="n">onnx</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;loop.onnx&#39;</span><span class="p">)</span>

<span class="n">rep</span> <span class="o">=</span> <span class="n">backend</span><span class="o">.</span><span class="n">prepare</span><span class="p">(</span><span class="n">model</span><span class="p">)</span>
<span class="n">outputs</span> <span class="o">=</span> <span class="n">rep</span><span class="o">.</span><span class="n">run</span><span class="p">((</span><span class="n">dummy_input</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="mi">9</span><span class="p">)</span><span class="o">.</span><span class="n">astype</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">int64</span><span class="p">)))</span>
<span class="nb">print</span><span class="p">(</span><span class="n">outputs</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
<span class="c1">#[[37 37 37]</span>
<span class="c1"># [37 37 37]]</span>


<span class="kn">import</span> <span class="nn">onnxruntime</span> <span class="k">as</span> <span class="nn">ort</span>
<span class="n">ort_sess</span> <span class="o">=</span> <span class="n">ort</span><span class="o">.</span><span class="n">InferenceSession</span><span class="p">(</span><span class="s1">&#39;loop.onnx&#39;</span><span class="p">)</span>
<span class="n">outputs</span> <span class="o">=</span> <span class="n">ort_sess</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="p">{</span><span class="s1">&#39;input_data&#39;</span><span class="p">:</span> <span class="n">dummy_input</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span>
                              <span class="s1">&#39;loop_range&#39;</span><span class="p">:</span> <span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">(</span><span class="mi">9</span><span class="p">)</span><span class="o">.</span><span class="n">astype</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">int64</span><span class="p">)})</span>
<span class="nb">print</span><span class="p">(</span><span class="n">outputs</span><span class="p">)</span>
<span class="c1">#[array([[37, 37, 37],</span>
<span class="c1">#       [37, 37, 37]], dtype=int64)]</span>
</pre></div>
</div>
<p>To avoid exporting a variable scalar tensor as a fixed value constant as part of the ONNX model, please
avoid use of <code class="docutils literal notranslate"><span class="pre">torch.Tensor.item()</span></code>. Torch supports implicit cast of single-element tensors to numbers.
E.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">LoopModel</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">):</span>
        <span class="n">res</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="n">arr</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">split</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="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">int</span><span class="p">(</span><span class="n">y</span><span class="p">)):</span>
            <span class="n">res</span> <span class="o">+=</span> <span class="p">[</span><span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="kc">False</span><span class="p">)]</span>
        <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">(</span><span class="n">res</span><span class="p">)</span>

<span class="n">model</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">jit</span><span class="o">.</span><span class="n">script</span><span class="p">(</span><span class="n">LoopModel</span><span class="p">())</span>
<span class="n">inputs</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">16</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">8</span><span class="p">))</span>

<span class="n">out</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="o">*</span><span class="n">inputs</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="n">inputs</span><span class="p">,</span> <span class="s1">&#39;loop_and_list.onnx&#39;</span><span class="p">,</span> <span class="n">opset_version</span><span class="o">=</span><span class="mi">11</span><span class="p">,</span> <span class="n">example_outputs</span><span class="o">=</span><span class="n">out</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="write-pytorch-model-in-torch-way">
<h2><a class="toc-backref" href="#id5">Write PyTorch model in Torch way</a><a class="headerlink" href="#write-pytorch-model-in-torch-way" title="Permalink to this headline">¶</a></h2>
<p>PyTorch models can be written using numpy manipulations, but this is not proper when we convert to the ONNX model.
For the trace-based exporter, tracing treats the numpy values as the constant node,
therefore it calculates the wrong result if we change the input.
So the PyTorch model need implement using torch operators.
For example, do not use numpy operators on numpy tensors:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">np</span><span class="o">.</span><span class="n">concatenate</span><span class="p">((</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">,</span> <span class="n">z</span><span class="p">),</span> <span class="n">axis</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
</pre></div>
</div>
<p>do not convert to numpy types:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">y</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">astype</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">int</span><span class="p">)</span>
</pre></div>
</div>
<p>Always use torch tensors and torch operators: torch.concat, etc.
In addition, Dropout layer need defined in init function so that inferencing can handle it properly, i.e.,</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">MyModule</span><span class="p">(</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">dropout</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">Dropout</span><span class="p">(</span><span class="mf">0.5</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="n">x</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">dropout</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="using-dictionaries-to-handle-named-arguments-as-model-inputs">
<h2><a class="toc-backref" href="#id6">Using dictionaries to handle Named Arguments as model inputs</a><a class="headerlink" href="#using-dictionaries-to-handle-named-arguments-as-model-inputs" title="Permalink to this headline">¶</a></h2>
<p>There are two ways to handle models which consist of named parameters or keyword arguments as inputs:</p>
<ul class="simple">
<li><p>The first method is to pass all the inputs in the same order as required by the model and pass None
values for the keyword arguments that do not require a value to be passed</p></li>
<li><p>The second and more intuitive method is to represent the keyword arguments as key-value pairs where
the key represents the name of the argument in the model signature and the value represents the value
of the argument to be passed</p></li>
</ul>
<p>For example, in the model:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Model</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
  <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">z</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">y</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
      <span class="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span>
    <span class="k">if</span> <span class="n">z</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
      <span class="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="n">z</span>
    <span class="k">return</span> <span class="n">x</span>
<span class="n">m</span> <span class="o">=</span> <span class="n">Model</span><span class="p">()</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="n">z</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>
</pre></div>
</div>
<p>There are two ways of exporting the model:</p>
<ul>
<li><p>Not using a dictionary for the keyword arguments and passing all the inputs in the same order
as required by the model</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>torch.onnx.export(model, (x, None, z), ‘test.onnx’)
</pre></div>
</div>
</li>
<li><p>Using a dictionary to represent the keyword arguments. This dictionary is always passed in
addition to the non-keyword arguments and is always the last argument in the args tuple.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>torch.onnx.export(model, (x, {&#39;y&#39;: None, &#39;z&#39;: z}), ‘test.onnx’)
</pre></div>
</div>
</li>
</ul>
<p>For cases in which there are no keyword arguments, models can be exported with either an
empty or no dictionary. For example,</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>torch.onnx.export(model, (x, {}), ‘test.onnx’)
or
torch.onnx.export(model, (x, ), ‘test.onnx’)
</pre></div>
</div>
<p>An exception to this rule are cases in which the last input is also of a dictionary type.
In these cases it is mandatory to have an empty dictionary as the last argument in the
args tuple. For example,</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Model</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
  <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">k</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
    <span class="o">...</span>
    <span class="k">return</span> <span class="n">x</span>
<span class="n">m</span> <span class="o">=</span> <span class="n">Model</span><span class="p">()</span>
<span class="n">k</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="n">x</span> <span class="o">=</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="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>
</pre></div>
</div>
<p>Without the presence of the empty dictionary, the export call assumes that the
‘x’ input is intended to represent the optional dictionary consisting of named arguments.
In order to prevent this from being an issue a constraint is placed to provide an empty
dictionary as the last input in the tuple args in such cases.
The new call would look like this.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>torch.onnx.export(model, (k, x, {}), ‘test.onnx’)
</pre></div>
</div>
</div>
<div class="section" id="indexing">
<h2><a class="toc-backref" href="#id7">Indexing</a><a class="headerlink" href="#indexing" title="Permalink to this headline">¶</a></h2>
<p>Tensor indexing in PyTorch is very flexible and complicated.
There are two categories of indexing. Both are largely supported in exporting today.
If you are experiencing issues exporting indexing that belongs to the supported patterns below,
please double check that you are exporting with the latest opset (opset_version=12).</p>
<div class="section" id="getter">
<h3><a class="toc-backref" href="#id8">Getter</a><a class="headerlink" href="#getter" title="Permalink to this headline">¶</a></h3>
<p>This type of indexing occurs on the RHS. Export is supported for ONNX opset version &gt;= 9. E.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data</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="n">index</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="c1"># RHS indexing is supported in ONNX opset &gt;= 11.</span>
<span class="k">class</span> <span class="nc">RHSIndexing</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">index</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">data</span><span class="p">[</span><span class="n">index</span><span class="p">]</span>

<span class="n">out</span> <span class="o">=</span> <span class="n">RHSIndexing</span><span class="p">()(</span><span class="n">data</span><span class="p">,</span> <span class="n">index</span><span class="p">)</span>

<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">RHSIndexing</span><span class="p">(),</span> <span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">index</span><span class="p">),</span> <span class="s1">&#39;indexing.onnx&#39;</span><span class="p">,</span> <span class="n">opset_version</span><span class="o">=</span><span class="mi">9</span><span class="p">)</span>

<span class="c1"># onnxruntime</span>
<span class="kn">import</span> <span class="nn">onnxruntime</span>
<span class="n">sess</span> <span class="o">=</span> <span class="n">onnxruntime</span><span class="o">.</span><span class="n">InferenceSession</span><span class="p">(</span><span class="s1">&#39;indexing.onnx&#39;</span><span class="p">)</span>
<span class="n">out_ort</span> <span class="o">=</span> <span class="n">sess</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="p">{</span>
    <span class="n">sess</span><span class="o">.</span><span class="n">get_inputs</span><span class="p">()[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">:</span> <span class="n">data</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span>
    <span class="n">sess</span><span class="o">.</span><span class="n">get_inputs</span><span class="p">()[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">:</span> <span class="n">index</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span>
<span class="p">})</span>

<span class="k">assert</span> <span class="n">torch</span><span class="o">.</span><span class="n">all</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">eq</span><span class="p">(</span><span class="n">out</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="n">out_ort</span><span class="p">)))</span>
</pre></div>
</div>
<p>Below is the list of supported patterns for RHS indexing.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Scalar indices</span>
<span class="n">data</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"># Slice indices</span>
<span class="n">data</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span>

<span class="c1"># Tensor indices</span>
<span class="n">data</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">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]])]</span>
<span class="n">data</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])]</span>
<span class="n">data</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">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">3</span><span class="p">])]</span>
<span class="n">data</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="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="c1"># Ellipsis</span>
<span class="c1"># Not supported in scripting</span>
<span class="c1"># i.e. torch.jit.script(model) will fail if model contains this pattern.</span>
<span class="c1"># Export is supported under tracing</span>
<span class="c1"># i.e. torch.onnx.export(model)</span>
<span class="n">data</span><span class="p">[</span><span class="o">...</span><span class="p">]</span>

<span class="c1"># The combination of above</span>
<span class="n">data</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="o">...</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="mi">3</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="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="p">[</span><span class="mi">2</span><span class="p">]])]</span>

<span class="c1"># Boolean mask (supported for ONNX opset version &gt;= 11)</span>
<span class="n">data</span><span class="p">[</span><span class="n">data</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">]</span>
</pre></div>
</div>
<p>And below is the list of unsupported patterns for RHS indexing.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Tensor indices that includes negative values.</span>
<span class="n">data</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">2</span><span class="p">,</span> <span class="o">-</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="o">-</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">])]</span>
</pre></div>
</div>
</div>
<div class="section" id="setter">
<h3><a class="toc-backref" href="#id9">Setter</a><a class="headerlink" href="#setter" title="Permalink to this headline">¶</a></h3>
<p>In code, this type of indexing occurs on the LHS.
Export is supported for ONNX opset version &gt;= 11. E.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">data</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">4</span><span class="p">)</span>
<span class="n">new_data</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">to</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float32</span><span class="p">)</span>

<span class="c1"># LHS indexing is supported in ONNX opset &gt;= 11.</span>
<span class="k">class</span> <span class="nc">LHSIndexing</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">data</span><span class="p">,</span> <span class="n">new_data</span><span class="p">):</span>
        <span class="n">data</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_data</span>
        <span class="k">return</span> <span class="n">data</span>

<span class="n">out</span> <span class="o">=</span> <span class="n">LHSIndexing</span><span class="p">()(</span><span class="n">data</span><span class="p">,</span> <span class="n">new_data</span><span class="p">)</span>

<span class="n">data</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">4</span><span class="p">)</span>
<span class="n">new_data</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">to</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">float32</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">LHSIndexing</span><span class="p">(),</span> <span class="p">(</span><span class="n">data</span><span class="p">,</span> <span class="n">new_data</span><span class="p">),</span> <span class="s1">&#39;inplace_assign.onnx&#39;</span><span class="p">,</span> <span class="n">opset_version</span><span class="o">=</span><span class="mi">11</span><span class="p">)</span>

<span class="c1"># onnxruntime</span>
<span class="kn">import</span> <span class="nn">onnxruntime</span>
<span class="n">sess</span> <span class="o">=</span> <span class="n">onnxruntime</span><span class="o">.</span><span class="n">InferenceSession</span><span class="p">(</span><span class="s1">&#39;inplace_assign.onnx&#39;</span><span class="p">)</span>
<span class="n">out_ort</span> <span class="o">=</span> <span class="n">sess</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="p">{</span>
    <span class="n">sess</span><span class="o">.</span><span class="n">get_inputs</span><span class="p">()[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">:</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">4</span><span class="p">)</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span>
    <span class="n">sess</span><span class="o">.</span><span class="n">get_inputs</span><span class="p">()[</span><span class="mi">1</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">:</span> <span class="n">new_data</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span>
<span class="p">})</span>

<span class="k">assert</span> <span class="n">torch</span><span class="o">.</span><span class="n">all</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">eq</span><span class="p">(</span><span class="n">out</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="n">out_ort</span><span class="p">)))</span>
</pre></div>
</div>
<p>Below is the list of supported patterns for LHS indexing.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Scalar indices</span>
<span class="n">data</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="o">=</span> <span class="n">new_data</span>

<span class="c1"># Slice indices</span>
<span class="n">data</span><span class="p">[:</span><span class="mi">3</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_data</span>

<span class="c1"># Tensor indices</span>
<span class="c1"># If more than one tensor are used as indices, only consecutive 1-d tensor indices are supported.</span>
<span class="n">data</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">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]])]</span> <span class="o">=</span> <span class="n">new_data</span>
<span class="n">data</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">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])]</span> <span class="o">=</span> <span class="n">new_data</span>

<span class="c1"># Ellipsis</span>
<span class="c1"># Not supported to export in script modules</span>
<span class="c1"># i.e. torch.onnx.export(torch.jit.script(model)) will fail if model contains this pattern.</span>
<span class="c1"># Export is supported under tracing</span>
<span class="c1"># i.e. torch.onnx.export(model)</span>
<span class="n">data</span><span class="p">[</span><span class="o">...</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_data</span>

<span class="c1"># The combination of above</span>
<span class="n">data</span><span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="o">...</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="mi">3</span><span class="p">]),</span> <span class="mi">2</span><span class="p">:</span><span class="mi">4</span><span class="p">]</span> <span class="o">+=</span> <span class="n">update</span>

<span class="c1"># Boolean mask</span>
<span class="n">data</span><span class="p">[</span><span class="n">data</span> <span class="o">!=</span> <span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_data</span>
</pre></div>
</div>
<p>And below is the list of unsupported patterns for LHS indexing.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Multiple tensor indices if any has rank &gt;= 2</span>
<span class="n">data</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">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">3</span><span class="p">])]</span> <span class="o">=</span> <span class="n">new_data</span>

<span class="c1"># Multiple tensor indices that are not consecutive</span>
<span class="n">data</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="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="o">=</span> <span class="n">new_data</span>

<span class="c1"># Tensor indices that includes negative values.</span>
<span class="n">data</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="o">-</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="o">-</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">new_data</span>
</pre></div>
</div>
<p>If you are experiencing issues exporting indexing that belongs to the above supported patterns, please double check that
you are exporting with the latest opset (opset_version=12).</p>
</div>
</div>
<div class="section" id="torchvision-support">
<h2><a class="toc-backref" href="#id10">TorchVision support</a><a class="headerlink" href="#torchvision-support" title="Permalink to this headline">¶</a></h2>
<p>All TorchVision models, except for quantized versions, are exportable to ONNX.
More details can be found in <a class="reference external" href="torchvision/models.html">TorchVision</a>.</p>
</div>
<div class="section" id="limitations">
<h2><a class="toc-backref" href="#id11">Limitations</a><a class="headerlink" href="#limitations" title="Permalink to this headline">¶</a></h2>
<ul class="simple">
<li><p>Only tuples, lists and Variables are supported as JIT inputs/outputs. Dictionaries and strings are also accepted
but their usage is not recommended. Users need to verify their dict inputs carefully, and keep in mind that
dynamic lookups are not available.</p></li>
<li><p>PyTorch and ONNX backends(Caffe2, ONNX Runtime, etc) often have implementations of operators with some
numeric differences.  Depending on model structure, these differences
may be negligible, but they can also cause major divergences in behavior
(especially on untrained models.)  We allow Caffe2 to call directly to Torch implementations of operators, to
help you smooth over these differences when precision is important,
and to also document these differences.</p></li>
</ul>
</div>
<div class="section" id="supported-operators">
<h2><a class="toc-backref" href="#id12">Supported operators</a><a class="headerlink" href="#supported-operators" title="Permalink to this headline">¶</a></h2>
<p>The following operators are supported:</p>
<ul class="simple">
<li><p>BatchNorm</p></li>
<li><p>ConstantPadNd</p></li>
<li><p>Conv</p></li>
<li><p>Dropout</p></li>
<li><p>Embedding (no optional arguments supported)</p></li>
<li><p>EmbeddingBag</p></li>
<li><p>FeatureDropout (training mode not supported)</p></li>
<li><p>Index</p></li>
<li><p>MaxPool1d</p></li>
<li><p>MaxPool2d</p></li>
<li><p>MaxPool3d</p></li>
<li><p>RNN</p></li>
<li><p>abs</p></li>
<li><p>absolute</p></li>
<li><p>acos</p></li>
<li><p>adaptive_avg_pool1d</p></li>
<li><p>adaptive_avg_pool2d</p></li>
<li><p>adaptive_avg_pool3d</p></li>
<li><p>adaptive_max_pool1d</p></li>
<li><p>adaptive_max_pool2d</p></li>
<li><p>adaptive_max_pool3d</p></li>
<li><p>add (nonzero alpha not supported)</p></li>
<li><p>addmm</p></li>
<li><p>and</p></li>
<li><p>arange</p></li>
<li><p>argmax</p></li>
<li><p>argmin</p></li>
<li><p>asin</p></li>
<li><p>atan</p></li>
<li><p>avg_pool1d</p></li>
<li><p>avg_pool2d</p></li>
<li><p>avg_pool2d</p></li>
<li><p>avg_pool3d</p></li>
<li><p>as_strided</p></li>
<li><p>baddbmm</p></li>
<li><p>bitshift</p></li>
<li><p>cat</p></li>
<li><p>ceil</p></li>
<li><p>celu</p></li>
<li><p>clamp</p></li>
<li><p>clamp_max</p></li>
<li><p>clamp_min</p></li>
<li><p>concat</p></li>
<li><p>copy</p></li>
<li><p>cos</p></li>
<li><p>cumsum</p></li>
<li><p>det</p></li>
<li><p>dim_arange</p></li>
<li><p>div</p></li>
<li><p>dropout</p></li>
<li><p>einsum</p></li>
<li><p>elu</p></li>
<li><p>empty</p></li>
<li><p>empty_like</p></li>
<li><p>eq</p></li>
<li><p>erf</p></li>
<li><p>exp</p></li>
<li><p>expand</p></li>
<li><p>expand_as</p></li>
<li><p>eye</p></li>
<li><p>flatten</p></li>
<li><p>floor</p></li>
<li><p>floor_divide</p></li>
<li><p>frobenius_norm</p></li>
<li><p>full</p></li>
<li><p>full_like</p></li>
<li><p>gather</p></li>
<li><p>ge</p></li>
<li><p>gelu</p></li>
<li><p>glu</p></li>
<li><p>group_norm</p></li>
<li><p>gt</p></li>
<li><p>hardswish</p></li>
<li><p>hardtanh</p></li>
<li><p>im2col</p></li>
<li><p>index_copy</p></li>
<li><p>index_fill</p></li>
<li><p>index_put</p></li>
<li><p>index_select</p></li>
<li><p>instance_norm</p></li>
<li><p>interpolate</p></li>
<li><p>isnan</p></li>
<li><p>KLDivLoss</p></li>
<li><p>layer_norm</p></li>
<li><p>le</p></li>
<li><p>leaky_relu</p></li>
<li><p>len</p></li>
<li><p>log</p></li>
<li><p>log1p</p></li>
<li><p>log2</p></li>
<li><p>log_sigmoid</p></li>
<li><p>log_softmax</p></li>
<li><p>logdet</p></li>
<li><p>logsumexp</p></li>
<li><p>lt</p></li>
<li><p>masked_fill</p></li>
<li><p>masked_scatter</p></li>
<li><p>masked_select</p></li>
<li><p>max</p></li>
<li><p>mean</p></li>
<li><p>min</p></li>
<li><p>mm</p></li>
<li><p>mul</p></li>
<li><p>multinomial</p></li>
<li><p>narrow</p></li>
<li><p>ne</p></li>
<li><p>neg</p></li>
<li><p>new_empty</p></li>
<li><p>new_full</p></li>
<li><p>new_zeros</p></li>
<li><p>nll_loss</p></li>
<li><p>nonzero</p></li>
<li><p>norm</p></li>
<li><p>ones</p></li>
<li><p>ones_like</p></li>
<li><p>or</p></li>
<li><p>permute</p></li>
<li><p>pixel_shuffle</p></li>
<li><p>pow</p></li>
<li><p>prelu (single weight shared among input channels not supported)</p></li>
<li><p>prod</p></li>
<li><p>rand</p></li>
<li><p>randn</p></li>
<li><p>randn_like</p></li>
<li><p>reciprocal</p></li>
<li><p>reflection_pad</p></li>
<li><p>relu</p></li>
<li><p>repeat</p></li>
<li><p>replication_pad</p></li>
<li><p>reshape</p></li>
<li><p>reshape_as</p></li>
<li><p>round</p></li>
<li><p>rrelu</p></li>
<li><p>rsqrt</p></li>
<li><p>rsub</p></li>
<li><p>scalar_tensor</p></li>
<li><p>scatter</p></li>
<li><p>scatter_add</p></li>
<li><p>select</p></li>
<li><p>selu</p></li>
<li><p>sigmoid</p></li>
<li><p>sign</p></li>
<li><p>sin</p></li>
<li><p>size</p></li>
<li><p>slice</p></li>
<li><p>softmax</p></li>
<li><p>softplus</p></li>
<li><p>sort</p></li>
<li><p>split</p></li>
<li><p>sqrt</p></li>
<li><p>squeeze</p></li>
<li><p>stack</p></li>
<li><p>std</p></li>
<li><p>sub (nonzero alpha not supported)</p></li>
<li><p>sum</p></li>
<li><p>t</p></li>
<li><p>tan</p></li>
<li><p>tanh</p></li>
<li><p>threshold (non-zero threshold/non-zero value not supported)</p></li>
<li><p>to</p></li>
<li><p>topk</p></li>
<li><p>transpose</p></li>
<li><p>true_divide</p></li>
<li><p>type_as</p></li>
<li><p>unbind</p></li>
<li><p>unfold (experimental support with ATen-Caffe2 integration)</p></li>
<li><p>unique</p></li>
<li><p>unsqueeze</p></li>
<li><p>upsample_nearest1d</p></li>
<li><p>upsample_nearest2d</p></li>
<li><p>upsample_nearest3d</p></li>
<li><p>view</p></li>
<li><p>weight_norm</p></li>
<li><p>where</p></li>
<li><p>zeros</p></li>
<li><p>zeros_like</p></li>
</ul>
<p>The operator set above is sufficient to export the following models:</p>
<ul class="simple">
<li><p>AlexNet</p></li>
<li><p>DCGAN</p></li>
<li><p>DenseNet</p></li>
<li><p>Inception (warning: this model is highly sensitive to changes in operator
implementation)</p></li>
<li><p>ResNet</p></li>
<li><p>SuperResolution</p></li>
<li><p>VGG</p></li>
<li><p><a class="reference external" href="https://github.com/pytorch/examples/tree/master/word_language_model">word_language_model</a></p></li>
</ul>
</div>
<div class="section" id="adding-support-for-operators">
<h2><a class="toc-backref" href="#id13">Adding support for operators</a><a class="headerlink" href="#adding-support-for-operators" title="Permalink to this headline">¶</a></h2>
<p>Adding export support for operators is an <em>advance usage</em>.</p>
<p>To achieve this, developers need to touch the source code of PyTorch.
Please follow the <a class="reference external" href="https://github.com/pytorch/pytorch#from-source">instructions</a>
for installing PyTorch from source.
If the wanted operator is standardized in ONNX, it should be easy to add
support for exporting such operator (adding a symbolic function for the operator).
To confirm whether the operator is standardized or not, please check the
<a class="reference external" href="https://github.com/onnx/onnx/blob/master/docs/Operators.md">ONNX operator list</a>.</p>
<div class="section" id="aten-operators">
<h3><a class="toc-backref" href="#id14">ATen operators</a><a class="headerlink" href="#aten-operators" title="Permalink to this headline">¶</a></h3>
<p>If the operator is an ATen operator, which means you can find the declaration
of the function in <code class="docutils literal notranslate"><span class="pre">torch/csrc/autograd/generated/VariableType.h</span></code>
(available in generated code in PyTorch install dir), you should add the symbolic
function in <code class="docutils literal notranslate"><span class="pre">torch/onnx/symbolic_opset&lt;version&gt;.py</span></code> and follow the instructions listed as below:</p>
<ul class="simple">
<li><p>Define the symbolic function in <code class="docutils literal notranslate"><span class="pre">torch/onnx/symbolic_opset&lt;version&gt;.py</span></code>, for example
<a class="reference external" href="https://github.com/pytorch/pytorch/blob/master/torch/onnx/symbolic_opset9.py">torch/onnx/symbolic_opset9.py</a>.
Make sure the function has the same name as the ATen operator/function
defined in <code class="docutils literal notranslate"><span class="pre">VariableType.h</span></code>.</p></li>
<li><p>The first parameter is always the exported ONNX graph.
Parameter names must EXACTLY match the names in <code class="docutils literal notranslate"><span class="pre">VariableType.h</span></code>,
because dispatch is done with keyword arguments.</p></li>
<li><p>Parameter ordering does NOT necessarily match what is in <code class="docutils literal notranslate"><span class="pre">VariableType.h</span></code>,
tensors (inputs) are always first, then non-tensor arguments.</p></li>
<li><p>In the symbolic function, if the operator is already standardized in ONNX,
we only need to create a node to represent the ONNX operator in the graph.</p></li>
<li><p>If the input argument is a tensor, but ONNX asks for a scalar, we have to
explicitly do the conversion. The helper function <code class="docutils literal notranslate"><span class="pre">_scalar</span></code> can convert a
scalar tensor into a python scalar, and <code class="docutils literal notranslate"><span class="pre">_if_scalar_type_as</span></code> can turn a
Python scalar into a PyTorch tensor.</p></li>
</ul>
</div>
<div class="section" id="non-aten-operators">
<h3><a class="toc-backref" href="#id15">Non-ATen operators</a><a class="headerlink" href="#non-aten-operators" title="Permalink to this headline">¶</a></h3>
<p>If the operator is a non-ATen operator, the symbolic function has to be
added in the corresponding PyTorch Function class. Please read the following
instructions:</p>
<ul class="simple">
<li><p>Create a symbolic function named <code class="docutils literal notranslate"><span class="pre">symbolic</span></code> in the corresponding Function class.</p></li>
<li><p>The first parameter is always the exported ONNX graph.</p></li>
<li><p>Parameter names except the first must EXACTLY match the names in <code class="docutils literal notranslate"><span class="pre">forward</span></code>.</p></li>
<li><p>The output tuple size must match the outputs of <code class="docutils literal notranslate"><span class="pre">forward</span></code>.</p></li>
<li><p>In the symbolic function, if the operator is already standardized in ONNX,
we just need to create a node to represent the ONNX operator in the graph.</p></li>
</ul>
<p>Symbolic functions should be implemented in Python. All of these functions interact
with Python methods which are implemented via C++-Python bindings,
but intuitively the interface they provide looks like this:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">operator</span><span class="o">/</span><span class="n">symbolic</span><span class="p">(</span><span class="n">g</span><span class="p">,</span> <span class="o">*</span><span class="n">inputs</span><span class="p">):</span>
  <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">  Modifies Graph (e.g., using &quot;op&quot;), adding the ONNX operations representing</span>
<span class="sd">  this PyTorch function, and returning a Value or tuple of Values specifying the</span>
<span class="sd">  ONNX outputs whose values correspond to the original PyTorch return values</span>
<span class="sd">  of the autograd Function (or None if an output is not supported by ONNX).</span>

<span class="sd">  Args:</span>
<span class="sd">    g (Graph): graph to write the ONNX representation into</span>
<span class="sd">    inputs (Value...): list of values representing the variables which contain</span>
<span class="sd">        the inputs for this function</span>
<span class="sd">  &quot;&quot;&quot;</span>

<span class="k">class</span> <span class="nc">Value</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
  <span class="sd">&quot;&quot;&quot;Represents an intermediate tensor value computed in ONNX.&quot;&quot;&quot;</span>
  <span class="k">def</span> <span class="nf">type</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;Returns the Type of the value.&quot;&quot;&quot;</span>

<span class="k">class</span> <span class="nc">Type</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
  <span class="k">def</span> <span class="nf">sizes</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;Returns a tuple of ints representing the shape of a tensor this describes.&quot;&quot;&quot;</span>

<span class="k">class</span> <span class="nc">Graph</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
  <span class="k">def</span> <span class="nf">op</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">opname</span><span class="p">,</span> <span class="o">*</span><span class="n">inputs</span><span class="p">,</span> <span class="o">**</span><span class="n">attrs</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    Create an ONNX operator &#39;opname&#39;, taking &#39;args&#39; as inputs</span>
<span class="sd">    and attributes &#39;kwargs&#39; and add it as a node to the current graph,</span>
<span class="sd">    returning the value representing the single output of this</span>
<span class="sd">    operator (see the `outputs` keyword argument for multi-return</span>
<span class="sd">    nodes).</span>

<span class="sd">    The set of operators and the inputs/attributes they take</span>
<span class="sd">    is documented at https://github.com/onnx/onnx/blob/master/docs/Operators.md</span>

<span class="sd">    Args:</span>
<span class="sd">        opname (string): The ONNX operator name, e.g., `Abs` or `Add`.</span>
<span class="sd">        args (Value...): The inputs to the operator; usually provided</span>
<span class="sd">            as arguments to the `symbolic` definition.</span>
<span class="sd">        kwargs: The attributes of the ONNX operator, with keys named</span>
<span class="sd">            according to the following convention: `alpha_f` indicates</span>
<span class="sd">            the `alpha` attribute with type `f`.  The valid type specifiers are</span>
<span class="sd">            `f` (float), `i` (int), `s` (string) or `t` (Tensor).  An attribute</span>
<span class="sd">            specified with type float accepts either a single float, or a</span>
<span class="sd">            list of floats (e.g., you would say `dims_i` for a `dims` attribute</span>
<span class="sd">            that takes a list of integers).</span>
<span class="sd">        outputs (int, optional):  The number of outputs this operator returns;</span>
<span class="sd">            by default an operator is assumed to return a single output.</span>
<span class="sd">            If `outputs` is greater than one, this functions returns a tuple</span>
<span class="sd">            of output `Value`, representing each output of the ONNX operator</span>
<span class="sd">            in positional.</span>
<span class="sd">    &quot;&quot;&quot;</span>
</pre></div>
</div>
<p>The ONNX graph C++ definition is in <code class="docutils literal notranslate"><span class="pre">torch/csrc/jit/ir/ir.h</span></code>.</p>
<p>Here is an example of handling missing symbolic function for <code class="docutils literal notranslate"><span class="pre">elu</span></code> operator.
We try to export the model and see the error message as below:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="ne">UserWarning</span><span class="p">:</span> <span class="n">ONNX</span> <span class="n">export</span> <span class="n">failed</span> <span class="n">on</span> <span class="n">elu</span> <span class="n">because</span> <span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">symbolic_opset9</span><span class="o">.</span><span class="n">elu</span> <span class="n">does</span> <span class="ow">not</span> <span class="n">exist</span>
<span class="ne">RuntimeError</span><span class="p">:</span> <span class="n">ONNX</span> <span class="n">export</span> <span class="n">failed</span><span class="p">:</span> <span class="n">Couldn</span><span class="s1">&#39;t export operator elu</span>
</pre></div>
</div>
<p>The export fails because PyTorch does not support exporting <code class="docutils literal notranslate"><span class="pre">elu</span></code> operator.
We find <code class="docutils literal notranslate"><span class="pre">virtual</span> <span class="pre">Tensor</span> <span class="pre">elu(const</span> <span class="pre">Tensor</span> <span class="pre">&amp;</span> <span class="pre">input,</span> <span class="pre">Scalar</span> <span class="pre">alpha,</span> <span class="pre">bool</span> <span class="pre">inplace)</span> <span class="pre">const</span> <span class="pre">override;</span></code>
in <code class="docutils literal notranslate"><span class="pre">VariableType.h</span></code>. This means <code class="docutils literal notranslate"><span class="pre">elu</span></code> is an ATen operator.
We check the <a class="reference external" href="https://github.com/onnx/onnx/blob/master/docs/Operators.md">ONNX operator list</a>,
and confirm that <code class="docutils literal notranslate"><span class="pre">Elu</span></code> is standardized in ONNX.
We add the following lines to <code class="docutils literal notranslate"><span class="pre">symbolic_opset9.py</span></code>:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">elu</span><span class="p">(</span><span class="n">g</span><span class="p">,</span> <span class="nb">input</span><span class="p">,</span> <span class="n">alpha</span><span class="p">,</span> <span class="n">inplace</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">g</span><span class="o">.</span><span class="n">op</span><span class="p">(</span><span class="s2">&quot;Elu&quot;</span><span class="p">,</span> <span class="nb">input</span><span class="p">,</span> <span class="n">alpha_f</span><span class="o">=</span><span class="n">_scalar</span><span class="p">(</span><span class="n">alpha</span><span class="p">))</span>
</pre></div>
</div>
<p>Now PyTorch is able to export <code class="docutils literal notranslate"><span class="pre">elu</span></code> operator.</p>
<p>There are more examples in
<a class="reference external" href="https://github.com/pytorch/pytorch/blob/master/torch/onnx/symbolic_opset9.py">symbolic_opset9.py</a>,
<a class="reference external" href="https://github.com/pytorch/pytorch/blob/master/torch/onnx/symbolic_opset10.py">symbolic_opset10.py</a>.</p>
<p>The interface for specifying operator definitions is experimental;
adventurous users should note that the APIs will probably
change in a future interface.</p>
</div>
<div class="section" id="custom-operators">
<h3><a class="toc-backref" href="#id16">Custom operators</a><a class="headerlink" href="#custom-operators" title="Permalink to this headline">¶</a></h3>
<p>Following this tutorial <a class="reference external" href="https://pytorch.org/tutorials/advanced/torch_script_custom_ops.html">Extending TorchScript with Custom C++ Operators</a>,
you can create and register your own custom ops implementation in PyTorch. Here’s how to export such model to ONNX.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Create custom symbolic function</span>
<span class="kn">from</span> <span class="nn">torch.onnx.symbolic_helper</span> <span class="kn">import</span> <span class="n">parse_args</span>
<span class="nd">@parse_args</span><span class="p">(</span><span class="s1">&#39;v&#39;</span><span class="p">,</span> <span class="s1">&#39;v&#39;</span><span class="p">,</span> <span class="s1">&#39;f&#39;</span><span class="p">,</span> <span class="s1">&#39;i&#39;</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">symbolic_foo_forward</span><span class="p">(</span><span class="n">g</span><span class="p">,</span> <span class="n">input1</span><span class="p">,</span> <span class="n">input2</span><span class="p">,</span> <span class="n">attr1</span><span class="p">,</span> <span class="n">attr2</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">g</span><span class="o">.</span><span class="n">op</span><span class="p">(</span><span class="s2">&quot;Foo&quot;</span><span class="p">,</span> <span class="n">input1</span><span class="p">,</span> <span class="n">input2</span><span class="p">,</span> <span class="n">attr1_f</span><span class="o">=</span><span class="n">attr1</span><span class="p">,</span> <span class="n">attr2_i</span><span class="o">=</span><span class="n">attr2</span><span class="p">)</span>

<span class="c1"># Register custom symbolic function</span>
<span class="kn">from</span> <span class="nn">torch.onnx</span> <span class="kn">import</span> <span class="n">register_custom_op_symbolic</span>
<span class="n">register_custom_op_symbolic</span><span class="p">(</span><span class="s1">&#39;custom_ops::foo_forward&#39;</span><span class="p">,</span> <span class="n">symbolic_foo_forward</span><span class="p">,</span> <span class="mi">9</span><span class="p">)</span>

<span class="k">class</span> <span class="nc">FooModel</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">attr1</span><span class="p">,</span> <span class="n">attr2</span><span class="p">):</span>
        <span class="nb">super</span><span class="p">(</span><span class="n">FooModule</span><span class="p">,</span> <span class="bp">self</span><span class="p">)</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">attr1</span> <span class="o">=</span> <span class="n">attr1</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">attr2</span> <span class="o">=</span> <span class="n">attr2</span>

    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">input1</span><span class="p">,</span> <span class="n">input2</span><span class="p">):</span>
        <span class="c1"># Calling custom op</span>
        <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">ops</span><span class="o">.</span><span class="n">custom_ops</span><span class="o">.</span><span class="n">foo_forward</span><span class="p">(</span><span class="n">input1</span><span class="p">,</span> <span class="n">input2</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">attr1</span><span class="p">,</span> <span class="bp">self</span><span class="o">.</span><span class="n">attr2</span><span class="p">)</span>

<span class="n">model</span> <span class="o">=</span> <span class="n">FooModel</span><span class="p">(</span><span class="n">attr1</span><span class="p">,</span> <span class="n">attr2</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="p">(</span><span class="n">dummy_input1</span><span class="p">,</span> <span class="n">dummy_input2</span><span class="p">),</span> <span class="s1">&#39;model.onnx&#39;</span><span class="p">,</span> <span class="n">custom_opsets</span><span class="o">=</span><span class="p">{</span><span class="s2">&quot;custom_domain&quot;</span><span class="p">:</span> <span class="mi">2</span><span class="p">})</span>
</pre></div>
</div>
<p>Depending on the custom operator, you can export it as one or a combination of existing ONNX ops.
You can also export it as a custom op in ONNX as well. In that case, you can specify the custom domain
and version (custom opset) using the <code class="docutils literal notranslate"><span class="pre">custom_opsets</span></code> dictionary at export. If not
explicitly specified, the custom opset version is set to 1 by default.
Using custom ONNX ops, you will need to extend the backend of your choice
with matching custom ops implementation, e.g. <a class="reference external" href="https://caffe2.ai/docs/custom-operators.html">Caffe2 custom ops</a>,
<a class="reference external" href="https://github.com/microsoft/onnxruntime/blob/master/docs/AddingCustomOp.md">ONNX Runtime custom ops</a>.</p>
</div>
</div>
<div class="section" id="operator-export-type">
<h2><a class="toc-backref" href="#id17">Operator Export Type</a><a class="headerlink" href="#operator-export-type" title="Permalink to this headline">¶</a></h2>
<p>Exporting models with unsupported ONNX operators can be achieved using the <code class="docutils literal notranslate"><span class="pre">operator_export_type</span></code> flag in export API.
This flag is useful when users try to export ATen and non-ATen operators that are not registered and supported in ONNX.</p>
<div class="section" id="id2">
<h3><a class="toc-backref" href="#id18">ONNX</a><a class="headerlink" href="#id2" title="Permalink to this headline">¶</a></h3>
<p>This mode is used to export all operators as regular ONNX operators. This is the default <code class="docutils literal notranslate"><span class="pre">operator_export_type</span></code> mode.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Example</span> <span class="n">torch</span> <span class="n">ir</span> <span class="n">graph</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">aten</span><span class="p">:</span><span class="n">exp</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">)</span>
    <span class="o">%</span><span class="mi">4</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">aten</span><span class="p">:</span><span class="n">div</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">3</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">4</span><span class="p">)</span>

<span class="n">Is</span> <span class="n">exported</span> <span class="k">as</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">onnx</span><span class="p">:</span><span class="n">Exp</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">)</span>
    <span class="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">onnx</span><span class="p">:</span><span class="n">Div</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">2</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="onnx-aten">
<h3><a class="toc-backref" href="#id19">ONNX_ATEN</a><a class="headerlink" href="#onnx-aten" title="Permalink to this headline">¶</a></h3>
<p>This mode is used to export all operators as ATen ops, and avoid conversion to ONNX.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Example</span> <span class="n">torch</span> <span class="n">ir</span> <span class="n">graph</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">exp</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">)</span>
    <span class="o">%</span><span class="mi">4</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">div</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">3</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">4</span><span class="p">)</span>

<span class="n">Is</span> <span class="n">exported</span> <span class="k">as</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">ATen</span><span class="p">[</span><span class="n">operator</span><span class="o">=</span><span class="s2">&quot;exp&quot;</span><span class="p">](</span><span class="o">%</span><span class="mi">0</span><span class="p">)</span>
    <span class="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">ATen</span><span class="p">[</span><span class="n">operator</span><span class="o">=</span><span class="s2">&quot;div&quot;</span><span class="p">](</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">2</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="onnx-aten-fallback">
<h3><a class="toc-backref" href="#id20">ONNX_ATEN_FALLBACK</a><a class="headerlink" href="#onnx-aten-fallback" title="Permalink to this headline">¶</a></h3>
<p>To fallback on unsupported ATen operators in ONNX. Supported operators are exported to ONNX regularly.
In the following example, aten::triu is not supported in ONNX. Exporter falls back on this operator.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Example</span> <span class="n">torch</span> <span class="n">ir</span> <span class="n">graph</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</span><span class="p">):</span>
    <span class="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="n">prim</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="mi">0</span><span class="p">]()</span>
    <span class="o">%</span><span class="mi">4</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">triu</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">3</span><span class="p">)</span> <span class="c1"># unsupported op</span>
    <span class="o">%</span><span class="mi">5</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">mul</span><span class="p">(</span><span class="o">%</span><span class="mi">4</span><span class="p">,</span> <span class="o">%</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># registered op</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">5</span><span class="p">)</span>

<span class="ow">is</span> <span class="n">exported</span> <span class="k">as</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</span><span class="p">):</span>
    <span class="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Long</span><span class="p">()</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">0</span><span class="p">}]()</span>
    <span class="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">ATen</span><span class="p">[</span><span class="n">operator</span><span class="o">=</span><span class="s2">&quot;triu&quot;</span><span class="p">](</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># unsupported op</span>
    <span class="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Mul</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">0</span><span class="p">)</span> <span class="c1"># registered op</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">3</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="raw">
<h3><a class="toc-backref" href="#id21">RAW</a><a class="headerlink" href="#raw" title="Permalink to this headline">¶</a></h3>
<p>To export a raw ir.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Example</span> <span class="n">torch</span> <span class="n">ir</span> <span class="n">graph</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">])):</span>
    <span class="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">exp</span><span class="p">(</span><span class="o">%</span><span class="n">x</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="n">Tensor</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">div</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span>
    <span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Tensor</span><span class="p">[]</span> <span class="o">=</span> <span class="n">prim</span><span class="p">::</span><span class="n">ListConstruct</span><span class="p">(</span><span class="o">%</span><span class="mi">2</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span><span class="p">)</span>

<span class="ow">is</span> <span class="n">exported</span> <span class="k">as</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Float</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">])):</span>
    <span class="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">exp</span><span class="p">(</span><span class="o">%</span><span class="n">x</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="n">Tensor</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">div</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span>
    <span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Tensor</span><span class="p">[]</span> <span class="o">=</span> <span class="n">prim</span><span class="p">::</span><span class="n">ListConstruct</span><span class="p">(</span><span class="o">%</span><span class="mi">2</span><span class="p">)</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="onnx-fallthrough">
<h3><a class="toc-backref" href="#id22">ONNX_FALLTHROUGH</a><a class="headerlink" href="#onnx-fallthrough" title="Permalink to this headline">¶</a></h3>
<p>This mode can be used to export any operator (ATen or non-ATen) that is not registered and supported in ONNX.
Exported falls through and exports the operator as is, as custom op. Exporting custom operators
enables users to register and implement the operator as part of their runtime backend.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Example</span> <span class="n">torch</span> <span class="n">ir</span> <span class="n">graph</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">6</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">foo_namespace</span><span class="p">::</span><span class="n">bar</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># custom op</span>
    <span class="o">%</span><span class="mi">7</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">div</span><span class="p">(</span><span class="o">%</span><span class="mi">6</span><span class="p">,</span> <span class="o">%</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># registered op</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">7</span><span class="p">))</span>

<span class="ow">is</span> <span class="n">exported</span> <span class="k">as</span><span class="p">:</span>

  <span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">foo_namespace</span><span class="p">::</span><span class="n">bar</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span> <span class="c1"># custom op</span>
    <span class="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="n">Float</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="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">12</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="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Div</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">0</span><span class="p">)</span> <span class="c1"># registered op</span>
    <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">3</span>
</pre></div>
</div>
</div>
</div>
<div class="section" id="frequently-asked-questions">
<h2><a class="toc-backref" href="#id23">Frequently Asked Questions</a><a class="headerlink" href="#frequently-asked-questions" title="Permalink to this headline">¶</a></h2>
<p>Q: I have exported my lstm model, but its input size seems to be fixed?</p>
<blockquote>
<div><p>The tracer records the example inputs shape in the graph. In case the model should accept
inputs of dynamic shape, you can utilize the parameter <cite>dynamic_axes</cite> in export api.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">layer_count</span> <span class="o">=</span> <span class="mi">4</span>

<span class="n">model</span> <span class="o">=</span> <span class="n">nn</span><span class="o">.</span><span class="n">LSTM</span><span class="p">(</span><span class="mi">10</span><span class="p">,</span> <span class="mi">20</span><span class="p">,</span> <span class="n">num_layers</span><span class="o">=</span><span class="n">layer_count</span><span class="p">,</span> <span class="n">bidirectional</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
<span class="n">model</span><span class="o">.</span><span class="n">eval</span><span class="p">()</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="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">5</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">h0</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="n">layer_count</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="mi">20</span><span class="p">)</span>
    <span class="n">c0</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="n">layer_count</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="mi">20</span><span class="p">)</span>
    <span class="n">output</span><span class="p">,</span> <span class="p">(</span><span class="n">hn</span><span class="p">,</span> <span class="n">cn</span><span class="p">)</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="nb">input</span><span class="p">,</span> <span class="p">(</span><span class="n">h0</span><span class="p">,</span> <span class="n">c0</span><span class="p">))</span>

    <span class="c1"># default export</span>
    <span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="p">(</span><span class="nb">input</span><span class="p">,</span> <span class="p">(</span><span class="n">h0</span><span class="p">,</span> <span class="n">c0</span><span class="p">)),</span> <span class="s1">&#39;lstm.onnx&#39;</span><span class="p">)</span>
    <span class="n">onnx_model</span> <span class="o">=</span> <span class="n">onnx</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;lstm.onnx&#39;</span><span class="p">)</span>
    <span class="c1"># input shape [5, 3, 10]</span>
    <span class="nb">print</span><span class="p">(</span><span class="n">onnx_model</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">input</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>

    <span class="c1"># export with `dynamic_axes`</span>
    <span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="p">(</span><span class="nb">input</span><span class="p">,</span> <span class="p">(</span><span class="n">h0</span><span class="p">,</span> <span class="n">c0</span><span class="p">)),</span> <span class="s1">&#39;lstm.onnx&#39;</span><span class="p">,</span>
                    <span class="n">input_names</span><span class="o">=</span><span class="p">[</span><span class="s1">&#39;input&#39;</span><span class="p">,</span> <span class="s1">&#39;h0&#39;</span><span class="p">,</span> <span class="s1">&#39;c0&#39;</span><span class="p">],</span>
                    <span class="n">output_names</span><span class="o">=</span><span class="p">[</span><span class="s1">&#39;output&#39;</span><span class="p">,</span> <span class="s1">&#39;hn&#39;</span><span class="p">,</span> <span class="s1">&#39;cn&#39;</span><span class="p">],</span>
                    <span class="n">dynamic_axes</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;input&#39;</span><span class="p">:</span> <span class="p">{</span><span class="mi">0</span><span class="p">:</span> <span class="s1">&#39;sequence&#39;</span><span class="p">},</span> <span class="s1">&#39;output&#39;</span><span class="p">:</span> <span class="p">{</span><span class="mi">0</span><span class="p">:</span> <span class="s1">&#39;sequence&#39;</span><span class="p">}})</span>
    <span class="n">onnx_model</span> <span class="o">=</span> <span class="n">onnx</span><span class="o">.</span><span class="n">load</span><span class="p">(</span><span class="s1">&#39;lstm.onnx&#39;</span><span class="p">)</span>
    <span class="c1"># input shape [&#39;sequence&#39;, 3, 10]</span>
    <span class="nb">print</span><span class="p">(</span><span class="n">onnx_model</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">input</span><span class="p">[</span><span class="mi">0</span><span class="p">])</span>
</pre></div>
</div>
</div></blockquote>
<p>Q: How to export models with loops in it?</p>
<blockquote>
<div><p>Please checkout <a class="reference internal" href="#tracing-vs-scripting">Tracing vs Scripting</a>.</p>
</div></blockquote>
<p>Q: Does ONNX support implicit scalar datatype casting?</p>
<blockquote>
<div><p>No, but the exporter will try to handle that part.  Scalars are converted to constant tensors in ONNX.
The exporter will try to figure out the right datatype for scalars.  However for cases that it failed
to do so, you will need to manually provide the datatype information.  This often happens with scripted models,
where the datatypes are not recorded.  We are trying to improve the datatype
propagation in the exporter such that manual changes are not required in the future.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">ImplicitCastType</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">jit</span><span class="o">.</span><span class="n">ScriptModule</span><span class="p">):</span>
    <span class="nd">@torch</span><span class="o">.</span><span class="n">jit</span><span class="o">.</span><span class="n">script_method</span>
    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="c1"># Exporter knows x is float32, will export &#39;2&#39; as float32 as well.</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="c1"># Without type propagation, exporter doesn&#39;t know the datatype of y.</span>
        <span class="c1"># Thus &#39;3&#39; is exported as int64 by default.</span>
        <span class="k">return</span> <span class="n">y</span> <span class="o">+</span> <span class="mi">3</span>
        <span class="c1"># The following will export correctly.</span>
        <span class="c1"># return y + torch.tensor([3], dtype=torch.float32)</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="mf">1.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">float32</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">ImplicitCastType</span><span class="p">(),</span> <span class="n">x</span><span class="p">,</span> <span class="s1">&#39;models/implicit_cast.onnx&#39;</span><span class="p">,</span>
                  <span class="n">example_outputs</span><span class="o">=</span><span class="n">ImplicitCastType</span><span class="p">()(</span><span class="n">x</span><span class="p">))</span>
</pre></div>
</div>
</div></blockquote>
<p>Q: Is tensor in-place indexed assignment like <cite>data[index] = new_data</cite> supported?</p>
<blockquote>
<div><p>Yes, this is supported for ONNX opset version &gt;= 11. Please checkout <a class="reference internal" href="#indexing">Indexing</a>.</p>
</div></blockquote>
<p>Q: Is tensor list exportable to ONNX?</p>
<blockquote>
<div><p>Yes, this is supported now for ONNX opset version &gt;= 11. ONNX introduced the concept of Sequence in opset 11.
Similar to list, Sequence is a data type that contains arbitrary number of Tensors.
Associated operators are also introduced in ONNX, such as SequenceInsert, SequenceAt, etc.
However, in-place list append within loops is not exportable to ONNX. To implement this, please use inplace
add operator.
E.g.:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">ListLoopModel</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">forward</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">x</span><span class="p">):</span>
        <span class="n">res</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="n">res1</span> <span class="o">=</span> <span class="p">[]</span>
        <span class="n">arr</span> <span class="o">=</span> <span class="n">x</span><span class="o">.</span><span class="n">split</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="n">res2</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">4</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="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">arr</span><span class="p">)):</span>
            <span class="n">res</span> <span class="o">+=</span> <span class="p">[</span><span class="n">arr</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="kc">False</span><span class="p">)]</span>
            <span class="n">res1</span> <span class="o">+=</span> <span class="p">[</span><span class="n">arr</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span> <span class="o">-</span> <span class="n">i</span><span class="p">]</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="kc">False</span><span class="p">)]</span>
            <span class="n">res2</span> <span class="o">+=</span> <span class="mi">1</span>
        <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">(</span><span class="n">res</span><span class="p">),</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">(</span><span class="n">res1</span><span class="p">),</span> <span class="n">res2</span>

<span class="n">model</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">jit</span><span class="o">.</span><span class="n">script</span><span class="p">(</span><span class="n">ListLoopModel</span><span class="p">())</span>
<span class="n">inputs</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">16</span><span class="p">)</span>

<span class="n">out</span> <span class="o">=</span> <span class="n">model</span><span class="p">(</span><span class="n">inputs</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="p">(</span><span class="n">inputs</span><span class="p">,</span> <span class="p">),</span> <span class="s1">&#39;loop_and_list.onnx&#39;</span><span class="p">,</span> <span class="n">opset_version</span><span class="o">=</span><span class="mi">11</span><span class="p">,</span> <span class="n">example_outputs</span><span class="o">=</span><span class="n">out</span><span class="p">)</span>

<span class="c1"># onnxruntime</span>
<span class="kn">import</span> <span class="nn">onnxruntime</span>
<span class="n">sess</span> <span class="o">=</span> <span class="n">onnxruntime</span><span class="o">.</span><span class="n">InferenceSession</span><span class="p">(</span><span class="s1">&#39;loop_and_list.onnx&#39;</span><span class="p">)</span>
<span class="n">out_ort</span> <span class="o">=</span> <span class="n">sess</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="kc">None</span><span class="p">,</span> <span class="p">{</span>
    <span class="n">sess</span><span class="o">.</span><span class="n">get_inputs</span><span class="p">()[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">name</span><span class="p">:</span> <span class="n">inputs</span><span class="o">.</span><span class="n">numpy</span><span class="p">(),</span>
<span class="p">})</span>

<span class="k">assert</span> <span class="p">[</span><span class="n">torch</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">o</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="n">o_ort</span><span class="p">))</span> <span class="k">for</span> <span class="n">o</span><span class="p">,</span> <span class="n">o_ort</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">out</span><span class="p">,</span> <span class="n">out_ort</span><span class="p">)]</span>
</pre></div>
</div>
</div></blockquote>
</div>
<div class="section" id="use-external-data-format">
<h2><a class="toc-backref" href="#id24">Use external data format</a><a class="headerlink" href="#use-external-data-format" title="Permalink to this headline">¶</a></h2>
<p><code class="docutils literal notranslate"><span class="pre">use_external_data_format</span></code> argument in export API enables export of models in ONNX external
data format. With this option enabled, the exporter stores some model parameters in external
binary files, rather than the ONNX file itself. These external binary files are stored in the
same location as the ONNX file. Argument ‘f’ must be a string specifying the location of the model.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">model</span> <span class="o">=</span> <span class="n">torchvision</span><span class="o">.</span><span class="n">models</span><span class="o">.</span><span class="n">mobilenet_v2</span><span class="p">(</span><span class="n">pretrained</span><span class="o">=</span><span class="kc">True</span><span class="p">)</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">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">224</span><span class="p">,</span> <span class="mi">224</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="n">torch</span><span class="o">.</span><span class="n">onnx</span><span class="o">.</span><span class="n">export</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="p">(</span><span class="nb">input</span><span class="p">,</span> <span class="p">),</span> <span class="s1">&#39;./large_model.onnx&#39;</span><span class="p">,</span> <span class="n">use_external_data_format</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
</pre></div>
</div>
<p>This argument enables export of large models to ONNX. Models larger than 2GB cannot be exported
in one file because of the protobuf size limit. Users should set <code class="docutils literal notranslate"><span class="pre">use_external_data_format</span></code> to
<code class="docutils literal notranslate"><span class="pre">True</span></code> to successfully export such models.</p>
</div>
<div class="section" id="training">
<h2><a class="toc-backref" href="#id25">Training</a><a class="headerlink" href="#training" title="Permalink to this headline">¶</a></h2>
<p><code class="docutils literal notranslate"><span class="pre">Training</span></code> argument in export API allows users to export models in a training-friendly mode.
<code class="docutils literal notranslate"><span class="pre">TrainingMode.TRAINING</span></code> exports model in a training-friendly mode that avoids certain model
optimizations which might interfere with model parameter training. <code class="docutils literal notranslate"><span class="pre">TrainingMode.PRESERVE</span></code>
exports the model in inference mode if <code class="docutils literal notranslate"><span class="pre">model.training</span></code> is <code class="docutils literal notranslate"><span class="pre">False</span></code>. Otherwise, it exports
the model in a training-friendly mode.
The default mode for this argument is <code class="docutils literal notranslate"><span class="pre">TrainingMode.EVAL</span></code> which exports the model in
inference mode.</p>
</div>
<div class="section" id="functions">
<h2><a class="toc-backref" href="#id26">Functions</a><a class="headerlink" href="#functions" title="Permalink to this headline">¶</a></h2>
<dl class="function">
<dt id="torch.onnx.export">
<code class="sig-prename descclassname">torch.onnx.</code><code class="sig-name descname">export</code><span class="sig-paren">(</span><em class="sig-param">model</em>, <em class="sig-param">args</em>, <em class="sig-param">f</em>, <em class="sig-param">export_params=True</em>, <em class="sig-param">verbose=False</em>, <em class="sig-param">training=&lt;TrainingMode.EVAL: 0&gt;</em>, <em class="sig-param">input_names=None</em>, <em class="sig-param">output_names=None</em>, <em class="sig-param">aten=False</em>, <em class="sig-param">export_raw_ir=False</em>, <em class="sig-param">operator_export_type=None</em>, <em class="sig-param">opset_version=None</em>, <em class="sig-param">_retain_param_name=True</em>, <em class="sig-param">do_constant_folding=True</em>, <em class="sig-param">example_outputs=None</em>, <em class="sig-param">strip_doc_string=True</em>, <em class="sig-param">dynamic_axes=None</em>, <em class="sig-param">keep_initializers_as_inputs=None</em>, <em class="sig-param">custom_opsets=None</em>, <em class="sig-param">enable_onnx_checker=True</em>, <em class="sig-param">use_external_data_format=False</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/onnx.html#export"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.onnx.export" title="Permalink to this definition">¶</a></dt>
<dd><p>Export a model into ONNX format.  This exporter runs your model
once in order to get a trace of its execution to be exported;
at the moment, it supports a limited set of dynamic models (e.g., RNNs.)</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>model</strong> (<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><em>torch.nn.Module</em></a>) – the model to be exported.</p></li>
<li><p><strong>args</strong> (<em>tuple of arguments</em><em> or </em><a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><em>torch.Tensor</em></a><em>, </em><em>a dictionary consisting of named arguments</em><em> (</em><em>optional</em><em>)</em>) – <p>a dictionary to specify the input to the corresponding named parameter:
- KEY: str, named parameter
- VALUE: corresponding input
args can be structured either as:</p>
<ol class="arabic">
<li><p>ONLY A TUPLE OF ARGUMENTS or torch.Tensor:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>‘’args = (x, y, z)’&#39;
</pre></div>
</div>
</li>
</ol>
<p>The inputs to the model, e.g., such that <code class="docutils literal notranslate"><span class="pre">model(*args)</span></code> is a valid invocation
of the model. Any non-Tensor arguments will be hard-coded into the exported model;
any Tensor arguments will become inputs of the exported model, in the order they
occur in args. If args is a Tensor, this is equivalent to having
called it with a 1-ary tuple of that Tensor.</p>
<ol class="arabic" start="2">
<li><p>A TUPLE OF ARGUEMENTS WITH A DICTIONARY OF NAMED PARAMETERS:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>‘’args = (x,
        {
        ‘y’: input_y,
        ‘z’: input_z
        }) ‘’
</pre></div>
</div>
</li>
</ol>
<p>The inputs to the model are structured as a tuple consisting of
non-keyword arguments and the last value of this tuple being a dictionary
consisting of named parameters and the corresponding inputs as key-value pairs.
If certain named argument is not present in the dictionary, it is assigned
the default value, or None if default value is not provided.</p>
<p>Cases in which an dictionary input is the last input of the args tuple
would cause a conflict when a dictionary of named parameters is used.
The model below provides such an example.</p>
<blockquote>
<div><dl class="simple">
<dt>class Model(torch.nn.Module):</dt><dd><dl class="simple">
<dt>def forward(self, k, x):</dt><dd><p>…
return x</p>
</dd>
</dl>
</dd>
</dl>
<p>m = Model()
k = torch.randn(2, 3)
x = {torch.tensor(1.): torch.randn(2, 3)}</p>
<p>In the previous iteration, the call to export API would look like</p>
<blockquote>
<div><p>torch.onnx.export(model, (k, x), ‘test.onnx’)</p>
</div></blockquote>
<p>This would work as intended. However, the export function
would now assume that the ‘x’ input is intended to represent the optional
dictionary consisting of named arguments. In order to prevent this from being
an issue a constraint is placed to provide an empty dictionary as the last
input in the tuple args in such cases. The new call would look like this.</p>
<blockquote>
<div><p>torch.onnx.export(model, (k, x, {}), ‘test.onnx’)</p>
</div></blockquote>
</div></blockquote>
</p></li>
<li><p><strong>f</strong> – a file-like object (has to implement fileno that returns a file descriptor)
or a string containing a file name.  A binary Protobuf will be written
to this file.</p></li>
<li><p><strong>export_params</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default True</em>) – if specified, all parameters will
be exported.  Set this to False if you want to export an untrained model.
In this case, the exported model will first take all of its parameters
as arguments, the ordering as specified by <code class="docutils literal notranslate"><span class="pre">model.state_dict().values()</span></code></p></li>
<li><p><strong>verbose</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default False</em>) – if specified, we will print out a debug
description of the trace being exported.</p></li>
<li><p><strong>training</strong> (<em>enum</em><em>, </em><em>default TrainingMode.EVAL</em>) – TrainingMode.EVAL: export the model in inference mode.
TrainingMode.PRESERVE: export the model in inference mode if model.training is
False and to a training friendly mode if model.training is True.
TrainingMode.TRAINING: export the model in a training friendly mode.</p></li>
<li><p><strong>input_names</strong> (<em>list of strings</em><em>, </em><em>default empty list</em>) – names to assign to the
input nodes of the graph, in order</p></li>
<li><p><strong>output_names</strong> (<em>list of strings</em><em>, </em><em>default empty list</em>) – names to assign to the
output nodes of the graph, in order</p></li>
<li><p><strong>aten</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default False</em>) – [DEPRECATED. use operator_export_type] export the
model in aten mode. If using aten mode, all the ops original exported
by the functions in symbolic_opset&lt;version&gt;.py are exported as ATen ops.</p></li>
<li><p><strong>export_raw_ir</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default False</em>) – [DEPRECATED. use operator_export_type]
export the internal IR directly instead of converting it to ONNX ops.</p></li>
<li><p><strong>operator_export_type</strong> (<em>enum</em><em>, </em><em>default OperatorExportTypes.ONNX</em>) – <p>OperatorExportTypes.ONNX: All ops are exported as regular ONNX ops
(with ONNX namespace).
OperatorExportTypes.ONNX_ATEN: All ops are exported as ATen ops
(with aten namespace).
OperatorExportTypes.ONNX_ATEN_FALLBACK: If an ATen op is not supported
in ONNX or its symbolic is missing, fall back on ATen op. Registered ops
are exported to ONNX regularly.
Example graph:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</span><span class="p">)::</span>
  <span class="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="n">prim</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="mi">0</span><span class="p">]()</span>
  <span class="o">%</span><span class="mi">4</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">triu</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">3</span><span class="p">)</span> <span class="c1"># missing op</span>
  <span class="o">%</span><span class="mi">5</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">mul</span><span class="p">(</span><span class="o">%</span><span class="mi">4</span><span class="p">,</span> <span class="o">%</span><span class="mi">0</span><span class="p">)</span> <span class="c1"># registered op</span>
  <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">5</span><span class="p">)</span>
</pre></div>
</div>
<p>is exported as:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="mi">0</span> <span class="p">:</span> <span class="n">Float</span><span class="p">)::</span>
  <span class="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Long</span><span class="p">()</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Constant</span><span class="p">[</span><span class="n">value</span><span class="o">=</span><span class="p">{</span><span class="mi">0</span><span class="p">}]()</span>
  <span class="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="n">ATen</span><span class="p">[</span><span class="n">operator</span><span class="o">=</span><span class="s2">&quot;triu&quot;</span><span class="p">](</span><span class="o">%</span><span class="mi">0</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span>  <span class="c1"># missing op</span>
  <span class="o">%</span><span class="mi">3</span> <span class="p">:</span> <span class="n">Float</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">Mul</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">0</span><span class="p">)</span> <span class="c1"># registered op</span>
  <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="mi">3</span><span class="p">)</span>
</pre></div>
</div>
<p>In the above example, aten::triu is not supported in ONNX, hence
exporter falls back on this op.
OperatorExportTypes.RAW: Export raw ir.
OperatorExportTypes.ONNX_FALLTHROUGH: If an op is not supported
in ONNX, fall through and export the operator as is, as a custom
ONNX op. Using this mode, the op can be exported and implemented by
the user for their runtime backend.
Example graph:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Long</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">]))::</span>
  <span class="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="kc">None</span> <span class="o">=</span> <span class="n">prim</span><span class="p">::</span><span class="n">Constant</span><span class="p">()</span>
  <span class="o">%</span><span class="mi">2</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">aten</span><span class="p">::</span><span class="nb">sum</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span><span class="p">,</span> <span class="o">%</span><span class="mi">1</span><span class="p">)</span>
  <span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Tensor</span><span class="p">[]</span> <span class="o">=</span> <span class="n">prim</span><span class="p">::</span><span class="n">ListConstruct</span><span class="p">(</span><span class="o">%</span><span class="mi">2</span><span class="p">)</span>
  <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span><span class="p">)</span>
</pre></div>
</div>
<p>is exported as:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">graph</span><span class="p">(</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Long</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="n">strides</span><span class="o">=</span><span class="p">[</span><span class="mi">1</span><span class="p">]))::</span>
  <span class="o">%</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Tensor</span> <span class="o">=</span> <span class="n">onnx</span><span class="p">::</span><span class="n">ReduceSum</span><span class="p">[</span><span class="n">keepdims</span><span class="o">=</span><span class="mi">0</span><span class="p">](</span><span class="o">%</span><span class="n">x</span><span class="o">.</span><span class="mi">1</span><span class="p">)</span>
  <span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span> <span class="p">:</span> <span class="n">Long</span><span class="p">()</span> <span class="o">=</span> <span class="n">prim</span><span class="p">::</span><span class="n">ListConstruct</span><span class="p">(</span><span class="o">%</span><span class="mi">1</span><span class="p">)</span>
  <span class="k">return</span> <span class="p">(</span><span class="o">%</span><span class="n">y</span><span class="o">.</span><span class="mi">1</span><span class="p">)</span>
</pre></div>
</div>
<p>In the above example, prim::ListConstruct is not supported, hence
exporter falls through.</p>
</p></li>
<li><p><strong>opset_version</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em>, </em><em>default is 9</em>) – by default we export the model to the
opset version of the onnx submodule. Since ONNX’s latest opset may
evolve before next stable release, by default we export to one stable
opset version. Right now, supported stable opset version is 9.
The opset_version must be _onnx_main_opset or in _onnx_stable_opsets
which are defined in torch/onnx/symbolic_helper.py</p></li>
<li><p><strong>do_constant_folding</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default False</em>) – If True, the constant-folding
optimization is applied to the model during export. Constant-folding
optimization will replace some of the ops that have all constant
inputs, with pre-computed constant nodes.</p></li>
<li><p><strong>example_outputs</strong> (<em>tuple of Tensors</em><em>, </em><em>default None</em>) – Model’s example outputs being exported.
example_outputs must be provided when exporting a ScriptModule or TorchScript Function.</p></li>
<li><p><strong>strip_doc_string</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default True</em>) – if True, strips the field
“doc_string” from the exported model, which information about the stack
trace.</p></li>
<li><p><strong>dynamic_axes</strong> (<em>dict&lt;string</em><em>, </em><em>dict&lt;python:int</em><em>, </em><em>string&gt;&gt;</em><em> or </em><em>dict&lt;string</em><em>, </em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#list" title="(in Python v3.9)"><em>list</em></a><em>(</em><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.9)"><em>int</em></a><em>)</em><em>&gt;</em><em>, </em><em>default empty dict</em>) – <p>a dictionary to specify dynamic axes of input/output, such that:
- KEY:  input and/or output names
- VALUE: index of dynamic axes for given key and potentially the name to be used for
exported dynamic axes. In general the value is defined according to one of the following
ways or a combination of both:
(1). A list of integers specifying the dynamic axes of provided input. In this scenario
automated names will be generated and applied to dynamic axes of provided input/output
during export.
OR (2). An inner dictionary that specifies a mapping FROM the index of dynamic axis in
corresponding input/output TO the name that is desired to be applied on such axis of
such input/output during export.</p>
<p>Example. if we have the following shape for inputs and outputs:</p>
<div class="highlight-none notranslate"><div class="highlight"><pre><span></span>shape(input_1) = (&#39;b&#39;, 3, &#39;w&#39;, &#39;h&#39;)
and shape(input_2) = (&#39;b&#39;, 4)
and shape(output)  = (&#39;b&#39;, &#39;d&#39;, 5)
</pre></div>
</div>
<p>Then <cite>dynamic axes</cite> can be defined either as:</p>
<ol class="arabic">
<li><p>ONLY INDICES:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>``dynamic_axes = {&#39;input_1&#39;:[0, 2, 3],
                  &#39;input_2&#39;:[0],
                  &#39;output&#39;:[0, 1]}``
where automatic names will be generated for exported dynamic axes
</pre></div>
</div>
</li>
<li><p>INDICES WITH CORRESPONDING NAMES:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>``dynamic_axes = {&#39;input_1&#39;:{0:&#39;batch&#39;,
                             1:&#39;width&#39;,
                             2:&#39;height&#39;},
                  &#39;input_2&#39;:{0:&#39;batch&#39;},
                  &#39;output&#39;:{0:&#39;batch&#39;,
                            1:&#39;detections&#39;}}``
where provided names will be applied to exported dynamic axes
</pre></div>
</div>
</li>
<li><p>MIXED MODE OF (1) and (2):</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span>``dynamic_axes = {&#39;input_1&#39;:[0, 2, 3],
                  &#39;input_2&#39;:{0:&#39;batch&#39;},
                  &#39;output&#39;:[0,1]}``
</pre></div>
</div>
</li>
</ol>
</p></li>
<li><p><strong>keep_initializers_as_inputs</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default None</em>) – <p>If True, all the
initializers (typically corresponding to parameters) in the
exported graph will also be added as inputs to the graph. If False,
then initializers are not added as inputs to the graph, and only
the non-parameter inputs are added as inputs.</p>
<p>This may allow for better optimizations (such as constant folding
etc.) by backends/runtimes that execute these graphs. If
unspecified (default None), then the behavior is chosen
automatically as follows. If operator_export_type is
OperatorExportTypes.ONNX, the behavior is equivalent to setting
this argument to False. For other values of operator_export_type,
the behavior is equivalent to setting this argument to True. Note
that for ONNX opset version &lt; 9, initializers MUST be part of graph
inputs. Therefore, if opset_version argument is set to a 8 or
lower, this argument will be ignored.</p>
</p></li>
<li><p><strong>custom_opsets</strong> (<em>dict&lt;string</em><em>, </em><em>int&gt;</em><em>, </em><em>default empty dict</em>) – A dictionary to indicate
custom opset domain and version at export. If model contains a custom opset,
it is optional to specify the domain and opset version in the dictionary:
- KEY: opset domain name
- VALUE: opset version
If the custom opset is not provided in this dictionary, opset version is set
to 1 by default.</p></li>
<li><p><strong>enable_onnx_checker</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default True</em>) – If True the onnx model checker will be run
as part of the export, to ensure the exported model is a valid ONNX model.</p></li>
<li><p><strong>external_data_format</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.9)"><em>bool</em></a><em>, </em><em>default False</em>) – If True, then the model is exported
in ONNX external data format, in which case some of the model parameters are stored
in external binary files and not in the ONNX model file itself. See link for format
details:
<a class="reference external" href="https://github.com/onnx/onnx/blob/8b3f7e2e7a0f2aba0e629e23d89f07c7fc0e6a5e/onnx/onnx.proto#L423">https://github.com/onnx/onnx/blob/8b3f7e2e7a0f2aba0e629e23d89f07c7fc0e6a5e/onnx/onnx.proto#L423</a>
Also, in this case,  argument ‘f’ must be a string specifying the location of the model.
The external binary files will be stored in the same location specified by the model
location ‘f’. If False, then the model is stored in regular format, i.e. model and
parameters are all in one file. This argument is ignored for all export types other
than ONNX.</p></li>
</ul>
</dd>
</dl>
</dd></dl>

<dl class="function">
<dt id="torch.onnx.export_to_pretty_string">
<code class="sig-prename descclassname">torch.onnx.</code><code class="sig-name descname">export_to_pretty_string</code><span class="sig-paren">(</span><em class="sig-param">*args</em>, <em class="sig-param">**kwargs</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/onnx.html#export_to_pretty_string"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.onnx.export_to_pretty_string" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="torch.onnx.register_custom_op_symbolic">
<code class="sig-prename descclassname">torch.onnx.</code><code class="sig-name descname">register_custom_op_symbolic</code><span class="sig-paren">(</span><em class="sig-param">symbolic_name</em>, <em class="sig-param">symbolic_fn</em>, <em class="sig-param">opset_version</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/onnx.html#register_custom_op_symbolic"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.onnx.register_custom_op_symbolic" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="torch.onnx.operators.shape_as_tensor">
<code class="sig-prename descclassname">torch.onnx.operators.</code><code class="sig-name descname">shape_as_tensor</code><span class="sig-paren">(</span><em class="sig-param">x</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/onnx/operators.html#shape_as_tensor"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.onnx.operators.shape_as_tensor" title="Permalink to this definition">¶</a></dt>
<dd></dd></dl>

<dl class="function">
<dt id="torch.onnx.select_model_mode_for_export">
<code class="sig-prename descclassname">torch.onnx.</code><code class="sig-name descname">select_model_mode_for_export</code><span class="sig-paren">(</span><em class="sig-param">model</em>, <em class="sig-param">mode</em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/onnx.html#select_model_mode_for_export"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.onnx.select_model_mode_for_export" title="Permalink to this definition">¶</a></dt>
<dd><p>A context manager to temporarily set the training mode of ‘model’
to ‘mode’, resetting it when we exit the with-block.  A no-op if
mode is None.</p>
<p>In version 1.6 changed to this from set_training</p>
</dd></dl>

<dl class="function">
<dt id="torch.onnx.is_in_onnx_export">
<code class="sig-prename descclassname">torch.onnx.</code><code class="sig-name descname">is_in_onnx_export</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/onnx.html#is_in_onnx_export"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#torch.onnx.is_in_onnx_export" title="Permalink to this definition">¶</a></dt>
<dd><p>Check whether it’s in the middle of the ONNX export.
This function returns True in the middle of torch.onnx.export().
torch.onnx.export should be executed with single thread.</p>
</dd></dl>

</div>
</div>


             </article>
             
            </div>
            <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="optim.html" class="btn btn-neutral float-right" title="torch.optim" accesskey="n" rel="next">Next <img src="_static/images/chevron-right-orange.svg" class="next-page"></a>
      
      
        <a href="nn.init.html" class="btn btn-neutral" title="torch.nn.init" 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 2019, 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.onnx</a><ul>
<li><a class="reference internal" href="#example-end-to-end-alexnet-from-pytorch-to-onnx">Example: End-to-end AlexNet from PyTorch to ONNX</a></li>
<li><a class="reference internal" href="#tracing-vs-scripting">Tracing vs Scripting</a></li>
<li><a class="reference internal" href="#write-pytorch-model-in-torch-way">Write PyTorch model in Torch way</a></li>
<li><a class="reference internal" href="#using-dictionaries-to-handle-named-arguments-as-model-inputs">Using dictionaries to handle Named Arguments as model inputs</a></li>
<li><a class="reference internal" href="#indexing">Indexing</a><ul>
<li><a class="reference internal" href="#getter">Getter</a></li>
<li><a class="reference internal" href="#setter">Setter</a></li>
</ul>
</li>
<li><a class="reference internal" href="#torchvision-support">TorchVision support</a></li>
<li><a class="reference internal" href="#limitations">Limitations</a></li>
<li><a class="reference internal" href="#supported-operators">Supported operators</a></li>
<li><a class="reference internal" href="#adding-support-for-operators">Adding support for operators</a><ul>
<li><a class="reference internal" href="#aten-operators">ATen operators</a></li>
<li><a class="reference internal" href="#non-aten-operators">Non-ATen operators</a></li>
<li><a class="reference internal" href="#custom-operators">Custom operators</a></li>
</ul>
</li>
<li><a class="reference internal" href="#operator-export-type">Operator Export Type</a><ul>
<li><a class="reference internal" href="#id2">ONNX</a></li>
<li><a class="reference internal" href="#onnx-aten">ONNX_ATEN</a></li>
<li><a class="reference internal" href="#onnx-aten-fallback">ONNX_ATEN_FALLBACK</a></li>
<li><a class="reference internal" href="#raw">RAW</a></li>
<li><a class="reference internal" href="#onnx-fallthrough">ONNX_FALLTHROUGH</a></li>
</ul>
</li>
<li><a class="reference internal" href="#frequently-asked-questions">Frequently Asked Questions</a></li>
<li><a class="reference internal" href="#use-external-data-format">Use external data format</a></li>
<li><a class="reference internal" href="#training">Training</a></li>
<li><a class="reference internal" href="#functions">Functions</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 src="_static/jquery.js"></script>
         <script src="_static/underscore.js"></script>
         <script src="_static/doctools.js"></script>
         <script src="_static/language_data.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 src="https://cdnjs.cloudflare.com/ajax/libs/list.js/1.5.0/list.min.js"></script>
  <script type="text/javascript" src="_static/js/theme.js"></script>

  <script type="text/javascript">
      jQuery(function () {
          SphinxRtdTheme.Navigation.enable(true);
      });
  </script>
 
<script script type="text/javascript">
  var collapsedSections = ['Notes', 'Language Bindings', 'Libraries', 'Community'];
</script>
<script>
  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
  (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
  m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
  })(window,document,'script','https://www.google-analytics.com/analytics.js','ga');

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

</script>

<script async src="https://www.googletagmanager.com/gtag/js?id=UA-117752657-2"></script>

<script>
  window.dataLayer = window.dataLayer || [];

  function gtag(){dataLayer.push(arguments);}

  gtag('js', new Date());
  gtag('config', 'UA-117752657-2');
</script>

<img height="1" width="1" style="border-style:none;" alt="" src="https://www.googleadservices.com/pagead/conversion/795629140/?label=txkmCPmdtosBENSssfsC&amp;guid=ON&amp;script=0"/>


  <!-- 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://github.com/pytorch/pytorch/blob/master/CONTRIBUTING.md">Contributing</a></li>
          </ul>
        </div>

        <div class="footer-links-col">
          <ul>
            <li class="list-title"><a href="https://pytorch.org/resources">Resources</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.org/assets/brand-guidelines/PyTorch-Brand-Guidelines.pdf" target="_blank">Brand Guidelines</a></li>
          </ul>
        </div>

        <div class="footer-links-col follow-us-col">
          <ul>
            <li class="list-title">Stay Connected</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>
            <a href="https://www.youtube.com/pytorch" target="_blank" class="youtube"></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="https://pytorch.org/get-started">Get Started</a>
          </li>

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

          <li>
            <a href="https://pytorch.org/mobile">Mobile</a>
          </li>

          <li>
            <a href="https://pytorch.org/hub">PyTorch Hub</a>
          </li>

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

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

          <li class="resources-mobile-menu-title" class="active">
            Docs
          </li>

          <ul class="resources-mobile-menu-items">
            <li>
              <a href="https://pytorch.org/docs/stable/index.html">PyTorch</a>
            </li>

            <li>
              <a href="https://pytorch.org/audio/stable/index.html">torchaudio</a>
            </li>

            <li>
              <a href="https://pytorch.org/text/stable/index.html">torchtext</a>
            </li>

            <li>
              <a href="https://pytorch.org/vision/stable/index.html">torchvision</a>
            </li>

            <li>
              <a href="https://pytorch.org/elastic/">TorchElastic</a>
            </li>

            <li>
              <a href="https://pytorch.org/serve/">TorchServe</a>
            </li>

            <li>
              <a href="https://pytorch.org/xla">PyTorch on XLA Devices</a>
            </li>
          </ul>

          <li class="resources-mobile-menu-title">
            Resources
          </li>

          <ul class="resources-mobile-menu-items">
            <li>
              <a href="https://pytorch.org/resources">Developer Resources</a>
            </li>

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

            <li>
              <a href="https://pytorch.org/hub">Models (Beta)</a>
            </li>

            <li>
              <a href="https://pytorch.org/#community-module">Community</a>
            </li>

            <li>
              <a href="https://discuss.pytorch.org/">Forums</a>
            </li>
          </ul>

          <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();
      mainMenuDropdown.bind();
      filterTags.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>