torch.html



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

  <script type="text/javascript" src="../_static/js/modernizr.min.js"></script>
  
    
      <script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
        <script src="../_static/jquery.js"></script>
        <script src="../_static/underscore.js"></script>
        <script src="../_static/doctools.js"></script>
        <script src="../_static/language_data.js"></script>
        <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
    
    <script type="text/javascript" src="../_static/js/theme.js"></script>

    
  <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/graphviz.css" type="text/css" />
    <link rel="index" title="Index" href="../genindex.html" />
    <link rel="search" title="Search" href="../search.html" /> 
</head>

<body class="wy-body-for-nav">

   
  <div class="wy-grid-for-nav">
    
    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
      <div class="wy-side-scroll">
        <div class="wy-side-nav-search" >
          

            <a href="../index.html" class="icon icon-home"> DI-treetensor
          

          </a>

          
              <div class="version">
                0.3.0
              </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>

        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
          
            
              <p><span class="caption-text">Tutorials</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../tutorials/installation/index.html">Installation</a></li>
<li class="toctree-l1"><a class="reference internal" href="../tutorials/quick_start/index.html">Quick Start</a></li>
<li class="toctree-l1"><a class="reference internal" href="../tutorials/plugins/index.html">Plugins</a></li>
</ul>
<p><span class="caption-text">Best Practice</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../best_practice/stack/index.html">Stack Structured Data</a></li>
<li class="toctree-l1"><a class="reference internal" href="../best_practice/operation/index.html">Customized Operations For Different Fields</a></li>
</ul>
<p><span class="caption-text">API Documentation</span></p>
<ul>
<li class="toctree-l1"><a class="reference internal" href="../api_doc/common/index.html">treetensor.common</a></li>
<li class="toctree-l1"><a class="reference internal" href="../api_doc/config/index.html">treetensor.config</a></li>
<li class="toctree-l1"><a class="reference internal" href="../api_doc/numpy/index.html">treetensor.numpy</a></li>
<li class="toctree-l1"><a class="reference internal" href="../api_doc/torch/index.html">treetensor.torch</a></li>
<li class="toctree-l1"><a class="reference internal" href="../api_doc/utils/index.html">treetensor.utils</a></li>
</ul>

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

    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">

      
      <nav class="wy-nav-top" aria-label="top navigation">
        
          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
          <a href="../index.html">DI-treetensor</a>
        
      </nav>


      <div class="wy-nav-content">
        
        <div class="rst-content">
        
          
<div role="navigation" aria-label="breadcrumbs navigation">

  <ul class="wy-breadcrumbs">
    
      <li><a href="../index.html">Docs</a> &raquo;</li>
        
          <li><a href="index.html">Module code</a> &raquo;</li>
        
      <li>torch</li>
    
    
      <li class="wy-breadcrumbs-aside">
        
      </li>
    
  </ul>

  
  <hr/>
</div>
          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
           <div itemprop="articleBody">
            
    
  <h1>Source code for torch</h1><div class="highlight"><pre>
<span></span>
<span class="sa">r</span><span class="sd">&quot;&quot;&quot;</span>
<span class="sd">The torch package contains data structures for multi-dimensional</span>
<span class="sd">tensors and defines mathematical operations over these tensors.</span>
<span class="sd">Additionally, it provides many utilities for efficient serializing of</span>
<span class="sd">Tensors and arbitrary types, and other useful utilities.</span>

<span class="sd">It has a CUDA counterpart, that enables you to run your tensor computations</span>
<span class="sd">on an NVIDIA GPU with compute capability &gt;= 3.0.</span>
<span class="sd">&quot;&quot;&quot;</span>

<span class="kn">import</span> <span class="nn">os</span>
<span class="kn">import</span> <span class="nn">sys</span>
<span class="kn">import</span> <span class="nn">platform</span>
<span class="kn">import</span> <span class="nn">textwrap</span>
<span class="kn">import</span> <span class="nn">ctypes</span>
<span class="kn">import</span> <span class="nn">warnings</span>

<span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span> <span class="o">&lt;</span> <span class="p">(</span><span class="mi">3</span><span class="p">,):</span>
    <span class="k">raise</span> <span class="ne">Exception</span><span class="p">(</span><span class="s2">&quot;Python 2 has reached end-of-life and is no longer supported by PyTorch.&quot;</span><span class="p">)</span>

<span class="kn">from</span> <span class="nn">._utils</span> <span class="kn">import</span> <span class="n">_import_dotted_name</span>
<span class="kn">from</span> <span class="nn">._utils_internal</span> <span class="kn">import</span> <span class="n">get_file_path</span><span class="p">,</span> <span class="n">prepare_multiprocessing_environment</span><span class="p">,</span> \
    <span class="n">USE_RTLD_GLOBAL_WITH_LIBTORCH</span><span class="p">,</span> <span class="n">USE_GLOBAL_DEPS</span>
<span class="c1"># TODO(torch_deploy) figure out how to freeze version.py in fbcode build</span>
<span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">executable</span> <span class="o">==</span> <span class="s1">&#39;torch_deploy&#39;</span><span class="p">:</span>
    <span class="n">__version__</span> <span class="o">=</span> <span class="s2">&quot;torch-deploy-1.8&quot;</span>
<span class="k">else</span><span class="p">:</span>
    <span class="kn">from</span> <span class="nn">.version</span> <span class="kn">import</span> <span class="n">__version__</span> <span class="k">as</span> <span class="n">__version__</span>
<span class="kn">from</span> <span class="nn">._six</span> <span class="kn">import</span> <span class="n">string_classes</span> <span class="k">as</span> <span class="n">_string_classes</span>

<span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Set</span><span class="p">,</span> <span class="n">Type</span><span class="p">,</span> <span class="n">TYPE_CHECKING</span>

<span class="n">__all__</span> <span class="o">=</span> <span class="p">[</span>
    <span class="s1">&#39;typename&#39;</span><span class="p">,</span> <span class="s1">&#39;is_tensor&#39;</span><span class="p">,</span> <span class="s1">&#39;is_storage&#39;</span><span class="p">,</span> <span class="s1">&#39;set_default_tensor_type&#39;</span><span class="p">,</span>
    <span class="s1">&#39;set_rng_state&#39;</span><span class="p">,</span> <span class="s1">&#39;get_rng_state&#39;</span><span class="p">,</span> <span class="s1">&#39;manual_seed&#39;</span><span class="p">,</span> <span class="s1">&#39;initial_seed&#39;</span><span class="p">,</span> <span class="s1">&#39;seed&#39;</span><span class="p">,</span>
    <span class="s1">&#39;save&#39;</span><span class="p">,</span> <span class="s1">&#39;load&#39;</span><span class="p">,</span> <span class="s1">&#39;set_printoptions&#39;</span><span class="p">,</span> <span class="s1">&#39;chunk&#39;</span><span class="p">,</span> <span class="s1">&#39;split&#39;</span><span class="p">,</span> <span class="s1">&#39;stack&#39;</span><span class="p">,</span> <span class="s1">&#39;matmul&#39;</span><span class="p">,</span>
    <span class="s1">&#39;no_grad&#39;</span><span class="p">,</span> <span class="s1">&#39;enable_grad&#39;</span><span class="p">,</span> <span class="s1">&#39;rand&#39;</span><span class="p">,</span> <span class="s1">&#39;randn&#39;</span><span class="p">,</span> <span class="s1">&#39;inference_mode&#39;</span><span class="p">,</span>
    <span class="s1">&#39;DoubleStorage&#39;</span><span class="p">,</span> <span class="s1">&#39;FloatStorage&#39;</span><span class="p">,</span> <span class="s1">&#39;LongStorage&#39;</span><span class="p">,</span> <span class="s1">&#39;IntStorage&#39;</span><span class="p">,</span>
    <span class="s1">&#39;ShortStorage&#39;</span><span class="p">,</span> <span class="s1">&#39;CharStorage&#39;</span><span class="p">,</span> <span class="s1">&#39;ByteStorage&#39;</span><span class="p">,</span> <span class="s1">&#39;BoolStorage&#39;</span><span class="p">,</span>
    <span class="s1">&#39;DoubleTensor&#39;</span><span class="p">,</span> <span class="s1">&#39;FloatTensor&#39;</span><span class="p">,</span> <span class="s1">&#39;LongTensor&#39;</span><span class="p">,</span> <span class="s1">&#39;IntTensor&#39;</span><span class="p">,</span>
    <span class="s1">&#39;ShortTensor&#39;</span><span class="p">,</span> <span class="s1">&#39;CharTensor&#39;</span><span class="p">,</span> <span class="s1">&#39;ByteTensor&#39;</span><span class="p">,</span> <span class="s1">&#39;BoolTensor&#39;</span><span class="p">,</span> <span class="s1">&#39;Tensor&#39;</span><span class="p">,</span>
    <span class="s1">&#39;lobpcg&#39;</span><span class="p">,</span> <span class="s1">&#39;use_deterministic_algorithms&#39;</span><span class="p">,</span> <span class="s1">&#39;set_deterministic&#39;</span><span class="p">,</span>
    <span class="s1">&#39;are_deterministic_algorithms_enabled&#39;</span><span class="p">,</span> <span class="s1">&#39;is_deterministic&#39;</span><span class="p">,</span>
    <span class="s1">&#39;set_warn_always&#39;</span><span class="p">,</span> <span class="s1">&#39;is_warn_always_enabled&#39;</span><span class="p">,</span>
<span class="p">]</span>

<span class="c1">################################################################################</span>
<span class="c1"># Load the extension module</span>
<span class="c1">################################################################################</span>

<span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">platform</span> <span class="o">==</span> <span class="s1">&#39;win32&#39;</span><span class="p">:</span>
    <span class="n">pfiles_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">getenv</span><span class="p">(</span><span class="s1">&#39;ProgramFiles&#39;</span><span class="p">,</span> <span class="s1">&#39;C:</span><span class="se">\\</span><span class="s1">Program Files&#39;</span><span class="p">)</span>
    <span class="n">py_dll_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">exec_prefix</span><span class="p">,</span> <span class="s1">&#39;Library&#39;</span><span class="p">,</span> <span class="s1">&#39;bin&#39;</span><span class="p">)</span>
    <span class="n">th_dll_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">dirname</span><span class="p">(</span><span class="vm">__file__</span><span class="p">),</span> <span class="s1">&#39;lib&#39;</span><span class="p">)</span>

    <span class="c1"># When users create a virtualenv that inherits the base environment,</span>
    <span class="c1"># we will need to add the corresponding library directory into</span>
    <span class="c1"># DLL search directories. Otherwise, it will rely on `PATH` which</span>
    <span class="c1"># is dependent on user settings.</span>
    <span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">exec_prefix</span> <span class="o">!=</span> <span class="n">sys</span><span class="o">.</span><span class="n">base_exec_prefix</span><span class="p">:</span>
        <span class="n">base_py_dll_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">sys</span><span class="o">.</span><span class="n">base_exec_prefix</span><span class="p">,</span> <span class="s1">&#39;Library&#39;</span><span class="p">,</span> <span class="s1">&#39;bin&#39;</span><span class="p">)</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="n">base_py_dll_path</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>

    <span class="n">dll_paths</span> <span class="o">=</span> <span class="nb">list</span><span class="p">(</span><span class="nb">filter</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">exists</span><span class="p">,</span> <span class="p">[</span><span class="n">th_dll_path</span><span class="p">,</span> <span class="n">py_dll_path</span><span class="p">,</span> <span class="n">base_py_dll_path</span><span class="p">]))</span>

    <span class="k">if</span> <span class="nb">all</span><span class="p">([</span><span class="ow">not</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">exists</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="s1">&#39;nvToolsExt64_1.dll&#39;</span><span class="p">))</span> <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">dll_paths</span><span class="p">]):</span>
        <span class="n">nvtoolsext_dll_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
            <span class="n">os</span><span class="o">.</span><span class="n">getenv</span><span class="p">(</span><span class="s1">&#39;NVTOOLSEXT_PATH&#39;</span><span class="p">,</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">pfiles_path</span><span class="p">,</span> <span class="s1">&#39;NVIDIA Corporation&#39;</span><span class="p">,</span> <span class="s1">&#39;NvToolsExt&#39;</span><span class="p">)),</span> <span class="s1">&#39;bin&#39;</span><span class="p">,</span> <span class="s1">&#39;x64&#39;</span><span class="p">)</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="n">nvtoolsext_dll_path</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>

    <span class="kn">from</span> <span class="nn">.version</span> <span class="kn">import</span> <span class="n">cuda</span> <span class="k">as</span> <span class="n">cuda_version</span>
    <span class="kn">import</span> <span class="nn">glob</span>
    <span class="k">if</span> <span class="n">cuda_version</span> <span class="ow">and</span> <span class="nb">all</span><span class="p">([</span><span class="ow">not</span> <span class="n">glob</span><span class="o">.</span><span class="n">glob</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="s1">&#39;cudart64*.dll&#39;</span><span class="p">))</span> <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">dll_paths</span><span class="p">]):</span>
        <span class="n">cuda_version_1</span> <span class="o">=</span> <span class="n">cuda_version</span><span class="o">.</span><span class="n">replace</span><span class="p">(</span><span class="s1">&#39;.&#39;</span><span class="p">,</span> <span class="s1">&#39;_&#39;</span><span class="p">)</span>
        <span class="n">cuda_path_var</span> <span class="o">=</span> <span class="s1">&#39;CUDA_PATH_V&#39;</span> <span class="o">+</span> <span class="n">cuda_version_1</span>
        <span class="n">default_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">pfiles_path</span><span class="p">,</span> <span class="s1">&#39;NVIDIA GPU Computing Toolkit&#39;</span><span class="p">,</span> <span class="s1">&#39;CUDA&#39;</span><span class="p">,</span> <span class="s1">&#39;v&#39;</span> <span class="o">+</span> <span class="n">cuda_version</span><span class="p">)</span>
        <span class="n">cuda_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">getenv</span><span class="p">(</span><span class="n">cuda_path_var</span><span class="p">,</span> <span class="n">default_path</span><span class="p">),</span> <span class="s1">&#39;bin&#39;</span><span class="p">)</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="n">cuda_path</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>

    <span class="n">dll_paths</span><span class="o">.</span><span class="n">extend</span><span class="p">(</span><span class="nb">filter</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">exists</span><span class="p">,</span> <span class="p">[</span><span class="n">nvtoolsext_dll_path</span><span class="p">,</span> <span class="n">cuda_path</span><span class="p">]))</span>

    <span class="n">kernel32</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">WinDLL</span><span class="p">(</span><span class="s1">&#39;kernel32.dll&#39;</span><span class="p">,</span> <span class="n">use_last_error</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
    <span class="n">with_load_library_flags</span> <span class="o">=</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">kernel32</span><span class="p">,</span> <span class="s1">&#39;AddDllDirectory&#39;</span><span class="p">)</span>
    <span class="n">prev_error_mode</span> <span class="o">=</span> <span class="n">kernel32</span><span class="o">.</span><span class="n">SetErrorMode</span><span class="p">(</span><span class="mh">0x0001</span><span class="p">)</span>

    <span class="n">kernel32</span><span class="o">.</span><span class="n">LoadLibraryW</span><span class="o">.</span><span class="n">restype</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_void_p</span>
    <span class="k">if</span> <span class="n">with_load_library_flags</span><span class="p">:</span>
        <span class="n">kernel32</span><span class="o">.</span><span class="n">AddDllDirectory</span><span class="o">.</span><span class="n">restype</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_void_p</span>
        <span class="n">kernel32</span><span class="o">.</span><span class="n">LoadLibraryExW</span><span class="o">.</span><span class="n">restype</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">c_void_p</span>

    <span class="k">for</span> <span class="n">dll_path</span> <span class="ow">in</span> <span class="n">dll_paths</span><span class="p">:</span>
        <span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span> <span class="o">&gt;=</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">8</span><span class="p">):</span>
            <span class="n">os</span><span class="o">.</span><span class="n">add_dll_directory</span><span class="p">(</span><span class="n">dll_path</span><span class="p">)</span>
        <span class="k">elif</span> <span class="n">with_load_library_flags</span><span class="p">:</span>
            <span class="n">res</span> <span class="o">=</span> <span class="n">kernel32</span><span class="o">.</span><span class="n">AddDllDirectory</span><span class="p">(</span><span class="n">dll_path</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">res</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                <span class="n">err</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">WinError</span><span class="p">(</span><span class="n">ctypes</span><span class="o">.</span><span class="n">get_last_error</span><span class="p">())</span>
                <span class="n">err</span><span class="o">.</span><span class="n">strerror</span> <span class="o">+=</span> <span class="sa">f</span><span class="s1">&#39; Error adding &quot;</span><span class="si">{</span><span class="n">dll_path</span><span class="si">}</span><span class="s1">&quot; to the DLL directories.&#39;</span>
                <span class="k">raise</span> <span class="n">err</span>

    <span class="k">try</span><span class="p">:</span>
        <span class="n">ctypes</span><span class="o">.</span><span class="n">CDLL</span><span class="p">(</span><span class="s1">&#39;vcruntime140.dll&#39;</span><span class="p">)</span>
        <span class="n">ctypes</span><span class="o">.</span><span class="n">CDLL</span><span class="p">(</span><span class="s1">&#39;msvcp140.dll&#39;</span><span class="p">)</span>
        <span class="k">if</span> <span class="n">cuda_version</span> <span class="ow">not</span> <span class="ow">in</span> <span class="p">(</span><span class="s1">&#39;9.2&#39;</span><span class="p">,</span> <span class="s1">&#39;10.0&#39;</span><span class="p">):</span>
            <span class="n">ctypes</span><span class="o">.</span><span class="n">CDLL</span><span class="p">(</span><span class="s1">&#39;vcruntime140_1.dll&#39;</span><span class="p">)</span>
    <span class="k">except</span> <span class="ne">OSError</span><span class="p">:</span>
        <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;&#39;&#39;Microsoft Visual C++ Redistributable is not installed, this may lead to the DLL load failure.</span>
<span class="s1">                 It can be downloaded at https://aka.ms/vs/16/release/vc_redist.x64.exe&#39;&#39;&#39;</span><span class="p">)</span>

    <span class="n">dlls</span> <span class="o">=</span> <span class="n">glob</span><span class="o">.</span><span class="n">glob</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">th_dll_path</span><span class="p">,</span> <span class="s1">&#39;*.dll&#39;</span><span class="p">))</span>
    <span class="n">path_patched</span> <span class="o">=</span> <span class="kc">False</span>
    <span class="k">for</span> <span class="n">dll</span> <span class="ow">in</span> <span class="n">dlls</span><span class="p">:</span>
        <span class="n">is_loaded</span> <span class="o">=</span> <span class="kc">False</span>
        <span class="k">if</span> <span class="n">with_load_library_flags</span><span class="p">:</span>
            <span class="n">res</span> <span class="o">=</span> <span class="n">kernel32</span><span class="o">.</span><span class="n">LoadLibraryExW</span><span class="p">(</span><span class="n">dll</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="mh">0x00001100</span><span class="p">)</span>
            <span class="n">last_error</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">get_last_error</span><span class="p">()</span>
            <span class="k">if</span> <span class="n">res</span> <span class="ow">is</span> <span class="kc">None</span> <span class="ow">and</span> <span class="n">last_error</span> <span class="o">!=</span> <span class="mi">126</span><span class="p">:</span>
                <span class="n">err</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">WinError</span><span class="p">(</span><span class="n">last_error</span><span class="p">)</span>
                <span class="n">err</span><span class="o">.</span><span class="n">strerror</span> <span class="o">+=</span> <span class="sa">f</span><span class="s1">&#39; Error loading &quot;</span><span class="si">{</span><span class="n">dll</span><span class="si">}</span><span class="s1">&quot; or one of its dependencies.&#39;</span>
                <span class="k">raise</span> <span class="n">err</span>
            <span class="k">elif</span> <span class="n">res</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
                <span class="n">is_loaded</span> <span class="o">=</span> <span class="kc">True</span>
        <span class="k">if</span> <span class="ow">not</span> <span class="n">is_loaded</span><span class="p">:</span>
            <span class="k">if</span> <span class="ow">not</span> <span class="n">path_patched</span><span class="p">:</span>
                <span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s1">&#39;PATH&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;;&#39;</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">dll_paths</span> <span class="o">+</span> <span class="p">[</span><span class="n">os</span><span class="o">.</span><span class="n">environ</span><span class="p">[</span><span class="s1">&#39;PATH&#39;</span><span class="p">]])</span>
                <span class="n">path_patched</span> <span class="o">=</span> <span class="kc">True</span>
            <span class="n">res</span> <span class="o">=</span> <span class="n">kernel32</span><span class="o">.</span><span class="n">LoadLibraryW</span><span class="p">(</span><span class="n">dll</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">res</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
                <span class="n">err</span> <span class="o">=</span> <span class="n">ctypes</span><span class="o">.</span><span class="n">WinError</span><span class="p">(</span><span class="n">ctypes</span><span class="o">.</span><span class="n">get_last_error</span><span class="p">())</span>
                <span class="n">err</span><span class="o">.</span><span class="n">strerror</span> <span class="o">+=</span> <span class="sa">f</span><span class="s1">&#39; Error loading &quot;</span><span class="si">{</span><span class="n">dll</span><span class="si">}</span><span class="s1">&quot; or one of its dependencies.&#39;</span>
                <span class="k">raise</span> <span class="n">err</span>

    <span class="n">kernel32</span><span class="o">.</span><span class="n">SetErrorMode</span><span class="p">(</span><span class="n">prev_error_mode</span><span class="p">)</span>


<span class="c1"># See Note [Global dependencies]</span>
<span class="k">def</span> <span class="nf">_load_global_deps</span><span class="p">():</span>
    <span class="k">if</span> <span class="n">platform</span><span class="o">.</span><span class="n">system</span><span class="p">()</span> <span class="o">==</span> <span class="s1">&#39;Windows&#39;</span> <span class="ow">or</span> <span class="n">sys</span><span class="o">.</span><span class="n">executable</span> <span class="o">==</span> <span class="s1">&#39;torch_deploy&#39;</span><span class="p">:</span>
        <span class="k">return</span>

    <span class="n">lib_name</span> <span class="o">=</span> <span class="s1">&#39;libtorch_global_deps&#39;</span> <span class="o">+</span> <span class="p">(</span><span class="s1">&#39;.dylib&#39;</span> <span class="k">if</span> <span class="n">platform</span><span class="o">.</span><span class="n">system</span><span class="p">()</span> <span class="o">==</span> <span class="s1">&#39;Darwin&#39;</span> <span class="k">else</span> <span class="s1">&#39;.so&#39;</span><span class="p">)</span>
    <span class="n">here</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">abspath</span><span class="p">(</span><span class="vm">__file__</span><span class="p">)</span>
    <span class="n">lib_path</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">dirname</span><span class="p">(</span><span class="n">here</span><span class="p">),</span> <span class="s1">&#39;lib&#39;</span><span class="p">,</span> <span class="n">lib_name</span><span class="p">)</span>

    <span class="n">ctypes</span><span class="o">.</span><span class="n">CDLL</span><span class="p">(</span><span class="n">lib_path</span><span class="p">,</span> <span class="n">mode</span><span class="o">=</span><span class="n">ctypes</span><span class="o">.</span><span class="n">RTLD_GLOBAL</span><span class="p">)</span>


<span class="k">if</span> <span class="p">(</span><span class="n">USE_RTLD_GLOBAL_WITH_LIBTORCH</span> <span class="ow">or</span> <span class="n">os</span><span class="o">.</span><span class="n">getenv</span><span class="p">(</span><span class="s1">&#39;TORCH_USE_RTLD_GLOBAL&#39;</span><span class="p">))</span> <span class="ow">and</span> \
        <span class="n">platform</span><span class="o">.</span><span class="n">system</span><span class="p">()</span> <span class="o">!=</span> <span class="s1">&#39;Windows&#39;</span><span class="p">:</span>
    <span class="c1"># Do it the hard way.  You might want to load libtorch with RTLD_GLOBAL in a</span>
    <span class="c1"># few circumstances:</span>
    <span class="c1">#</span>
    <span class="c1">#   1. You&#39;re in a build environment (e.g., fbcode) where</span>
    <span class="c1">#      libtorch_global_deps is not available, but you still need</span>
    <span class="c1">#      to get mkl to link in with RTLD_GLOBAL or it will just</span>
    <span class="c1">#      not work.</span>
    <span class="c1">#</span>
    <span class="c1">#   2. You&#39;re trying to run PyTorch under UBSAN and you need</span>
    <span class="c1">#      to ensure that only one copy of libtorch is loaded, so</span>
    <span class="c1">#      vptr checks work properly</span>
    <span class="c1">#</span>
    <span class="c1"># If you&#39;re using this setting, you must verify that all the libraries</span>
    <span class="c1"># you load consistently use the same libstdc++, or you may have</span>
    <span class="c1"># mysterious segfaults.</span>
    <span class="c1">#</span>
    <span class="kn">import</span> <span class="nn">os</span> <span class="k">as</span> <span class="nn">_dl_flags</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">_dl_flags</span><span class="p">,</span> <span class="s1">&#39;RTLD_GLOBAL&#39;</span><span class="p">)</span> <span class="ow">or</span> <span class="ow">not</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">_dl_flags</span><span class="p">,</span> <span class="s1">&#39;RTLD_LAZY&#39;</span><span class="p">):</span>
        <span class="k">try</span><span class="p">:</span>
            <span class="c1"># next try if DLFCN exists</span>
            <span class="kn">import</span> <span class="nn">DLFCN</span> <span class="k">as</span> <span class="nn">_dl_flags</span>  <span class="c1"># type: ignore[import, no-redef]</span>
        <span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
            <span class="c1"># as a last attempt, use compile-time constants</span>
            <span class="kn">import</span> <span class="nn">torch._dl</span> <span class="k">as</span> <span class="nn">_dl_flags</span>  <span class="c1"># type: ignore[import, no-redef]</span>
    <span class="n">old_flags</span> <span class="o">=</span> <span class="n">sys</span><span class="o">.</span><span class="n">getdlopenflags</span><span class="p">()</span>
    <span class="n">sys</span><span class="o">.</span><span class="n">setdlopenflags</span><span class="p">(</span><span class="n">_dl_flags</span><span class="o">.</span><span class="n">RTLD_GLOBAL</span> <span class="o">|</span> <span class="n">_dl_flags</span><span class="o">.</span><span class="n">RTLD_LAZY</span><span class="p">)</span>
    <span class="kn">from</span> <span class="nn">torch._C</span> <span class="kn">import</span> <span class="o">*</span>  <span class="c1"># noqa: F403</span>
    <span class="n">sys</span><span class="o">.</span><span class="n">setdlopenflags</span><span class="p">(</span><span class="n">old_flags</span><span class="p">)</span>
    <span class="k">del</span> <span class="n">old_flags</span>
    <span class="k">del</span> <span class="n">_dl_flags</span>

<span class="k">else</span><span class="p">:</span>
    <span class="c1"># Easy way.  You want this most of the time, because it will prevent</span>
    <span class="c1"># C++ symbols from libtorch clobbering C++ symbols from other</span>
    <span class="c1"># libraries, leading to mysterious segfaults.</span>
    <span class="c1">#</span>
    <span class="c1"># If building in an environment where libtorch_global_deps isn&#39;t available</span>
    <span class="c1"># like parts of fbsource, but where RTLD_GLOBAL causes segfaults, you will</span>
    <span class="c1"># want USE_RTLD_GLOBAL_WITH_LIBTORCH = False and USE_GLOBAL_DEPS = False</span>
    <span class="c1">#</span>
    <span class="c1"># See Note [Global dependencies]</span>
    <span class="k">if</span> <span class="n">USE_GLOBAL_DEPS</span><span class="p">:</span>
        <span class="n">_load_global_deps</span><span class="p">()</span>
    <span class="kn">from</span> <span class="nn">torch._C</span> <span class="kn">import</span> <span class="o">*</span>  <span class="c1"># noqa: F403</span>

<span class="c1"># Appease the type checker; ordinarily this binding is inserted by the</span>
<span class="c1"># torch._C module initialization code in C</span>
<span class="k">if</span> <span class="n">TYPE_CHECKING</span><span class="p">:</span>
    <span class="kn">import</span> <span class="nn">torch._C</span> <span class="k">as</span> <span class="nn">_C</span>

<span class="c1"># Check to see if we can load C extensions, and if not provide some guidance</span>
<span class="c1"># on what the problem might be.</span>
<span class="k">try</span><span class="p">:</span>
    <span class="c1"># _initExtension is chosen (arbitrarily) as a sentinel.</span>
    <span class="kn">from</span> <span class="nn">torch._C</span> <span class="kn">import</span> <span class="n">_initExtension</span>
<span class="k">except</span> <span class="ne">ImportError</span><span class="p">:</span>
    <span class="kn">import</span> <span class="nn">torch._C</span> <span class="k">as</span> <span class="nn">_C_for_compiled_check</span>

    <span class="c1"># The __file__ check only works for Python 3.7 and above.</span>
    <span class="k">if</span> <span class="n">sys</span><span class="o">.</span><span class="n">version_info</span> <span class="o">&gt;=</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span> <span class="mi">7</span><span class="p">)</span> <span class="ow">and</span> <span class="n">_C_for_compiled_check</span><span class="o">.</span><span class="vm">__file__</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>
        <span class="k">raise</span> <span class="ne">ImportError</span><span class="p">(</span><span class="n">textwrap</span><span class="o">.</span><span class="n">dedent</span><span class="p">(</span><span class="s1">&#39;&#39;&#39;</span>
<span class="s1">            Failed to load PyTorch C extensions:</span>
<span class="s1">                It appears that PyTorch has loaded the `torch/_C` folder</span>
<span class="s1">                of the PyTorch repository rather than the C extensions which</span>
<span class="s1">                are expected in the `torch._C` namespace. This can occur when</span>
<span class="s1">                using the `install` workflow. e.g.</span>
<span class="s1">                    $ python setup.py install &amp;&amp; python -c &quot;import torch&quot;</span>

<span class="s1">                This error can generally be solved using the `develop` workflow</span>
<span class="s1">                    $ python setup.py develop &amp;&amp; python -c &quot;import torch&quot;  # This should succeed</span>
<span class="s1">                or by running Python from a different directory.</span>
<span class="s1">            &#39;&#39;&#39;</span><span class="p">)</span><span class="o">.</span><span class="n">strip</span><span class="p">())</span> <span class="kn">from</span> <span class="bp">None</span>
    <span class="k">raise</span>  <span class="c1"># If __file__ is not None the cause is unknown, so just re-raise.</span>


<span class="n">__all__</span> <span class="o">+=</span> <span class="p">[</span><span class="n">name</span> <span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">dir</span><span class="p">(</span><span class="n">_C</span><span class="p">)</span>
            <span class="k">if</span> <span class="n">name</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">!=</span> <span class="s1">&#39;_&#39;</span> <span class="ow">and</span>
            <span class="ow">not</span> <span class="n">name</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s1">&#39;Base&#39;</span><span class="p">)]</span>

<span class="k">if</span> <span class="ow">not</span> <span class="n">TYPE_CHECKING</span><span class="p">:</span>
    <span class="c1"># issue 38137 and python issue 43367. Submodules of a C extension are</span>
    <span class="c1"># non-standard, and attributes of those submodules cannot be pickled since</span>
    <span class="c1"># pickle expect to be able to import them as &quot;from _C.sub import attr&quot;</span>
    <span class="c1"># which fails with &quot;_C is not a package</span>
    <span class="k">for</span> <span class="n">attr</span> <span class="ow">in</span> <span class="nb">dir</span><span class="p">(</span><span class="n">_C</span><span class="p">):</span>
        <span class="n">candidate</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">_C</span><span class="p">,</span> <span class="n">attr</span><span class="p">)</span>
        <span class="k">if</span> <span class="nb">type</span><span class="p">(</span><span class="n">candidate</span><span class="p">)</span> <span class="ow">is</span> <span class="nb">type</span><span class="p">(</span><span class="n">_C</span><span class="p">):</span>
            <span class="c1"># submodule</span>
            <span class="k">if</span> <span class="sa">f</span><span class="s1">&#39;torch._C.</span><span class="si">{</span><span class="n">attr</span><span class="si">}</span><span class="s1">&#39;</span> <span class="ow">not</span> <span class="ow">in</span> <span class="n">sys</span><span class="o">.</span><span class="n">modules</span><span class="p">:</span>
                <span class="n">sys</span><span class="o">.</span><span class="n">modules</span><span class="p">[</span><span class="sa">f</span><span class="s1">&#39;torch._C.</span><span class="si">{</span><span class="n">attr</span><span class="si">}</span><span class="s1">&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">candidate</span>


<span class="c1">################################################################################</span>
<span class="c1"># Define basic utilities</span>
<span class="c1">################################################################################</span>


<span class="k">def</span> <span class="nf">typename</span><span class="p">(</span><span class="n">o</span><span class="p">):</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="n">torch</span><span class="o">.</span><span class="n">Tensor</span><span class="p">):</span>
        <span class="k">return</span> <span class="n">o</span><span class="o">.</span><span class="n">type</span><span class="p">()</span>

    <span class="n">module</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>
    <span class="n">class_name</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>
    <span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="s1">&#39;__module__&#39;</span><span class="p">)</span> <span class="ow">and</span> <span class="n">o</span><span class="o">.</span><span class="vm">__module__</span> <span class="o">!=</span> <span class="s1">&#39;builtins&#39;</span> \
            <span class="ow">and</span> <span class="n">o</span><span class="o">.</span><span class="vm">__module__</span> <span class="o">!=</span> <span class="s1">&#39;__builtin__&#39;</span> <span class="ow">and</span> <span class="n">o</span><span class="o">.</span><span class="vm">__module__</span> <span class="ow">is</span> <span class="ow">not</span> <span class="kc">None</span><span class="p">:</span>
        <span class="n">module</span> <span class="o">=</span> <span class="n">o</span><span class="o">.</span><span class="vm">__module__</span> <span class="o">+</span> <span class="s1">&#39;.&#39;</span>

    <span class="k">if</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="s1">&#39;__qualname__&#39;</span><span class="p">):</span>
        <span class="n">class_name</span> <span class="o">=</span> <span class="n">o</span><span class="o">.</span><span class="vm">__qualname__</span>
    <span class="k">elif</span> <span class="nb">hasattr</span><span class="p">(</span><span class="n">o</span><span class="p">,</span> <span class="s1">&#39;__name__&#39;</span><span class="p">):</span>
        <span class="n">class_name</span> <span class="o">=</span> <span class="n">o</span><span class="o">.</span><span class="vm">__name__</span>
    <span class="k">else</span><span class="p">:</span>
        <span class="n">class_name</span> <span class="o">=</span> <span class="n">o</span><span class="o">.</span><span class="vm">__class__</span><span class="o">.</span><span class="vm">__name__</span>

    <span class="k">return</span> <span class="n">module</span> <span class="o">+</span> <span class="n">class_name</span>


<span class="k">def</span> <span class="nf">is_tensor</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Returns True if `obj` is a PyTorch tensor.</span>

<span class="sd">    Note that this function is simply doing ``isinstance(obj, Tensor)``.</span>
<span class="sd">    Using that ``isinstance`` check is better for typechecking with mypy,</span>
<span class="sd">    and more explicit - so it&#39;s recommended to use that instead of</span>
<span class="sd">    ``is_tensor``.</span>

<span class="sd">    Args:</span>
<span class="sd">        obj (Object): Object to test</span>
<span class="sd">    Example::</span>

<span class="sd">        &gt;&gt;&gt; x=torch.tensor([1,2,3])</span>
<span class="sd">        &gt;&gt;&gt; torch.is_tensor(x)</span>
<span class="sd">        True</span>

<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">obj</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="k">def</span> <span class="nf">is_storage</span><span class="p">(</span><span class="n">obj</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Returns True if `obj` is a PyTorch storage object.</span>

<span class="sd">    Args:</span>
<span class="sd">        obj (Object): Object to test</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="nb">type</span><span class="p">(</span><span class="n">obj</span><span class="p">)</span> <span class="ow">in</span> <span class="n">_storage_classes</span>


<span class="k">def</span> <span class="nf">set_default_tensor_type</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Sets the default ``torch.Tensor`` type to floating point tensor type</span>
<span class="sd">    ``t``. This type will also be used as default floating point type for</span>
<span class="sd">    type inference in :func:`torch.tensor`.</span>

<span class="sd">    The default floating point tensor type is initially ``torch.FloatTensor``.</span>

<span class="sd">    Args:</span>
<span class="sd">        t (type or string): the floating point tensor type or its name</span>

<span class="sd">    Example::</span>

<span class="sd">        &gt;&gt;&gt; torch.tensor([1.2, 3]).dtype    # initial default for floating point is torch.float32</span>
<span class="sd">        torch.float32</span>
<span class="sd">        &gt;&gt;&gt; torch.set_default_tensor_type(torch.DoubleTensor)</span>
<span class="sd">        &gt;&gt;&gt; torch.tensor([1.2, 3]).dtype    # a new floating point tensor</span>
<span class="sd">        torch.float64</span>

<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">t</span><span class="p">,</span> <span class="n">_string_classes</span><span class="p">):</span>
        <span class="n">t</span> <span class="o">=</span> <span class="n">_import_dotted_name</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>
    <span class="n">_C</span><span class="o">.</span><span class="n">_set_default_tensor_type</span><span class="p">(</span><span class="n">t</span><span class="p">)</span>


<span class="k">def</span> <span class="nf">set_default_dtype</span><span class="p">(</span><span class="n">d</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Sets the default floating point dtype to :attr:`d`.</span>
<span class="sd">    This dtype is:</span>

<span class="sd">    1. The inferred dtype for python floats in :func:`torch.tensor`.</span>
<span class="sd">    2. Used to infer dtype for python complex numbers. The default complex dtype is set to</span>
<span class="sd">       ``torch.complex128`` if default floating point dtype is ``torch.float64``,</span>
<span class="sd">       otherwise it&#39;s set to ``torch.complex64``</span>

<span class="sd">    The default floating point dtype is initially ``torch.float32``.</span>

<span class="sd">    Args:</span>
<span class="sd">        d (:class:`torch.dtype`): the floating point dtype to make the default</span>

<span class="sd">    Example:</span>
<span class="sd">        &gt;&gt;&gt; # initial default for floating point is torch.float32</span>
<span class="sd">        &gt;&gt;&gt; torch.tensor([1.2, 3]).dtype</span>
<span class="sd">        torch.float32</span>
<span class="sd">        &gt;&gt;&gt; # initial default for floating point is torch.complex64</span>
<span class="sd">        &gt;&gt;&gt; torch.tensor([1.2, 3j]).dtype</span>
<span class="sd">        torch.complex64</span>
<span class="sd">        &gt;&gt;&gt; torch.set_default_dtype(torch.float64)</span>
<span class="sd">        &gt;&gt;&gt; torch.tensor([1.2, 3]).dtype    # a new floating point tensor</span>
<span class="sd">        torch.float64</span>
<span class="sd">        &gt;&gt;&gt; torch.tensor([1.2, 3j]).dtype   # a new complex tensor</span>
<span class="sd">        torch.complex128</span>

<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">_C</span><span class="o">.</span><span class="n">_set_default_dtype</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">use_deterministic_algorithms</span><span class="p">(</span><span class="n">mode</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot; Sets whether PyTorch operations must use &quot;deterministic&quot;</span>
<span class="sd">    algorithms. That is, algorithms which, given the same input, and when</span>
<span class="sd">    run on the same software and hardware, always produce the same output.</span>
<span class="sd">    When enabled, operations will use deterministic algorithms when available,</span>
<span class="sd">    and if only nondeterministic algorithms are available they will throw a</span>
<span class="sd">    :class:`RuntimeError` when called.</span>

<span class="sd">    The following normally-nondeterministic operations will act</span>
<span class="sd">    deterministically when ``mode=True``:</span>

<span class="sd">        * :class:`torch.nn.Conv1d` when called on CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.Conv2d` when called on CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.Conv3d` when called on CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.ConvTranspose1d` when called on CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.ConvTranspose2d` when called on CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.ConvTranspose3d` when called on CUDA tensor</span>
<span class="sd">        * :func:`torch.bmm` when called on sparse-dense CUDA tensors</span>
<span class="sd">        * :func:`torch.Tensor.__getitem__` when attempting to differentiate a CPU tensor</span>
<span class="sd">          and the index is a list of tensors</span>
<span class="sd">        * :func:`torch.Tensor.index_put` with ``accumulate=False``</span>
<span class="sd">        * :func:`torch.Tensor.index_put` with ``accumulate=True`` when called on a CPU</span>
<span class="sd">          tensor</span>
<span class="sd">        * :func:`torch.Tensor.put_` with ``accumulate=True`` when called on a CPU</span>
<span class="sd">          tensor</span>
<span class="sd">        * :func:`torch.gather` when ``input`` dimension is one and called</span>
<span class="sd">          on a CUDA tensor that requires grad</span>
<span class="sd">        * :func:`torch.index_add` when called on CUDA tensor</span>
<span class="sd">        * :func:`torch.index_select` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :func:`torch.repeat_interleave` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :func:`torch.Tensor.index_copy` when called on a CPU or CUDA tensor</span>

<span class="sd">    The following normally-nondeterministic operations will throw a</span>
<span class="sd">    :class:`RuntimeError` when ``mode=True``:</span>

<span class="sd">        * :class:`torch.nn.AvgPool3d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.AdaptiveAvgPool2d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.AdaptiveAvgPool3d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.MaxPool3d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.AdaptiveMaxPool2d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.FractionalMaxPool2d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.FractionalMaxPool3d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :func:`torch.nn.functional.interpolate` when attempting to differentiate a CUDA tensor</span>
<span class="sd">          and one of the following modes is used:</span>

<span class="sd">          - ``linear``</span>
<span class="sd">          - ``bilinear``</span>
<span class="sd">          - ``bicubic``</span>
<span class="sd">          - ``trilinear``</span>

<span class="sd">        * :class:`torch.nn.ReflectionPad1d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.ReflectionPad2d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.ReplicationPad1d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.ReplicationPad2d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.ReplicationPad3d` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.NLLLoss` when called on a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.CTCLoss` when attempting to differentiate a CUDA tensor</span>
<span class="sd">        * :class:`torch.nn.EmbeddingBag` when attempting to differentiate a CUDA tensor when</span>
<span class="sd">          ``mode=&#39;max&#39;``</span>
<span class="sd">        * :func:`torch.Tensor.scatter_add_` when called on a CUDA tensor</span>
<span class="sd">        * :func:`torch.Tensor.put_` when ``accumulate=False``</span>
<span class="sd">        * :func:`torch.Tensor.put_` when ``accumulate=True`` and called on a CUDA tensor</span>
<span class="sd">        * :func:`torch.histc` when called on a CUDA tensor</span>
<span class="sd">        * :func:`torch.bincount` when called on a CUDA tensor</span>
<span class="sd">        * :func:`torch.kthvalue` with called on a CUDA tensor</span>
<span class="sd">        * :func:`torch.median` with indices output when called on a CUDA tensor</span>
<span class="sd">        * :func:`torch.gather` when ``input`` dimension is larger than one</span>
<span class="sd">          and called on a CUDA tensor that requires grad</span>
<span class="sd">        * :func:`torch.nn.functional.grid_sample` when attempting to differentiate a CUDA tensor</span>

<span class="sd">    A handful of CUDA operations are nondeterministic if the CUDA version is</span>
<span class="sd">    10.2 or greater, unless the environment variable ``CUBLAS_WORKSPACE_CONFIG=:4096:8``</span>
<span class="sd">    or ``CUBLAS_WORKSPACE_CONFIG=:16:8`` is set. See the CUDA documentation for more</span>
<span class="sd">    details: `&lt;https://docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility&gt;`_</span>
<span class="sd">    If one of these environment variable configurations is not set, a :class:`RuntimeError`</span>
<span class="sd">    will be raised from these operations when called with CUDA tensors:</span>

<span class="sd">        * :func:`torch.mm`</span>
<span class="sd">        * :func:`torch.mv`</span>
<span class="sd">        * :func:`torch.bmm`</span>

<span class="sd">    Note that deterministic operations tend to have worse performance than</span>
<span class="sd">    nondeterministic operations.</span>

<span class="sd">    .. note::</span>

<span class="sd">        This flag does not detect or prevent nondeterministic behavior caused</span>
<span class="sd">        by calling an inplace operation on a tensor with an internal memory</span>
<span class="sd">        overlap or by giving such a tensor as the :attr:`out` argument for an</span>
<span class="sd">        operation. In these cases, multiple writes of different data may target</span>
<span class="sd">        a single memory location, and the order of writes is not guaranteed.</span>

<span class="sd">    Args:</span>
<span class="sd">        mode (:class:`bool`): If True, makes potentially nondeterministic</span>
<span class="sd">            operations switch to a deterministic algorithm or throw a runtime</span>
<span class="sd">            error. If False, allows nondeterministic operations.</span>

<span class="sd">    Example::</span>

<span class="sd">        &gt;&gt;&gt; torch.use_deterministic_algorithms(True)</span>

<span class="sd">        # Forward mode nondeterministic error</span>
<span class="sd">        &gt;&gt;&gt; torch.randn(10).index_copy(0, torch.tensor([0]), torch.randn(1))</span>
<span class="sd">        ...</span>
<span class="sd">        RuntimeError: index_copy does not have a deterministic implementation...</span>

<span class="sd">        # Backward mode nondeterministic error</span>
<span class="sd">        &gt;&gt;&gt; torch.randn(10, requires_grad=True, device=&#39;cuda&#39;).index_select(0, torch.tensor([0], device=&#39;cuda&#39;)).backward()</span>
<span class="sd">        ...</span>
<span class="sd">        RuntimeError: index_add_cuda_ does not have a deterministic implementation...</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">_C</span><span class="o">.</span><span class="n">_set_deterministic_algorithms</span><span class="p">(</span><span class="n">mode</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">set_deterministic</span><span class="p">(</span><span class="n">d</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;This function is deprecated and will be removed in a future release.</span>
<span class="sd">    Please use :func:`torch.use_deterministic_algorithms` instead.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">((</span>
        <span class="s2">&quot;torch.set_deterministic is deprecated and will be removed in a future &quot;</span>
        <span class="s2">&quot;release. Please use torch.use_deterministic_algorithms instead&quot;</span><span class="p">))</span>

    <span class="n">use_deterministic_algorithms</span><span class="p">(</span><span class="n">d</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">are_deterministic_algorithms_enabled</span><span class="p">():</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Returns True if the global deterministic flag is turned on. Refer to</span>
<span class="sd">    :func:`torch.use_deterministic_algorithms` documentation for more details.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="n">_C</span><span class="o">.</span><span class="n">_get_deterministic_algorithms</span><span class="p">()</span>

<span class="k">def</span> <span class="nf">is_deterministic</span><span class="p">():</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;This function is deprecated and will be removed in a future release.</span>
<span class="sd">    Please use :func:`torch.are_deterministic_algorithms_enabled` instead.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">warnings</span><span class="o">.</span><span class="n">warn</span><span class="p">((</span>
        <span class="s2">&quot;torch.is_deterministic is deprecated and will be removed in a future &quot;</span>
        <span class="s2">&quot;release. Please use torch.are_deterministic_algorithms_enabled instead&quot;</span><span class="p">))</span>
    <span class="k">return</span> <span class="n">are_deterministic_algorithms_enabled</span><span class="p">()</span>


<span class="k">def</span> <span class="nf">set_warn_always</span><span class="p">(</span><span class="n">b</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;When this flag is False (default) then some PyTorch warnings may only</span>
<span class="sd">    appear once per process. This helps avoid excessive warning information.</span>
<span class="sd">    Setting it to True causes these warnings to always appear, which may be</span>
<span class="sd">    helpful when debugging.</span>

<span class="sd">    Args:</span>
<span class="sd">        b (:class:`bool`): If True, force warnings to always be emitted</span>
<span class="sd">                           If False, set to the default behaviour</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="n">_C</span><span class="o">.</span><span class="n">_set_warnAlways</span><span class="p">(</span><span class="n">b</span><span class="p">)</span>

<span class="k">def</span> <span class="nf">is_warn_always_enabled</span><span class="p">():</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Returns True if the global warn_always flag is turned on. Refer to</span>
<span class="sd">    :func:`torch.set_warn_always` documentation for more details.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="n">_C</span><span class="o">.</span><span class="n">_get_warnAlways</span><span class="p">()</span>

<span class="c1">################################################################################</span>
<span class="c1"># Define Storage and Tensor classes</span>
<span class="c1">################################################################################</span>

<span class="kn">from</span> <span class="nn">._tensor</span> <span class="kn">import</span> <span class="n">Tensor</span>
<span class="kn">from</span> <span class="nn">.storage</span> <span class="kn">import</span> <span class="n">_StorageBase</span>


<span class="k">class</span> <span class="nc">DoubleStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">DoubleStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">FloatStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">FloatStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">HalfStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">HalfStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">LongStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">LongStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">IntStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">IntStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">ShortStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">ShortStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">CharStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">CharStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">ByteStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">ByteStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">BoolStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">BoolStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>


<span class="k">class</span> <span class="nc">BFloat16Storage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">BFloat16StorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>

<span class="k">class</span> <span class="nc">ComplexDoubleStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">ComplexDoubleStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>

<span class="k">class</span> <span class="nc">ComplexFloatStorage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">ComplexFloatStorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>

<span class="k">class</span> <span class="nc">QUInt8Storage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">QUInt8StorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>

<span class="k">class</span> <span class="nc">QInt8Storage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">QInt8StorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>

<span class="k">class</span> <span class="nc">QInt32Storage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">QInt32StorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>

<span class="k">class</span> <span class="nc">QUInt4x2Storage</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">QUInt4x2StorageBase</span><span class="p">,</span> <span class="n">_StorageBase</span><span class="p">):</span>
    <span class="k">pass</span>

<span class="n">_storage_classes</span> <span class="o">=</span> <span class="p">{</span>
    <span class="n">DoubleStorage</span><span class="p">,</span> <span class="n">FloatStorage</span><span class="p">,</span> <span class="n">LongStorage</span><span class="p">,</span> <span class="n">IntStorage</span><span class="p">,</span> <span class="n">ShortStorage</span><span class="p">,</span>
    <span class="n">CharStorage</span><span class="p">,</span> <span class="n">ByteStorage</span><span class="p">,</span> <span class="n">HalfStorage</span><span class="p">,</span> <span class="n">BoolStorage</span><span class="p">,</span> <span class="n">QUInt8Storage</span><span class="p">,</span> <span class="n">QInt8Storage</span><span class="p">,</span>
    <span class="n">QInt32Storage</span><span class="p">,</span> <span class="n">BFloat16Storage</span><span class="p">,</span> <span class="n">ComplexFloatStorage</span><span class="p">,</span> <span class="n">ComplexDoubleStorage</span><span class="p">,</span> <span class="n">QUInt4x2Storage</span>
<span class="p">}</span>

<span class="c1"># The _tensor_classes set is initialized by the call to _C._initialize_tensor_type_bindings()</span>
<span class="n">_tensor_classes</span><span class="p">:</span> <span class="n">Set</span><span class="p">[</span><span class="n">Type</span><span class="p">]</span> <span class="o">=</span> <span class="nb">set</span><span class="p">()</span>

<span class="c1"># If you edit these imports, please update torch/__init__.py.in as well</span>
<span class="kn">from</span> <span class="nn">.random</span> <span class="kn">import</span> <span class="n">set_rng_state</span><span class="p">,</span> <span class="n">get_rng_state</span><span class="p">,</span> <span class="n">manual_seed</span><span class="p">,</span> <span class="n">initial_seed</span><span class="p">,</span> <span class="n">seed</span>
<span class="kn">from</span> <span class="nn">.serialization</span> <span class="kn">import</span> <span class="n">save</span><span class="p">,</span> <span class="n">load</span>
<span class="kn">from</span> <span class="nn">._tensor_str</span> <span class="kn">import</span> <span class="n">set_printoptions</span>

<span class="c1">################################################################################</span>
<span class="c1"># Initialize extension</span>
<span class="c1">################################################################################</span>

<span class="k">def</span> <span class="nf">manager_path</span><span class="p">():</span>
    <span class="k">if</span> <span class="n">platform</span><span class="o">.</span><span class="n">system</span><span class="p">()</span> <span class="o">==</span> <span class="s1">&#39;Windows&#39;</span> <span class="ow">or</span> <span class="n">sys</span><span class="o">.</span><span class="n">executable</span> <span class="o">==</span> <span class="s1">&#39;torch_deploy&#39;</span><span class="p">:</span>
        <span class="k">return</span> <span class="sa">b</span><span class="s2">&quot;&quot;</span>
    <span class="n">path</span> <span class="o">=</span> <span class="n">get_file_path</span><span class="p">(</span><span class="s1">&#39;torch&#39;</span><span class="p">,</span> <span class="s1">&#39;bin&#39;</span><span class="p">,</span> <span class="s1">&#39;torch_shm_manager&#39;</span><span class="p">)</span>
    <span class="n">prepare_multiprocessing_environment</span><span class="p">(</span><span class="n">get_file_path</span><span class="p">(</span><span class="s1">&#39;torch&#39;</span><span class="p">))</span>
    <span class="k">if</span> <span class="ow">not</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">exists</span><span class="p">(</span><span class="n">path</span><span class="p">):</span>
        <span class="k">raise</span> <span class="ne">RuntimeError</span><span class="p">(</span><span class="s2">&quot;Unable to find torch_shm_manager at &quot;</span> <span class="o">+</span> <span class="n">path</span><span class="p">)</span>
    <span class="k">return</span> <span class="n">path</span><span class="o">.</span><span class="n">encode</span><span class="p">(</span><span class="s1">&#39;utf-8&#39;</span><span class="p">)</span>


<span class="c1"># Shared memory manager needs to know the exact location of manager executable</span>
<span class="n">_C</span><span class="o">.</span><span class="n">_initExtension</span><span class="p">(</span><span class="n">manager_path</span><span class="p">())</span>
<span class="k">del</span> <span class="n">manager_path</span>

<span class="c1"># Appease the type checker: it can&#39;t deal with direct setting of globals().</span>
<span class="c1"># Note that we will see &quot;too many&quot; functions when reexporting this way; there</span>
<span class="c1"># is not a good way to fix this problem.  Perhaps, try to redesign VariableFunctions</span>
<span class="c1"># so that this import is good enough</span>
<span class="k">if</span> <span class="n">TYPE_CHECKING</span><span class="p">:</span>
    <span class="c1"># Some type signatures pulled in from _VariableFunctions here clash with</span>
    <span class="c1"># signatures already imported. For now these clashes are ignored; see</span>
    <span class="c1"># PR #43339 for details.</span>
    <span class="kn">from</span> <span class="nn">torch._C._VariableFunctions</span> <span class="kn">import</span> <span class="o">*</span>  <span class="c1"># type: ignore[misc] # noqa: F403</span>

<span class="k">for</span> <span class="n">name</span> <span class="ow">in</span> <span class="nb">dir</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">_VariableFunctions</span><span class="p">):</span>
    <span class="k">if</span> <span class="n">name</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s1">&#39;__&#39;</span><span class="p">):</span>
        <span class="k">continue</span>
    <span class="nb">globals</span><span class="p">()[</span><span class="n">name</span><span class="p">]</span> <span class="o">=</span> <span class="nb">getattr</span><span class="p">(</span><span class="n">_C</span><span class="o">.</span><span class="n">_VariableFunctions</span><span class="p">,</span> <span class="n">name</span><span class="p">)</span>
    <span class="n">__all__</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>

<span class="c1">################################################################################</span>
<span class="c1"># Import interface functions defined in Python</span>
<span class="c1">################################################################################</span>

<span class="c1"># needs to be after the above ATen bindings so we can overwrite from Python side</span>
<span class="kn">from</span> <span class="nn">.functional</span> <span class="kn">import</span> <span class="o">*</span>  <span class="c1"># noqa: F403</span>


<span class="c1">################################################################################</span>
<span class="c1"># Remove unnecessary members</span>
<span class="c1">################################################################################</span>

<span class="k">del</span> <span class="n">DoubleStorageBase</span>
<span class="k">del</span> <span class="n">FloatStorageBase</span>
<span class="k">del</span> <span class="n">LongStorageBase</span>
<span class="k">del</span> <span class="n">IntStorageBase</span>
<span class="k">del</span> <span class="n">ShortStorageBase</span>
<span class="k">del</span> <span class="n">CharStorageBase</span>
<span class="k">del</span> <span class="n">ByteStorageBase</span>
<span class="k">del</span> <span class="n">BoolStorageBase</span>
<span class="k">del</span> <span class="n">QUInt8StorageBase</span>
<span class="k">del</span> <span class="n">BFloat16StorageBase</span>
<span class="k">del</span> <span class="n">ComplexDoubleStorageBase</span>
<span class="k">del</span> <span class="n">ComplexFloatStorageBase</span>
<span class="k">del</span> <span class="n">QUInt4x2StorageBase</span>

<span class="c1">################################################################################</span>
<span class="c1"># Define _assert</span>
<span class="c1">################################################################################</span>

<span class="c1"># needs to be before the submodule imports to avoid circular dependencies</span>
<span class="k">def</span> <span class="nf">_assert</span><span class="p">(</span><span class="n">condition</span><span class="p">,</span> <span class="n">message</span><span class="p">):</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;A wrapper around Python&#39;s assert which is symbolically traceable.</span>
<span class="sd">    &quot;&quot;&quot;</span>
    <span class="kn">from</span> <span class="nn">.overrides</span> <span class="kn">import</span> <span class="n">has_torch_function</span><span class="p">,</span> <span class="n">handle_torch_function</span>

    <span class="k">if</span> <span class="nb">type</span><span class="p">(</span><span class="n">condition</span><span class="p">)</span> <span class="ow">is</span> <span class="ow">not</span> <span class="n">torch</span><span class="o">.</span><span class="n">Tensor</span> <span class="ow">and</span> <span class="n">has_torch_function</span><span class="p">((</span><span class="n">condition</span><span class="p">,)):</span>
        <span class="k">return</span> <span class="n">handle_torch_function</span><span class="p">(</span><span class="n">_assert</span><span class="p">,</span> <span class="p">(</span><span class="n">condition</span><span class="p">,),</span> <span class="n">condition</span><span class="p">,</span> <span class="n">message</span><span class="p">)</span>
    <span class="k">assert</span> <span class="n">condition</span><span class="p">,</span> <span class="n">message</span>

<span class="c1">################################################################################</span>
<span class="c1"># Import most common subpackages</span>
<span class="c1">################################################################################</span>

<span class="c1"># Use the redundant form so that type checkers know that these are a part of</span>
<span class="c1"># the public API. The &quot;regular&quot; import lines are there solely for the runtime</span>
<span class="c1"># side effect of adding to the imported module&#39;s members for other users.</span>

<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">cuda</span> <span class="k">as</span> <span class="n">cuda</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">autograd</span> <span class="k">as</span> <span class="n">autograd</span>
<span class="kn">from</span> <span class="nn">torch.autograd</span> <span class="kn">import</span> <span class="p">(</span>
    <span class="n">no_grad</span> <span class="k">as</span> <span class="n">no_grad</span><span class="p">,</span>
    <span class="n">enable_grad</span> <span class="k">as</span> <span class="n">enable_grad</span><span class="p">,</span>
    <span class="n">set_grad_enabled</span> <span class="k">as</span> <span class="n">set_grad_enabled</span><span class="p">,</span>
    <span class="n">inference_mode</span> <span class="k">as</span> <span class="n">inference_mode</span><span class="p">,</span>
<span class="p">)</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">fft</span> <span class="k">as</span> <span class="n">fft</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">futures</span> <span class="k">as</span> <span class="n">futures</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">nn</span> <span class="k">as</span> <span class="n">nn</span>
<span class="kn">import</span> <span class="nn">torch.nn.intrinsic</span>
<span class="kn">import</span> <span class="nn">torch.nn.quantizable</span>
<span class="kn">import</span> <span class="nn">torch.nn.quantized</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">optim</span> <span class="k">as</span> <span class="n">optim</span>
<span class="kn">import</span> <span class="nn">torch.optim._multi_tensor</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">multiprocessing</span> <span class="k">as</span> <span class="n">multiprocessing</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">sparse</span> <span class="k">as</span> <span class="n">sparse</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">special</span> <span class="k">as</span> <span class="n">special</span>
<span class="kn">import</span> <span class="nn">torch.utils.backcompat</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">onnx</span> <span class="k">as</span> <span class="n">onnx</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">jit</span> <span class="k">as</span> <span class="n">jit</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">linalg</span> <span class="k">as</span> <span class="n">linalg</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">hub</span> <span class="k">as</span> <span class="n">hub</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">random</span> <span class="k">as</span> <span class="n">random</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">distributions</span> <span class="k">as</span> <span class="n">distributions</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">testing</span> <span class="k">as</span> <span class="n">testing</span>
<span class="kn">import</span> <span class="nn">torch.backends.cuda</span>
<span class="kn">import</span> <span class="nn">torch.backends.mkl</span>
<span class="kn">import</span> <span class="nn">torch.backends.mkldnn</span>
<span class="kn">import</span> <span class="nn">torch.backends.openmp</span>
<span class="kn">import</span> <span class="nn">torch.backends.quantized</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">quantization</span> <span class="k">as</span> <span class="n">quantization</span>
<span class="kn">import</span> <span class="nn">torch.utils.data</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">__config__</span> <span class="k">as</span> <span class="n">__config__</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">__future__</span> <span class="k">as</span> <span class="n">__future__</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">profiler</span> <span class="k">as</span> <span class="n">profiler</span>

<span class="n">_C</span><span class="o">.</span><span class="n">_init_names</span><span class="p">(</span><span class="nb">list</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">_storage_classes</span><span class="p">))</span>

<span class="c1"># attach docstrings to torch and tensor functions</span>
<span class="kn">from</span> <span class="nn">.</span> <span class="kn">import</span> <span class="n">_torch_docs</span><span class="p">,</span> <span class="n">_tensor_docs</span><span class="p">,</span> <span class="n">_storage_docs</span>
<span class="k">del</span> <span class="n">_torch_docs</span><span class="p">,</span> <span class="n">_tensor_docs</span><span class="p">,</span> <span class="n">_storage_docs</span>


<span class="k">def</span> <span class="nf">compiled_with_cxx11_abi</span><span class="p">():</span>
    <span class="sa">r</span><span class="sd">&quot;&quot;&quot;Returns whether PyTorch was built with _GLIBCXX_USE_CXX11_ABI=1&quot;&quot;&quot;</span>
    <span class="k">return</span> <span class="n">_C</span><span class="o">.</span><span class="n">_GLIBCXX_USE_CXX11_ABI</span>


<span class="c1"># Import the ops &quot;namespace&quot;</span>
<span class="kn">from</span> <span class="nn">torch._ops</span> <span class="kn">import</span> <span class="n">ops</span>
<span class="kn">from</span> <span class="nn">torch._classes</span> <span class="kn">import</span> <span class="n">classes</span>

<span class="c1"># Import the quasi random sampler</span>
<span class="kn">from</span> <span class="nn">torch</span> <span class="kn">import</span> <span class="n">quasirandom</span> <span class="k">as</span> <span class="n">quasirandom</span>

<span class="c1"># If you are seeing this, it means that this call site was not checked if</span>
<span class="c1"># the memory format could be preserved, and it was switched to old default</span>
<span class="c1"># behaviour of contiguous</span>
<span class="n">legacy_contiguous_format</span> <span class="o">=</span> <span class="n">contiguous_format</span>

<span class="c1"># Register fork handler to initialize OpenMP in child processes (see gh-28389)</span>
<span class="kn">from</span> <span class="nn">torch.multiprocessing._atfork</span> <span class="kn">import</span> <span class="n">register_after_fork</span>
<span class="n">register_after_fork</span><span class="p">(</span><span class="n">torch</span><span class="o">.</span><span class="n">get_num_threads</span><span class="p">)</span>
<span class="k">del</span> <span class="n">register_after_fork</span>

<span class="c1"># Import tools that require fully imported torch (for applying</span>
<span class="c1"># torch.jit.script as a decorator, for instance):</span>
<span class="kn">from</span> <span class="nn">._lobpcg</span> <span class="kn">import</span> <span class="n">lobpcg</span> <span class="k">as</span> <span class="n">lobpcg</span>

<span class="c1"># These were previously defined in native_functions.yaml and appeared on the</span>
<span class="c1"># `torch` namespace, but we moved them to c10 dispatch to facilitate custom</span>
<span class="c1"># class usage. We add these lines here to preserve backward compatibility.</span>
<span class="n">quantized_lstm</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">ops</span><span class="o">.</span><span class="n">aten</span><span class="o">.</span><span class="n">quantized_lstm</span>
<span class="n">quantized_gru</span> <span class="o">=</span> <span class="n">torch</span><span class="o">.</span><span class="n">ops</span><span class="o">.</span><span class="n">aten</span><span class="o">.</span><span class="n">quantized_gru</span>
</pre></div>


           </div>
           
          </div>
          <footer>
  

  <hr/>

  <div role="contentinfo">
    <p>
        &copy; Copyright 2022, HansBug, DI-engine&#39;s Contributors

    </p>
  </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>. 

</footer>

        </div>
      </div>

    </section>

  </div>
  
    <div class="rst-versions" data-toggle="rst-versions" role="note" aria-label="versions">
  <span class="rst-current-version" data-toggle="rst-current-version">
    <span class="fa fa-book"> Other Versions</span>
    v: dev/stream
    <span class="fa fa-caret-down"></span>
  </span>
        <div class="rst-other-versions">
                <dl>
                    <dt>Tags</dt>
                        <dd><a href="../../../v0.2.1/index.html">v0.2.1</a></dd>
                        <dd><a href="../../../v0.3.0/index.html">v0.3.0</a></dd>
                </dl>
                <dl>
                    <dt>Branches</dt>
                        <dd><a href="../../../12/merge/index.html">12/merge</a></dd>
                        <dd><a href="torch.html">dev/stream</a></dd>
                        <dd><a href="../../../main/index.html">main</a></dd>
                        <dd><a href="../../../run/xdemos/index.html">run/xdemos</a></dd>
                        <dd><a href="../../../test/os/index.html">test/os</a></dd>
                </dl>
        </div>
    </div>

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

  
</body>
</html>