1.11/fx.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.fx &mdash; PyTorch 1.11.0 documentation</title>
  

    <link rel="canonical" href="https://pytorch.org/docs/stable/fx.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="_static/copybutton.css" type="text/css" />
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.0-beta/dist/katex.min.css" type="text/css" />
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.13.11/dist/katex.min.css" type="text/css" />
  <link rel="stylesheet" href="_static/katex-math.css" type="text/css" />
  <link rel="stylesheet" href="_static/css/jit.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.hub" href="hub.html" />
    <link rel="prev" title="torch.futures" href="futures.html" />


  <!-- Google Analytics -->
  
    <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>
  
  <!-- End Google Analytics -->
  

  <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 docs-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/torchrec">
                  <span class="dropdown-title">TorchRec</span>
                  <p></p>
                </a>
                <a class="doc-dropdown-option nav-dropdown-item" href="https://pytorch.org/data">
                  <span class="dropdown-title">TorchData</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.11.0 &#x25BC</a>
    </div>
    

<div role="search">
  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
    <input type="text" name="q" placeholder="Search Docs" />
    <input type="hidden" name="check_keywords" value="yes" />
    <input type="hidden" name="area" value="default" />
  </form>
</div>

          </div>

          
              <p class="caption"><span class="caption-text">Notes</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="notes/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/gradcheck.html">Gradcheck mechanics</a></li>
<li class="toctree-l1"><a class="reference internal" href="notes/hip.html">HIP (ROCm) semantics</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/numerical_accuracy.html">Numerical accuracy</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>
<li class="toctree-l1"><a class="reference internal" href="deploy.html">torch::deploy</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="distributed.algorithms.join.html">torch.distributed.algorithms.join</a></li>
<li class="toctree-l1"><a class="reference internal" href="distributed.elastic.html">torch.distributed.elastic</a></li>
<li class="toctree-l1"><a class="reference internal" href="fsdp.html">torch.distributed.fsdp</a></li>
<li class="toctree-l1"><a class="reference internal" href="distributed.optim.html">torch.distributed.optim</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 current"><a class="current reference internal" href="#">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="monitor.html">torch.monitor</a></li>
<li class="toctree-l1"><a class="reference internal" href="special.html">torch.special</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="package.html">torch.package</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"><a class="reference internal" href="onnx.html">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="testing.html">torch.testing</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/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.fx</li>
    
    
      <li class="pytorch-breadcrumbs-aside">
        
            
            <a href="_sources/fx.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-fx">
<h1>torch.fx<a class="headerlink" href="#torch-fx" title="Permalink to this headline">¶</a></h1>
<div class="section" id="module-torch.fx">
<span id="overview"></span><h2>Overview<a class="headerlink" href="#module-torch.fx" title="Permalink to this headline">¶</a></h2>
<p>FX is a toolkit for developers to use to transform <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code>
instances. FX consists of three main components: a <strong>symbolic tracer,</strong>
an <strong>intermediate representation</strong>, and <strong>Python code generation</strong>. A
demonstration of these components in action:</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"># Simple module for demonstration</span>
<span class="k">class</span> <span class="nc">MyModule</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="nb">super</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">param</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Parameter</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">rand</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="bp">self</span><span class="o">.</span><span class="n">linear</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>

    <span class="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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">linear</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">param</span><span class="p">)</span><span class="o">.</span><span class="n">clamp</span><span class="p">(</span><span class="nb">min</span><span class="o">=</span><span class="mf">0.0</span><span class="p">,</span> <span class="nb">max</span><span class="o">=</span><span class="mf">1.0</span><span class="p">)</span>

<span class="n">module</span> <span class="o">=</span> <span class="n">MyModule</span><span class="p">()</span>

<span class="kn">from</span> <span class="nn">torch.fx</span> <span class="kn">import</span> <span class="n">symbolic_trace</span>
<span class="c1"># Symbolic tracing frontend - captures the semantics of the module</span>
<span class="n">symbolic_traced</span> <span class="p">:</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span> <span class="o">=</span> <span class="n">symbolic_trace</span><span class="p">(</span><span class="n">module</span><span class="p">)</span>

<span class="c1"># High-level intermediate representation (IR) - Graph representation</span>
<span class="nb">print</span><span class="p">(</span><span class="n">symbolic_traced</span><span class="o">.</span><span class="n">graph</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">graph():</span>
<span class="sd">    %x : [#users=1] = placeholder[target=x]</span>
<span class="sd">    %param : [#users=1] = get_attr[target=param]</span>
<span class="sd">    %add : [#users=1] = call_function[target=operator.add](args = (%x, %param), kwargs = {})</span>
<span class="sd">    %linear : [#users=1] = call_module[target=linear](args = (%add,), kwargs = {})</span>
<span class="sd">    %clamp : [#users=1] = call_method[target=clamp](args = (%linear,), kwargs = {min: 0.0, max: 1.0})</span>
<span class="sd">    return clamp</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="c1"># Code generation - valid Python code</span>
<span class="nb">print</span><span class="p">(</span><span class="n">symbolic_traced</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">def forward(self, x):</span>
<span class="sd">    param = self.param</span>
<span class="sd">    add = x + param;  x = param = None</span>
<span class="sd">    linear = self.linear(add);  add = None</span>
<span class="sd">    clamp = linear.clamp(min = 0.0, max = 1.0);  linear = None</span>
<span class="sd">    return clamp</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>The <strong>symbolic tracer</strong> performs “symbolic execution” of the Python
code. It feeds fake values, called Proxies, through the code. Operations
on theses Proxies are recorded. More information about symbolic tracing
can be found in the <a class="reference internal" href="#torch.fx.symbolic_trace" title="torch.fx.symbolic_trace"><code class="xref py py-func docutils literal notranslate"><span class="pre">symbolic_trace()</span></code></a> and <a class="reference internal" href="#torch.fx.Tracer" title="torch.fx.Tracer"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tracer</span></code></a>
documentation.</p>
<p>The <strong>intermediate representation</strong> is the container for the operations
that were recorded during symbolic tracing. It consists of a list of
Nodes that represent function inputs, callsites (to functions, methods,
or <a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> instances), and return values. More information
about the IR can be found in the documentation for <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>. The
IR is the format on which transformations are applied.</p>
<p><strong>Python code generation</strong> is what makes FX a Python-to-Python (or
Module-to-Module) transformation toolkit. For each Graph IR, we can
create valid Python code matching the Graph’s semantics. This
functionality is wrapped up in <a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><code class="xref py py-class docutils literal notranslate"><span class="pre">GraphModule</span></code></a>, which is a
<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> instance that holds a <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> as well as a
<code class="docutils literal notranslate"><span class="pre">forward</span></code> method generated from the Graph.</p>
<p>Taken together, this pipeline of components (symbolic tracing -&gt;
intermediate representation -&gt; transforms -&gt; Python code generation)
constitutes the Python-to-Python transformation pipeline of FX. In
addition, these components can be used separately. For example,
symbolic tracing can be used in isolation to capture a form of
the code for analysis (and not transformation) purposes. Code
generation can be used for programmatically generating models, for
example from a config file. There are many uses for FX!</p>
<p>Several example transformations can be found at the
<a class="reference external" href="https://github.com/pytorch/examples/tree/master/fx">examples</a>
repository.</p>
</div>
<div class="section" id="writing-transformations">
<span id="id1"></span><h2>Writing Transformations<a class="headerlink" href="#writing-transformations" title="Permalink to this headline">¶</a></h2>
<p>What is an FX transform? Essentially, it’s a function that looks like this.</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">torch.fx</span>

<span class="k">def</span> <span class="nf">transform</span><span class="p">(</span><span class="n">m</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="n">tracer_class</span> <span class="p">:</span> <span class="nb">type</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">Tracer</span><span class="p">)</span> <span class="o">-&gt;</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="c1"># Step 1: Acquire a Graph representing the code in `m`</span>

    <span class="c1"># NOTE: torch.fx.symbolic_trace is a wrapper around a call to</span>
    <span class="c1"># fx.Tracer.trace and constructing a GraphModule. We&#39;ll</span>
    <span class="c1"># split that out in our transform to allow the caller to</span>
    <span class="c1"># customize tracing behavior.</span>
    <span class="n">graph</span> <span class="p">:</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">Graph</span> <span class="o">=</span> <span class="n">tracer_class</span><span class="p">()</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>

    <span class="c1"># Step 2: Modify this Graph or create a new one</span>
    <span class="n">graph</span> <span class="o">=</span> <span class="o">...</span>

    <span class="c1"># Step 3: Construct a Module to return</span>
    <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span><span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="n">graph</span><span class="p">)</span>
</pre></div>
</div>
<p>Your transform will take in an <a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a>, acquire a <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>
from it, do some modifications, and return a new
<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a>. You should think of the <a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> that your FX
transform returns as identical to a regular <a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> – you can pass it to another
FX transform, you can pass it to TorchScript, or you can
run it. Ensuring that the inputs and outputs of your FX transform are a
<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> will allow for composability.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>It is also possible to modify an existing <a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><code class="xref py py-class docutils literal notranslate"><span class="pre">GraphModule</span></code></a> instead of
creating a new one, like so:</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">torch.fx</span>

<span class="k">def</span> <span class="nf">transform</span><span class="p">(</span><span class="n">m</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="o">-&gt;</span> <span class="n">nn</span><span class="o">.</span><span class="n">Module</span><span class="p">:</span>
    <span class="n">gm</span> <span class="p">:</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>

    <span class="c1"># Modify gm.graph</span>
    <span class="c1"># &lt;...&gt;</span>

    <span class="c1"># Recompile the forward() method of `gm` from its Graph</span>
    <span class="n">gm</span><span class="o">.</span><span class="n">recompile</span><span class="p">()</span>

    <span class="k">return</span> <span class="n">gm</span>
</pre></div>
</div>
<p>Note that you MUST call <a class="reference internal" href="#torch.fx.GraphModule.recompile" title="torch.fx.GraphModule.recompile"><code class="xref py py-meth docutils literal notranslate"><span class="pre">GraphModule.recompile()</span></code></a> to bring the generated
<code class="docutils literal notranslate"><span class="pre">forward()</span></code> method on the <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code> in sync with the modified <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>.</p>
</div>
<p>Given that you’ve passed in a <a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> that has been traced into a
<a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>, there are now two primary approaches you can take to building a new
<a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>.</p>
<div class="section" id="a-quick-primer-on-graphs">
<h3>A Quick Primer on Graphs<a class="headerlink" href="#a-quick-primer-on-graphs" title="Permalink to this headline">¶</a></h3>
<p>Full treatment of the semantics of graphs can be found in the <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>
documentation, but we are going to cover the basics here. A <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> is
a data structure that represents a method on a <a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><code class="xref py py-class docutils literal notranslate"><span class="pre">GraphModule</span></code></a>. The
information that this requires is:</p>
<ul class="simple">
<li><p>What are the inputs to the method?</p></li>
<li><p>What are the operations that run inside the method?</p></li>
<li><p>What is the output (i.e. return) value from the method?</p></li>
</ul>
<p>All three of these concepts are represented with <a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><code class="xref py py-class docutils literal notranslate"><span class="pre">Node</span></code></a> instances.
Let’s see what we mean by that with a short 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="kn">import</span> <span class="nn">torch.fx</span>

<span class="k">class</span> <span class="nc">MyModule</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="nb">super</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">param</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Parameter</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">rand</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="bp">self</span><span class="o">.</span><span class="n">linear</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>

    <span class="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="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">topk</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span>
            <span class="bp">self</span><span class="o">.</span><span class="n">linear</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">linear</span><span class="o">.</span><span class="n">weight</span><span class="p">)</span><span class="o">.</span><span class="n">relu</span><span class="p">(),</span> <span class="n">dim</span><span class="o">=-</span><span class="mi">1</span><span class="p">),</span> <span class="mi">3</span><span class="p">)</span>

<span class="n">m</span> <span class="o">=</span> <span class="n">MyModule</span><span class="p">()</span>
<span class="n">gm</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>

<span class="n">gm</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">print_tabular</span><span class="p">()</span>
</pre></div>
</div>
<p>Here we define a module <code class="docutils literal notranslate"><span class="pre">MyModule</span></code> for demonstration purposes, instantiate it,
symbolically trace it, then call the <a class="reference internal" href="#torch.fx.Graph.print_tabular" title="torch.fx.Graph.print_tabular"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Graph.print_tabular()</span></code></a> method to print
out a table showing the nodes of this <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>:</p>
<blockquote>
<div><table class="docutils colwidths-auto align-default">
<thead>
<tr class="row-odd"><th class="head"><p>opcode</p></th>
<th class="head"><p>name</p></th>
<th class="head"><p>target</p></th>
<th class="head"><p>args</p></th>
<th class="head"><p>kwargs</p></th>
</tr>
</thead>
<tbody>
<tr class="row-even"><td><p>placeholder</p></td>
<td><p>x</p></td>
<td><p>x</p></td>
<td><p>()</p></td>
<td><p>{}</p></td>
</tr>
<tr class="row-odd"><td><p>get_attr</p></td>
<td><p>linear_weight</p></td>
<td><p>linear.weight</p></td>
<td><p>()</p></td>
<td><p>{}</p></td>
</tr>
<tr class="row-even"><td><p>call_function</p></td>
<td><p>add_1</p></td>
<td><p>&lt;built-in function add&gt;</p></td>
<td><p>(x, linear_weight)</p></td>
<td><p>{}</p></td>
</tr>
<tr class="row-odd"><td><p>call_module</p></td>
<td><p>linear_1</p></td>
<td><p>linear</p></td>
<td><p>(add_1,)</p></td>
<td><p>{}</p></td>
</tr>
<tr class="row-even"><td><p>call_method</p></td>
<td><p>relu_1</p></td>
<td><p>relu</p></td>
<td><p>(linear_1,)</p></td>
<td><p>{}</p></td>
</tr>
<tr class="row-odd"><td><p>call_function</p></td>
<td><p>sum_1</p></td>
<td><p>&lt;built-in method sum …&gt;</p></td>
<td><p>(relu_1,)</p></td>
<td><p>{‘dim’: -1}</p></td>
</tr>
<tr class="row-even"><td><p>call_function</p></td>
<td><p>topk_1</p></td>
<td><p>&lt;built-in method topk …&gt;</p></td>
<td><p>(sum_1, 3)</p></td>
<td><p>{}</p></td>
</tr>
<tr class="row-odd"><td><p>output</p></td>
<td><p>output</p></td>
<td><p>output</p></td>
<td><p>(topk_1,)</p></td>
<td><p>{}</p></td>
</tr>
</tbody>
</table>
</div></blockquote>
<p>We can use this information to answer the questions we posed above.</p>
<ul class="simple">
<li><p>What are the inputs to the method? In FX, method inputs are specified
via special <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> nodes. In this case, we have a single
<code class="docutils literal notranslate"><span class="pre">placeholder</span></code> node with a <code class="docutils literal notranslate"><span class="pre">target</span></code> of <code class="docutils literal notranslate"><span class="pre">x</span></code>, meaning we have
a single (non-self) argument named x.</p></li>
<li><p>What are the operations within the method? The <code class="docutils literal notranslate"><span class="pre">get_attr</span></code>,
<code class="docutils literal notranslate"><span class="pre">call_function</span></code>, <code class="docutils literal notranslate"><span class="pre">call_module</span></code>, and <code class="docutils literal notranslate"><span class="pre">call_method</span></code> nodes
represent the operations in the method. A full treatment of
the semantics of all of these can be found in the <a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><code class="xref py py-class docutils literal notranslate"><span class="pre">Node</span></code></a>
documentation.</p></li>
<li><p>What is the return value of the method? The return value in a
<a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> is specified by a special <code class="docutils literal notranslate"><span class="pre">output</span></code> node.</p></li>
</ul>
<p>Given that we now know the basics of how code is represented in
FX, we can now explore how we would edit a <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>.</p>
</div>
<div class="section" id="graph-manipulation">
<h3>Graph Manipulation<a class="headerlink" href="#graph-manipulation" title="Permalink to this headline">¶</a></h3>
<div class="section" id="direct-graph-manipulation">
<h4>Direct Graph Manipulation<a class="headerlink" href="#direct-graph-manipulation" title="Permalink to this headline">¶</a></h4>
<p>One approach to building this new <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> is to directly manipulate your old
one. To aid in this, we can simply take the <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> we obtain from symbolic
tracing and modify it. For example, let’s say we desire to replace
<a class="reference internal" href="generated/torch.add.html#torch.add" title="torch.add"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.add()</span></code></a> calls with <a class="reference internal" href="generated/torch.mul.html#torch.mul" title="torch.mul"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.mul()</span></code></a> calls.</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">torch.fx</span>

<span class="c1"># Sample module</span>
<span class="k">class</span> <span class="nc">M</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">torch</span><span class="o">.</span><span class="n">add</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">def</span> <span class="nf">transform</span><span class="p">(</span><span class="n">m</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="n">tracer_class</span> <span class="p">:</span> <span class="nb">type</span> <span class="o">=</span> <span class="n">fx</span><span class="o">.</span><span class="n">Tracer</span><span class="p">)</span> <span class="o">-&gt;</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="n">graph</span> <span class="p">:</span> <span class="n">fx</span><span class="o">.</span><span class="n">Graph</span> <span class="o">=</span> <span class="n">tracer_class</span><span class="p">()</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
    <span class="c1"># FX represents its Graph as an ordered list of</span>
    <span class="c1"># nodes, so we can iterate through them.</span>
    <span class="k">for</span> <span class="n">node</span> <span class="ow">in</span> <span class="n">graph</span><span class="o">.</span><span class="n">nodes</span><span class="p">:</span>
        <span class="c1"># Checks if we&#39;re calling a function (i.e:</span>
        <span class="c1"># torch.add)</span>
        <span class="k">if</span> <span class="n">node</span><span class="o">.</span><span class="n">op</span> <span class="o">==</span> <span class="s1">&#39;call_function&#39;</span><span class="p">:</span>
            <span class="c1"># The target attribute is the function</span>
            <span class="c1"># that call_function calls.</span>
            <span class="k">if</span> <span class="n">node</span><span class="o">.</span><span class="n">target</span> <span class="o">==</span> <span class="n">torch</span><span class="o">.</span><span class="n">add</span><span class="p">:</span>
                <span class="n">node</span><span class="o">.</span><span class="n">target</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">mul</span>

    <span class="n">graph</span><span class="o">.</span><span class="n">lint</span><span class="p">()</span> <span class="c1"># Does some checks to make sure the</span>
                 <span class="c1"># Graph is well-formed.</span>

    <span class="k">return</span> <span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span><span class="p">(</span><span class="n">m</span><span class="p">,</span> <span class="n">graph</span><span class="p">)</span>
</pre></div>
</div>
<p>We can also do more involved <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> rewrites, such as
deleting or appending nodes. To aid in these transformations,
FX has utility functions for transforming the graph that can
be found in the <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> documentation. An
example of using these APIs to append a <code class="xref py py-func docutils literal notranslate"><span class="pre">torch.relu()</span></code> call
can be found below.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Specifies the insertion point. Any nodes added to the</span>
<span class="c1"># Graph within this scope will be inserted after `node`</span>
<span class="k">with</span> <span class="n">traced</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">inserting_after</span><span class="p">(</span><span class="n">node</span><span class="p">):</span>
    <span class="c1"># Insert a new `call_function` node calling `torch.relu`</span>
    <span class="n">new_node</span> <span class="o">=</span> <span class="n">traced</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">call_function</span><span class="p">(</span>
        <span class="n">torch</span><span class="o">.</span><span class="n">relu</span><span class="p">,</span> <span class="n">args</span><span class="o">=</span><span class="p">(</span><span class="n">node</span><span class="p">,))</span>

    <span class="c1"># We want all places that used the value of `node` to</span>
    <span class="c1"># now use that value after the `relu` call we&#39;ve added.</span>
    <span class="c1"># We use the `replace_all_uses_with` API to do this.</span>
    <span class="n">node</span><span class="o">.</span><span class="n">replace_all_uses_with</span><span class="p">(</span><span class="n">new_node</span><span class="p">)</span>
</pre></div>
</div>
<p>For simple transformations that only consist of substitutions, you can also
make use of the <a class="reference external" href="https://github.com/pytorch/pytorch/blob/master/torch/fx/subgraph_rewriter.py">subgraph rewriter.</a></p>
</div>
<div class="section" id="subgraph-rewriting-with-replace-pattern">
<h4>Subgraph Rewriting With replace_pattern()<a class="headerlink" href="#subgraph-rewriting-with-replace-pattern" title="Permalink to this headline">¶</a></h4>
<p>FX also provides another level of automation on top of direct graph manipulation.
The <a class="reference internal" href="#torch.fx.replace_pattern" title="torch.fx.replace_pattern"><code class="xref py py-func docutils literal notranslate"><span class="pre">replace_pattern()</span></code></a> API is essentially a “find/replace” tool for editing
<a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>s. It allows you to specify a <code class="docutils literal notranslate"><span class="pre">pattern</span></code> and <code class="docutils literal notranslate"><span class="pre">replacement</span></code> function
and it will trace through those functions, find instances of the group of operations
in the <code class="docutils literal notranslate"><span class="pre">pattern</span></code> graph, and replace those instances with copies of the <code class="docutils literal notranslate"><span class="pre">replacement</span></code>
graph. This can help to greatly automate tedious graph manipulation code, which can
get unwieldy as the transformations get more complex.</p>
</div>
<div class="section" id="graph-manipulation-examples">
<h4>Graph Manipulation Examples<a class="headerlink" href="#graph-manipulation-examples" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><a class="reference external" href="https://github.com/pytorch/examples/blob/master/fx/replace_op.py">Replace one
op</a></p></li>
<li><p><a class="reference external" href="https://github.com/pytorch/pytorch/blob/40cbf342d3c000712da92cfafeaca651b3e0bd3e/torch/fx/experimental/optimization.py#L50">Conv/Batch Norm
fusion</a></p></li>
<li><p><a class="reference external" href="https://github.com/pytorch/examples/blob/master/fx/subgraph_rewriter_basic_use.py">replace_pattern: Basic usage</a></p></li>
<li><p><a class="reference external" href="https://pytorch.org/docs/master/quantization.html#prototype-fx-graph-mode-quantization">Quantization</a></p></li>
<li><p><a class="reference external" href="https://github.com/pytorch/examples/blob/master/fx/invert.py">Invert Transformation</a></p></li>
</ul>
</div>
</div>
<div class="section" id="proxy-retracing">
<h3>Proxy/Retracing<a class="headerlink" href="#proxy-retracing" title="Permalink to this headline">¶</a></h3>
<p>Another way of manipulating <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>s is by reusing the <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a>
machinery used in symbolic tracing. For example, let’s
imagine that we wanted to write a transformation that decomposed
PyTorch functions into smaller operations. It would transform every
<code class="docutils literal notranslate"><span class="pre">F.relu(x)</span></code> call into <code class="docutils literal notranslate"><span class="pre">(x</span> <span class="pre">&gt;</span> <span class="pre">0)</span> <span class="pre">*</span> <span class="pre">x</span></code>. One possibility would be to
perform the requisite graph rewriting to insert the comparison and
multiplication after the <code class="docutils literal notranslate"><span class="pre">F.relu</span></code>, and then clean up the original
<code class="docutils literal notranslate"><span class="pre">F.relu</span></code>. However, we can automate this process by using <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a>
objects to automatically record operations into the <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>.</p>
<p>To use this method, we write the operations that we want inserted as regular
PyTorch code and invoke that code with <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a> objects as arguments.
These <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a> objects will capture the operations that are performed
on them and append them to the <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a>.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Note that this decomposition rule can be read as regular Python</span>
<span class="k">def</span> <span class="nf">relu_decomposition</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="p">(</span><span class="n">x</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="o">*</span> <span class="n">x</span>

<span class="n">decomposition_rules</span> <span class="o">=</span> <span class="p">{}</span>
<span class="n">decomposition_rules</span><span class="p">[</span><span class="n">F</span><span class="o">.</span><span class="n">relu</span><span class="p">]</span> <span class="o">=</span> <span class="n">relu_decomposition</span>

<span class="k">def</span> <span class="nf">decompose</span><span class="p">(</span><span class="n">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="n">tracer_class</span> <span class="p">:</span> <span class="nb">type</span> <span class="o">=</span> <span class="n">fx</span><span class="o">.</span><span class="n">Tracer</span><span class="p">)</span> <span class="o">-&gt;</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="sd">&quot;&quot;&quot;</span>
<span class="sd">    Decompose `model` into smaller constituent operations.</span>
<span class="sd">    Currently,this only supports decomposing ReLU into its</span>
<span class="sd">    mathematical definition: (x &gt; 0) * x</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">graph</span> <span class="p">:</span> <span class="n">fx</span><span class="o">.</span><span class="n">Graph</span> <span class="o">=</span> <span class="n">tracer_class</span><span class="p">()</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">model</span><span class="p">)</span>
    <span class="n">new_graph</span> <span class="o">=</span> <span class="n">fx</span><span class="o">.</span><span class="n">Graph</span><span class="p">()</span>
    <span class="n">env</span> <span class="o">=</span> <span class="p">{}</span>
    <span class="n">tracer</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">proxy</span><span class="o">.</span><span class="n">GraphAppendingTracer</span><span class="p">(</span><span class="n">graph</span><span class="p">)</span>
    <span class="k">for</span> <span class="n">node</span> <span class="ow">in</span> <span class="n">graph</span><span class="o">.</span><span class="n">nodes</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">node</span><span class="o">.</span><span class="n">op</span> <span class="o">==</span> <span class="s1">&#39;call_function&#39;</span> <span class="ow">and</span> <span class="n">node</span><span class="o">.</span><span class="n">target</span> <span class="ow">in</span> <span class="n">decomposition_rules</span><span class="p">:</span>
            <span class="c1"># By wrapping the arguments with proxies,</span>
            <span class="c1"># we can dispatch to the appropriate</span>
            <span class="c1"># decomposition rule and implicitly add it</span>
            <span class="c1"># to the Graph by symbolically tracing it.</span>
            <span class="n">proxy_args</span> <span class="o">=</span> <span class="p">[</span>
                <span class="n">fx</span><span class="o">.</span><span class="n">Proxy</span><span class="p">(</span><span class="n">env</span><span class="p">[</span><span class="n">x</span><span class="o">.</span><span class="n">name</span><span class="p">],</span> <span class="n">tracer</span><span class="p">)</span> <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">fx</span><span class="o">.</span><span class="n">Node</span><span class="p">)</span> <span class="k">else</span> <span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">node</span><span class="o">.</span><span class="n">args</span><span class="p">]</span>
            <span class="n">output_proxy</span> <span class="o">=</span> <span class="n">decomposition_rules</span><span class="p">[</span><span class="n">node</span><span class="o">.</span><span class="n">target</span><span class="p">](</span><span class="o">*</span><span class="n">proxy_args</span><span class="p">)</span>

            <span class="c1"># Operations on `Proxy` always yield new `Proxy`s, and the</span>
            <span class="c1"># return value of our decomposition rule is no exception.</span>
            <span class="c1"># We need to extract the underlying `Node` from the `Proxy`</span>
            <span class="c1"># to use it in subsequent iterations of this transform.</span>
            <span class="n">new_node</span> <span class="o">=</span> <span class="n">output_proxy</span><span class="o">.</span><span class="n">node</span>
            <span class="n">env</span><span class="p">[</span><span class="n">node</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_node</span>
        <span class="k">else</span><span class="p">:</span>
            <span class="c1"># Default case: we don&#39;t have a decomposition rule for this</span>
            <span class="c1"># node, so just copy the node over into the new graph.</span>
            <span class="n">new_node</span> <span class="o">=</span> <span class="n">new_graph</span><span class="o">.</span><span class="n">node_copy</span><span class="p">(</span><span class="n">node</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="n">env</span><span class="p">[</span><span class="n">x</span><span class="o">.</span><span class="n">name</span><span class="p">])</span>
            <span class="n">env</span><span class="p">[</span><span class="n">node</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_node</span>
    <span class="k">return</span> <span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span><span class="p">(</span><span class="n">model</span><span class="p">,</span> <span class="n">new_graph</span><span class="p">)</span>
</pre></div>
</div>
<p>In addition to avoiding explicit graph manipulation, using <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a>s
also allows you to specify your rewrite rules as native Python code.
For transformations that require a large amount of rewrite rules
(such as vmap or grad), this can often improve readability and
maintainability of the rules. Note that while calling <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a> we also
passed a tracer pointing to the underlying variable <cite>graph</cite>. This is done so
if in case the operations in graph are n-ary (e.g. add is a binary operator)
the call to <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a> does not create multiple instances of a graph
tracer which can lead to unexpected runtime errors. We recommend this method
of using <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a> especially when the underlying operators can not be
safely assumed to be unary.</p>
<p>A worked example of using <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a>s for <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> manipulation
can be found
<a class="reference external" href="https://github.com/pytorch/examples/blob/master/fx/proxy_based_graph_creation.py">here</a>.</p>
</div>
<div class="section" id="the-interpreter-pattern">
<h3>The Interpreter Pattern<a class="headerlink" href="#the-interpreter-pattern" title="Permalink to this headline">¶</a></h3>
<p>A useful code organizational pattern in FX is to loop over all the <a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><code class="xref py py-class docutils literal notranslate"><span class="pre">Node</span></code></a>s
in a <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> and execute them. This can be used for several things including
runtime analysis of values flowing through the graph or transformation of the code
via retracing with <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a>s. For example, suppose we want to run a
<a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><code class="xref py py-class docutils literal notranslate"><span class="pre">GraphModule</span></code></a> and record the <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.Tensor</span></code></a> shape and dtype
properties on the nodes as we see them at runtime. That might look like:</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">torch.fx</span>
<span class="kn">from</span> <span class="nn">torch.fx.node</span> <span class="kn">import</span> <span class="n">Node</span>

<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Dict</span>

<span class="k">class</span> <span class="nc">ShapeProp</span><span class="p">:</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    Shape propagation. This class takes a `GraphModule`.</span>
<span class="sd">    Then, its `propagate` method executes the `GraphModule`</span>
<span class="sd">    node-by-node with the given arguments. As each operation</span>
<span class="sd">    executes, the ShapeProp class stores away the shape and</span>
<span class="sd">    element type for the output values of each operation on</span>
<span class="sd">    the `shape` and `dtype` attributes of the operation&#39;s</span>
<span class="sd">    `Node`.</span>
<span class="sd">    &quot;&quot;&quot;</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">mod</span><span class="p">):</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">mod</span> <span class="o">=</span> <span class="n">mod</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">graph</span> <span class="o">=</span> <span class="n">mod</span><span class="o">.</span><span class="n">graph</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">modules</span> <span class="o">=</span> <span class="nb">dict</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">mod</span><span class="o">.</span><span class="n">named_modules</span><span class="p">())</span>

    <span class="k">def</span> <span class="nf">propagate</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">):</span>
        <span class="n">args_iter</span> <span class="o">=</span> <span class="nb">iter</span><span class="p">(</span><span class="n">args</span><span class="p">)</span>
        <span class="n">env</span> <span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Node</span><span class="p">]</span> <span class="o">=</span> <span class="p">{}</span>

        <span class="k">def</span> <span class="nf">load_arg</span><span class="p">(</span><span class="n">a</span><span class="p">):</span>
            <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">map_arg</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">n</span><span class="p">:</span> <span class="n">env</span><span class="p">[</span><span class="n">n</span><span class="o">.</span><span class="n">name</span><span class="p">])</span>

        <span class="k">def</span> <span class="nf">fetch_attr</span><span class="p">(</span><span class="n">target</span> <span class="p">:</span> <span class="nb">str</span><span class="p">):</span>
            <span class="n">target_atoms</span> <span class="o">=</span> <span class="n">target</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">&#39;.&#39;</span><span class="p">)</span>
            <span class="n">attr_itr</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">mod</span>
            <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">atom</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">target_atoms</span><span class="p">):</span>
                <span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">attr_itr</span><span class="p">,</span> <span class="n">atom</span><span class="p">):</span>
                    <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;Node referenced nonexistant target </span><span class="si">{</span><span class="s1">&#39;.&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">target_atoms</span><span class="p">[:</span><span class="n">i</span><span class="p">])</span><span class="si">}</span><span class="s2">&quot;</span><span class="p">)</span>
                <span class="n">attr_itr</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">attr_itr</span><span class="p">,</span> <span class="n">atom</span><span class="p">)</span>
            <span class="k">return</span> <span class="n">attr_itr</span>

        <span class="k">for</span> <span class="n">node</span> <span class="ow">in</span> <span class="bp">self</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">nodes</span><span class="p">:</span>
            <span class="k">if</span> <span class="n">node</span><span class="o">.</span><span class="n">op</span> <span class="o">==</span> <span class="s1">&#39;placeholder&#39;</span><span class="p">:</span>
                <span class="n">result</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">args_iter</span><span class="p">)</span>
            <span class="k">elif</span> <span class="n">node</span><span class="o">.</span><span class="n">op</span> <span class="o">==</span> <span class="s1">&#39;get_attr&#39;</span><span class="p">:</span>
                <span class="n">result</span> <span class="o">=</span> <span class="n">fetch_attr</span><span class="p">(</span><span class="n">node</span><span class="o">.</span><span class="n">target</span><span class="p">)</span>
            <span class="k">elif</span> <span class="n">node</span><span class="o">.</span><span class="n">op</span> <span class="o">==</span> <span class="s1">&#39;call_function&#39;</span><span class="p">:</span>
                <span class="n">result</span> <span class="o">=</span> <span class="n">node</span><span class="o">.</span><span class="n">target</span><span class="p">(</span><span class="o">*</span><span class="n">load_arg</span><span class="p">(</span><span class="n">node</span><span class="o">.</span><span class="n">args</span><span class="p">),</span> <span class="o">**</span><span class="n">load_arg</span><span class="p">(</span><span class="n">node</span><span class="o">.</span><span class="n">kwargs</span><span class="p">))</span>
            <span class="k">elif</span> <span class="n">node</span><span class="o">.</span><span class="n">op</span> <span class="o">==</span> <span class="s1">&#39;call_method&#39;</span><span class="p">:</span>
                <span class="n">self_obj</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span> <span class="o">=</span> <span class="n">load_arg</span><span class="p">(</span><span class="n">node</span><span class="o">.</span><span class="n">args</span><span class="p">)</span>
                <span class="n">kwargs</span> <span class="o">=</span> <span class="n">load_arg</span><span class="p">(</span><span class="n">node</span><span class="o">.</span><span class="n">kwargs</span><span class="p">)</span>
                <span class="n">result</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">self_obj</span><span class="p">,</span> <span class="n">node</span><span class="o">.</span><span class="n">target</span><span class="p">)(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
            <span class="k">elif</span> <span class="n">node</span><span class="o">.</span><span class="n">op</span> <span class="o">==</span> <span class="s1">&#39;call_module&#39;</span><span class="p">:</span>
                <span class="n">result</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">modules</span><span class="p">[</span><span class="n">node</span><span class="o">.</span><span class="n">target</span><span class="p">](</span><span class="o">*</span><span class="n">load_arg</span><span class="p">(</span><span class="n">node</span><span class="o">.</span><span class="n">args</span><span class="p">),</span> <span class="o">**</span><span class="n">load_arg</span><span class="p">(</span><span class="n">node</span><span class="o">.</span><span class="n">kwargs</span><span class="p">))</span>

            <span class="c1"># This is the only code specific to shape propagation.</span>
            <span class="c1"># you can delete this `if` branch and this becomes</span>
            <span class="c1"># a generic GraphModule interpreter.</span>
            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">result</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">node</span><span class="o">.</span><span class="n">shape</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">shape</span>
                <span class="n">node</span><span class="o">.</span><span class="n">dtype</span> <span class="o">=</span> <span class="n">result</span><span class="o">.</span><span class="n">dtype</span>

            <span class="n">env</span><span class="p">[</span><span class="n">node</span><span class="o">.</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="n">result</span>

        <span class="k">return</span> <span class="n">load_arg</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">result</span><span class="p">)</span>
</pre></div>
</div>
<p>As you can see, a full interpreter for FX is not that complicated
but it can be very useful. To ease using this pattern, we provide
the <a class="reference internal" href="#torch.fx.Interpreter" title="torch.fx.Interpreter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Interpreter</span></code></a> class, which encompasses the above logic
in a way that certain aspects of the interpreter’s execution can
be overridden via method overrides.</p>
<p>In addition to executing operations, we can also generate a new
<cite>Graph</cite> by feeding <a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a> values through an interpreter.
Similarly, we provide the <a class="reference internal" href="#torch.fx.Transformer" title="torch.fx.Transformer"><code class="xref py py-class docutils literal notranslate"><span class="pre">Transformer</span></code></a> class to encompass
this pattern. <a class="reference internal" href="#torch.fx.Transformer" title="torch.fx.Transformer"><code class="xref py py-class docutils literal notranslate"><span class="pre">Transformer</span></code></a> behaves similarly to
<a class="reference internal" href="#torch.fx.Interpreter" title="torch.fx.Interpreter"><code class="xref py py-class docutils literal notranslate"><span class="pre">Interpreter</span></code></a>, but instead of calling the <code class="docutils literal notranslate"><span class="pre">run</span></code> method to
get a concrete output value from the Module, you would call the
<a class="reference internal" href="#torch.fx.Transformer.transform" title="torch.fx.Transformer.transform"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Transformer.transform()</span></code></a> method to return a new
<a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><code class="xref py py-class docutils literal notranslate"><span class="pre">GraphModule</span></code></a> which was subject to any transformation rules
you installed as overridden methods.</p>
<div class="section" id="examples-of-the-interpreter-pattern">
<h4>Examples of the Interpreter Pattern<a class="headerlink" href="#examples-of-the-interpreter-pattern" title="Permalink to this headline">¶</a></h4>
<ul class="simple">
<li><p><a class="reference external" href="https://github.com/pytorch/pytorch/blob/master/torch/fx/passes/shape_prop.py">Shape
Propagation</a></p></li>
<li><p><a class="reference external" href="https://github.com/pytorch/tutorials/pull/1319">Performance Profiler</a></p></li>
</ul>
</div>
</div>
</div>
<div class="section" id="debugging">
<h2>Debugging<a class="headerlink" href="#debugging" title="Permalink to this headline">¶</a></h2>
<div class="section" id="introduction">
<h3>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h3>
<p>Often in the course of authoring transformations, our code will not be quite right.
In this case, we may need to do some debugging. The key is to work
backwards: first, check the results of invoking the generated module to prove or
disprove correctness. Then, inspect and debug the generated code. Then, debug the
process of transformations that led to the generated code.</p>
<p>If you’re not familiar with debuggers, please see the auxiliary section
<a class="reference internal" href="#available-debuggers"><span class="std std-ref">Available Debuggers</span></a>.</p>
</div>
<div class="section" id="common-pitfalls-in-transform-authoring">
<h3>Common Pitfalls in Transform Authoring<a class="headerlink" href="#common-pitfalls-in-transform-authoring" title="Permalink to this headline">¶</a></h3>
<ul class="simple">
<li><p>Nondeterministic <code class="docutils literal notranslate"><span class="pre">set</span></code> iteration order. In Python, the <code class="docutils literal notranslate"><span class="pre">set</span></code> datatype is
unordered. Using <code class="docutils literal notranslate"><span class="pre">set</span></code> to contain collections of objects like <code class="docutils literal notranslate"><span class="pre">Node</span></code>s,
for example, can cause unexpected nondeterminism. An example is iterating
over a set of <code class="docutils literal notranslate"><span class="pre">Node</span></code>s to insert them into a <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. Because the
<code class="docutils literal notranslate"><span class="pre">set</span></code> data type is unordered, the ordering of the operations in the output
program will be nondeterministic and can change across program invocations.
The recommended alternative is to use a <code class="docutils literal notranslate"><span class="pre">dict</span></code> data type, which is
<a class="reference external" href="https://mail.python.org/pipermail/python-dev/2017-December/151283.html">insertion ordered</a>
as of Python 3.7 (and as of cPython 3.6). A <code class="docutils literal notranslate"><span class="pre">dict</span></code> can be used equivalently
to a set by storing values to be deduplicated in the keys of the <code class="docutils literal notranslate"><span class="pre">dict</span></code>.</p></li>
</ul>
</div>
<div class="section" id="checking-correctness-of-modules">
<h3>Checking Correctness of Modules<a class="headerlink" href="#checking-correctness-of-modules" title="Permalink to this headline">¶</a></h3>
<p>Because the output of most deep learning modules consists of floating
point <a class="reference internal" href="tensors.html#torch.Tensor" title="torch.Tensor"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.Tensor</span></code></a> instances, checking for equivalence between
the results of two <a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> is not as straightforward
as doing a simple equality check. To motivate this, let’s use an
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="kn">import</span> <span class="nn">torch.fx</span>
<span class="kn">import</span> <span class="nn">torchvision.models</span> <span class="k">as</span> <span class="nn">models</span>

<span class="k">def</span> <span class="nf">transform</span><span class="p">(</span><span class="n">m</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="o">-&gt;</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="n">gm</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>

    <span class="c1"># Imagine we&#39;re doing some transforms here</span>
    <span class="c1"># &lt;...&gt;</span>

    <span class="n">gm</span><span class="o">.</span><span class="n">recompile</span><span class="p">()</span>

    <span class="k">return</span> <span class="n">gm</span>

<span class="n">resnet18</span> <span class="o">=</span> <span class="n">models</span><span class="o">.</span><span class="n">resnet18</span><span class="p">()</span>
<span class="n">transformed_resnet18</span> <span class="o">=</span> <span class="n">transform</span><span class="p">(</span><span class="n">resnet18</span><span class="p">)</span>

<span class="n">input_image</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">224</span><span class="p">,</span> <span class="mi">224</span><span class="p">)</span>

<span class="k">assert</span> <span class="n">resnet18</span><span class="p">(</span><span class="n">input_image</span><span class="p">)</span> <span class="o">==</span> <span class="n">transformed_resnet18</span><span class="p">(</span><span class="n">input_image</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">RuntimeError: Boolean value of Tensor with more than one value is ambiguous</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>Here, we’ve tried to check equality of the values of two deep learning
models with the <code class="docutils literal notranslate"><span class="pre">==</span></code> equality operator. However, this is not well-
defined both due to the issue of that operator returning a tensor
and not a bool, but also because comparison of floating point values
should use a margin of error (or epsilon) to account for the
non-commutativity of floating point operations (see
<a class="reference external" href="https://floating-point-gui.de/errors/comparison/">here</a> for more
details). We can use <a class="reference internal" href="generated/torch.allclose.html#torch.allclose" title="torch.allclose"><code class="xref py py-func docutils literal notranslate"><span class="pre">torch.allclose()</span></code></a> instead, which will give
us an approximate comparison taking into account a relative and
absolute tolerance threshold:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">assert</span> <span class="n">torch</span><span class="o">.</span><span class="n">allclose</span><span class="p">(</span><span class="n">resnet18</span><span class="p">(</span><span class="n">input_image</span><span class="p">),</span> <span class="n">transformed_resnet18</span><span class="p">(</span><span class="n">input_image</span><span class="p">))</span>
</pre></div>
</div>
<p>This is the first tool in our toolbox to check if transformed modules are
behaving as we expect compared to a reference implementation.</p>
</div>
<div class="section" id="debugging-the-generated-code">
<h3>Debugging the Generated Code<a class="headerlink" href="#debugging-the-generated-code" title="Permalink to this headline">¶</a></h3>
<p>Because FX generates the <code class="docutils literal notranslate"><span class="pre">forward()</span></code> function on <a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><code class="xref py py-class docutils literal notranslate"><span class="pre">GraphModule</span></code></a>s, using
traditional debugging techniques like <code class="docutils literal notranslate"><span class="pre">print</span></code> statements or <code class="docutils literal notranslate"><span class="pre">pdb</span></code> is
not as straightforward. Luckily, we have several techniques we can use
for debugging the generated code.</p>
<div class="section" id="use-pdb">
<h4>Use <code class="docutils literal notranslate"><span class="pre">pdb</span></code><a class="headerlink" href="#use-pdb" title="Permalink to this headline">¶</a></h4>
<p>Invoke <code class="docutils literal notranslate"><span class="pre">pdb</span></code> to step into the running program. Although the code that
represents the <a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><code class="xref py py-class docutils literal notranslate"><span class="pre">Graph</span></code></a> is not in any source file, we can still step
into it manually using <code class="docutils literal notranslate"><span class="pre">pdb</span></code> when the forward pass is invoked.</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">torch.fx</span>
<span class="kn">import</span> <span class="nn">torchvision.models</span> <span class="k">as</span> <span class="nn">models</span>

<span class="k">def</span> <span class="nf">my_pass</span><span class="p">(</span><span class="n">inp</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="n">tracer_class</span> <span class="p">:</span> <span class="nb">type</span> <span class="o">=</span> <span class="n">fx</span><span class="o">.</span><span class="n">Tracer</span><span class="p">)</span> <span class="o">-&gt;</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="n">graph</span> <span class="o">=</span> <span class="n">tracer_class</span><span class="p">()</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">inp</span><span class="p">)</span>
    <span class="c1"># Transformation logic here</span>
    <span class="c1"># &lt;...&gt;</span>

    <span class="c1"># Return new Module</span>
    <span class="k">return</span> <span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span><span class="p">(</span><span class="n">inp</span><span class="p">,</span> <span class="n">graph</span><span class="p">)</span>

<span class="n">my_module</span> <span class="o">=</span> <span class="n">models</span><span class="o">.</span><span class="n">resnet18</span><span class="p">()</span>
<span class="n">my_module_transformed</span> <span class="o">=</span> <span class="n">my_pass</span><span class="p">(</span><span class="n">my_module</span><span class="p">)</span>

<span class="n">input_value</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">224</span><span class="p">,</span> <span class="mi">224</span><span class="p">)</span>

<span class="c1"># When this line is executed at runtime, we will be dropped into an</span>
<span class="c1"># interactive `pdb` prompt. We can use the `step` or `s` command to</span>
<span class="c1"># step into the execution of the next line</span>
<span class="kn">import</span> <span class="nn">pdb</span><span class="p">;</span> <span class="n">pdb</span><span class="o">.</span><span class="n">set_trace</span><span class="p">()</span>

<span class="n">my_module_transformed</span><span class="p">(</span><span class="n">input_value</span><span class="p">)</span>
</pre></div>
</div>
</div>
<div class="section" id="print-the-generated-code">
<span id="id2"></span><h4>Print the Generated Code<a class="headerlink" href="#print-the-generated-code" title="Permalink to this headline">¶</a></h4>
<p>If you’d like to run the same code multiple times, then it can be
a bit tedious to step to the right code with <code class="docutils literal notranslate"><span class="pre">pdb</span></code>. In that case, one
approach is to simply copy-paste the generated <code class="docutils literal notranslate"><span class="pre">forward</span></code> pass into
your code and examine it from there.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Assume that `traced` is a GraphModule that has undergone some</span>
<span class="c1"># number of transforms</span>

<span class="c1"># Copy this code for later</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced</span><span class="p">)</span>
<span class="c1"># Print the code generated from symbolic tracing. This outputs:</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">def forward(self, y):</span>
<span class="sd">    x = self.x</span>
<span class="sd">    add_1 = x + y;  x = y = None</span>
<span class="sd">    return add_1</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="c1"># Subclass the original Module</span>
<span class="k">class</span> <span class="nc">SubclassM</span><span class="p">(</span><span class="n">M</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="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</span><span class="p">()</span>

    <span class="c1"># Paste the generated `forward` function (the one we printed and</span>
    <span class="c1"># copied above) here</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">y</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">x</span>
        <span class="n">add_1</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span><span class="p">;</span>  <span class="n">x</span> <span class="o">=</span> <span class="n">y</span> <span class="o">=</span> <span class="kc">None</span>
        <span class="k">return</span> <span class="n">add_1</span>

<span class="c1"># Create an instance of the original, untraced Module. Then, create an</span>
<span class="c1"># instance of the Module with the copied `forward` function. We can</span>
<span class="c1"># now compare the output of both the original and the traced version.</span>
<span class="n">pre_trace</span> <span class="o">=</span> <span class="n">M</span><span class="p">()</span>
<span class="n">post_trace</span> <span class="o">=</span> <span class="n">SubclassM</span><span class="p">()</span>
</pre></div>
</div>
</div>
<div class="section" id="use-the-to-folder-function-from-graphmodule">
<h4>Use the <code class="docutils literal notranslate"><span class="pre">to_folder</span></code> Function From <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code><a class="headerlink" href="#use-the-to-folder-function-from-graphmodule" title="Permalink to this headline">¶</a></h4>
<p><a class="reference internal" href="#torch.fx.GraphModule.to_folder" title="torch.fx.GraphModule.to_folder"><code class="xref py py-meth docutils literal notranslate"><span class="pre">GraphModule.to_folder()</span></code></a> is a method in <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code> that allows
you to dump out the generated FX code to a folder. Although copying the
forward pass into the code often suffices as in <a class="reference internal" href="#print-the-generated-code"><span class="std std-ref">Print the Generated Code</span></a>,
it may be easier to examine modules and parameters using <code class="docutils literal notranslate"><span class="pre">to_folder</span></code>.</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">m</span> <span class="o">=</span> <span class="n">symbolic_trace</span><span class="p">(</span><span class="n">M</span><span class="p">())</span>
<span class="n">m</span><span class="o">.</span><span class="n">to_folder</span><span class="p">(</span><span class="s2">&quot;foo&quot;</span><span class="p">,</span> <span class="s2">&quot;Bar&quot;</span><span class="p">)</span>
<span class="kn">from</span> <span class="nn">foo</span> <span class="kn">import</span> <span class="n">Bar</span>
<span class="n">y</span> <span class="o">=</span> <span class="n">Bar</span><span class="p">()</span>
</pre></div>
</div>
<p>After running the above example, we can then look at the code within
<code class="docutils literal notranslate"><span class="pre">foo/module.py</span></code> and modify it as desired (e.g. adding <code class="docutils literal notranslate"><span class="pre">print</span></code>
statements or using <code class="docutils literal notranslate"><span class="pre">pdb</span></code>) to debug the generated code.</p>
</div>
</div>
<div class="section" id="debugging-the-transformation">
<h3>Debugging the Transformation<a class="headerlink" href="#debugging-the-transformation" title="Permalink to this headline">¶</a></h3>
<p>Now that we’ve identified that a transformation is creating incorrect
code, it’s time to debug the transformation itself. First, we’ll check
the <a class="reference internal" href="#limitations-of-symbolic-tracing"><span class="std std-ref">Limitations of Symbolic Tracing</span></a> section in the documentation.
Once we verify that tracing is working as expected, the goal
becomes figuring out what went wrong during our <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code>
transformation. There may be a quick answer in
<a class="reference internal" href="#writing-transformations"><span class="std std-ref">Writing Transformations</span></a>, but, if not, there are several ways to
examine our traced module:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Sample Module</span>
<span class="k">class</span> <span class="nc">M</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">x</span> <span class="o">+</span> <span class="n">y</span>

<span class="c1"># Create an instance of `M`</span>
<span class="n">m</span> <span class="o">=</span> <span class="n">M</span><span class="p">()</span>

<span class="c1"># Symbolically trace an instance of `M` (returns a GraphModule). In</span>
<span class="c1"># this example, we&#39;ll only be discussing how to inspect a</span>
<span class="c1"># GraphModule, so we aren&#39;t showing any sample transforms for the</span>
<span class="c1"># sake of brevity.</span>
<span class="n">traced</span> <span class="o">=</span> <span class="n">symbolic_trace</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>

<span class="c1"># Print the code produced by tracing the module.</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced</span><span class="p">)</span>
<span class="c1"># The generated `forward` function is:</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">def forward(self, x, y):</span>
<span class="sd">    add = x + y;  x = y = None</span>
<span class="sd">    return add</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="c1"># Print the internal Graph.</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced</span><span class="o">.</span><span class="n">graph</span><span class="p">)</span>
<span class="c1"># This print-out returns:</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">graph():</span>
<span class="sd">    %x : [#users=1] = placeholder[target=x]</span>
<span class="sd">    %y : [#users=1] = placeholder[target=y]</span>
<span class="sd">    %add : [#users=1] = call_function[target=operator.add](args = (%x, %y), kwargs = {})</span>
<span class="sd">    return add</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="c1"># Print a tabular representation of the internal Graph.</span>
<span class="n">traced</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">print_tabular</span><span class="p">()</span>
<span class="c1"># This gives us:</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">opcode         name    target                   args    kwargs</span>
<span class="sd">-------------  ------  -----------------------  ------  --------</span>
<span class="sd">placeholder    x       x                        ()      {}</span>
<span class="sd">placeholder    y       y                        ()      {}</span>
<span class="sd">call_function  add     &lt;built-in function add&gt;  (x, y)  {}</span>
<span class="sd">output         output  output                   (add,)  {}</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>Using the utility functions above, we can compare our traced Module
before and after we’ve applied our transformations. Sometimes, a
simple visual comparison is enough to trace down a bug. If it’s still
not clear what’s going wrong, a debugger like <code class="docutils literal notranslate"><span class="pre">pdb</span></code> can be a good
next step.</p>
<p>Going off of the example above, consider the following code:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Sample user-defined function</span>
<span class="k">def</span> <span class="nf">transform_graph</span><span class="p">(</span><span class="n">module</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="n">tracer_class</span> <span class="p">:</span> <span class="nb">type</span> <span class="o">=</span> <span class="n">fx</span><span class="o">.</span><span class="n">Tracer</span><span class="p">)</span> <span class="o">-&gt;</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="c1"># Get the Graph from our traced Module</span>
    <span class="n">g</span> <span class="o">=</span> <span class="n">tracer_class</span><span class="p">()</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">module</span><span class="p">)</span>

    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    Transformations on `g` go here</span>
<span class="sd">    &quot;&quot;&quot;</span>

    <span class="k">return</span> <span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span><span class="p">(</span><span class="n">module</span><span class="p">,</span> <span class="n">g</span><span class="p">)</span>

<span class="c1"># Transform the Graph</span>
<span class="n">transformed</span> <span class="o">=</span> <span class="n">transform_graph</span><span class="p">(</span><span class="n">traced</span><span class="p">)</span>

<span class="c1"># Print the new code after our transforms. Check to see if it was</span>
<span class="c1"># what we expected</span>
<span class="nb">print</span><span class="p">(</span><span class="n">transformed</span><span class="p">)</span>
</pre></div>
</div>
<p>Using the above example, let’s say that the call to <code class="docutils literal notranslate"><span class="pre">print(traced)</span></code>
showed us that there was an error in our transforms. We want to find
what goes wrong using a debugger. We start a <code class="docutils literal notranslate"><span class="pre">pdb</span></code> session. We can see
what’s happening during the transform by breaking on
<code class="docutils literal notranslate"><span class="pre">transform_graph(traced)</span></code>, then pressing <code class="docutils literal notranslate"><span class="pre">s</span></code> to “step into” the call
to <code class="docutils literal notranslate"><span class="pre">transform_graph(traced)</span></code>.</p>
<p>We may also have good luck by editing the <code class="docutils literal notranslate"><span class="pre">print_tabular</span></code> method to print
different attributes of the Nodes in the Graph. (For example, we might
want to see the Node’s <code class="docutils literal notranslate"><span class="pre">input_nodes</span></code> and <code class="docutils literal notranslate"><span class="pre">users</span></code>.)</p>
</div>
<div class="section" id="available-debuggers">
<span id="id3"></span><h3>Available Debuggers<a class="headerlink" href="#available-debuggers" title="Permalink to this headline">¶</a></h3>
<p>The most common Python debugger is
<a class="reference external" href="https://docs.python.org/3/library/pdb.html">pdb</a>. You can start
your program in “debug mode” with <code class="docutils literal notranslate"><span class="pre">pdb</span></code> by typing
<code class="docutils literal notranslate"><span class="pre">python</span> <span class="pre">-m</span> <span class="pre">pdb</span> <span class="pre">FILENAME.py</span></code> into the command line, where <code class="docutils literal notranslate"><span class="pre">FILENAME</span></code>
is the name of the file you want to debug. After that, you can use the
<code class="docutils literal notranslate"><span class="pre">pdb</span></code> <a class="reference external" href="https://docs.python.org/3/library/pdb.html#debugger-commands">debugger commands</a>
to move through your running program stepwise. It’s common to set a
breakpoint (<code class="docutils literal notranslate"><span class="pre">b</span> <span class="pre">LINE-NUMBER</span></code>) when you start <code class="docutils literal notranslate"><span class="pre">pdb</span></code>, then call <code class="docutils literal notranslate"><span class="pre">c</span></code> to
run the program until that point. This prevents you from having to step
through each line of execution (using <code class="docutils literal notranslate"><span class="pre">s</span></code> or <code class="docutils literal notranslate"><span class="pre">n</span></code>) to get to the part
of the code you want to examine. Alternatively, you can write
<code class="docutils literal notranslate"><span class="pre">import</span> <span class="pre">pdb;</span> <span class="pre">pdb.set_trace()</span></code> before the line you want to break at.
If you add <code class="docutils literal notranslate"><span class="pre">pdb.set_trace()</span></code>, your program will automatically start
in debug mode when you run it. (In other words, you can just type
<code class="docutils literal notranslate"><span class="pre">python</span> <span class="pre">FILENAME.py</span></code> into the command line instead of
<code class="docutils literal notranslate"><span class="pre">python</span> <span class="pre">-m</span> <span class="pre">pdb</span> <span class="pre">FILENAME.py</span></code>.) Once you’re running your file in
debug mode, you can step through the code and examine your program’s
internal state using certain commands. There are many excellent
tutorials on <code class="docutils literal notranslate"><span class="pre">pdb</span></code> online, including RealPython’s
<a class="reference external" href="https://realpython.com/python-debugging-pdb/">“Python Debugging With Pdb”</a>.</p>
<p>IDEs like PyCharm or VSCode usually have a debugger built in. In your
IDE, you can choose to either a) use <code class="docutils literal notranslate"><span class="pre">pdb</span></code> by pulling up a terminal
window in your IDE (e.g. View → Terminal in VSCode), or b) use the
built-in debugger (usually a graphical wrapper around <code class="docutils literal notranslate"><span class="pre">pdb</span></code>).</p>
</div>
</div>
<div class="section" id="limitations-of-symbolic-tracing">
<span id="id4"></span><h2>Limitations of Symbolic Tracing<a class="headerlink" href="#limitations-of-symbolic-tracing" title="Permalink to this headline">¶</a></h2>
<p>FX uses a system of <strong>symbolic tracing</strong> (a.k.a <a class="reference external" href="https://en.wikipedia.org/wiki/Symbolic_execution">symbolic
execution</a>)
to capture the semantics of programs in a transformable/analyzable form.
The system is <strong>tracing</strong> in that it executes the program (really a
<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><code class="xref py py-class docutils literal notranslate"><span class="pre">torch.nn.Module</span></code></a> or function) to record operations. It is
<strong>symbolic</strong> in that the data flowing through the program during this
execution is not real data, but rather symbols (<a class="reference internal" href="#torch.fx.Proxy" title="torch.fx.Proxy"><code class="xref py py-class docutils literal notranslate"><span class="pre">Proxy</span></code></a> in FX parlance).</p>
<p>Although symbolic tracing works for most neural net code, it has some
limitations.</p>
<div class="section" id="dynamic-control-flow">
<h3>Dynamic Control Flow<a class="headerlink" href="#dynamic-control-flow" title="Permalink to this headline">¶</a></h3>
<p>The main limitation of symbolic tracing is it does not currently support
<em>dynamic control flow</em>. That is, loops or <code class="docutils literal notranslate"><span class="pre">if</span></code> statements where the
condition may depend on the input values of the program.</p>
<p>For example, let’s examine the following program:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">func_to_trace</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">x</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">relu</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>

<span class="n">traced</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">func_to_trace</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">  &lt;...&gt;</span>
<span class="sd">  File &quot;dyn.py&quot;, line 6, in func_to_trace</span>
<span class="sd">    if x.sum() &gt; 0:</span>
<span class="sd">  File &quot;pytorch/torch/fx/proxy.py&quot;, line 155, in __bool__</span>
<span class="sd">    return self.tracer.to_bool(self)</span>
<span class="sd">  File &quot;pytorch/torch/fx/proxy.py&quot;, line 85, in to_bool</span>
<span class="sd">    raise TraceError(&#39;symbolically traced variables cannot be used as inputs to control flow&#39;)</span>
<span class="sd">torch.fx.proxy.TraceError: symbolically traced variables cannot be used as inputs to control flow</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>The condition to the <code class="docutils literal notranslate"><span class="pre">if</span></code> statement relies on the value of <code class="docutils literal notranslate"><span class="pre">x.sum()</span></code>,
which relies on the value of <code class="docutils literal notranslate"><span class="pre">x</span></code>, a function input. Since
<code class="docutils literal notranslate"><span class="pre">x</span></code> can change (i.e. if you pass a new input tensor to the traced
function), this is <em>dynamic control flow</em>. The traceback walks back up
through your code to show you where this situation happens.</p>
<div class="section" id="static-control-flow">
<h4>Static Control Flow<a class="headerlink" href="#static-control-flow" title="Permalink to this headline">¶</a></h4>
<p>On the other hand, so-called <em>static control flow</em> is supported. Static
control flow is loops or <code class="docutils literal notranslate"><span class="pre">if</span></code> statements whose value cannot change
across invocations. Typically, in PyTorch programs, this control flow
arises for code making decisions about a model’s architecture based on
hyper-parameters. As a concrete 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="kn">import</span> <span class="nn">torch.fx</span>

<span class="k">class</span> <span class="nc">MyModule</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">do_activation</span> <span class="p">:</span> <span class="nb">bool</span> <span class="o">=</span> <span class="kc">False</span><span class="p">):</span>
        <span class="nb">super</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">do_activation</span> <span class="o">=</span> <span class="n">do_activation</span>
        <span class="bp">self</span><span class="o">.</span><span class="n">linear</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">512</span><span class="p">,</span> <span class="mi">512</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">linear</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
        <span class="c1"># This if-statement is so-called static control flow.</span>
        <span class="c1"># Its condition does not depend on any input values</span>
        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">do_activation</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">relu</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
        <span class="k">return</span> <span class="n">x</span>

<span class="n">without_activation</span> <span class="o">=</span> <span class="n">MyModule</span><span class="p">(</span><span class="n">do_activation</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span>
<span class="n">with_activation</span> <span class="o">=</span> <span class="n">MyModule</span><span class="p">(</span><span class="n">do_activation</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>

<span class="n">traced_without_activation</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">without_activation</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced_without_activation</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">def forward(self, x):</span>
<span class="sd">    linear_1 = self.linear(x);  x = None</span>
<span class="sd">    return linear_1</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="n">traced_with_activation</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">with_activation</span><span class="p">)</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced_with_activation</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">import torch</span>
<span class="sd">def forward(self, x):</span>
<span class="sd">    linear_1 = self.linear(x);  x = None</span>
<span class="sd">    relu_1 = torch.relu(linear_1);  linear_1 = None</span>
<span class="sd">    return relu_1</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>The if-statement <code class="docutils literal notranslate"><span class="pre">if</span> <span class="pre">self.do_activation</span></code> does not depend on any
function inputs, thus it is static. <code class="docutils literal notranslate"><span class="pre">do_activation</span></code> can be considered
to be a hyper-parameter, and the traces of different instances of
<code class="docutils literal notranslate"><span class="pre">MyModule</span></code> with different values for that parameter have different
code. This is a valid pattern that is supported by symbolic tracing.</p>
<p>Many instances of dynamic control flow are semantically static control
flow. These instances can be made to support symbolic tracing by
removing the data dependencies on input values, for example by moving
values to <code class="docutils literal notranslate"><span class="pre">Module</span></code> attributes or by binding concrete values to arguments
during symbolic tracing:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">flag</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">flag</span><span class="p">:</span> <span class="k">return</span> <span class="n">x</span>
    <span class="k">else</span><span class="p">:</span> <span class="k">return</span> <span class="n">x</span><span class="o">*</span><span class="mi">2</span>

<span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">f</span><span class="p">)</span> <span class="c1"># Fails!</span>

<span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">concrete_args</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;flag&#39;</span><span class="p">:</span> <span class="kc">True</span><span class="p">})</span>
</pre></div>
</div>
<p>In the case of truly dynamic control flow, the sections of the program
that contain this code can be traced as calls to the Method (see
<a class="reference internal" href="#customizing-tracing"><span class="std std-ref">Customizing Tracing with the Tracer class</span></a>) or function (see
<a class="reference internal" href="#torch.fx.wrap" title="torch.fx.wrap"><code class="xref py py-func docutils literal notranslate"><span class="pre">wrap()</span></code></a>) rather than tracing through them.</p>
</div>
</div>
<div class="section" id="non-torch-functions">
<h3>Non-<code class="docutils literal notranslate"><span class="pre">torch</span></code> Functions<a class="headerlink" href="#non-torch-functions" title="Permalink to this headline">¶</a></h3>
<p>FX uses <code class="docutils literal notranslate"><span class="pre">__torch_function__</span></code> as the mechanism by which it intercepts
calls (see the <a class="reference external" href="https://github.com/pytorch/pytorch/blob/master/torch/fx/OVERVIEW.md#technical-details">technical
overview</a>
for more information about this). Some functions, such as builtin Python
functions or those in the <code class="docutils literal notranslate"><span class="pre">math</span></code> module, are not covered by
<code class="docutils literal notranslate"><span class="pre">__torch_function__</span></code>, but we would still like to capture them in
symbolic tracing. For 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="kn">import</span> <span class="nn">torch.fx</span>
<span class="kn">from</span> <span class="nn">math</span> <span class="kn">import</span> <span class="n">sqrt</span>

<span class="k">def</span> <span class="nf">normalize</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="sd">&quot;&quot;&quot;</span>
<span class="sd">    Normalize `x` by the size of the batch dimension</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="n">x</span> <span class="o">/</span> <span class="n">sqrt</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>

<span class="c1"># It&#39;s valid Python code</span>
<span class="n">normalize</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">rand</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">traced</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">normalize</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">  &lt;...&gt;</span>
<span class="sd">  File &quot;sqrt.py&quot;, line 9, in normalize</span>
<span class="sd">    return x / sqrt(len(x))</span>
<span class="sd">  File &quot;pytorch/torch/fx/proxy.py&quot;, line 161, in __len__</span>
<span class="sd">    raise RuntimeError(&quot;&#39;len&#39; is not supported in symbolic tracing by default. If you want &quot;</span>
<span class="sd">RuntimeError: &#39;len&#39; is not supported in symbolic tracing by default. If you want this call to be recorded, please call torch.fx.wrap(&#39;len&#39;) at module scope</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>The error tells us that the built-in function <code class="docutils literal notranslate"><span class="pre">len</span></code> is not supported.
We can make it so that functions like this are recorded in the trace as
direct calls using the <a class="reference internal" href="#torch.fx.wrap" title="torch.fx.wrap"><code class="xref py py-func docutils literal notranslate"><span class="pre">wrap()</span></code></a> API:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">wrap</span><span class="p">(</span><span class="s1">&#39;len&#39;</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">wrap</span><span class="p">(</span><span class="s1">&#39;sqrt&#39;</span><span class="p">)</span>

<span class="n">traced</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">normalize</span><span class="p">)</span>

<span class="nb">print</span><span class="p">(</span><span class="n">traced</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">import math</span>
<span class="sd">def forward(self, x):</span>
<span class="sd">    len_1 = len(x)</span>
<span class="sd">    sqrt_1 = math.sqrt(len_1);  len_1 = None</span>
<span class="sd">    truediv = x / sqrt_1;  x = sqrt_1 = None</span>
<span class="sd">    return truediv</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
</div>
<div class="section" id="customizing-tracing-with-the-tracer-class">
<span id="customizing-tracing"></span><h3>Customizing Tracing with the <code class="docutils literal notranslate"><span class="pre">Tracer</span></code> class<a class="headerlink" href="#customizing-tracing-with-the-tracer-class" title="Permalink to this headline">¶</a></h3>
<p>The <a class="reference internal" href="#torch.fx.Tracer" title="torch.fx.Tracer"><code class="xref py py-class docutils literal notranslate"><span class="pre">Tracer</span></code></a> class is the class that underlies the
implementation of <code class="docutils literal notranslate"><span class="pre">symbolic_trace</span></code>. The behavior of tracing can be
customized by subclassing Tracer, like so:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">MyCustomTracer</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">Tracer</span><span class="p">):</span>
    <span class="c1"># Inside here you can override various methods</span>
    <span class="c1"># to customize tracing. See the `Tracer` API</span>
    <span class="c1"># reference</span>
    <span class="k">pass</span>


<span class="c1"># Let&#39;s use this custom tracer to trace through this module</span>
<span class="k">class</span> <span class="nc">MyModule</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="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">relu</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">+</span> <span class="n">torch</span><span class="o">.</span><span class="n">ones</span><span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>

<span class="n">mod</span> <span class="o">=</span> <span class="n">MyModule</span><span class="p">()</span>

<span class="n">traced_graph</span> <span class="o">=</span> <span class="n">MyCustomTracer</span><span class="p">()</span><span class="o">.</span><span class="n">trace</span><span class="p">(</span><span class="n">mod</span><span class="p">)</span>
<span class="c1"># trace() returns a Graph. Let&#39;s wrap it up in a</span>
<span class="c1"># GraphModule to make it runnable</span>
<span class="n">traced</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span><span class="p">(</span><span class="n">mod</span><span class="p">,</span> <span class="n">traced_graph</span><span class="p">)</span>
</pre></div>
</div>
<div class="section" id="leaf-modules">
<h4>Leaf Modules<a class="headerlink" href="#leaf-modules" title="Permalink to this headline">¶</a></h4>
<p>Leaf Modules are the modules that appear as calls in the symbolic trace
rather than being traced through. The default set of leaf modules is the
set of standard <code class="docutils literal notranslate"><span class="pre">torch.nn</span></code> module instances. For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">MySpecialSubmodule</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="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>

<span class="k">class</span> <span class="nc">MyModule</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="nb">super</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">linear</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Linear</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="bp">self</span><span class="o">.</span><span class="n">submod</span> <span class="o">=</span> <span class="n">MySpecialSubmodule</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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">submod</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">linear</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>

<span class="n">traced</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">MyModule</span><span class="p">())</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
<span class="c1"># `linear` is preserved as a call, yet `submod` is traced though.</span>
<span class="c1"># This is because the default set of &quot;Leaf Modules&quot; includes all</span>
<span class="c1"># standard `torch.nn` modules.</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">import torch</span>
<span class="sd">def forward(self, x):</span>
<span class="sd">    linear_1 = self.linear(x);  x = None</span>
<span class="sd">    neg_1 = torch.neg(linear_1);  linear_1 = None</span>
<span class="sd">    return neg_1</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
<p>The set of leaf modules can be customized by overriding
<a class="reference internal" href="#torch.fx.Tracer.is_leaf_module" title="torch.fx.Tracer.is_leaf_module"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Tracer.is_leaf_module()</span></code></a>.</p>
</div>
</div>
<div class="section" id="miscellanea">
<h3>Miscellanea<a class="headerlink" href="#miscellanea" title="Permalink to this headline">¶</a></h3>
<ul>
<li><p>Tensor constructors (e.g. <code class="docutils literal notranslate"><span class="pre">torch.zeros</span></code>, <code class="docutils literal notranslate"><span class="pre">torch.ones</span></code>,
<code class="docutils literal notranslate"><span class="pre">torch.rand</span></code>, <code class="docutils literal notranslate"><span class="pre">torch.randn</span></code>, <code class="docutils literal notranslate"><span class="pre">torch.sparse_coo_tensor</span></code>)
are currently not traceable.</p>
<ul class="simple">
<li><p>The deterministic constructors (<code class="docutils literal notranslate"><span class="pre">zeros</span></code>, <code class="docutils literal notranslate"><span class="pre">ones</span></code>) can be used
and the value they produce will be embedded in the trace as a
constant. This is only problematic if the arguments to these
constructors refers to dynamic input sizes. In this case,
<code class="docutils literal notranslate"><span class="pre">ones_like</span></code> or <code class="docutils literal notranslate"><span class="pre">zeros_like</span></code> may be a viable substitute.</p></li>
<li><p>Nondeterministic constructors (<code class="docutils literal notranslate"><span class="pre">rand</span></code>, <code class="docutils literal notranslate"><span class="pre">randn</span></code>) will have a
single random value embedded in the trace. This is likely not the
intended behavior. One workaround is to wrap <code class="docutils literal notranslate"><span class="pre">torch.randn</span></code> in a <code class="docutils literal notranslate"><span class="pre">torch.fx.wrap</span></code> function and call that instead.</p></li>
</ul>
<blockquote>
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nd">@torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">wrap</span>
<span class="k">def</span> <span class="nf">torch_randn</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">shape</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">randn</span><span class="p">(</span><span class="n">shape</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="n">torch_randn</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>
<span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
</pre></div>
</div>
</div></blockquote>
<ul class="simple">
<li><p>This behavior may be fixed in a future release.</p></li>
</ul>
</li>
<li><p>Type annotations</p>
<ul class="simple">
<li><p>Python 3-style type annotations (e.g.
<code class="docutils literal notranslate"><span class="pre">func(x</span> <span class="pre">:</span> <span class="pre">torch.Tensor,</span> <span class="pre">y</span> <span class="pre">:</span> <span class="pre">int)</span> <span class="pre">-&gt;</span> <span class="pre">torch.Tensor</span></code>) are supported
and will be preserved by symbolic tracing.</p></li>
<li><p>Python 2-style comment type annotations
<code class="docutils literal notranslate"><span class="pre">#</span> <span class="pre">type:</span> <span class="pre">(torch.Tensor,</span> <span class="pre">int)</span> <span class="pre">-&gt;</span> <span class="pre">torch.Tensor</span></code> are not currently
supported.</p></li>
<li><p>Annotations on local names within a function are not currently
supported.</p></li>
</ul>
</li>
<li><p>Gotcha around <code class="docutils literal notranslate"><span class="pre">training</span></code> flag and submodules</p>
<ul class="simple">
<li><p>When using functionals like <code class="docutils literal notranslate"><span class="pre">torch.nn.functional.dropout</span></code>, it will be common for the training argument to be passed in as <code class="docutils literal notranslate"><span class="pre">self.training</span></code>. During FX tracing, this will likely be baked in as a constant value.</p></li>
</ul>
<blockquote>
<div><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">torch.fx</span>

<span class="k">class</span> <span class="nc">DropoutRepro</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="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">functional</span><span class="o">.</span><span class="n">dropout</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">training</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">training</span><span class="p">)</span>


<span class="n">traced</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">DropoutRepro</span><span class="p">())</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">def forward(self, x):</span>
<span class="sd">  dropout = torch.nn.functional.dropout(x, p = 0.5, training = True, inplace = False);  x = None</span>
<span class="sd">  return dropout</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="n">traced</span><span class="o">.</span><span class="n">eval</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">5</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">testing</span><span class="o">.</span><span class="n">assert_allclose</span><span class="p">(</span><span class="n">traced</span><span class="p">(</span><span class="n">x</span><span class="p">),</span> <span class="n">x</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">AssertionError: Tensor-likes are not close!</span>

<span class="sd">Mismatched elements: 15 / 15 (100.0%)</span>
<span class="sd">Greatest absolute difference: 1.6207983493804932 at index (0, 2) (up to 1e-05 allowed)</span>
<span class="sd">Greatest relative difference: 1.0 at index (0, 0) (up to 0.0001 allowed)</span>
<span class="sd">&quot;&quot;&quot;</span>
</pre></div>
</div>
</div></blockquote>
<ul class="simple">
<li><p>However, when the standard <code class="docutils literal notranslate"><span class="pre">nn.Dropout()</span></code> submodule is used, the training flag is encapsulated and–because of the preservation of the <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> object model–can be changed.</p></li>
</ul>
<blockquote>
<div><div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">DropoutRepro2</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="nb">super</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">drop</span> <span class="o">=</span> <span class="n">torch</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="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="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">drop</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>

<span class="n">traced</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">DropoutRepro2</span><span class="p">())</span>
<span class="nb">print</span><span class="p">(</span><span class="n">traced</span><span class="o">.</span><span class="n">code</span><span class="p">)</span>
<span class="sd">&quot;&quot;&quot;</span>
<span class="sd">def forward(self, x):</span>
<span class="sd">  drop = self.drop(x);  x = None</span>
<span class="sd">  return drop</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="n">traced</span><span class="o">.</span><span class="n">eval</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">5</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">testing</span><span class="o">.</span><span class="n">assert_allclose</span><span class="p">(</span><span class="n">traced</span><span class="p">(</span><span class="n">x</span><span class="p">),</span> <span class="n">x</span><span class="p">)</span>
</pre></div>
</div>
</div></blockquote>
</li>
</ul>
<blockquote>
<div><ul class="simple">
<li><p>Because of this difference, consider marking modules that interact with the <code class="docutils literal notranslate"><span class="pre">training</span></code> flag dynamically as leaf modules.</p></li>
</ul>
</div></blockquote>
</div>
</div>
<div class="section" id="api-reference">
<h2>API Reference<a class="headerlink" href="#api-reference" title="Permalink to this headline">¶</a></h2>
<dl class="py function">
<dt id="torch.fx.symbolic_trace">
<code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">symbolic_trace</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">root</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">concrete_args</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#symbolic_trace"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.symbolic_trace" title="Permalink to this definition">¶</a></dt>
<dd><p>Symbolic tracing API</p>
<p>Given an <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> or function instance <code class="docutils literal notranslate"><span class="pre">root</span></code>, this function will return a <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code>
constructed by recording operations seen while tracing through <code class="docutils literal notranslate"><span class="pre">root</span></code>.</p>
<p><code class="docutils literal notranslate"><span class="pre">concrete_args</span></code> allows you to partially specialize your function, whether it’s to remove control flow or data structures.</p>
<p>For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">a</span><span class="p">,</span> <span class="n">b</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">b</span> <span class="o">==</span> <span class="kc">True</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">a</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="k">return</span> <span class="n">a</span><span class="o">*</span><span class="mi">2</span>
</pre></div>
</div>
<p>FX can typically not trace through this due to the presence of control
flow. However, we can use <cite>concrete_args</cite> to specialize on the value of
<cite>b</cite> to trace through this.</p>
<blockquote>
<div><p>f = fx.symbolic_trace(f, concrete_args={‘b’: False})
assert f(3, False)  == 6</p>
</div></blockquote>
<p>Note that although you can still pass in different values of <cite>b</cite>, they will be ignored.</p>
<p>We can also use <cite>concrete_args</cite> to eliminate data-structure handling from
our function. This will use pytrees to flatten your input. To avoid
overspecializing, pass in <cite>fx.PH</cite> for values that shouldn’t be
specialized. For example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">f</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="n">out</span> <span class="o">=</span> <span class="mi">0</span>
    <span class="k">for</span> <span class="n">v</span> <span class="ow">in</span> <span class="n">x</span><span class="o">.</span><span class="n">values</span><span class="p">():</span>
        <span class="n">out</span> <span class="o">+=</span> <span class="n">v</span>
    <span class="k">return</span> <span class="n">out</span>
<span class="n">f</span> <span class="o">=</span> <span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">f</span><span class="p">,</span> <span class="n">concrete_args</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;x&#39;</span><span class="p">:</span> <span class="p">{</span><span class="s1">&#39;a&#39;</span><span class="p">:</span> <span class="n">fx</span><span class="o">.</span><span class="n">PH</span><span class="p">,</span> <span class="s1">&#39;b&#39;</span><span class="p">:</span> <span class="n">fx</span><span class="o">.</span><span class="n">PH</span><span class="p">,</span> <span class="s1">&#39;c&#39;</span><span class="p">:</span> <span class="n">fx</span><span class="o">.</span><span class="n">PH</span><span class="p">}})</span>
<span class="k">assert</span> <span class="n">f</span><span class="p">({</span><span class="s1">&#39;a&#39;</span><span class="p">:</span> <span class="mi">1</span><span class="p">,</span> <span class="s1">&#39;b&#39;</span><span class="p">:</span> <span class="mi">2</span><span class="p">,</span> <span class="s1">&#39;c&#39;</span><span class="p">:</span> <span class="mi">4</span><span class="p">})</span> <span class="o">==</span> <span class="mi">7</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>root</strong> (<em>Union</em><em>[</em><a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><em>torch.nn.Module</em></a><em>, </em><em>Callable</em><em>]</em>) – Module or function to be traced and converted
into a Graph representation.</p></li>
<li><p><strong>concrete_args</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>any</em><em>]</em><em>]</em>) – Inputs to be partially specialized</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>a Module created from the recorded operations from <code class="docutils literal notranslate"><span class="pre">root</span></code>.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule">GraphModule</a></p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py function">
<dt id="torch.fx.wrap">
<code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">wrap</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">fn_or_name</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#wrap"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.wrap" title="Permalink to this definition">¶</a></dt>
<dd><p>This function can be called at module-level scope to register fn_or_name as a “leaf function”.
A “leaf function” will be preserved as a CallFunction node in the FX trace instead of being
traced through:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># foo/bar/baz.py</span>
<span class="k">def</span> <span class="nf">my_custom_function</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">x</span> <span class="o">*</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span> <span class="o">*</span> <span class="n">y</span>

<span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">wrap</span><span class="p">(</span><span class="s1">&#39;my_custom_function&#39;</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">fn_to_be_traced</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">):</span>
    <span class="c1"># When symbolic tracing, the below call to my_custom_function will be inserted into</span>
    <span class="c1"># the graph rather than tracing it.</span>
    <span class="k">return</span> <span class="n">my_custom_function</span><span class="p">(</span><span class="n">x</span><span class="p">,</span> <span class="n">y</span><span class="p">)</span>
</pre></div>
</div>
<p>This function can also equivalently be used as a decorator:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># foo/bar/baz.py</span>
<span class="nd">@torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">wrap</span>
<span class="k">def</span> <span class="nf">my_custom_function</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">x</span> <span class="o">*</span> <span class="n">x</span> <span class="o">+</span> <span class="n">y</span> <span class="o">*</span> <span class="n">y</span>
</pre></div>
</div>
<p>A wrapped function can be thought of a “leaf function”, analogous to the concept of
“leaf modules”, that is, they are functions that are left as calls in the FX trace
rather than traced through.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>fn_or_name</strong> (<em>Union</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>Callable</em><em>]</em>) – The function or name of the global function to insert into the
graph when it’s called</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py class">
<dt id="torch.fx.GraphModule">
<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">GraphModule</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph_module.html#GraphModule"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.GraphModule" title="Permalink to this definition">¶</a></dt>
<dd><p>GraphModule is an nn.Module generated from an fx.Graph. Graphmodule has a
<code class="docutils literal notranslate"><span class="pre">graph</span></code> attribute, as well as <code class="docutils literal notranslate"><span class="pre">code</span></code> and <code class="docutils literal notranslate"><span class="pre">forward</span></code> attributes generated
from that <code class="docutils literal notranslate"><span class="pre">graph</span></code>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>When <code class="docutils literal notranslate"><span class="pre">graph</span></code> is reassigned, <code class="docutils literal notranslate"><span class="pre">code</span></code> and <code class="docutils literal notranslate"><span class="pre">forward</span></code> will be automatically
regenerated. However, if you edit the contents of the <code class="docutils literal notranslate"><span class="pre">graph</span></code> without reassigning
the <code class="docutils literal notranslate"><span class="pre">graph</span></code> attribute itself, you must call <code class="docutils literal notranslate"><span class="pre">recompile()</span></code> to update the generated
code.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
<dl class="py method">
<dt id="torch.fx.GraphModule.__init__">
<code class="sig-name descname"><span class="pre">__init__</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">root</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">graph</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">class_name</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'GraphModule'</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph_module.html#GraphModule.__init__"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.GraphModule.__init__" title="Permalink to this definition">¶</a></dt>
<dd><p>Construct a GraphModule.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>root</strong> (<em>Union</em><em>[</em><a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><em>torch.nn.Module</em></a><em>, </em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>Any</em><em>]</em>) – <code class="docutils literal notranslate"><span class="pre">root</span></code> can either be an nn.Module instance or a Dict mapping strings to any attribute type.
In the case that <code class="docutils literal notranslate"><span class="pre">root</span></code> is a Module, any references to Module-based objects (via qualified
name) in the Graph’s Nodes’ <code class="docutils literal notranslate"><span class="pre">target</span></code> field will be copied over from the respective place
within <code class="docutils literal notranslate"><span class="pre">root</span></code>’s Module hierarchy into the GraphModule’s module hierarchy.
In the case that <code class="docutils literal notranslate"><span class="pre">root</span></code> is a dict, the qualified name found in a Node’s <code class="docutils literal notranslate"><span class="pre">target</span></code> will be
looked up directly in the dict’s keys. The object mapped to by the Dict will be copied
over into the appropriate place within the GraphModule’s module hierarchy.</p></li>
<li><p><strong>graph</strong> (<a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><em>Graph</em></a>) – <code class="docutils literal notranslate"><span class="pre">graph</span></code> contains the nodes this GraphModule should use for code generation</p></li>
<li><p><strong>class_name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – <code class="docutils literal notranslate"><span class="pre">name</span></code> denotes the name of this GraphModule for debugging purposes. If it’s unset, all
error messages will report as originating from <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code>. It may be helpful to set this
to <code class="docutils literal notranslate"><span class="pre">root</span></code>’s original name or a name that makes sense within the context of your transform.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.GraphModule.add_submodule">
<code class="sig-name descname"><span class="pre">add_submodule</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">m</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph_module.html#GraphModule.add_submodule"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.GraphModule.add_submodule" title="Permalink to this definition">¶</a></dt>
<dd><p>Adds the given submodule to <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p>
<p>This installs empty Modules where none exist yet if they are
subpaths of <code class="docutils literal notranslate"><span class="pre">target</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> – The fully-qualified string name of the new submodule
(See example in <code class="docutils literal notranslate"><span class="pre">nn.Module.get_submodule</span></code> for how to
specify a fully-qualified string.)</p></li>
<li><p><strong>m</strong> – The submodule itself; the actual object we want to
install in the current Module</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><dl class="simple">
<dt>Whether or not the submodule could be inserted. For</dt><dd><p>this method to return True, each object in the chain
denoted by <code class="docutils literal notranslate"><span class="pre">target</span></code> must either a) not exist yet,
or b) reference an <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> (not a parameter or
other attribute)</p>
</dd>
</dl>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.10)">bool</a></p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.GraphModule.code">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">code</span></code><a class="headerlink" href="#torch.fx.GraphModule.code" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the Python code generated from the <code class="docutils literal notranslate"><span class="pre">Graph</span></code> underlying this
<code class="docutils literal notranslate"><span class="pre">GraphModule</span></code>.</p>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.GraphModule.delete_all_unused_submodules">
<code class="sig-name descname"><span class="pre">delete_all_unused_submodules</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph_module.html#GraphModule.delete_all_unused_submodules"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.GraphModule.delete_all_unused_submodules" title="Permalink to this definition">¶</a></dt>
<dd><p>Deletes all unused submodules from <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p>
<p>A Module is considered “used” if any one of the following is
true:
1. It has children that are used
2. Its forward is called directly via a <code class="docutils literal notranslate"><span class="pre">call_module</span></code> node
3. It has a non-Module attribute that is used from a
<code class="docutils literal notranslate"><span class="pre">get_attr</span></code> node</p>
<p>This method can be called to clean up an <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> without
manually calling <code class="docutils literal notranslate"><span class="pre">delete_submodule</span></code> on each unused submodule.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.GraphModule.delete_submodule">
<code class="sig-name descname"><span class="pre">delete_submodule</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph_module.html#GraphModule.delete_submodule"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.GraphModule.delete_submodule" title="Permalink to this definition">¶</a></dt>
<dd><p>Deletes the given submodule from <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p>
<p>The module will not be deleted if <code class="docutils literal notranslate"><span class="pre">target</span></code> is not a valid
target.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>target</strong> – The fully-qualified string name of the new submodule
(See example in <code class="docutils literal notranslate"><span class="pre">nn.Module.get_submodule</span></code> for how to
specify a fully-qualified string.)</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><dl class="simple">
<dt>Whether or not the target string referenced a</dt><dd><p>submodule we want to delete. A return value of <code class="docutils literal notranslate"><span class="pre">False</span></code>
means that the <code class="docutils literal notranslate"><span class="pre">target</span></code> was not a valid reference to
a submodule.</p>
</dd>
</dl>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.10)">bool</a></p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.GraphModule.graph">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">graph</span></code><a class="headerlink" href="#torch.fx.GraphModule.graph" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the <code class="docutils literal notranslate"><span class="pre">Graph</span></code> underlying this <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code></p>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.GraphModule.recompile">
<code class="sig-name descname"><span class="pre">recompile</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph_module.html#GraphModule.recompile"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.GraphModule.recompile" title="Permalink to this definition">¶</a></dt>
<dd><p>Recompile this GraphModule from its <code class="docutils literal notranslate"><span class="pre">graph</span></code> attribute. This should be
called after editing the contained <code class="docutils literal notranslate"><span class="pre">graph</span></code>, otherwise the generated
code of this <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code> will be out of date.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.GraphModule.to_folder">
<code class="sig-name descname"><span class="pre">to_folder</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">folder</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">module_name</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">'FxModule'</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph_module.html#GraphModule.to_folder"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.GraphModule.to_folder" title="Permalink to this definition">¶</a></dt>
<dd><dl>
<dt>Dumps out module to <code class="docutils literal notranslate"><span class="pre">folder</span></code> with <code class="docutils literal notranslate"><span class="pre">module_name</span></code> so that it can be</dt><dd><p>imported with <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">&lt;folder&gt;</span> <span class="pre">import</span> <span class="pre">&lt;module_name&gt;</span></code></p>
<p>Args:</p>
<blockquote>
<div><p>folder (Union[str, os.PathLike]): The folder to write the code out to</p>
<dl class="simple">
<dt>module_name (str): Top-level name to use for the <code class="docutils literal notranslate"><span class="pre">Module</span></code> while</dt><dd><p>writing out the code</p>
</dd>
</dl>
</div></blockquote>
</dd>
</dl>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This API is experimental and is <em>NOT</em> backward-compatible.</p>
</div>
</dd></dl>

</dd></dl>

<dl class="py class">
<dt id="torch.fx.Graph">
<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">Graph</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">owning_module</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tracer_cls</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">Graph</span></code> is the main data structure used in the FX Intermediate Representation.
It consists of a series of <code class="docutils literal notranslate"><span class="pre">Node</span></code> s, each representing callsites (or other
syntactic constructs). The list of <code class="docutils literal notranslate"><span class="pre">Node</span></code> s, taken together, constitute a
valid Python function.</p>
<p>For example, the following code</p>
<div class="highlight-python 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">torch.fx</span>

<span class="k">class</span> <span class="nc">MyModule</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="nb">super</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">param</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Parameter</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">rand</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="bp">self</span><span class="o">.</span><span class="n">linear</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">nn</span><span class="o">.</span><span class="n">Linear</span><span class="p">(</span><span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">)</span>

    <span class="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="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">topk</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">sum</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">linear</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">linear</span><span class="o">.</span><span class="n">weight</span><span class="p">)</span><span class="o">.</span><span class="n">relu</span><span class="p">(),</span> <span class="n">dim</span><span class="o">=-</span><span class="mi">1</span><span class="p">),</span> <span class="mi">3</span><span class="p">)</span>

<span class="n">m</span> <span class="o">=</span> <span class="n">MyModule</span><span class="p">()</span>
<span class="n">gm</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">m</span><span class="p">)</span>
</pre></div>
</div>
<p>Will produce the following Graph:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="n">gm</span><span class="o">.</span><span class="n">graph</span><span class="p">)</span>
</pre></div>
</div>
<div class="highlight-text notranslate"><div class="highlight"><pre><span></span>graph(x):
    %linear_weight : [#users=1] = self.linear.weight
    %add_1 : [#users=1] = call_function[target=operator.add](args = (%x, %linear_weight), kwargs = {})
    %linear_1 : [#users=1] = call_module[target=linear](args = (%add_1,), kwargs = {})
    %relu_1 : [#users=1] = call_method[target=relu](args = (%linear_1,), kwargs = {})
    %sum_1 : [#users=1] = call_function[target=torch.sum](args = (%relu_1,), kwargs = {dim: -1})
    %topk_1 : [#users=1] = call_function[target=torch.topk](args = (%sum_1, 3), kwargs = {})
    return topk_1
</pre></div>
</div>
<p>For the semantics of operations represented in the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>, please see <a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><code class="xref py py-class docutils literal notranslate"><span class="pre">Node</span></code></a>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
<dl class="py method">
<dt id="torch.fx.Graph.__init__">
<code class="sig-name descname"><span class="pre">__init__</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">owning_module</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tracer_cls</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.__init__"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.__init__" title="Permalink to this definition">¶</a></dt>
<dd><p>Construct an empty Graph.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.call_function">
<code class="sig-name descname"><span class="pre">call_function</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">the_function</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.call_function"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.call_function" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert a <code class="docutils literal notranslate"><span class="pre">call_function</span></code> <code class="docutils literal notranslate"><span class="pre">Node</span></code> into the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. A <code class="docutils literal notranslate"><span class="pre">call_function</span></code> node
represents a call to a Python callable, specified by <code class="docutils literal notranslate"><span class="pre">the_function</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>the_function</strong> (<em>Callable</em><em>[</em><em>..</em><em>, </em><em>Any</em><em>]</em>) – The function to be called. Can be any PyTorch
operator, Python function, or member of the <code class="docutils literal notranslate"><span class="pre">builtins</span></code> or <code class="docutils literal notranslate"><span class="pre">operator</span></code>
namespaces.</p></li>
<li><p><strong>args</strong> (<em>Optional</em><em>[</em><em>Tuple</em><em>[</em><em>Argument</em><em>, </em><em>..</em><em>]</em><em>]</em>) – The positional arguments to be passed
to the called function.</p></li>
<li><p><strong>kwargs</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>Argument</em><em>]</em><em>]</em>) – The keyword arguments to be passed
to the called function</p></li>
<li><p><strong>type_expr</strong> (<em>Optional</em><em>[</em><em>Any</em><em>]</em>) – an optional type annotation representing the
Python type the output of this node will have.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The newly created and inserted <code class="docutils literal notranslate"><span class="pre">call_function</span></code> node.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The same insertion point and type expression rules apply for this method
as <a class="reference internal" href="#torch.fx.Graph.create_node" title="torch.fx.Graph.create_node"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Graph.create_node()</span></code></a>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.call_method">
<code class="sig-name descname"><span class="pre">call_method</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">method_name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.call_method"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.call_method" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert a <code class="docutils literal notranslate"><span class="pre">call_method</span></code> <code class="docutils literal notranslate"><span class="pre">Node</span></code> into the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. A <code class="docutils literal notranslate"><span class="pre">call_method</span></code> node
represents a call to a given method on the 0th element of <code class="docutils literal notranslate"><span class="pre">args</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>method_name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – The name of the method to apply to the self argument.
For example, if args[0] is a <code class="docutils literal notranslate"><span class="pre">Node</span></code> representing a <code class="docutils literal notranslate"><span class="pre">Tensor</span></code>,
then to call <code class="docutils literal notranslate"><span class="pre">relu()</span></code> on that <code class="docutils literal notranslate"><span class="pre">Tensor</span></code>, pass <code class="docutils literal notranslate"><span class="pre">relu</span></code> to <code class="docutils literal notranslate"><span class="pre">method_name</span></code>.</p></li>
<li><p><strong>args</strong> (<em>Optional</em><em>[</em><em>Tuple</em><em>[</em><em>Argument</em><em>, </em><em>..</em><em>]</em><em>]</em>) – The positional arguments to be passed
to the called method. Note that this <em>should</em> include a <code class="docutils literal notranslate"><span class="pre">self</span></code> argument.</p></li>
<li><p><strong>kwargs</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>Argument</em><em>]</em><em>]</em>) – The keyword arguments to be passed
to the called method</p></li>
<li><p><strong>type_expr</strong> (<em>Optional</em><em>[</em><em>Any</em><em>]</em>) – an optional type annotation representing the
Python type the output of this node will have.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The newly created and inserted <code class="docutils literal notranslate"><span class="pre">call_method</span></code> node.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The same insertion point and type expression rules apply for this method
as <a class="reference internal" href="#torch.fx.Graph.create_node" title="torch.fx.Graph.create_node"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Graph.create_node()</span></code></a>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.call_module">
<code class="sig-name descname"><span class="pre">call_module</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">module_name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.call_module"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.call_module" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert a <code class="docutils literal notranslate"><span class="pre">call_module</span></code> <code class="docutils literal notranslate"><span class="pre">Node</span></code> into the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. A <code class="docutils literal notranslate"><span class="pre">call_module</span></code> node
represents a call to the forward() function of a <code class="docutils literal notranslate"><span class="pre">Module</span></code> in the <code class="docutils literal notranslate"><span class="pre">Module</span></code>
hierarchy.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>module_name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – The qualified name of the <code class="docutils literal notranslate"><span class="pre">Module</span></code> in the <code class="docutils literal notranslate"><span class="pre">Module</span></code>
hierarchy to be called. For example, if the traced <code class="docutils literal notranslate"><span class="pre">Module</span></code> has a
submodule named <code class="docutils literal notranslate"><span class="pre">foo</span></code>, which has a submodule named <code class="docutils literal notranslate"><span class="pre">bar</span></code>, the
qualified name <code class="docutils literal notranslate"><span class="pre">foo.bar</span></code> should be passed as <code class="docutils literal notranslate"><span class="pre">module_name</span></code> to
call that module.</p></li>
<li><p><strong>args</strong> (<em>Optional</em><em>[</em><em>Tuple</em><em>[</em><em>Argument</em><em>, </em><em>..</em><em>]</em><em>]</em>) – The positional arguments to be passed
to the called method. Note that this should <em>not</em> include a <code class="docutils literal notranslate"><span class="pre">self</span></code> argument.</p></li>
<li><p><strong>kwargs</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>Argument</em><em>]</em><em>]</em>) – The keyword arguments to be passed
to the called method</p></li>
<li><p><strong>type_expr</strong> (<em>Optional</em><em>[</em><em>Any</em><em>]</em>) – an optional type annotation representing the
Python type the output of this node will have.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The newly-created and inserted <code class="docutils literal notranslate"><span class="pre">call_module</span></code> node.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The same insertion point and type expression rules apply for this method
as <a class="reference internal" href="#torch.fx.Graph.create_node" title="torch.fx.Graph.create_node"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Graph.create_node()</span></code></a>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.create_node">
<code class="sig-name descname"><span class="pre">create_node</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.create_node"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.create_node" title="Permalink to this definition">¶</a></dt>
<dd><p>Create a <code class="docutils literal notranslate"><span class="pre">Node</span></code> and add it to the <code class="docutils literal notranslate"><span class="pre">Graph</span></code> at the current insert-point.
Note that the current insert-point can be set via <a class="reference internal" href="#torch.fx.Graph.inserting_before" title="torch.fx.Graph.inserting_before"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Graph.inserting_before()</span></code></a>
and <a class="reference internal" href="#torch.fx.Graph.inserting_after" title="torch.fx.Graph.inserting_after"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Graph.inserting_after()</span></code></a>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>op</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – the opcode for this Node. One of ‘call_function’, ‘call_method’, ‘get_attr’,
‘call_module’, ‘placeholder’, or ‘output’. The semantics of these opcodes are
described in the <code class="docutils literal notranslate"><span class="pre">Graph</span></code> docstring.</p></li>
<li><p><strong>args</strong> (<em>Optional</em><em>[</em><em>Tuple</em><em>[</em><em>Argument</em><em>, </em><em>..</em><em>]</em><em>]</em>) – is a tuple of arguments to this node.</p></li>
<li><p><strong>kwargs</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>Argument</em><em>]</em><em>]</em>) – the kwargs of this Node</p></li>
<li><p><strong>name</strong> (<em>Optional</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>]</em>) – an optional string name for the <code class="docutils literal notranslate"><span class="pre">Node</span></code>.
This will influence the name of the value assigned to in the
Python generated code.</p></li>
<li><p><strong>type_expr</strong> (<em>Optional</em><em>[</em><em>Any</em><em>]</em>) – an optional type annotation representing the
Python type the output of this node will have.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The newly-created and inserted node.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.eliminate_dead_code">
<code class="sig-name descname"><span class="pre">eliminate_dead_code</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.eliminate_dead_code"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.eliminate_dead_code" title="Permalink to this definition">¶</a></dt>
<dd><p>Remove all dead code from the graph, based on each node’s number of
users, and whether the nodes have any side effects. The graph must be
topologically sorted before calling.</p>
<dl class="field-list simple">
<dt class="field-odd">Returns</dt>
<dd class="field-odd"><p>Whether the graph was changed as a result of the pass.</p>
</dd>
<dt class="field-even">Return type</dt>
<dd class="field-even"><p><a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.10)">bool</a></p>
</dd>
</dl>
<p>Example:</p>
<p>Before dead code is eliminated, <cite>a</cite> from <cite>a = x + 1</cite> below has no users
and thus can be eliminated from the graph without having an effect.</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></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">a</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="mi">1</span>
    <span class="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">attr_1</span>
</pre></div>
</div>
<p>After dead code is eliminated, <cite>a = x + 1</cite> has been removed, and the rest
of <cite>forward</cite> remains.</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></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="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">attr_1</span>
</pre></div>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.erase_node">
<code class="sig-name descname"><span class="pre">erase_node</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">to_erase</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.erase_node"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.erase_node" title="Permalink to this definition">¶</a></dt>
<dd><p>Erases a <code class="docutils literal notranslate"><span class="pre">Node</span></code> from the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. Throws an exception if
there are still users of that node in the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>to_erase</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The <code class="docutils literal notranslate"><span class="pre">Node</span></code> to erase from the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.flatten_inps">
<code class="sig-name descname"><span class="pre">flatten_inps</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.flatten_inps"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.flatten_inps" title="Permalink to this definition">¶</a></dt>
<dd><div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This API is experimental and is <em>NOT</em> backward-compatible.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.get_attr">
<code class="sig-name descname"><span class="pre">get_attr</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">qualified_name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.get_attr"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.get_attr" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert a <code class="docutils literal notranslate"><span class="pre">get_attr</span></code> node into the Graph. A <code class="docutils literal notranslate"><span class="pre">get_attr</span></code> <code class="docutils literal notranslate"><span class="pre">Node</span></code> represents the
fetch of an attribute from the <code class="docutils literal notranslate"><span class="pre">Module</span></code> hierarchy.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>qualified_name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – the fully-qualified name of the attribute to be retrieved.
For example, if the traced Module has a submodule named <code class="docutils literal notranslate"><span class="pre">foo</span></code>, which has a
submodule named <code class="docutils literal notranslate"><span class="pre">bar</span></code>, which has an attribute named <code class="docutils literal notranslate"><span class="pre">baz</span></code>, the qualified
name <code class="docutils literal notranslate"><span class="pre">foo.bar.baz</span></code> should be passed as <code class="docutils literal notranslate"><span class="pre">qualified_name</span></code>.</p></li>
<li><p><strong>type_expr</strong> (<em>Optional</em><em>[</em><em>Any</em><em>]</em>) – an optional type annotation representing the
Python type the output of this node will have.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The newly-created and inserted <code class="docutils literal notranslate"><span class="pre">get_attr</span></code> node.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The same insertion point and type expression rules apply for this method
as <code class="docutils literal notranslate"><span class="pre">Graph.create_node</span></code>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.graph_copy">
<code class="sig-name descname"><span class="pre">graph_copy</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">g</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">val_map</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">return_output_node</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.graph_copy"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.graph_copy" title="Permalink to this definition">¶</a></dt>
<dd><p>Copy all nodes from a given graph into <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>g</strong> (<a class="reference internal" href="#torch.fx.Graph" title="torch.fx.Graph"><em>Graph</em></a>) – The source graph from which to copy Nodes.</p></li>
<li><p><strong>val_map</strong> (<em>Dict</em><em>[</em><a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a><em>, </em><a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a><em>]</em>) – a dictionary that will be populated with a mapping
from nodes in <code class="docutils literal notranslate"><span class="pre">g</span></code> to nodes in <code class="docutils literal notranslate"><span class="pre">self</span></code>. Note that <code class="docutils literal notranslate"><span class="pre">val_map</span></code> can be passed
in with values in it already to override copying of certain values.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The value in <code class="docutils literal notranslate"><span class="pre">self</span></code> that is now equivalent to the output value in <code class="docutils literal notranslate"><span class="pre">g</span></code>,
if <code class="docutils literal notranslate"><span class="pre">g</span></code> had an <code class="docutils literal notranslate"><span class="pre">output</span></code> node. <code class="docutils literal notranslate"><span class="pre">None</span></code> otherwise.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.inserting_after">
<code class="sig-name descname"><span class="pre">inserting_after</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.inserting_after"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.inserting_after" title="Permalink to this definition">¶</a></dt>
<dd><dl>
<dt>Set the point at which create_node and companion methods will insert into the graph.</dt><dd><p>When used within a ‘with’ statement, this will temporary set the insert point and
then restore it when the with statement exits:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">with</span> <span class="n">g</span><span class="o">.</span><span class="n">inserting_after</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="o">...</span> <span class="c1"># inserting after node n</span>
<span class="o">...</span> <span class="c1"># insert point restored to what it was previously</span>
<span class="n">g</span><span class="o">.</span><span class="n">inserting_after</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="c1">#  set the insert point permanently</span>
</pre></div>
</div>
<p>Args:</p>
<blockquote>
<div><dl class="simple">
<dt>n (Optional[Node]): The node before which to insert. If None this will insert after</dt><dd><p>the beginning of the entire graph.</p>
</dd>
</dl>
</div></blockquote>
<dl class="simple">
<dt>Returns:</dt><dd><p>A resource manager that will restore the insert point on <code class="docutils literal notranslate"><span class="pre">__exit__</span></code>.</p>
</dd>
</dl>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.inserting_before">
<code class="sig-name descname"><span class="pre">inserting_before</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">n</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.inserting_before"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.inserting_before" title="Permalink to this definition">¶</a></dt>
<dd><dl>
<dt>Set the point at which create_node and companion methods will insert into the graph.</dt><dd><p>When used within a ‘with’ statement, this will temporary set the insert point and
then restore it when the with statement exits:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">with</span> <span class="n">g</span><span class="o">.</span><span class="n">inserting_before</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
    <span class="o">...</span> <span class="c1"># inserting before node n</span>
<span class="o">...</span> <span class="c1"># insert point restored to what it was previously</span>
<span class="n">g</span><span class="o">.</span><span class="n">inserting_before</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="c1">#  set the insert point permanently</span>
</pre></div>
</div>
<p>Args:</p>
<blockquote>
<div><dl class="simple">
<dt>n (Optional[Node]): The node before which to insert. If None this will insert before</dt><dd><p>the beginning of the entire graph.</p>
</dd>
</dl>
</div></blockquote>
<dl class="simple">
<dt>Returns:</dt><dd><p>A resource manager that will restore the insert point on <code class="docutils literal notranslate"><span class="pre">__exit__</span></code>.</p>
</dd>
</dl>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.lint">
<code class="sig-name descname"><span class="pre">lint</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.lint"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.lint" title="Permalink to this definition">¶</a></dt>
<dd><p>Runs various checks on this Graph to make sure it is well-formed. In
particular:
- Checks Nodes have correct ownership (owned by this graph)
- Checks Nodes appear in topological order
- If this Graph has an owning GraphModule, checks that targets
exist in that GraphModule</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.node_copy">
<code class="sig-name descname"><span class="pre">node_copy</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="pre">node</span></em>, <em class="sig-param"><span class="pre">arg_transform=&lt;function</span> <span class="pre">Graph.&lt;lambda&gt;&gt;</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.node_copy"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.node_copy" title="Permalink to this definition">¶</a></dt>
<dd><p>Copy a node from one graph into another. <code class="docutils literal notranslate"><span class="pre">arg_transform</span></code> needs to transform arguments from
the graph of node to the graph of self. Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># Copying all the nodes in `g` into `new_graph`</span>
<span class="n">g</span> <span class="p">:</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">Graph</span> <span class="o">=</span> <span class="o">...</span>
<span class="n">new_graph</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">graph</span><span class="p">()</span>
<span class="n">value_remap</span> <span class="o">=</span> <span class="p">{}</span>
<span class="k">for</span> <span class="n">node</span> <span class="ow">in</span> <span class="n">g</span><span class="o">.</span><span class="n">nodes</span><span class="p">:</span>
    <span class="n">value_remap</span><span class="p">[</span><span class="n">node</span><span class="p">]</span> <span class="o">=</span> <span class="n">new_graph</span><span class="o">.</span><span class="n">node_copy</span><span class="p">(</span><span class="n">node</span><span class="p">,</span> <span class="k">lambda</span> <span class="n">n</span> <span class="p">:</span> <span class="n">value_remap</span><span class="p">[</span><span class="n">n</span><span class="p">])</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>node</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The node to copy into <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p></li>
<li><p><strong>arg_transform</strong> (<em>Callable</em><em>[</em><em>[</em><a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a><em>]</em><em>, </em><em>Argument</em><em>]</em>) – A function that transforms
<code class="docutils literal notranslate"><span class="pre">Node</span></code> arguments in node’s <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> into the
equivalent argument in <code class="docutils literal notranslate"><span class="pre">self</span></code>. In the simplest case, this should
retrieve a value out of a table mapping Nodes in the original
graph to <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.nodes">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">nodes</span></code><a class="headerlink" href="#torch.fx.Graph.nodes" title="Permalink to this definition">¶</a></dt>
<dd><p>Get the list of Nodes that constitute this Graph.</p>
<p>Note that this <code class="docutils literal notranslate"><span class="pre">Node</span></code> list representation is a doubly-linked list. Mutations
during iteration (e.g. delete a Node, add a Node) are safe.</p>
<dl class="field-list simple">
<dt class="field-odd">Returns</dt>
<dd class="field-odd"><p>A doubly-linked list of Nodes. Note that <code class="docutils literal notranslate"><span class="pre">reversed</span></code> can be called on
this list to switch iteration order.</p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.on_generate_code">
<code class="sig-name descname"><span class="pre">on_generate_code</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">make_transformer</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.on_generate_code"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.on_generate_code" title="Permalink to this definition">¶</a></dt>
<dd><p>Register a transformer function when python code is generated</p>
<blockquote>
<div><dl>
<dt>Args:</dt><dd><dl>
<dt>make_transformer (Callable[[Optional[TransformCodeFunc]], TransformCodeFunc]):</dt><dd><p>a function that returns a code transformer to be registered.
This function is called by <cite>on_generate_code</cite> to obtain the
code transformer.</p>
<p>This function is also given as its input the currently
registered code transformer (or None if nothing is registered),
in case it is not desirable to overwrite it. This is useful to
chain code transformers together.</p>
</dd>
</dl>
</dd>
<dt>Returns:</dt><dd><p>a context manager that when used in a <cite>with</cite> statement, to automatically
restore the previously registered code transformer.</p>
</dd>
</dl>
<p>Example:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="n">gm</span><span class="p">:</span> <span class="n">fx</span><span class="o">.</span><span class="n">GraphModule</span> <span class="o">=</span> <span class="o">...</span>

<span class="c1"># This is a code transformer we want to register. This code</span>
<span class="c1"># transformer prepends a pdb import and trace statement at the very</span>
<span class="c1"># beginning of the generated torch.fx code to allow for manual</span>
<span class="c1"># debugging with the PDB library.</span>
<span class="k">def</span> <span class="nf">insert_pdb</span><span class="p">(</span><span class="n">body</span><span class="p">):</span>
    <span class="k">return</span> <span class="p">[</span><span class="s2">&quot;import pdb; pdb.set_trace()</span><span class="se">\n</span><span class="s2">&quot;</span><span class="p">,</span> <span class="o">*</span><span class="n">body</span><span class="p">]</span>

<span class="c1"># Registers `insert_pdb`, and overwrites the current registered</span>
<span class="c1"># code transformer (given by `_` to the lambda):</span>
<span class="n">gm</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">on_generate_code</span><span class="p">(</span>
    <span class="k">lambda</span> <span class="n">_</span><span class="p">:</span> <span class="n">insert_pdb</span>
<span class="p">)</span>

<span class="c1"># Or alternatively, registers a code transformer which first</span>
<span class="c1"># runs `body` through existing registered transformer, then</span>
<span class="c1"># through `insert_pdb`:</span>
<span class="n">gm</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">on_generate_code</span><span class="p">(</span>
    <span class="k">lambda</span> <span class="n">current_trans</span><span class="p">:</span> <span class="p">(</span>
        <span class="k">lambda</span> <span class="n">body</span><span class="p">:</span> <span class="n">insert_pdb</span><span class="p">(</span>
            <span class="n">current_trans</span><span class="p">(</span><span class="n">body</span><span class="p">)</span> <span class="k">if</span> <span class="n">current_trans</span>
            <span class="k">else</span> <span class="n">body</span>
        <span class="p">)</span>
    <span class="p">)</span>
<span class="p">)</span>

<span class="n">gm</span><span class="o">.</span><span class="n">recompile</span><span class="p">()</span>
<span class="n">gm</span><span class="p">(</span><span class="o">*</span><span class="n">inputs</span><span class="p">)</span>  <span class="c1"># drops into pdb</span>
</pre></div>
</div>
<p>This function can also be used as a context manager, with the benefit to
automatically restores the previously registered code transformer:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="c1"># ... continue from previous example</span>

<span class="k">with</span> <span class="n">gm</span><span class="o">.</span><span class="n">graph</span><span class="o">.</span><span class="n">on_generate_code</span><span class="p">(</span><span class="k">lambda</span> <span class="n">_</span><span class="p">:</span> <span class="n">insert_pdb</span><span class="p">):</span>
    <span class="c1"># do more stuff with `gm`...</span>
    <span class="n">gm</span><span class="o">.</span><span class="n">recompile</span><span class="p">()</span>
    <span class="n">gm</span><span class="p">(</span><span class="o">*</span><span class="n">inputs</span><span class="p">)</span>  <span class="c1"># drops into pdb</span>

<span class="c1"># now previous code transformer is restored (but `gm`&#39;s code with pdb</span>
<span class="c1"># remains - that means you can run `gm` with pdb here too, until you</span>
<span class="c1"># run next `recompile()`).</span>
</pre></div>
</div>
</div></blockquote>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This API is experimental and is <em>NOT</em> backward-compatible.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.output">
<code class="sig-name descname"><span class="pre">output</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">result</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.output"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.output" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert an <code class="docutils literal notranslate"><span class="pre">output</span></code> <code class="docutils literal notranslate"><span class="pre">Node</span></code> into the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. An <code class="docutils literal notranslate"><span class="pre">output</span></code> node represents
a <code class="docutils literal notranslate"><span class="pre">return</span></code> statement in Python code. <code class="docutils literal notranslate"><span class="pre">result</span></code> is the value that should
be returned.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>result</strong> (<em>Argument</em>) – The value to be returned.</p></li>
<li><p><strong>type_expr</strong> (<em>Optional</em><em>[</em><em>Any</em><em>]</em>) – an optional type annotation representing the
Python type the output of this node will have.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The same insertion point and type expression rules apply for this method
as <code class="docutils literal notranslate"><span class="pre">Graph.create_node</span></code>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.owning_module">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">owning_module</span></code><a class="headerlink" href="#torch.fx.Graph.owning_module" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the module that owns this <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code>, if there is one,
<code class="docutils literal notranslate"><span class="pre">None</span></code> if there is no owning module or if there are multiple owning
modules.</p>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.placeholder">
<code class="sig-name descname"><span class="pre">placeholder</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="pre">name</span></em>, <em class="sig-param"><span class="pre">type_expr=None</span></em>, <em class="sig-param"><span class="pre">default_value</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.placeholder"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.placeholder" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert a <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> node into the Graph. A <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> represents
a function input.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – A name for the input value. This corresponds to the name
of the positional argument to the function this <code class="docutils literal notranslate"><span class="pre">Graph</span></code> represents.</p></li>
<li><p><strong>type_expr</strong> (<em>Optional</em><em>[</em><em>Any</em><em>]</em>) – an optional type annotation representing the
Python type the output of this node will have. This is needed in some
cases for proper code generation (e.g. when the function is used
subsequently in TorchScript compilation).</p></li>
<li><p><strong>default_value</strong> (<em>Any</em>) – The default value this function argument should take
on. NOTE: to allow for <cite>None</cite> as a default value, <cite>inspect.Signature.empty</cite>
should be passed as this argument to specify that the parameter does _not_
have a default value.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>The same insertion point and type expression rules apply for this method
as <code class="docutils literal notranslate"><span class="pre">Graph.create_node</span></code>.</p>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.print_tabular">
<code class="sig-name descname"><span class="pre">print_tabular</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.print_tabular"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.print_tabular" title="Permalink to this definition">¶</a></dt>
<dd><p>Prints the intermediate representation of the graph in tabular
format. Note that this API requires the <code class="docutils literal notranslate"><span class="pre">tabulate</span></code> module to be
installed.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.python_code">
<code class="sig-name descname"><span class="pre">python_code</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">root_module</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.python_code"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.python_code" title="Permalink to this definition">¶</a></dt>
<dd><p>Turn this <code class="docutils literal notranslate"><span class="pre">Graph</span></code> into valid Python code.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>root_module</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – The name of the root module on which to look-up
qualified name targets. This is usually ‘self’.</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>src: the Python source code representing the object
globals: a dictionary of global names in <cite>src</cite> -&gt; the objects that they reference.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>A PythonCode object, consisting of two fields</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Graph.unflatten_outs">
<code class="sig-name descname"><span class="pre">unflatten_outs</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">out</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/graph.html#Graph.unflatten_outs"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Graph.unflatten_outs" title="Permalink to this definition">¶</a></dt>
<dd><div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This API is experimental and is <em>NOT</em> backward-compatible.</p>
</div>
</dd></dl>

</dd></dl>

<dl class="py class">
<dt id="torch.fx.Node">
<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">Node</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">graph</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">op</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">return_type</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">Node</span></code> is the data structure that represents individual operations within
a <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. For the most part, Nodes represent callsites to various entities,
such as operators, methods, and Modules (some exceptions include nodes that
specify function inputs and outputs). Each <code class="docutils literal notranslate"><span class="pre">Node</span></code> has a function specified
by its <code class="docutils literal notranslate"><span class="pre">op</span></code> property. The <code class="docutils literal notranslate"><span class="pre">Node</span></code> semantics for each value of <code class="docutils literal notranslate"><span class="pre">op</span></code> are as follows:</p>
<ul class="simple">
<li><p><code class="docutils literal notranslate"><span class="pre">placeholder</span></code> represents a function input. The <code class="docutils literal notranslate"><span class="pre">name</span></code> attribute specifies the name this value will take on.
<code class="docutils literal notranslate"><span class="pre">target</span></code> is similarly the name of the argument. <code class="docutils literal notranslate"><span class="pre">args</span></code> holds either: 1) nothing, or 2) a single argument
denoting the default parameter of the function input. <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> is don’t-care. Placeholders correspond to
the function parameters (e.g. <code class="docutils literal notranslate"><span class="pre">x</span></code>) in the graph printout.</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">get_attr</span></code> retrieves a parameter from the module hierarchy. <code class="docutils literal notranslate"><span class="pre">name</span></code> is similarly the name the result of the
fetch is assigned to. <code class="docutils literal notranslate"><span class="pre">target</span></code> is the fully-qualified name of the parameter’s position in the module hierarchy.
<code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> are don’t-care</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">call_function</span></code> applies a free function to some values. <code class="docutils literal notranslate"><span class="pre">name</span></code> is similarly the name of the value to assign
to. <code class="docutils literal notranslate"><span class="pre">target</span></code> is the function to be applied. <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> represent the arguments to the function,
following the Python calling convention</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">call_module</span></code> applies a module in the module hierarchy’s <code class="docutils literal notranslate"><span class="pre">forward()</span></code> method to given arguments. <code class="docutils literal notranslate"><span class="pre">name</span></code> is
as previous. <code class="docutils literal notranslate"><span class="pre">target</span></code> is the fully-qualified name of the module in the module hierarchy to call.
<code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> represent the arguments to invoke the module on, <em>including the self argument</em>.</p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">call_method</span></code> calls a method on a value. <code class="docutils literal notranslate"><span class="pre">name</span></code> is as similar. <code class="docutils literal notranslate"><span class="pre">target</span></code> is the string name of the method
to apply to the <code class="docutils literal notranslate"><span class="pre">self</span></code> argument. <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> represent the arguments to invoke the module on,
<em>including the self argument</em></p></li>
<li><p><code class="docutils literal notranslate"><span class="pre">output</span></code> contains the output of the traced function in its <code class="docutils literal notranslate"><span class="pre">args[0]</span></code> attribute. This corresponds to the “return” statement
in the Graph printout.</p></li>
</ul>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
<dl class="py method">
<dt id="torch.fx.Node.all_input_nodes">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">all_input_nodes</span></code><a class="headerlink" href="#torch.fx.Node.all_input_nodes" title="Permalink to this definition">¶</a></dt>
<dd><p>Return all Nodes that are inputs to this Node. This is equivalent to
iterating over <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> and only collecting the values that
are Nodes.</p>
<dl class="field-list simple">
<dt class="field-odd">Returns</dt>
<dd class="field-odd"><p>List of <code class="docutils literal notranslate"><span class="pre">Nodes</span></code> that appear in the <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> of this
<code class="docutils literal notranslate"><span class="pre">Node</span></code>, in that order.</p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.append">
<code class="sig-name descname"><span class="pre">append</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.append"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.append" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert <code class="docutils literal notranslate"><span class="pre">x</span></code> after this node in the list of nodes in the graph.
Equivalent to <code class="docutils literal notranslate"><span class="pre">self.next.prepend(x)</span></code></p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>x</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The node to put after this node. Must be a member of the same graph.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.args">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">args</span></code><a class="headerlink" href="#torch.fx.Node.args" title="Permalink to this definition">¶</a></dt>
<dd><p>The tuple of arguments to this <code class="docutils literal notranslate"><span class="pre">Node</span></code>. The interpretation of arguments
depends on the node’s opcode. See the <a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><code class="xref py py-class docutils literal notranslate"><span class="pre">Node</span></code></a> docstring for more
information.</p>
<p>Assignment to this property is allowed. All accounting of uses and users
is updated automatically on assignment.</p>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.format_node">
<code class="sig-name descname"><span class="pre">format_node</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">placeholder_names</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">maybe_return_typename</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.format_node"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.format_node" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a descriptive string representation of <code class="docutils literal notranslate"><span class="pre">self</span></code>.</p>
<p>This method can be used with no arguments as a debugging
utility.</p>
<p>This function is also used internally in the <code class="docutils literal notranslate"><span class="pre">__str__</span></code> method
of <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. Together, the strings in <code class="docutils literal notranslate"><span class="pre">placeholder_names</span></code>
and <code class="docutils literal notranslate"><span class="pre">maybe_return_typename</span></code> make up the signature of the
autogenerated <code class="docutils literal notranslate"><span class="pre">forward</span></code> function in this Graph’s surrounding
GraphModule. <code class="docutils literal notranslate"><span class="pre">placeholder_names</span></code> and <code class="docutils literal notranslate"><span class="pre">maybe_return_typename</span></code>
should not be used otherwise.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>placeholder_names</strong> – A list that will store formatted strings
representing the placeholders in the generated
<code class="docutils literal notranslate"><span class="pre">forward</span></code> function. Internal use only.</p></li>
<li><p><strong>maybe_return_typename</strong> – A single-element list that will store
a formatted string representing the output of the
generated <code class="docutils literal notranslate"><span class="pre">forward</span></code> function. Internal use only.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><dl class="simple">
<dt>If 1) we’re using <code class="docutils literal notranslate"><span class="pre">format_node</span></code> as an internal helper</dt><dd><p>in the <code class="docutils literal notranslate"><span class="pre">__str__</span></code> method of <code class="docutils literal notranslate"><span class="pre">Graph</span></code>, and 2) <code class="docutils literal notranslate"><span class="pre">self</span></code>
is a placeholder Node, return <code class="docutils literal notranslate"><span class="pre">None</span></code>. Otherwise,
return a  descriptive string representation of the
current Node.</p>
</dd>
</dl>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)">str</a></p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.is_impure">
<code class="sig-name descname"><span class="pre">is_impure</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.is_impure"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.is_impure" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns whether this op is impure, i.e. if its op is a placeholder or
output, or if a call_function or call_module which is impure.</p>
<dl class="field-list simple">
<dt class="field-odd">Returns</dt>
<dd class="field-odd"><p>If the op is impure or not.</p>
</dd>
<dt class="field-even">Return type</dt>
<dd class="field-even"><p><a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.10)">bool</a></p>
</dd>
</dl>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This API is experimental and is <em>NOT</em> backward-compatible.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.kwargs">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">kwargs</span></code><a class="headerlink" href="#torch.fx.Node.kwargs" title="Permalink to this definition">¶</a></dt>
<dd><p>The dict of keyword arguments to this <code class="docutils literal notranslate"><span class="pre">Node</span></code>. The interpretation of arguments
depends on the node’s opcode. See the <a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><code class="xref py py-class docutils literal notranslate"><span class="pre">Node</span></code></a> docstring for more
information.</p>
<p>Assignment to this property is allowed. All accounting of uses and users
is updated automatically on assignment.</p>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.next">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">next</span></code><a class="headerlink" href="#torch.fx.Node.next" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the next <code class="docutils literal notranslate"><span class="pre">Node</span></code> in the linked list of Nodes.</p>
<dl class="field-list simple">
<dt class="field-odd">Returns</dt>
<dd class="field-odd"><p>The next <code class="docutils literal notranslate"><span class="pre">Node</span></code> in the linked list of Nodes.</p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.normalized_arguments">
<code class="sig-name descname"><span class="pre">normalized_arguments</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">root</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">arg_types</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwarg_types</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">normalize_to_only_use_kwargs</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.normalized_arguments"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.normalized_arguments" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns normalized arguments to Python targets. This means that
<cite>args/kwargs</cite> will be matched up to the module/functional’s
signature and return exclusively kwargs in positional order
if <cite>normalize_to_only_use_kwargs</cite> is true.
Also populates default values. Does not support positional-only
parameters or varargs parameters.</p>
<p>Supports module calls.</p>
<p>May require <cite>arg_types</cite> and <cite>kwarg_types</cite> in order to disambiguate overloads.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>root</strong> (<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><em>torch.nn.Module</em></a>) – Module upon which to resolve module targets.</p></li>
<li><p><strong>arg_types</strong> (<em>Optional</em><em>[</em><em>Tuple</em><em>[</em><em>Any</em><em>]</em><em>]</em>) – Tuple of arg types for the args</p></li>
<li><p><strong>kwarg_types</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>Any</em><em>]</em><em>]</em>) – Dict of arg types for the kwargs</p></li>
<li><p><strong>normalize_to_only_use_kwargs</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.10)"><em>bool</em></a>) – Whether to normalize to only use kwargs.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>Returns NamedTuple ArgsKwargsPair, or <cite>None</cite> if not successful.</p>
</dd>
</dl>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This API is experimental and is <em>NOT</em> backward-compatible.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.prepend">
<code class="sig-name descname"><span class="pre">prepend</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">x</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.prepend"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.prepend" title="Permalink to this definition">¶</a></dt>
<dd><p>Insert x before this node in the list of nodes in the graph. Example:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Before</span><span class="p">:</span> <span class="n">p</span> <span class="o">-&gt;</span> <span class="bp">self</span>
        <span class="n">bx</span> <span class="o">-&gt;</span> <span class="n">x</span> <span class="o">-&gt;</span> <span class="n">ax</span>
<span class="n">After</span><span class="p">:</span>  <span class="n">p</span> <span class="o">-&gt;</span> <span class="n">x</span> <span class="o">-&gt;</span> <span class="bp">self</span>
        <span class="n">bx</span> <span class="o">-&gt;</span> <span class="n">ax</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>x</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The node to put before this node. Must be a member of the same graph.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.prev">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">prev</span></code><a class="headerlink" href="#torch.fx.Node.prev" title="Permalink to this definition">¶</a></dt>
<dd><p>Returns the previous <code class="docutils literal notranslate"><span class="pre">Node</span></code> in the linked list of Nodes.</p>
<dl class="field-list simple">
<dt class="field-odd">Returns</dt>
<dd class="field-odd"><p>The previous <code class="docutils literal notranslate"><span class="pre">Node</span></code> in the linked list of Nodes.</p>
</dd>
</dl>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.replace_all_uses_with">
<code class="sig-name descname"><span class="pre">replace_all_uses_with</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">replace_with</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.replace_all_uses_with"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.replace_all_uses_with" title="Permalink to this definition">¶</a></dt>
<dd><p>Replace all uses of <code class="docutils literal notranslate"><span class="pre">self</span></code> in the Graph with the Node <code class="docutils literal notranslate"><span class="pre">replace_with</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>replace_with</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The node to replace all uses of <code class="docutils literal notranslate"><span class="pre">self</span></code> with.</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The list of Nodes on which this change was made.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.replace_input_with">
<code class="sig-name descname"><span class="pre">replace_input_with</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">old_input</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">new_input</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.replace_input_with"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.replace_input_with" title="Permalink to this definition">¶</a></dt>
<dd><p>Loop through input nodes of <code class="docutils literal notranslate"><span class="pre">self</span></code>, and replace all instances of
<code class="docutils literal notranslate"><span class="pre">old_input</span></code> with <code class="docutils literal notranslate"><span class="pre">new_input</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>old_input</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The old input node to be replaced.</p></li>
<li><p><strong>new_input</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The new input node to replace <code class="docutils literal notranslate"><span class="pre">old_input</span></code>.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.stack_trace">
<em class="property"><span class="pre">property</span> </em><code class="sig-name descname"><span class="pre">stack_trace</span></code><a class="headerlink" href="#torch.fx.Node.stack_trace" title="Permalink to this definition">¶</a></dt>
<dd><p>Return the Python stack trace that was recorded during tracing, if any.
This property is usually populated by <cite>Tracer.create_proxy</cite>. To record
stack traces during tracing for debug purposes, set
<cite>record_stack_traces = True</cite> on the <cite>Tracer</cite> instance.</p>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.update_arg">
<code class="sig-name descname"><span class="pre">update_arg</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">idx</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">arg</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.update_arg"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.update_arg" title="Permalink to this definition">¶</a></dt>
<dd><p>Update an existing positional argument to contain the new value
<code class="docutils literal notranslate"><span class="pre">arg</span></code>. After calling, <code class="docutils literal notranslate"><span class="pre">self.args[idx]</span> <span class="pre">==</span> <span class="pre">arg</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>idx</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.10)"><em>int</em></a>) – The index into <code class="docutils literal notranslate"><span class="pre">self.args</span></code> of the element to update</p></li>
<li><p><strong>arg</strong> (<em>Argument</em>) – The new argument value to write into <code class="docutils literal notranslate"><span class="pre">args</span></code></p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Node.update_kwarg">
<code class="sig-name descname"><span class="pre">update_kwarg</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">key</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">arg</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/node.html#Node.update_kwarg"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Node.update_kwarg" title="Permalink to this definition">¶</a></dt>
<dd><p>Update an existing keyword argument to contain the new value
<code class="docutils literal notranslate"><span class="pre">arg</span></code>. After calling, <code class="docutils literal notranslate"><span class="pre">self.kwargs[key]</span> <span class="pre">==</span> <span class="pre">arg</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>key</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – The key in <code class="docutils literal notranslate"><span class="pre">self.kwargs</span></code> of the element to update</p></li>
<li><p><strong>arg</strong> (<em>Argument</em>) – The new argument value to write into <code class="docutils literal notranslate"><span class="pre">kwargs</span></code></p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

</dd></dl>

<dl class="py class">
<dt id="torch.fx.Tracer">
<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">Tracer</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">autowrap_modules</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">(math)</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">autowrap_functions</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">()</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#Tracer"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Tracer" title="Permalink to this definition">¶</a></dt>
<dd><blockquote>
<div><p><code class="docutils literal notranslate"><span class="pre">Tracer</span></code> is the class that implements the symbolic tracing functionality
of <code class="docutils literal notranslate"><span class="pre">torch.fx.symbolic_trace</span></code>. A call to <code class="docutils literal notranslate"><span class="pre">symbolic_trace(m)</span></code> is equivalent
to <code class="docutils literal notranslate"><span class="pre">Tracer().trace(m)</span></code>.</p>
<p>Tracer can be subclassed to override various behaviors of the tracing
process. The different behaviors that can be overridden are described
in the docstrings of the methods on this class.</p>
</div></blockquote>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
<dl class="py method">
<dt id="torch.fx.Tracer.call_module">
<code class="sig-name descname"><span class="pre">call_module</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">m</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">forward</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#Tracer.call_module"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Tracer.call_module" title="Permalink to this definition">¶</a></dt>
<dd><p>Method that specifies the behavior of this <code class="docutils literal notranslate"><span class="pre">Tracer</span></code> when it encounters
a call to an <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> instance.</p>
<p>By default, the behavior is to check if the called module is a leaf module
via <code class="docutils literal notranslate"><span class="pre">is_leaf_module</span></code>. If it is, emit a <code class="docutils literal notranslate"><span class="pre">call_module</span></code> node referring to
<code class="docutils literal notranslate"><span class="pre">m</span></code> in the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>. Otherwise, call the <code class="docutils literal notranslate"><span class="pre">Module</span></code> normally, tracing through
the operations in its <code class="docutils literal notranslate"><span class="pre">forward</span></code> function.</p>
<p>This method can be overridden to–for example–create nested traced
GraphModules, or any other behavior you would want while tracing across
<code class="docutils literal notranslate"><span class="pre">Module</span></code> boundaries.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>m</strong> (<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><em>Module</em></a>) – The module for which a call is being emitted</p></li>
<li><p><strong>forward</strong> (<em>Callable</em>) – The forward() method of the <code class="docutils literal notranslate"><span class="pre">Module</span></code> to be invoked</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – args of the module callsite</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – kwargs of the module callsite</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The return value from the Module call. In the case that a <code class="docutils literal notranslate"><span class="pre">call_module</span></code>
node was emitted, this is a <code class="docutils literal notranslate"><span class="pre">Proxy</span></code> value. Otherwise, it is whatever
value was returned from the <code class="docutils literal notranslate"><span class="pre">Module</span></code> invocation.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.create_arg">
<code class="sig-name descname"><span class="pre">create_arg</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">a</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#Tracer.create_arg"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Tracer.create_arg" title="Permalink to this definition">¶</a></dt>
<dd><p>A method to specify the behavior of tracing when preparing values to
be used as arguments to nodes in the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>.</p>
<p>By default, the behavior includes:</p>
<ol class="arabic">
<li><p>Iterate through collection types (e.g. tuple, list, dict) and recursively
call <code class="docutils literal notranslate"><span class="pre">create_args</span></code> on the elements.</p></li>
<li><p>Given a Proxy object, return a reference to the underlying IR <code class="docutils literal notranslate"><span class="pre">Node</span></code></p></li>
<li><p>Given a non-Proxy Tensor object, emit IR for various cases:</p>
<blockquote>
<div><ul class="simple">
<li><p>For a Parameter, emit a <code class="docutils literal notranslate"><span class="pre">get_attr</span></code> node referring to that Parameter</p></li>
<li><p>For a non-Parameter Tensor, store the Tensor away in a special
attribute referring to that attribute.</p></li>
</ul>
</div></blockquote>
</li>
</ol>
<p>This method can be overridden to support more types.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>a</strong> (<em>Any</em>) – The value to be emitted as an <code class="docutils literal notranslate"><span class="pre">Argument</span></code> in the <code class="docutils literal notranslate"><span class="pre">Graph</span></code>.</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The value <code class="docutils literal notranslate"><span class="pre">a</span></code> converted into the appropriate <code class="docutils literal notranslate"><span class="pre">Argument</span></code></p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.create_args_for_root">
<code class="sig-name descname"><span class="pre">create_args_for_root</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">root_fn</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">is_module</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">concrete_args</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#Tracer.create_args_for_root"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Tracer.create_args_for_root" title="Permalink to this definition">¶</a></dt>
<dd><p>Create <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> nodes corresponding to the signature of the <code class="docutils literal notranslate"><span class="pre">root</span></code>
Module. This method introspects root’s signature and emits those
nodes accordingly, also supporting <code class="docutils literal notranslate"><span class="pre">*args</span></code> and <code class="docutils literal notranslate"><span class="pre">**kwargs</span></code>.</p>
<div class="admonition warning">
<p class="admonition-title">Warning</p>
<p>This API is experimental and is <em>NOT</em> backward-compatible.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.create_node">
<code class="sig-name descname"><span class="pre">create_node</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">kind</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#torch.fx.Tracer.create_node" title="Permalink to this definition">¶</a></dt>
<dd><p>Inserts a graph node given target, args, kwargs, and name.</p>
<p>This method can be overridden to do extra checking, validation, or
modification of values used in node creation. For example, one might
want to disallow in-place operations from being recorded.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.create_proxy">
<code class="sig-name descname"><span class="pre">create_proxy</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">kind</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">name</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">type_expr</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">proxy_factory_fn</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#torch.fx.Tracer.create_proxy" title="Permalink to this definition">¶</a></dt>
<dd><p>Create a Node from the given arguments, then return the Node
wrapped in a Proxy object.</p>
<p>If kind = ‘placeholder’, then we’re creating a Node that
represents the parameter of a function. If we need to encode
a default parameter, we use the <code class="docutils literal notranslate"><span class="pre">args</span></code> tuple. <code class="docutils literal notranslate"><span class="pre">args</span></code> is
otherwise empty for <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> Nodes.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.is_leaf_module">
<code class="sig-name descname"><span class="pre">is_leaf_module</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">m</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">module_qualified_name</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#Tracer.is_leaf_module"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Tracer.is_leaf_module" title="Permalink to this definition">¶</a></dt>
<dd><p>A method to specify whether a given <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> is a “leaf” module.</p>
<p>Leaf modules are the atomic units that appear in
the IR, referenced by <code class="docutils literal notranslate"><span class="pre">call_module</span></code> calls. By default,
Modules in the PyTorch standard library namespace (torch.nn)
are leaf modules. All other modules are traced through and
their constituent ops are recorded, unless specified otherwise
via this parameter.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>m</strong> (<a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><em>Module</em></a>) – The module being queried about</p></li>
<li><p><strong>module_qualified_name</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – The path to root of this module. For example,
if you have a module hierarchy where submodule <code class="docutils literal notranslate"><span class="pre">foo</span></code> contains
submodule <code class="docutils literal notranslate"><span class="pre">bar</span></code>, which contains submodule <code class="docutils literal notranslate"><span class="pre">baz</span></code>, that module will
appear with the qualified name <code class="docutils literal notranslate"><span class="pre">foo.bar.baz</span></code> here.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.iter">
<code class="sig-name descname"><span class="pre">iter</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#torch.fx.Tracer.iter" title="Permalink to this definition">¶</a></dt>
<dd><dl class="simple">
<dt>Called when a proxy object is being iterated over, such as</dt><dd><p>when used in control flow.  Normally we don’t know what to do because
we don’t know the value of the proxy, but a custom tracer can attach more
information to the graph node using create_node and can choose to return an iterator.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.keys">
<code class="sig-name descname"><span class="pre">keys</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#torch.fx.Tracer.keys" title="Permalink to this definition">¶</a></dt>
<dd><dl class="simple">
<dt>Called when a proxy object is has the keys() method called.</dt><dd><p>This is what happens when ** is called on a proxy. This should return an
iterator it ** is suppose to work in your custom tracer.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.path_of_module">
<code class="sig-name descname"><span class="pre">path_of_module</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">mod</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#Tracer.path_of_module"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Tracer.path_of_module" title="Permalink to this definition">¶</a></dt>
<dd><p>Helper method to find the qualified name of <code class="docutils literal notranslate"><span class="pre">mod</span></code> in the Module hierarchy
of <code class="docutils literal notranslate"><span class="pre">root</span></code>. For example, if <code class="docutils literal notranslate"><span class="pre">root</span></code> has a submodule named <code class="docutils literal notranslate"><span class="pre">foo</span></code>, which has
a submodule named <code class="docutils literal notranslate"><span class="pre">bar</span></code>, passing <code class="docutils literal notranslate"><span class="pre">bar</span></code> into this function will return
the string “foo.bar”.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>mod</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – The <code class="docutils literal notranslate"><span class="pre">Module</span></code> to retrieve the qualified name for.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.proxy">
<code class="sig-name descname"><span class="pre">proxy</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#torch.fx.Tracer.proxy" title="Permalink to this definition">¶</a></dt>
<dd><div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.to_bool">
<code class="sig-name descname"><span class="pre">to_bool</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">obj</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#torch.fx.Tracer.to_bool" title="Permalink to this definition">¶</a></dt>
<dd><dl class="simple">
<dt>Called when a proxy object is being converted to a boolean, such as</dt><dd><p>when used in control flow.  Normally we don’t know what to do because
we don’t know the value of the proxy, but a custom tracer can attach more
information to the graph node using create_node and can choose to return a value.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Tracer.trace">
<code class="sig-name descname"><span class="pre">trace</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">root</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">concrete_args</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/_symbolic_trace.html#Tracer.trace"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Tracer.trace" title="Permalink to this definition">¶</a></dt>
<dd><p>Trace <code class="docutils literal notranslate"><span class="pre">root</span></code> and return the corresponding FX <code class="docutils literal notranslate"><span class="pre">Graph</span></code> representation. <code class="docutils literal notranslate"><span class="pre">root</span></code>
can either be an <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> instance or a Python callable.</p>
<p>Note that after this call, <code class="docutils literal notranslate"><span class="pre">self.root</span></code> may be different from the <code class="docutils literal notranslate"><span class="pre">root</span></code> passed
in here. For example, when a free function is passed to <code class="docutils literal notranslate"><span class="pre">trace()</span></code>, we will
create an <code class="docutils literal notranslate"><span class="pre">nn.Module</span></code> instance to use as the root and add embedded constants
to.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>root</strong> (<em>Union</em><em>[</em><a class="reference internal" href="generated/torch.nn.Module.html#torch.nn.Module" title="torch.nn.Module"><em>Module</em></a><em>, </em><em>Callable</em><em>]</em>) – Either a <code class="docutils literal notranslate"><span class="pre">Module</span></code> or a function to be
traced through. Backwards-compatibility for this parameter is
guaranteed.</p></li>
<li><p><strong>concrete_args</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a><em>, </em><em>any</em><em>]</em><em>]</em>) – Concrete arguments that should
not be treated as Proxies. This parameter is experimental and
its backwards-compatibility is <em>NOT</em> guaranteed.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>A <code class="docutils literal notranslate"><span class="pre">Graph</span></code> representing the semantics of the passed-in <code class="docutils literal notranslate"><span class="pre">root</span></code>.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

</dd></dl>

<dl class="py class">
<dt id="torch.fx.Proxy">
<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">Proxy</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">node</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">tracer</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/proxy.html#Proxy"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Proxy" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">Proxy</span></code> objects are <code class="docutils literal notranslate"><span class="pre">Node</span></code> wrappers that flow through the
program during symbolic tracing and record all the operations
(<code class="docutils literal notranslate"><span class="pre">torch</span></code> function calls, method calls, operators) that they touch
into the growing FX Graph.</p>
<p>If you’re doing graph transforms, you can wrap your own <code class="docutils literal notranslate"><span class="pre">Proxy</span></code>
method around a raw <code class="docutils literal notranslate"><span class="pre">Node</span></code> so that you can use the overloaded
operators to add additional things to a <code class="docutils literal notranslate"><span class="pre">Graph</span></code>.</p>
<p><code class="docutils literal notranslate"><span class="pre">Proxy</span></code> objects cannot be iterated. In other words, the symbolic
tracer will throw an error if a <code class="docutils literal notranslate"><span class="pre">Proxy</span></code> is used in a loop or as
an <code class="docutils literal notranslate"><span class="pre">*args</span></code>/<code class="docutils literal notranslate"><span class="pre">**kwargs</span></code> function argument.</p>
<p>There are two main ways around this:
1. Factor out the untraceable logic into a top-level function and
use <code class="docutils literal notranslate"><span class="pre">fx.wrap</span></code> on it.
2. If the control flow is static (i.e. the loop trip count is
based on some hyperparameter), the code can be kept in its original
position and refactored into something like:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></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="bp">self</span><span class="o">.</span><span class="n">some_hyperparameter</span><span class="p">):</span>
    <span class="n">indexed_item</span> <span class="o">=</span> <span class="n">proxied_value</span><span class="p">[</span><span class="n">i</span><span class="p">]</span>
</pre></div>
</div>
<p>For a more detailed description into the Proxy internals, check out
the “Proxy” section in <cite>torch/fx/OVERVIEW.md</cite></p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py class">
<dt id="torch.fx.Interpreter">
<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">Interpreter</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">module</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">garbage_collect_values</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">True</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter" title="Permalink to this definition">¶</a></dt>
<dd><p>An Interpreter executes an FX graph Node-by-Node. This pattern
can be useful for many things, including writing code
transformations as well as analysis passes.</p>
<p>Methods in the Interpreter class can be overridden to customize
the behavior of execution. The map of overrideable methods
in terms of call hierarchy:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">run</span><span class="p">()</span>
    <span class="o">+--</span> <span class="n">run_node</span>
        <span class="o">+--</span> <span class="n">placeholder</span><span class="p">()</span>
        <span class="o">+--</span> <span class="n">get_attr</span><span class="p">()</span>
        <span class="o">+--</span> <span class="n">call_function</span><span class="p">()</span>
        <span class="o">+--</span> <span class="n">call_method</span><span class="p">()</span>
        <span class="o">+--</span> <span class="n">call_module</span><span class="p">()</span>
        <span class="o">+--</span> <span class="n">output</span><span class="p">()</span>
</pre></div>
</div>
<p class="rubric">Example</p>
<p>Suppose we want to swap all instances of <code class="docutils literal notranslate"><span class="pre">torch.neg</span></code> with
<code class="docutils literal notranslate"><span class="pre">torch.sigmoid</span></code> and vice versa (including their <code class="docutils literal notranslate"><span class="pre">Tensor</span></code>
method equivalents). We could subclass Interpreter like so:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">NegSigmSwapInterpreter</span><span class="p">(</span><span class="n">Interpreter</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">call_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">target</span> <span class="p">:</span> <span class="n">Target</span><span class="p">,</span>
                      <span class="n">args</span> <span class="p">:</span> <span class="n">Tuple</span><span class="p">,</span> <span class="n">kwargs</span> <span class="p">:</span> <span class="n">Dict</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">target</span> <span class="o">==</span> <span class="n">torch</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">call_function</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">call_method</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">target</span> <span class="p">:</span> <span class="n">Target</span><span class="p">,</span>
                    <span class="n">args</span> <span class="p">:</span> <span class="n">Tuple</span><span class="p">,</span> <span class="n">kwargs</span> <span class="p">:</span> <span class="n">Dict</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">target</span> <span class="o">==</span> <span class="s1">&#39;neg&#39;</span><span class="p">:</span>
            <span class="n">call_self</span><span class="p">,</span> <span class="o">*</span><span class="n">args_tail</span> <span class="o">=</span> <span class="n">args</span>
            <span class="k">return</span> <span class="n">call_self</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">(</span><span class="o">*</span><span class="n">args_tail</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">call_method</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">fn</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">neg</span><span class="p">()</span>

<span class="n">gm</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">fn</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">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="n">result</span> <span class="o">=</span> <span class="n">NegSigmSwapInterpreter</span><span class="p">(</span><span class="n">gm</span><span class="p">)</span><span class="o">.</span><span class="n">run</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">testing</span><span class="o">.</span><span class="n">assert_allclose</span><span class="p">(</span><span class="n">result</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">())</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>module</strong> (<a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><em>GraphModule</em></a>) – The module to be executed</p></li>
<li><p><strong>garbage_collect_values</strong> (<a class="reference external" href="https://docs.python.org/3/library/functions.html#bool" title="(in Python v3.10)"><em>bool</em></a>) – Whether to delete values after their last
use within the Module’s execution. This ensures optimal memory usage during
execution. This can be disabled to, for example, examine all of the intermediate
values in the execution by looking at the <code class="docutils literal notranslate"><span class="pre">Interpreter.env</span></code> attribute.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
<dl class="py method">
<dt id="torch.fx.Interpreter.call_function">
<code class="sig-name descname"><span class="pre">call_function</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.call_function"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.call_function" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute a <code class="docutils literal notranslate"><span class="pre">call_function</span></code> node and return the result.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
</dl>
<dl class="simple">
<dt>Return</dt><dd><p>Any: The value returned by the function invocation</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.call_method">
<code class="sig-name descname"><span class="pre">call_method</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.call_method"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.call_method" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute a <code class="docutils literal notranslate"><span class="pre">call_method</span></code> node and return the result.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
</dl>
<dl class="simple">
<dt>Return</dt><dd><p>Any: The value returned by the method invocation</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.call_module">
<code class="sig-name descname"><span class="pre">call_module</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.call_module"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.call_module" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute a <code class="docutils literal notranslate"><span class="pre">call_module</span></code> node and return the result.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
</dl>
<dl class="simple">
<dt>Return</dt><dd><p>Any: The value returned by the module invocation</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.fetch_args_kwargs_from_env">
<code class="sig-name descname"><span class="pre">fetch_args_kwargs_from_env</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">n</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.fetch_args_kwargs_from_env"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.fetch_args_kwargs_from_env" title="Permalink to this definition">¶</a></dt>
<dd><p>Fetch the concrete values of <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> of node <code class="docutils literal notranslate"><span class="pre">n</span></code>
from the current execution environment.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>n</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The node for which <code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> should be fetched.</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><code class="docutils literal notranslate"><span class="pre">args</span></code> and <code class="docutils literal notranslate"><span class="pre">kwargs</span></code> with concrete values for <code class="docutils literal notranslate"><span class="pre">n</span></code>.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>Tuple[Tuple, Dict]</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.fetch_attr">
<code class="sig-name descname"><span class="pre">fetch_attr</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.fetch_attr"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.fetch_attr" title="Permalink to this definition">¶</a></dt>
<dd><p>Fetch an attribute from the <code class="docutils literal notranslate"><span class="pre">Module</span></code> hierarchy of <code class="docutils literal notranslate"><span class="pre">self.module</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>target</strong> (<a class="reference external" href="https://docs.python.org/3/library/stdtypes.html#str" title="(in Python v3.10)"><em>str</em></a>) – The fully-qualfiied name of the attribute to fetch</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The value of the attribute.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>Any</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.get_attr">
<code class="sig-name descname"><span class="pre">get_attr</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.get_attr"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.get_attr" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute a <code class="docutils literal notranslate"><span class="pre">get_attr</span></code> node. Will retrieve an attribute
value from the <code class="docutils literal notranslate"><span class="pre">Module</span></code> hierarchy of <code class="docutils literal notranslate"><span class="pre">self.module</span></code>.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The value of the attribute that was retrieved</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>Any</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.map_nodes_to_values">
<code class="sig-name descname"><span class="pre">map_nodes_to_values</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">n</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.map_nodes_to_values"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.map_nodes_to_values" title="Permalink to this definition">¶</a></dt>
<dd><p>Recursively descend through <code class="docutils literal notranslate"><span class="pre">args</span></code> and look up the concrete value
for each <code class="docutils literal notranslate"><span class="pre">Node</span></code> in the current execution environment.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>args</strong> (<em>Argument</em>) – Data structure within which to look up concrete values</p></li>
<li><p><strong>n</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – Node to which <code class="docutils literal notranslate"><span class="pre">args</span></code> belongs. This is only used for error reporting.</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.output">
<code class="sig-name descname"><span class="pre">output</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.output"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.output" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute an <code class="docutils literal notranslate"><span class="pre">output</span></code> node. This really just retrieves
the value referenced by the <code class="docutils literal notranslate"><span class="pre">output</span></code> node and returns it.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The return value referenced by the output node</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>Any</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.placeholder">
<code class="sig-name descname"><span class="pre">placeholder</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.placeholder"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.placeholder" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute a <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> node. Note that this is stateful:
<code class="docutils literal notranslate"><span class="pre">Interpreter</span></code> maintains an internal iterator over
arguments passed to <code class="docutils literal notranslate"><span class="pre">run</span></code> and this method returns
next() on that iterator.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The argument value that was retrieved.</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>Any</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.run">
<code class="sig-name descname"><span class="pre">run</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">initial_env</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">None</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.run"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.run" title="Permalink to this definition">¶</a></dt>
<dd><p>Run <cite>module</cite> via interpretation and return the result.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>*args</strong> – The arguments to the Module to run, in positional order</p></li>
<li><p><strong>initial_env</strong> (<em>Optional</em><em>[</em><em>Dict</em><em>[</em><a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a><em>, </em><em>Any</em><em>]</em><em>]</em>) – An optional starting environment for execution.
This is a dict mapping <cite>Node</cite> to any value. This can be used, for example, to
pre-populate results for certain <cite>Nodes</cite> so as to do only partial evaluation within
the interpreter.</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The value returned from executing the Module</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>Any</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Interpreter.run_node">
<code class="sig-name descname"><span class="pre">run_node</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">n</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Interpreter.run_node"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Interpreter.run_node" title="Permalink to this definition">¶</a></dt>
<dd><p>Run a specific node <code class="docutils literal notranslate"><span class="pre">n</span></code> and return the result.
Calls into placeholder, get_attr, call_function,
call_method, call_module, or output depending
on <code class="docutils literal notranslate"><span class="pre">node.op</span></code></p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>n</strong> (<a class="reference internal" href="#torch.fx.Node" title="torch.fx.Node"><em>Node</em></a>) – The Node to execute</p>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p>The result of executing <code class="docutils literal notranslate"><span class="pre">n</span></code></p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>Any</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

</dd></dl>

<dl class="py class">
<dt id="torch.fx.Transformer">
<em class="property"><span class="pre">class</span> </em><code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">Transformer</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">module</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Transformer"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Transformer" title="Permalink to this definition">¶</a></dt>
<dd><p><code class="docutils literal notranslate"><span class="pre">Transformer</span></code> is a special type of interpreter that produces a
new <code class="docutils literal notranslate"><span class="pre">Module</span></code>. It exposes a <code class="docutils literal notranslate"><span class="pre">transform()</span></code> method that returns
the transformed <code class="docutils literal notranslate"><span class="pre">Module</span></code>. <code class="docutils literal notranslate"><span class="pre">Transformer</span></code> does not require
arguments to run, as <code class="docutils literal notranslate"><span class="pre">Interpreter</span></code> does. <code class="docutils literal notranslate"><span class="pre">Transformer</span></code> works
entirely symbolically.</p>
<p class="rubric">Example</p>
<p>Suppose we want to swap all instances of <code class="docutils literal notranslate"><span class="pre">torch.neg</span></code> with
<code class="docutils literal notranslate"><span class="pre">torch.sigmoid</span></code> and vice versa (including their <code class="docutils literal notranslate"><span class="pre">Tensor</span></code>
method equivalents). We could subclass <code class="docutils literal notranslate"><span class="pre">Transformer</span></code> like so:</p>
<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">NegSigmSwapXformer</span><span class="p">(</span><span class="n">Transformer</span><span class="p">):</span>
    <span class="k">def</span> <span class="nf">call_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">target</span> <span class="p">:</span> <span class="s1">&#39;Target&#39;</span><span class="p">,</span> <span class="n">args</span> <span class="p">:</span> <span class="n">Tuple</span><span class="p">[</span><span class="n">Argument</span><span class="p">,</span> <span class="o">...</span><span class="p">],</span> <span class="n">kwargs</span> <span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">target</span> <span class="o">==</span> <span class="n">torch</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">:</span>
            <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">call_function</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>

    <span class="k">def</span> <span class="nf">call_method</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">target</span> <span class="p">:</span> <span class="s1">&#39;Target&#39;</span><span class="p">,</span> <span class="n">args</span> <span class="p">:</span> <span class="n">Tuple</span><span class="p">[</span><span class="n">Argument</span><span class="p">,</span> <span class="o">...</span><span class="p">],</span> <span class="n">kwargs</span> <span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="nb">str</span><span class="p">,</span> <span class="n">Any</span><span class="p">])</span> <span class="o">-&gt;</span> <span class="n">Any</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">target</span> <span class="o">==</span> <span class="s1">&#39;neg&#39;</span><span class="p">:</span>
            <span class="n">call_self</span><span class="p">,</span> <span class="o">*</span><span class="n">args_tail</span> <span class="o">=</span> <span class="n">args</span>
            <span class="k">return</span> <span class="n">call_self</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">(</span><span class="o">*</span><span class="n">args_tail</span><span class="p">,</span> <span class="o">**</span><span class="n">kwargs</span><span class="p">)</span>
        <span class="k">return</span> <span class="nb">super</span><span class="p">()</span><span class="o">.</span><span class="n">call_method</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">fn</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">(</span><span class="n">x</span><span class="p">)</span><span class="o">.</span><span class="n">neg</span><span class="p">()</span>

<span class="n">gm</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">fx</span><span class="o">.</span><span class="n">symbolic_trace</span><span class="p">(</span><span class="n">fn</span><span class="p">)</span>

<span class="n">transformed</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="o">=</span> <span class="n">NegSigmSwapXformer</span><span class="p">(</span><span class="n">gm</span><span class="p">)</span><span class="o">.</span><span class="n">transform</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">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">)</span>
<span class="n">torch</span><span class="o">.</span><span class="n">testing</span><span class="o">.</span><span class="n">assert_allclose</span><span class="p">(</span><span class="n">transformed</span><span class="p">(</span><span class="nb">input</span><span class="p">),</span> <span class="n">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="nb">input</span><span class="p">)</span><span class="o">.</span><span class="n">sigmoid</span><span class="p">())</span>
</pre></div>
</div>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><p><strong>module</strong> (<a class="reference internal" href="#torch.fx.GraphModule" title="torch.fx.GraphModule"><em>GraphModule</em></a>) – The <code class="docutils literal notranslate"><span class="pre">Module</span></code> to be transformed.</p>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
<dl class="py method">
<dt id="torch.fx.Transformer.call_function">
<code class="sig-name descname"><span class="pre">call_function</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Transformer.call_function"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Transformer.call_function" title="Permalink to this definition">¶</a></dt>
<dd><div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Transformer.call_module">
<code class="sig-name descname"><span class="pre">call_module</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Transformer.call_module"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Transformer.call_module" title="Permalink to this definition">¶</a></dt>
<dd><div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Transformer.get_attr">
<code class="sig-name descname"><span class="pre">get_attr</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Transformer.get_attr"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Transformer.get_attr" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute a <code class="docutils literal notranslate"><span class="pre">get_attr</span></code> node. In <code class="docutils literal notranslate"><span class="pre">Transformer</span></code>, this is
overridden to insert a new <code class="docutils literal notranslate"><span class="pre">get_attr</span></code> node into the output
graph.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Transformer.placeholder">
<code class="sig-name descname"><span class="pre">placeholder</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">target</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">kwargs</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Transformer.placeholder"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Transformer.placeholder" title="Permalink to this definition">¶</a></dt>
<dd><p>Execute a <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> node. In <code class="docutils literal notranslate"><span class="pre">Transformer</span></code>, this is
overridden to insert a new <code class="docutils literal notranslate"><span class="pre">placeholder</span></code> into the output
graph.</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>target</strong> (<em>Target</em>) – The call target for this node. See
<a class="reference external" href="https://pytorch.org/docs/master/fx.html#torch.fx.Node">Node</a> for
details on semantics</p></li>
<li><p><strong>args</strong> (<em>Tuple</em>) – Tuple of positional args for this invocation</p></li>
<li><p><strong>kwargs</strong> (<em>Dict</em>) – Dict of keyword arguments for this invocation</p></li>
</ul>
</dd>
</dl>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

<dl class="py method">
<dt id="torch.fx.Transformer.transform">
<code class="sig-name descname"><span class="pre">transform</span></code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/interpreter.html#Transformer.transform"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.Transformer.transform" title="Permalink to this definition">¶</a></dt>
<dd><p>Transform <code class="docutils literal notranslate"><span class="pre">self.module</span></code> and return the transformed
<code class="docutils literal notranslate"><span class="pre">GraphModule</span></code>.</p>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

</dd></dl>

<dl class="py function">
<dt id="torch.fx.replace_pattern">
<code class="sig-prename descclassname"><span class="pre">torch.fx.</span></code><code class="sig-name descname"><span class="pre">replace_pattern</span></code><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">gm</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">pattern</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">replacement</span></span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/torch/fx/subgraph_rewriter.html#replace_pattern"><span class="viewcode-link"><span class="pre">[source]</span></span></a><a class="headerlink" href="#torch.fx.replace_pattern" title="Permalink to this definition">¶</a></dt>
<dd><p>Matches all possible non-overlapping sets of operators and their
data dependencies (<code class="docutils literal notranslate"><span class="pre">pattern</span></code>) in the Graph of a GraphModule
(<code class="docutils literal notranslate"><span class="pre">gm</span></code>), then replaces each of these matched subgraphs with another
subgraph (<code class="docutils literal notranslate"><span class="pre">replacement</span></code>).</p>
<dl class="field-list simple">
<dt class="field-odd">Parameters</dt>
<dd class="field-odd"><ul class="simple">
<li><p><strong>gm</strong> – The GraphModule that wraps the Graph to operate on</p></li>
<li><p><strong>pattern</strong> – The subgraph to match in <code class="docutils literal notranslate"><span class="pre">gm</span></code> for replacement</p></li>
<li><p><strong>replacement</strong> – The subgraph to replace <code class="docutils literal notranslate"><span class="pre">pattern</span></code> with</p></li>
</ul>
</dd>
<dt class="field-even">Returns</dt>
<dd class="field-even"><p><p>A list of <code class="docutils literal notranslate"><span class="pre">Match</span></code> objects representing the places
in the original graph that <code class="docutils literal notranslate"><span class="pre">pattern</span></code> was matched to. The list
is empty if there are no matches. <code class="docutils literal notranslate"><span class="pre">Match</span></code> is defined as:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Match</span><span class="p">(</span><span class="n">NamedTuple</span><span class="p">):</span>
    <span class="c1"># Node from which the match was found</span>
    <span class="n">anchor</span><span class="p">:</span> <span class="n">Node</span>
    <span class="c1"># Maps nodes in the pattern subgraph to nodes in the larger graph</span>
    <span class="n">nodes_map</span><span class="p">:</span> <span class="n">Dict</span><span class="p">[</span><span class="n">Node</span><span class="p">,</span> <span class="n">Node</span><span class="p">]</span>
</pre></div>
</div>
</p>
</dd>
<dt class="field-odd">Return type</dt>
<dd class="field-odd"><p>List[Match]</p>
</dd>
</dl>
<p>Examples:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">torch</span>
<span class="kn">from</span> <span class="nn">torch.fx</span> <span class="kn">import</span> <span class="n">symbolic_trace</span><span class="p">,</span> <span class="n">subgraph_rewriter</span>

<span class="k">class</span> <span class="nc">M</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="nb">super</span><span class="p">()</span><span class="o">.</span><span class="fm">__init__</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">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">):</span>
        <span class="n">m1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cat</span><span class="p">([</span><span class="n">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">])</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span>
        <span class="n">m2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">cat</span><span class="p">([</span><span class="n">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">])</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span>
        <span class="k">return</span> <span class="n">x</span> <span class="o">+</span> <span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">m1</span><span class="p">)</span> <span class="o">+</span> <span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">m2</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">pattern</span><span class="p">(</span><span class="n">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">):</span>
    <span class="k">return</span> <span class="n">torch</span><span class="o">.</span><span class="n">cat</span><span class="p">([</span><span class="n">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">])</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span>

<span class="k">def</span> <span class="nf">replacement</span><span class="p">(</span><span class="n">w1</span><span class="p">,</span> <span class="n">w2</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">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">])</span>

<span class="n">traced_module</span> <span class="o">=</span> <span class="n">symbolic_trace</span><span class="p">(</span><span class="n">M</span><span class="p">())</span>

<span class="n">subgraph_rewriter</span><span class="o">.</span><span class="n">replace_pattern</span><span class="p">(</span><span class="n">traced_module</span><span class="p">,</span> <span class="n">pattern</span><span class="p">,</span> <span class="n">replacement</span><span class="p">)</span>
</pre></div>
</div>
<p>The above code will first match <code class="docutils literal notranslate"><span class="pre">pattern</span></code> in the <code class="docutils literal notranslate"><span class="pre">forward</span></code>
method of <code class="docutils literal notranslate"><span class="pre">traced_module</span></code>. Pattern-matching is done based on
use-def relationships, not node names. For example, if you had
<code class="docutils literal notranslate"><span class="pre">p</span> <span class="pre">=</span> <span class="pre">torch.cat([a,</span> <span class="pre">b])</span></code> in <code class="docutils literal notranslate"><span class="pre">pattern</span></code>, you could match
<code class="docutils literal notranslate"><span class="pre">m</span> <span class="pre">=</span> <span class="pre">torch.cat([a,</span> <span class="pre">b])</span></code> in the original <code class="docutils literal notranslate"><span class="pre">forward</span></code> function,
despite the variable names being different (<code class="docutils literal notranslate"><span class="pre">p</span></code> vs <code class="docutils literal notranslate"><span class="pre">m</span></code>).</p>
<p>The <code class="docutils literal notranslate"><span class="pre">return</span></code> statement in <code class="docutils literal notranslate"><span class="pre">pattern</span></code> is matched based on its
value only; it may or may not match to the <code class="docutils literal notranslate"><span class="pre">return</span></code> statement in
the larger graph. In other words, the pattern doesn’t have to extend
to the end of the larger graph.</p>
<p>When the pattern is matched, it will be removed from the larger
function and replaced by <code class="docutils literal notranslate"><span class="pre">replacement</span></code>. If there are multiple
matches for <code class="docutils literal notranslate"><span class="pre">pattern</span></code> in the larger function, each non-overlapping
match will be replaced. In the case of a match overlap, the first
found match in the set of overlapping matches will be replaced.
(“First” here being defined as the first in a topological ordering
of the Nodes’ use-def relationships. In most cases, the first Node
is the parameter that appears directly after <code class="docutils literal notranslate"><span class="pre">self</span></code>, while the
last Node is whatever the function returns.)</p>
<p>One important thing to note is that the parameters of the
<code class="docutils literal notranslate"><span class="pre">pattern</span></code> Callable must be used in the Callable itself,
and the parameters of the <code class="docutils literal notranslate"><span class="pre">replacement</span></code> Callable must match
the pattern. The first rule is why, in the above code block, the
<code class="docutils literal notranslate"><span class="pre">forward</span></code> function has parameters <code class="docutils literal notranslate"><span class="pre">x,</span> <span class="pre">w1,</span> <span class="pre">w2</span></code>, but the
<code class="docutils literal notranslate"><span class="pre">pattern</span></code> function only has parameters <code class="docutils literal notranslate"><span class="pre">w1,</span> <span class="pre">w2</span></code>. <code class="docutils literal notranslate"><span class="pre">pattern</span></code>
doesn’t use <code class="docutils literal notranslate"><span class="pre">x</span></code>, so it shouldn’t specify <code class="docutils literal notranslate"><span class="pre">x</span></code> as a parameter.
As an example of the second rule, consider replacing</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">pattern</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">torch</span><span class="o">.</span><span class="n">neg</span><span class="p">(</span><span class="n">x</span><span class="p">)</span> <span class="o">+</span> <span class="n">torch</span><span class="o">.</span><span class="n">relu</span><span class="p">(</span><span class="n">y</span><span class="p">)</span>
</pre></div>
</div>
<p>with</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">replacement</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">torch</span><span class="o">.</span><span class="n">relu</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
</pre></div>
</div>
<p>In this case, <code class="docutils literal notranslate"><span class="pre">replacement</span></code> needs the same number of parameters
as <code class="docutils literal notranslate"><span class="pre">pattern</span></code> (both <code class="docutils literal notranslate"><span class="pre">x</span></code> and <code class="docutils literal notranslate"><span class="pre">y</span></code>), even though the parameter
<code class="docutils literal notranslate"><span class="pre">y</span></code> isn’t used in <code class="docutils literal notranslate"><span class="pre">replacement</span></code>.</p>
<p>After calling <code class="docutils literal notranslate"><span class="pre">subgraph_rewriter.replace_pattern</span></code>, the generated
Python code looks like this:</p>
<div class="highlight-python notranslate"><div class="highlight"><pre><span></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">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">):</span>
    <span class="n">stack_1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">([</span><span class="n">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">])</span>
    <span class="n">sum_1</span> <span class="o">=</span> <span class="n">stack_1</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span>
    <span class="n">stack_2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">stack</span><span class="p">([</span><span class="n">w1</span><span class="p">,</span> <span class="n">w2</span><span class="p">])</span>
    <span class="n">sum_2</span> <span class="o">=</span> <span class="n">stack_2</span><span class="o">.</span><span class="n">sum</span><span class="p">()</span>
    <span class="n">max_1</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">sum_1</span><span class="p">)</span>
    <span class="n">add_1</span> <span class="o">=</span> <span class="n">x</span> <span class="o">+</span> <span class="n">max_1</span>
    <span class="n">max_2</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">max</span><span class="p">(</span><span class="n">sum_2</span><span class="p">)</span>
    <span class="n">add_2</span> <span class="o">=</span> <span class="n">add_1</span> <span class="o">+</span> <span class="n">max_2</span>
    <span class="k">return</span> <span class="n">add_2</span>
</pre></div>
</div>
<div class="admonition note">
<p class="admonition-title">Note</p>
<p>Backwards-compatibility for this API is guaranteed.</p>
</div>
</dd></dl>

</div>
</div>


             </article>
             
            </div>
            <footer>
  
    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
      
        <a href="hub.html" class="btn btn-neutral float-right" title="torch.hub" accesskey="n" rel="next">Next <img src="_static/images/chevron-right-orange.svg" class="next-page"></a>
      
      
        <a href="futures.html" class="btn btn-neutral" title="torch.futures" 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.fx</a><ul>
<li><a class="reference internal" href="#module-torch.fx">Overview</a></li>
<li><a class="reference internal" href="#writing-transformations">Writing Transformations</a><ul>
<li><a class="reference internal" href="#a-quick-primer-on-graphs">A Quick Primer on Graphs</a></li>
<li><a class="reference internal" href="#graph-manipulation">Graph Manipulation</a><ul>
<li><a class="reference internal" href="#direct-graph-manipulation">Direct Graph Manipulation</a></li>
<li><a class="reference internal" href="#subgraph-rewriting-with-replace-pattern">Subgraph Rewriting With replace_pattern()</a></li>
<li><a class="reference internal" href="#graph-manipulation-examples">Graph Manipulation Examples</a></li>
</ul>
</li>
<li><a class="reference internal" href="#proxy-retracing">Proxy/Retracing</a></li>
<li><a class="reference internal" href="#the-interpreter-pattern">The Interpreter Pattern</a><ul>
<li><a class="reference internal" href="#examples-of-the-interpreter-pattern">Examples of the Interpreter Pattern</a></li>
</ul>
</li>
</ul>
</li>
<li><a class="reference internal" href="#debugging">Debugging</a><ul>
<li><a class="reference internal" href="#introduction">Introduction</a></li>
<li><a class="reference internal" href="#common-pitfalls-in-transform-authoring">Common Pitfalls in Transform Authoring</a></li>
<li><a class="reference internal" href="#checking-correctness-of-modules">Checking Correctness of Modules</a></li>
<li><a class="reference internal" href="#debugging-the-generated-code">Debugging the Generated Code</a><ul>
<li><a class="reference internal" href="#use-pdb">Use <code class="docutils literal notranslate"><span class="pre">pdb</span></code></a></li>
<li><a class="reference internal" href="#print-the-generated-code">Print the Generated Code</a></li>
<li><a class="reference internal" href="#use-the-to-folder-function-from-graphmodule">Use the <code class="docutils literal notranslate"><span class="pre">to_folder</span></code> Function From <code class="docutils literal notranslate"><span class="pre">GraphModule</span></code></a></li>
</ul>
</li>
<li><a class="reference internal" href="#debugging-the-transformation">Debugging the Transformation</a></li>
<li><a class="reference internal" href="#available-debuggers">Available Debuggers</a></li>
</ul>
</li>
<li><a class="reference internal" href="#limitations-of-symbolic-tracing">Limitations of Symbolic Tracing</a><ul>
<li><a class="reference internal" href="#dynamic-control-flow">Dynamic Control Flow</a><ul>
<li><a class="reference internal" href="#static-control-flow">Static Control Flow</a></li>
</ul>
</li>
<li><a class="reference internal" href="#non-torch-functions">Non-<code class="docutils literal notranslate"><span class="pre">torch</span></code> Functions</a></li>
<li><a class="reference internal" href="#customizing-tracing-with-the-tracer-class">Customizing Tracing with the <code class="docutils literal notranslate"><span class="pre">Tracer</span></code> class</a><ul>
<li><a class="reference internal" href="#leaf-modules">Leaf Modules</a></li>
</ul>
</li>
<li><a class="reference internal" href="#miscellanea">Miscellanea</a></li>
</ul>
</li>
<li><a class="reference internal" href="#api-reference">API Reference</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/clipboard.min.js"></script>
         <script src="_static/copybutton.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>

<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>