Initial commit

fairscale/nn/pipe/worker.py

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Copyright 2019 Kakao Brain
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Multithreading in pipeline parallelism."""
+from contextlib import contextmanager
+from queue import Queue
+import sys
+from threading import Thread
+from types import TracebackType
+from typing import TYPE_CHECKING, Callable, Dict, Generator, List, Optional, Tuple, Type, Union, cast
+
+import torch
+
+from .microbatch import Batch
+from .stream import AbstractStream, use_device, use_stream
+
+__all__: List[str] = []
+
+
+ExcInfo = Tuple[Type[BaseException], BaseException, TracebackType]
+
+# Queue is generic only in stubs.
+# https://mypy.readthedocs.io/en/latest/common_issues.html#using-classes-that-are-generic-in-stubs-but-not-at-runtime
+if TYPE_CHECKING:
+    InQueue = Queue[Optional["Task"]]
+    OutQueue = Queue[Tuple[bool, Union[Tuple["Task", Batch], ExcInfo, None]]]
+else:
+    InQueue = Queue
+    OutQueue = Queue
+
+
+class Task:
+    """A task represents how to compute a micro-batch on a partition.
+
+    It consists of two parts: :meth:`compute` and :meth:`finalize`.
+    :meth:`compute` should be executed in worker threads concurrently.
+    :meth:`finalize` should be executed after when worker threads complete to
+    execute :meth:`compute`.
+
+    :meth:`compute` might be boosted by worker threads. Because it produces
+    several CUDA API calls by user code. In PyTorch, parallel CUDA API calls
+    are not serialized through GIL. So more than one CUDA API call can be
+    produced at the same time.
+
+    """
+
+    def __init__(
+        self, stream: AbstractStream, *, compute: Callable[[], Batch], finalize: Optional[Callable[[Batch], None]],
+    ) -> None:
+        self.stream = stream
+        self._compute = compute
+        self._finalize = finalize
+        self._grad_enabled = torch.is_grad_enabled()
+
+    def compute(self) -> Batch:
+        with use_stream(self.stream), torch.set_grad_enabled(self._grad_enabled):
+            return self._compute()
+
+    def finalize(self, batch: Batch) -> None:
+        if self._finalize is None:
+            return
+        with use_stream(self.stream), torch.set_grad_enabled(self._grad_enabled):
+            self._finalize(batch)
+
+
+def worker(in_queue: InQueue, out_queue: OutQueue, device: torch.device) -> None:
+    """The main loop of a worker thread."""
+    with use_device(device):
+        while True:
+            task = in_queue.get()
+
+            if task is None:
+                break
+
+            try:
+                batch = task.compute()
+            except Exception:
+                exc_info = cast(ExcInfo, sys.exc_info())
+                out_queue.put((False, exc_info))
+                continue
+
+            out_queue.put((True, (task, batch)))
+
+    done = (False, None)
+    out_queue.put(done)
+
+
+def create_workers(devices: List[torch.device],) -> Tuple[List[InQueue], List[OutQueue]]:
+    """Spawns worker threads. A worker thread is bound to a device."""
+    in_queues: List[InQueue] = []
+    out_queues: List[OutQueue] = []
+
+    # Spawn workers.
+    workers: Dict[torch.device, Tuple[InQueue, OutQueue]] = {}
+
+    def normalize_device(device: torch.device) -> torch.device:
+        if device.type == "cuda" and device.index is None:
+            return torch.device("cuda", index=torch.cuda.current_device())
+
+        if device.type == "cpu" and device.index is not None:
+            return torch.device("cpu")
+
+        return device
+
+    for device in devices:
+        device = normalize_device(device)
+
+        try:
+            in_queue, out_queue = workers[device]
+        except KeyError:
+            in_queue = Queue()
+            out_queue = Queue()
+            workers[device] = (in_queue, out_queue)
+
+            t = Thread(target=worker, args=(in_queue, out_queue, device), daemon=True,)
+            t.start()
+
+        in_queues.append(in_queue)
+        out_queues.append(out_queue)
+
+    return (in_queues, out_queues)
+
+
+def join_workers(in_queues: List[InQueue], out_queues: List[OutQueue]) -> None:
+    # Close workers.
+    for in_queue in set(in_queues):
+        in_queue.put(None)
+
+    # Join running workers.
+    running = set(out_queues)
+    while running:
+        out_queue = running.pop()
+        ok, payload = out_queue.get()
+
+        done = (False, None)
+        if (ok, payload) == done:
+            continue
+
+        running.add(out_queue)
+
+
+@contextmanager
+def spawn_workers(devices: List[torch.device],) -> Generator[Tuple[List[InQueue], List[OutQueue]], None, None]:
+    try:
+        (in_queues, out_queues) = create_workers(devices)
+        yield (in_queues, out_queues)
+    finally:
+        join_workers(in_queues, out_queues)

fairscale/optim/__init__.py

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+:mod:`fairgc.optim` is a package implementing various torch optimization algorithms.
+"""
+
+from .oss import OSS

fairscale/optim/oss.py

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+#
+# This source code is licensed under the BSD license found in the
+# LICENSE file in the root directory of this source tree.
+
+import copy
+from typing import TYPE_CHECKING, Any, Callable, List, Optional, Type
+
+import torch.distributed as dist
+from torch.optim import SGD, Optimizer
+
+if TYPE_CHECKING:
+    from torch.optim.optimizer import _params_t
+else:
+    _params_t = Any
+
+
+class OSS(Optimizer):
+    """Wraps an arbitrary :class:`optim.Optimizer <torch.optim.Optimizer>`
+    optimizer and shards its state as describe by ZeRO_.
+    ::
+        opt = OSS(params, optim=torch.optim.Adam, lr=0.01)
+
+    .. _ZeRO: https://arxiv.org/abs/1910.02054
+
+    Pipe combines pipeline parallelism with checkpointing to reduce peak
+    memory required to train while minimizing device under-utilization.
+
+    You should determine the balance when defining a :class:`Pipe` module, as
+    balancing will not be done automatically. The module will be partitioned
+    into multiple devices according to the given balance. You may rely on
+    heuristics to find your own optimal configuration.
+
+    Args:
+        params (list of tensors):
+            parameters to be optimized
+    Keyword Args:
+        optim (torch.nn.Optimizer):
+            optimizer to shard (default: SGD)
+        group (group):
+            torch.distributed group (default: group.WORLD)
+    """
+
+    optim: Optimizer
+    in_super_constructor: bool
+
+    def __init__(self, params: _params_t, optim: Type[Optimizer] = SGD, group: Any = dist.group.WORLD, **defaults: Any):
+        self.in_super_constructor = True
+        super().__init__(params, defaults)
+        self.in_super_constructor = False
+
+        self.group = group
+        self.rank = dist.get_rank(group)
+        param_groups = self.partition_parameters()
+        self.optim = optim(param_groups[self.rank], **defaults)
+
+    def partition_parameters(self) -> List[List[dict]]:
+        """Partitions parameters across distributed ranks.
+
+        Returns a list of param_groups (which is a list of dict) where each
+        element of the list contains the param_groups for a rank. Element 0
+        corresponds to rank 0, etc. We need all the ranks for the broadcast
+        inside step().
+        """
+        world_size = dist.get_world_size(self.group)
+        param_groups: List[List] = [list() for _ in range(world_size)]
+        sizes = [0] * world_size
+        for param_group in self.param_groups:
+            param_lists: List[List] = [list() for _ in range(world_size)]
+            for param in param_group["params"]:
+                # Add this param to rank with smallest size.
+                rank = sizes.index(min(sizes))
+                param_lists[rank].append(param)
+                sizes[rank] += param.numel()
+            for rank, params in enumerate(param_lists):
+                if len(params):
+                    pg = copy.copy(param_group)
+                    pg["params"] = params
+                    param_groups[rank].append(pg)
+        return param_groups
+
+    def step(self, closure: Optional[Callable[[], float]] = None) -> Optional[float]:
+        loss = self.optim.step(closure=closure)
+        for rank, param_groups in enumerate(self.partition_parameters()):
+            for param_group in param_groups:
+                for param in param_group["params"]:
+                    dist.broadcast(param, rank, group=self.group)
+        return loss
+
+    def state_dict(self) -> dict:
+        """ Gets this rank's state_dict. """
+        return self.optim.state_dict()
+
+    def load_state_dict(self, state_dict: dict) -> None:
+        """ Loads this rank's state_dict. """
+        self.optim.load_state_dict(state_dict)
+
+    def add_param_group(self, param_group: dict) -> None:
+        super().add_param_group(param_group)
+        if not self.in_super_constructor:
+            param_groups = self.partition_parameters()[self.rank]
+            if len(param_groups) == len(self.optim.param_groups) + 1:
+                self.optim.add_param_group(param_groups[-1])

pyproject.toml

+[build-system]
+requires = [
+    "setuptools >= 40.6.2",
+    "wheel >= 0.30.0"
+]
+build-backend = "setuptools.build_meta"
+
+[tool.black]
+line-length = 120
+exclude = '''
+/(
+    \.git
+  | \.mypy_cache
+  | \.pytest_cache
+  | build
+  | stubs
+)/
+'''

requirements-dev.txt

+-r requirements.txt
+pre-commit

requirements-test.txt

+black == 19.10b0
+flake8 == 3.7.9
+isort == 4.3.21
+mypy == 0.770
+pytest == 5.4.1
+torchtext == 0.6.0
+torch == 1.4.0
+# NOTE(msb) not a dependency but needed by torch == 1.4.0
+numpy == 1.17.4

requirements.txt

+torch >= 1.4.0

setup.cfg

+# -----------------------------------------------------------------------------
+# pytest
+# -----------------------------------------------------------------------------
+
+[tool:pytest]
+testpaths = tests
+addopts = --verbose
+junit_family = xunit2
+
+[aliases]
+test = pytest
+
+# -----------------------------------------------------------------------------
+# coverage
+# -----------------------------------------------------------------------------
+
+[coverage:report]
+# Coverage couldn't detect backward functions because they are called by C++.
+# Append "# pragma: no cover" to the definition lines to ignore them.
+# https://www.janfreyberg.com/blog/2019-04-01-testing-pytorch-functions/
+exclude_lines = pragma: no cover
+
+# -----------------------------------------------------------------------------
+# flake8
+# -----------------------------------------------------------------------------
+
+[flake8]
+select = B,C,E,F,P,T4,W,B9
+max-line-length = 120
+# C408 ignored because we like the dict keyword argument syntax
+# E501 is not flexible enough, we're using B950 instead
+ignore =
+    E203,E305,E402,E501,E721,E741,F403,F405,F821,F841,F999,W503,W504,C408,E302,W291,E303,
+per-file-ignores = __init__.py: F401
+exclude = build,*.pyi,.git
+
+# -----------------------------------------------------------------------------
+# isort
+# -----------------------------------------------------------------------------
+
+[isort]
+line_length = 120
+multi_line_output=3
+include_trailing_comma=True
+force_grid_wrap=0
+use_parentheses=True
+skip_glob = build/*,stubs/*
+# Don't split "import" and "from".
+force_sort_within_sections = true
+known_third_party = models,pytest,setuptools,torch,torchtext
+
+# -----------------------------------------------------------------------------
+# mypy
+# -----------------------------------------------------------------------------
+
+# Docs for mypy config: https://mypy.readthedocs.io/en/latest/config_file.html
+[mypy]
+mypy_path = ./stubs/
+follow_imports = normal
+
+# This project must be strictly typed.
+[mypy-fairscale.*]
+check_untyped_defs = true
+disallow_untyped_defs = true
+disallow_untyped_calls = true
+disallow_untyped_decorators = true
+disallow_incomplete_defs = true
+warn_unused_ignores = true
+
+# Ignore missing imports from untyped third-party libraries.
+[mypy-torch.*,torchvision.*,setuptools.*,pytest.*]
+ignore_missing_imports = true

setup.py

+#!/usr/bin/env python3
+
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+import setuptools
+
+
+def fetch_requirements():
+    with open("requirements.txt") as f:
+        reqs = f.read().strip().split("\n")
+    return reqs
+
+
+if __name__ == "__main__":
+    setuptools.setup(
+        name="fairscale",
+        description="fairscale: Utility library for large-scale and high-performance training.",
+        install_requires=fetch_requirements(),
+        include_package_data=True,
+        packages=setuptools.find_packages(exclude=("tests", "tests.*")),
+        python_requires=">=3.6",
+        author="Facebook AI Research",
+        author_email="todo@fb.com",
+        classifiers=[
+            "Programming Language :: Python :: 3.6",
+            "Programming Language :: Python :: 3.7",
+            "Programming Language :: Python :: 3.8",
+            "License :: OSI Approved :: BSD License",
+            "Topic :: Scientific/Engineering :: Artificial Intelligence",
+            "Operating System :: OS Independent",
+        ],
+    )

stubs/torch/__init__.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+# @generated from torch/__init__.pyi.in
+
+from typing import List, Tuple, Optional, Union, Any, ContextManager, Callable, overload, Iterator
+from torch._six import inf
+
+import builtins
+
+# These identifiers are reexported from other modules.  These modules
+# are not mypy-clean yet, so in order to use this stub file usefully
+# from mypy you will need to specify --follow-imports=silent.
+# Not all is lost: these imports still enable IDEs like PyCharm to offer
+# autocomplete.
+#
+# Note: Why does the syntax here look so strange?  Import visibility
+# rules in stubs are different from normal Python files!  You must use
+# 'from ... import ... as ...' syntax to cause an identifier to be
+# exposed (or use a wildcard); regular syntax is not exposed.
+from .random import set_rng_state as set_rng_state, get_rng_state as get_rng_state, \
+    manual_seed as manual_seed, initial_seed as initial_seed, seed as seed
+from ._tensor_str import set_printoptions as set_printoptions
+from .functional import *
+from .serialization import save as save, load as load
+from .autograd import no_grad as no_grad, enable_grad as enable_grad, \
+    set_grad_enabled as set_grad_enabled
+from . import cuda as cuda
+from . import optim as optim
+from . import nn as nn
+
+#MODIFIED BY TORCHGPIPE
+from . import backends
+from . import version
+#END
+
+class dtype: ...
+
+class layout: ...
+
+strided : layout = ...
+
+class memory_format: ...
+
+contiguous_format: memory_format = ...
+
+class qscheme: ...
+
+per_tensor_affine: qscheme = ...
+
+# See https://github.com/python/mypy/issues/4146 for why these workarounds
+# is necessary
+_int = builtins.int
+_float = builtins.float
+_bool = builtins.bool
+
+class device:
+    type: str
+    index: _int
+
+#MODIFIED BY TORCHGPIPE
+    @overload
+    def __init__(self, device: device) -> None: ...
+#END
+
+    @overload
+    def __init__(self, device: Union[_int, str]) -> None: ...
+
+    @overload
+    def __init__(self, type: str, index: _int) -> None: ...
+
+#MODIFIED BY TORCHGPIPE
+class Size(tuple):
+    def numel(self) -> _int: ...
+#END
+
+#MODIFIED BY TORCHGPIPE
+class Storage:
+    def size(self) -> _int: ...
+    def element_size(self) -> _int: ...
+#END
+
+# See https://github.com/python/mypy/issues/4146 for why these workarounds
+# is necessary
+_dtype = dtype
+_device = device
+_qscheme = qscheme
+_size = Union[Size, List[_int], Tuple[_int, ...]]
+_layout = layout
+
+# Meta-type for "numeric" things; matches our docs
+Number = Union[builtins.int, builtins.float, builtins.bool]
+
+class Generator:
+    device: _device = ...
+
+    @overload
+    def __init__(self, device: Optional[_device]=None) -> None: ...
+
+    @overload
+    def __init__(self, device: Union[_int, str]) -> None: ...
+
+# TODO: One downside of doing it this way, is direct use of
+# torch.tensor.Tensor doesn't get type annotations.  Nobody
+# should really do that, so maybe this is not so bad.
+class Tensor:
+    requires_grad: _bool = ...
+    grad: Optional[Tensor] = ...
+    data: Tensor = ...
+    names: List[str] = ...
+    @property
+    def dtype(self) -> _dtype: ...
+    @property
+    def shape(self) -> Size: ...
+    @property
+    def device(self) -> _device: ...
+    @property
+    def T(self) -> Tensor: ...
+    @property
+    def grad_fn(self) -> Optional[Any]: ...
+    @property
+    def ndim(self) -> _int: ...
+    @property
+    def layout(self) -> _layout: ...
+
+    def __abs__(self) -> Tensor: ...
+    def __add__(self, other: Any) -> Tensor: ...
+    @overload
+    def __and__(self, other: Number) -> Tensor: ...
+    @overload
+    def __and__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __and__(self, other: Any) -> Tensor: ...
+    def __bool__(self) -> builtins.bool: ...
+    def __div__(self, other: Any) -> Tensor: ...
+    def __eq__(self, other: Any) -> Tensor: ...  # type: ignore
+    def __float__(self) -> builtins.float: ...
+    def __floordiv__(self, other: Any) -> Tensor: ...
+    def __ge__(self, other: Any) -> Tensor: ...  # type: ignore
+    def __getitem__(self, indices: Union[None, _int, slice, Tensor, List, Tuple]) -> Tensor: ...
+    def __gt__(self, other: Any) -> Tensor: ...  # type: ignore
+    def __iadd__(self, other: Any) -> Tensor: ...
+    @overload
+    def __iand__(self, other: Number) -> Tensor: ...
+    @overload
+    def __iand__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __iand__(self, other: Any) -> Tensor: ...
+    def __idiv__(self, other: Any) -> Tensor: ...
+    @overload
+    def __ilshift__(self, other: Number) -> Tensor: ...
+    @overload
+    def __ilshift__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __ilshift__(self, other: Any) -> Tensor: ...
+    def __imul__(self, other: Any) -> Tensor: ...
+    def __index__(self) -> builtins.int: ...
+    def __int__(self) -> builtins.int: ...
+    def __invert__(self) -> Tensor: ...
+    @overload
+    def __ior__(self, other: Number) -> Tensor: ...
+    @overload
+    def __ior__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __ior__(self, other: Any) -> Tensor: ...
+    @overload
+    def __irshift__(self, other: Number) -> Tensor: ...
+    @overload
+    def __irshift__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __irshift__(self, other: Any) -> Tensor: ...
+    def __isub__(self, other: Any) -> Tensor: ...
+    def __itruediv__(self, other: Any) -> Tensor: ...
+    @overload
+    def __ixor__(self, other: Number) -> Tensor: ...
+    @overload
+    def __ixor__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __ixor__(self, other: Any) -> Tensor: ...
+    def __le__(self, other: Any) -> Tensor: ...  # type: ignore
+    def __long__(self) -> builtins.int: ...
+    @overload
+    def __lshift__(self, other: Number) -> Tensor: ...
+    @overload
+    def __lshift__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __lshift__(self, other: Any) -> Tensor: ...
+    def __lt__(self, other: Any) -> Tensor: ...  # type: ignore
+    def __matmul__(self, other: Any) -> Tensor: ...
+    def __mod__(self, other: Any) -> Tensor: ...
+    def __mul__(self, other: Any) -> Tensor: ...
+    def __ne__(self, other: Any) -> Tensor: ...  # type: ignore
+    def __neg__(self) -> Tensor: ...
+    def __nonzero__(self) -> builtins.bool: ...
+    @overload
+    def __or__(self, other: Number) -> Tensor: ...
+    @overload
+    def __or__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __or__(self, other: Any) -> Tensor: ...
+    def __pow__(self, other: Any) -> Tensor: ...
+    def __radd__(self, other: Any) -> Tensor: ...
+    def __rfloordiv__(self, other: Any) -> Tensor: ...
+    def __rmul__(self, other: Any) -> Tensor: ...
+    @overload
+    def __rshift__(self, other: Number) -> Tensor: ...
+    @overload
+    def __rshift__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __rshift__(self, other: Any) -> Tensor: ...
+    def __setitem__(self, indices: Union[None, _int, slice, Tensor, List, Tuple], val: Union[Tensor, Number]) -> None: ...
+    def __sub__(self, other: Any) -> Tensor: ...
+    def __truediv__(self, other: Any) -> Tensor: ...
+    @overload
+    def __xor__(self, other: Number) -> Tensor: ...
+    @overload
+    def __xor__(self, other: Tensor) -> Tensor: ...
+    @overload
+    def __xor__(self, other: Any) -> Tensor: ...
+    def _coalesced_(self, coalesced: _bool) -> Tensor: ...
+    def _dimI(self) -> _int: ...
+    def _dimV(self) -> _int: ...
+    def _indices(self) -> Tensor: ...
+    def _nnz(self) -> _int: ...
+    def _values(self) -> Tensor: ...
+    def abs(self) -> Tensor: ...
+    def abs_(self) -> Tensor: ...
+    def acos(self) -> Tensor: ...
+    def acos_(self) -> Tensor: ...
+    def addbmm(self, batch1: Tensor, batch2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def addbmm_(self, batch1: Tensor, batch2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def addcdiv(self, tensor1: Tensor, tensor2: Tensor, *, value: Number=1) -> Tensor: ...
+    def addcdiv_(self, tensor1: Tensor, tensor2: Tensor, *, value: Number=1) -> Tensor: ...
+    def addcmul(self, tensor1: Tensor, tensor2: Tensor, *, value: Number=1) -> Tensor: ...
+    def addcmul_(self, tensor1: Tensor, tensor2: Tensor, *, value: Number=1) -> Tensor: ...
+    def addmm(self, mat1: Tensor, mat2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def addmm_(self, mat1: Tensor, mat2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def addmv(self, mat: Tensor, vec: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def addmv_(self, mat: Tensor, vec: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def addr(self, vec1: Tensor, vec2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def addr_(self, vec1: Tensor, vec2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def align_as(self, other: Tensor) -> Tensor: ...
+    @overload
+    def align_to(self, names: List[Union[str, None]]) -> Tensor: ...
+    @overload
+    def align_to(self, order: List[Union[str, None]], ellipsis_idx: _int) -> Tensor: ...
+    @overload
+    def all(self, dim: _int, keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def all(self, dim: Union[str, None], keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def all(self) -> Tensor: ...
+    def allclose(self, other: Tensor, rtol: _float=1e-05, atol: _float=1e-08, equal_nan: _bool=False) -> _bool: ...
+    def angle(self) -> Tensor: ...
+    @overload
+    def any(self, dim: _int, keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def any(self, dim: Union[str, None], keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def any(self) -> Tensor: ...
+    def apply_(self, callable: Callable) -> Tensor: ...
+    def argmax(self, dim: Optional[_int]=None, keepdim: _bool=False) -> Tensor: ...
+    def argmin(self, dim: Optional[_int]=None, keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def argsort(self, dim: _int=-1, descending: _bool=False) -> Tensor: ...
+    @overload
+    def argsort(self, dim: Union[str, None], descending: _bool=False) -> Tensor: ...
+    def as_strided(self, size: _size, stride: _size, storage_offset: Optional[_int]=None) -> Tensor: ...
+    def as_strided_(self, size: _size, stride: _size, storage_offset: Optional[_int]=None) -> Tensor: ...
+    def asin(self) -> Tensor: ...
+    def asin_(self) -> Tensor: ...
+    def atan(self) -> Tensor: ...
+    def atan2(self, other: Tensor) -> Tensor: ...
+    def atan2_(self, other: Tensor) -> Tensor: ...
+    def atan_(self) -> Tensor: ...
+    def backward(self, gradient: Optional[Tensor]=None, keep_graph: _bool=False, create_graph: _bool=False) -> None: ...
+    def baddbmm(self, batch1: Tensor, batch2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    def baddbmm_(self, batch1: Tensor, batch2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    @overload
+    def bernoulli(self, *, generator: Generator=None) -> Tensor: ...
+    @overload
+    def bernoulli(self, p: _float, *, generator: Generator=None) -> Tensor: ...
+    @overload
+    def bernoulli_(self, p: Tensor, *, generator: Generator=None) -> Tensor: ...
+    @overload
+    def bernoulli_(self, p: _float=0.5, *, generator: Generator=None) -> Tensor: ...
+    def bincount(self, weights: Optional[Tensor]=None, minlength: _int=0) -> Tensor: ...
+    def bitwise_not(self) -> Tensor: ...
+    def bitwise_not_(self) -> Tensor: ...
+    @overload
+    def bitwise_xor(self, other: Number) -> Tensor: ...
+    @overload
+    def bitwise_xor(self, other: Tensor) -> Tensor: ...
+    @overload
+    def bitwise_xor_(self, other: Number) -> Tensor: ...
+    @overload
+    def bitwise_xor_(self, other: Tensor) -> Tensor: ...
+    def bmm(self, mat2: Tensor) -> Tensor: ...
+    def bool(self) -> Tensor: ...
+    def byte(self) -> Tensor: ...
+    def cauchy_(self, median: _float=0, sigma: _float=1, *, generator: Generator=None) -> Tensor: ...
+    def ceil(self) -> Tensor: ...
+    def ceil_(self) -> Tensor: ...
+    def char(self) -> Tensor: ...
+    def cholesky(self, upper: _bool=False) -> Tensor: ...
+    def cholesky_inverse(self, upper: _bool=False) -> Tensor: ...
+    def cholesky_solve(self, input2: Tensor, upper: _bool=False) -> Tensor: ...
+    def chunk(self, chunks: _int, dim: _int=0) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+    def clamp(self, min: _float=-inf, max: _float=inf, *, out: Optional[Tensor]=None) -> Tensor: ...
+    def clamp_(self, min: _float=-inf, max: _float=inf) -> Tensor: ...
+    def clamp_max(self, max: Number) -> Tensor: ...
+    def clamp_max_(self, max: Number) -> Tensor: ...
+    def clamp_min(self, min: Number) -> Tensor: ...
+    def clamp_min_(self, min: Number) -> Tensor: ...
+    def clone(self, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+    def coalesce(self) -> Tensor: ...
+    def conj(self) -> Tensor: ...
+    def contiguous(self) -> Tensor: ...
+    def cos(self) -> Tensor: ...
+    def cos_(self) -> Tensor: ...
+    def cosh(self) -> Tensor: ...
+    def cosh_(self) -> Tensor: ...
+    def cpu(self) -> Tensor: ...
+    def cross(self, other: Tensor, dim: Optional[_int]=None) -> Tensor: ...
+    def cuda(self, device: Optional[_device]=None, non_blocking: _bool=False) -> Tensor: ...
+    @overload
+    def cumprod(self, dim: _int, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def cumprod(self, dim: Union[str, None], *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def cumsum(self, dim: _int, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def cumsum(self, dim: Union[str, None], *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    def dense_dim(self) -> _int: ...
+    def dequantize(self) -> Tensor: ...
+    def det(self) -> Tensor: ...
+    def detach(self) -> Tensor: ...
+    def detach_(self) -> Tensor: ...
+    def diag(self, diagonal: _int=0) -> Tensor: ...
+    def diag_embed(self, offset: _int=0, dim1: _int=-2, dim2: _int=-1) -> Tensor: ...
+    def diagflat(self, offset: _int=0) -> Tensor: ...
+    def diagonal(self, offset: _int=0, dim1: _int=0, dim2: _int=1) -> Tensor: ...
+    def digamma(self) -> Tensor: ...
+    def digamma_(self) -> Tensor: ...
+    def dim(self) -> _int: ...
+    def dist(self, other: Tensor, p: Number=2) -> Tensor: ...
+    def dot(self, tensor: Tensor) -> Tensor: ...
+    def double(self) -> Tensor: ...
+    def eig(self, eigenvectors: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    def element_size(self) -> _int: ...
+    @overload
+    def eq(self, other: Number) -> Tensor: ...
+    @overload
+    def eq(self, other: Tensor) -> Tensor: ...
+    @overload
+    def eq_(self, other: Number) -> Tensor: ...
+    @overload
+    def eq_(self, other: Tensor) -> Tensor: ...
+    def equal(self, other: Tensor) -> _bool: ...
+    def erf(self) -> Tensor: ...
+    def erf_(self) -> Tensor: ...
+    def erfc(self) -> Tensor: ...
+    def erfc_(self) -> Tensor: ...
+    def erfinv(self) -> Tensor: ...
+    def erfinv_(self) -> Tensor: ...
+    def exp(self) -> Tensor: ...
+    def exp_(self) -> Tensor: ...
+    @overload
+    def expand(self, size: _size, *, implicit: _bool=False) -> Tensor: ...
+    @overload
+    def expand(self, *size: _int, implicit: _bool=False) -> Tensor: ...
+    def expand_as(self, other: Tensor) -> Tensor: ...
+    def expm1(self) -> Tensor: ...
+    def expm1_(self) -> Tensor: ...
+    def exponential_(self, lambd: _float=1, *, generator: Generator=None) -> Tensor: ...
+    def fft(self, signal_ndim: _int, normalized: _bool=False) -> Tensor: ...
+    @overload
+    def fill_(self, value: Number) -> Tensor: ...
+    @overload
+    def fill_(self, value: Tensor) -> Tensor: ...
+    def fill_diagonal_(self, fill_value: Number, wrap: _bool=False) -> Tensor: ...
+    @overload
+    def flatten(self, start_dim: _int=0, end_dim: _int=-1) -> Tensor: ...
+    @overload
+    def flatten(self, start_dim: _int, end_dim: _int, out_dim: Union[str, None]) -> Tensor: ...
+    @overload
+    def flatten(self, start_dim: Union[str, None], end_dim: Union[str, None], out_dim: Union[str, None]) -> Tensor: ...
+    @overload
+    def flatten(self, dims: List[Union[str, None]], out_dim: Union[str, None]) -> Tensor: ...
+    @overload
+    def flip(self, dims: _size) -> Tensor: ...
+    @overload
+    def flip(self, *dims: _int) -> Tensor: ...
+    def float(self) -> Tensor: ...
+    def floor(self) -> Tensor: ...
+    def floor_(self) -> Tensor: ...
+    @overload
+    def fmod(self, other: Number) -> Tensor: ...
+    @overload
+    def fmod(self, other: Tensor) -> Tensor: ...
+    @overload
+    def fmod_(self, other: Number) -> Tensor: ...
+    @overload
+    def fmod_(self, other: Tensor) -> Tensor: ...
+    def frac(self) -> Tensor: ...
+    def frac_(self) -> Tensor: ...
+    @overload
+    def gather(self, dim: _int, index: Tensor, *, sparse_grad: _bool=False) -> Tensor: ...
+    @overload
+    def gather(self, dim: Union[str, None], index: Tensor, *, sparse_grad: _bool=False) -> Tensor: ...
+    @overload
+    def ge(self, other: Number) -> Tensor: ...
+    @overload
+    def ge(self, other: Tensor) -> Tensor: ...
+    @overload
+    def ge_(self, other: Number) -> Tensor: ...
+    @overload
+    def ge_(self, other: Tensor) -> Tensor: ...
+    def geometric_(self, p: _float, *, generator: Generator=None) -> Tensor: ...
+    def geqrf(self) -> Tuple[Tensor, Tensor]: ...
+    def ger(self, vec2: Tensor) -> Tensor: ...
+    def get_device(self) -> _int: ...
+    @overload
+    def gt(self, other: Number) -> Tensor: ...
+    @overload
+    def gt(self, other: Tensor) -> Tensor: ...
+    @overload
+    def gt_(self, other: Number) -> Tensor: ...
+    @overload
+    def gt_(self, other: Tensor) -> Tensor: ...
+    def half(self) -> Tensor: ...
+    def hardshrink(self, lambd: Number=0.5) -> Tensor: ...
+    def histc(self, bins: _int=100, min: Number=0, max: Number=0) -> Tensor: ...
+    def ifft(self, signal_ndim: _int, normalized: _bool=False) -> Tensor: ...
+    def imag(self) -> Tensor: ...
+    @overload
+    def index_add(self, dim: _int, index: Tensor, source: Tensor) -> Tensor: ...
+    @overload
+    def index_add(self, dim: Union[str, None], index: Tensor, source: Tensor) -> Tensor: ...
+    def index_add_(self, dim: _int, index: Tensor, source: Tensor) -> Tensor: ...
+    @overload
+    def index_copy(self, dim: _int, index: Tensor, source: Tensor) -> Tensor: ...
+    @overload
+    def index_copy(self, dim: Union[str, None], index: Tensor, source: Tensor) -> Tensor: ...
+    @overload
+    def index_copy_(self, dim: _int, index: Tensor, source: Tensor) -> Tensor: ...
+    @overload
+    def index_copy_(self, dim: Union[str, None], index: Tensor, source: Tensor) -> Tensor: ...
+    @overload
+    def index_fill(self, dim: _int, index: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def index_fill(self, dim: _int, index: Tensor, value: Tensor) -> Tensor: ...
+    @overload
+    def index_fill(self, dim: Union[str, None], index: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def index_fill(self, dim: Union[str, None], index: Tensor, value: Tensor) -> Tensor: ...
+    @overload
+    def index_fill_(self, dim: _int, index: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def index_fill_(self, dim: _int, index: Tensor, value: Tensor) -> Tensor: ...
+    @overload
+    def index_fill_(self, dim: Union[str, None], index: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def index_fill_(self, dim: Union[str, None], index: Tensor, value: Tensor) -> Tensor: ...
+    def index_put(self, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool=False) -> Tensor: ...
+    def index_put_(self, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool=False) -> Tensor: ...
+    @overload
+    def index_select(self, dim: _int, index: Tensor) -> Tensor: ...
+    @overload
+    def index_select(self, dim: Union[str, None], index: Tensor) -> Tensor: ...
+    def indices(self) -> Tensor: ...
+    def int(self) -> Tensor: ...
+    def int_repr(self) -> Tensor: ...
+    def inverse(self) -> Tensor: ...
+    def irfft(self, signal_ndim: _int, normalized: _bool=False, onesided: _bool=True, signal_sizes: _size=()) -> Tensor: ...
+    def is_coalesced(self) -> _bool: ...
+    def is_complex(self) -> _bool: ...
+    def is_contiguous(self) -> _bool: ...
+    is_cuda: _bool
+    def is_distributed(self) -> _bool: ...
+    def is_floating_point(self) -> _bool: ...
+    is_leaf: _bool
+    def is_nonzero(self) -> _bool: ...
+    def is_pinned(self) -> _bool: ...
+    def is_same_size(self, other: Tensor) -> _bool: ...
+    def is_set_to(self, tensor: Tensor) -> _bool: ...
+    def is_signed(self) -> _bool: ...
+    def isclose(self, other: Tensor, rtol: _float=1e-05, atol: _float=1e-08, equal_nan: _bool=False) -> Tensor: ...
+    def item(self) -> Number: ...
+    @overload
+    def kthvalue(self, k: _int, dim: _int=-1, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def kthvalue(self, k: _int, dim: Union[str, None], keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def le(self, other: Number) -> Tensor: ...
+    @overload
+    def le(self, other: Tensor) -> Tensor: ...
+    @overload
+    def le_(self, other: Number) -> Tensor: ...
+    @overload
+    def le_(self, other: Tensor) -> Tensor: ...
+    @overload
+    def lerp(self, end: Tensor, weight: Number) -> Tensor: ...
+    @overload
+    def lerp(self, end: Tensor, weight: Tensor) -> Tensor: ...
+    @overload
+    def lerp_(self, end: Tensor, weight: Number) -> Tensor: ...
+    @overload
+    def lerp_(self, end: Tensor, weight: Tensor) -> Tensor: ...
+    def lgamma(self) -> Tensor: ...
+    def lgamma_(self) -> Tensor: ...
+    def log(self) -> Tensor: ...
+    def log10(self) -> Tensor: ...
+    def log10_(self) -> Tensor: ...
+    def log1p(self) -> Tensor: ...
+    def log1p_(self) -> Tensor: ...
+    def log2(self) -> Tensor: ...
+    def log2_(self) -> Tensor: ...
+    def log_(self) -> Tensor: ...
+    def log_normal_(self, mean: _float=1, std: _float=2, *, generator: Generator=None) -> Tensor: ...
+    @overload
+    def log_softmax(self, dim: _int, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def log_softmax(self, dim: Union[str, None], *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    def logdet(self) -> Tensor: ...
+    def logical_not(self) -> Tensor: ...
+    def logical_not_(self) -> Tensor: ...
+    def logical_xor(self, other: Tensor) -> Tensor: ...
+    def logical_xor_(self, other: Tensor) -> Tensor: ...
+    @overload
+    def logsumexp(self, dim: Union[_int, _size], keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def logsumexp(self, dim: List[Union[str, None]], keepdim: _bool=False) -> Tensor: ...
+    def long(self) -> Tensor: ...
+    def lstsq(self, A: Tensor) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def lt(self, other: Number) -> Tensor: ...
+    @overload
+    def lt(self, other: Tensor) -> Tensor: ...
+    @overload
+    def lt_(self, other: Number) -> Tensor: ...
+    @overload
+    def lt_(self, other: Tensor) -> Tensor: ...
+    def lu_solve(self, LU_data: Tensor, LU_pivots: Tensor) -> Tensor: ...
+    def map_(tensor: Tensor, callable: Callable) -> Tensor: ...
+    @overload
+    def masked_fill(self, mask: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def masked_fill(self, mask: Tensor, value: Tensor) -> Tensor: ...
+    @overload
+    def masked_fill_(self, mask: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def masked_fill_(self, mask: Tensor, value: Tensor) -> Tensor: ...
+    def masked_scatter(self, mask: Tensor, source: Tensor) -> Tensor: ...
+    def masked_scatter_(self, mask: Tensor, source: Tensor) -> Tensor: ...
+    def masked_select(self, mask: Tensor) -> Tensor: ...
+    def matmul(self, other: Tensor) -> Tensor: ...
+    def matrix_power(self, n: _int) -> Tensor: ...
+    @overload
+    def max(self, dim: _int, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def max(self, dim: Union[str, None], keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def max(self, other: Tensor) -> Tensor: ...
+    @overload
+    def max(self) -> Tensor: ...
+    @overload
+    def mean(self, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def mean(self, dim: Union[_int, _size], keepdim: _bool=False, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def mean(self, dim: List[Union[str, None]], keepdim: _bool=False, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def median(self, dim: _int, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def median(self, dim: Union[str, None], keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def median(self) -> Tensor: ...
+    @overload
+    def min(self, dim: _int, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def min(self, dim: Union[str, None], keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def min(self, other: Tensor) -> Tensor: ...
+    @overload
+    def min(self) -> Tensor: ...
+    def mm(self, mat2: Tensor) -> Tensor: ...
+    @overload
+    def mode(self, dim: _int=-1, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def mode(self, dim: Union[str, None], keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    def multinomial(self, num_samples: _int, replacement: _bool=False, *, generator: Generator=None) -> Tensor: ...
+    def mv(self, vec: Tensor) -> Tensor: ...
+    def mvlgamma(self, p: _int) -> Tensor: ...
+    def mvlgamma_(self, p: _int) -> Tensor: ...
+    def narrow(self, dim: _int, start: _int, length: _int) -> Tensor: ...
+    def narrow_copy(self, dim: _int, start: _int, length: _int) -> Tensor: ...
+    def ndimension(self) -> _int: ...
+    @overload
+    def ne(self, other: Number) -> Tensor: ...
+    @overload
+    def ne(self, other: Tensor) -> Tensor: ...
+    @overload
+    def ne_(self, other: Number) -> Tensor: ...
+    @overload
+    def ne_(self, other: Tensor) -> Tensor: ...
+    def neg(self) -> Tensor: ...
+    def neg_(self) -> Tensor: ...
+    def nelement(self) -> _int: ...
+    @overload
+    def new_empty(self, size: _size, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+    @overload
+    def new_empty(self, *size: _int, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+    def new_full(self, size: _size, fill_value: Number, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+    def new_ones(self, size: _size, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+    def new_tensor(self, data: Any, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+    @overload
+    def new_zeros(self, size: _size, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+    @overload
+    def new_zeros(self, *size: _int, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+    def normal_(self, mean: _float=0, std: _float=1, *, generator: Generator=None) -> Tensor: ...
+    def numel(self) -> _int: ...
+    def numpy(self) -> Any: ...
+    def orgqr(self, input2: Tensor) -> Tensor: ...
+    def ormqr(self, input2: Tensor, input3: Tensor, left: _bool=True, transpose: _bool=False) -> Tensor: ...
+    @overload
+    def permute(self, dims: _size) -> Tensor: ...
+    @overload
+    def permute(self, *dims: _int) -> Tensor: ...
+    def pin_memory(self) -> Tensor: ...
+    def pinverse(self, rcond: _float=1e-15) -> Tensor: ...
+    def polygamma(self, n: _int) -> Tensor: ...
+    def polygamma_(self, n: _int) -> Tensor: ...
+    @overload
+    def pow(self, exponent: Number) -> Tensor: ...
+    @overload
+    def pow(self, exponent: Tensor) -> Tensor: ...
+    @overload
+    def pow_(self, exponent: Number) -> Tensor: ...
+    @overload
+    def pow_(self, exponent: Tensor) -> Tensor: ...
+    def prelu(self, weight: Tensor) -> Tensor: ...
+    @overload
+    def prod(self, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def prod(self, dim: _int, keepdim: _bool=False, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def prod(self, dim: Union[str, None], keepdim: _bool=False, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    def put_(self, index: Tensor, source: Tensor, accumulate: _bool=False) -> Tensor: ...
+    def q_per_channel_axis(self) -> _int: ...
+    def q_per_channel_scales(self) -> Tensor: ...
+    def q_per_channel_zero_points(self) -> Tensor: ...
+    def q_scale(self) -> _float: ...
+    def q_zero_point(self) -> _int: ...
+    def qr(self, some: _bool=True) -> Tuple[Tensor, Tensor]: ...
+    def qscheme(self) -> _qscheme: ...
+    @overload
+    def random_(self, from_: _int, to: _int, *, generator: Generator=None) -> Tensor: ...
+    @overload
+    def random_(self, to: _int, *, generator: Generator=None) -> Tensor: ...
+    @overload
+    def random_(self, *, generator: Generator=None) -> Tensor: ...
+    def real(self) -> Tensor: ...
+    def reciprocal(self) -> Tensor: ...
+    def reciprocal_(self) -> Tensor: ...
+    def refine_names(self, names: List[Union[str, None]]) -> Tensor: ...
+    def relu(self) -> Tensor: ...
+    def relu_(self) -> Tensor: ...
+    @overload
+    def remainder(self, other: Number) -> Tensor: ...
+    @overload
+    def remainder(self, other: Tensor) -> Tensor: ...
+    @overload
+    def remainder_(self, other: Number) -> Tensor: ...
+    @overload
+    def remainder_(self, other: Tensor) -> Tensor: ...
+    def rename(self, names: Optional[List[Union[str, None]]]) -> Tensor: ...
+    def rename_(self, names: Optional[List[Union[str, None]]]) -> Tensor: ...
+    def renorm(self, p: Number, dim: _int, maxnorm: Number) -> Tensor: ...
+    def renorm_(self, p: Number, dim: _int, maxnorm: Number) -> Tensor: ...
+    @overload
+    def repeat(self, repeats: _size) -> Tensor: ...
+    @overload
+    def repeat(self, *repeats: _int) -> Tensor: ...
+    @overload
+    def repeat_interleave(self, repeats: Tensor, dim: Optional[_int]=None) -> Tensor: ...
+    @overload
+    def repeat_interleave(self, repeats: _int, dim: Optional[_int]=None) -> Tensor: ...
+    def requires_grad_(self, mode: _bool=True) -> Tensor: ...
+    @overload
+    def reshape(self, shape: _size) -> Tensor: ...
+    @overload
+    def reshape(self, *shape: _int) -> Tensor: ...
+    def reshape_as(self, other: Tensor) -> Tensor: ...
+    @overload
+    def resize_(self, size: _size, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+    @overload
+    def resize_(self, *size: _int, memory_format: Optional[memory_format]=None) -> Tensor: ...
+    def resize_as_(self, the_template: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+    def rfft(self, signal_ndim: _int, normalized: _bool=False, onesided: _bool=True) -> Tensor: ...
+    def roll(self, shifts: Union[_int, _size], dims: Union[_int, _size]=()) -> Tensor: ...
+    def rot90(self, k: _int=1, dims: _size=(0,1)) -> Tensor: ...
+    def round(self) -> Tensor: ...
+    def round_(self) -> Tensor: ...
+    def rsqrt(self) -> Tensor: ...
+    def rsqrt_(self) -> Tensor: ...
+    @overload
+    def scatter(self, dim: _int, index: Tensor, src: Tensor) -> Tensor: ...
+    @overload
+    def scatter(self, dim: _int, index: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def scatter(self, dim: Union[str, None], index: Tensor, src: Tensor) -> Tensor: ...
+    @overload
+    def scatter(self, dim: Union[str, None], index: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def scatter_(self, dim: _int, index: Tensor, src: Tensor) -> Tensor: ...
+    @overload
+    def scatter_(self, dim: _int, index: Tensor, value: Number) -> Tensor: ...
+    @overload
+    def scatter_add(self, dim: _int, index: Tensor, src: Tensor) -> Tensor: ...
+    @overload
+    def scatter_add(self, dim: Union[str, None], index: Tensor, src: Tensor) -> Tensor: ...
+    def scatter_add_(self, dim: _int, index: Tensor, src: Tensor) -> Tensor: ...
+    @overload
+    def select(self, dim: Union[str, None], index: _int) -> Tensor: ...
+    @overload
+    def select(self, dim: _int, index: _int) -> Tensor: ...
+    @overload
+    def set_(self, source: Storage) -> Tensor: ...
+    @overload
+    def set_(self, source: Storage, storage_offset: _int, size: _size, stride: _size=()) -> Tensor: ...
+    @overload
+    def set_(self, source: Tensor) -> Tensor: ...
+    @overload
+    def set_(self) -> Tensor: ...
+    def short(self) -> Tensor: ...
+    def sigmoid(self) -> Tensor: ...
+    def sigmoid_(self) -> Tensor: ...
+    def sign(self) -> Tensor: ...
+    def sign_(self) -> Tensor: ...
+    def sin(self) -> Tensor: ...
+    def sin_(self) -> Tensor: ...
+    def sinh(self) -> Tensor: ...
+    def sinh_(self) -> Tensor: ...
+    @overload
+    def size(self) -> Size: ...
+    @overload
+    def size(self, _int) -> _int: ...
+    def slogdet(self) -> Tuple[Tensor, Tensor]: ...
+    def smm(self, mat2: Tensor) -> Tensor: ...
+    @overload
+    def softmax(self, dim: _int, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def softmax(self, dim: Union[str, None], *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    def solve(self, A: Tensor) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def sort(self, dim: _int=-1, descending: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    @overload
+    def sort(self, dim: Union[str, None], descending: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    def sparse_dim(self) -> _int: ...
+    def sparse_mask(self, mask: Tensor) -> Tensor: ...
+    def sparse_resize_(self, size: _size, sparse_dim: _int, dense_dim: _int) -> Tensor: ...
+    def sparse_resize_and_clear_(self, size: _size, sparse_dim: _int, dense_dim: _int) -> Tensor: ...
+    def split_with_sizes(self, split_sizes: _size, dim: _int=0) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+    def sqrt(self) -> Tensor: ...
+    def sqrt_(self) -> Tensor: ...
+    @overload
+    def squeeze(self) -> Tensor: ...
+    @overload
+    def squeeze(self, dim: _int) -> Tensor: ...
+    @overload
+    def squeeze(self, dim: Union[str, None]) -> Tensor: ...
+    @overload
+    def squeeze_(self) -> Tensor: ...
+    @overload
+    def squeeze_(self, dim: _int) -> Tensor: ...
+    @overload
+    def squeeze_(self, dim: Union[str, None]) -> Tensor: ...
+    def sspaddmm(self, mat1: Tensor, mat2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+    @overload
+    def std(self, unbiased: _bool=True) -> Tensor: ...
+    @overload
+    def std(self, dim: Union[_int, _size], unbiased: _bool=True, keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def std(self, dim: List[Union[str, None]], unbiased: _bool=True, keepdim: _bool=False) -> Tensor: ...
+    def storage(self) -> Storage: ...
+    def storage_offset(self) -> _int: ...
+    @overload
+    def stride(self) -> Tuple[_int]: ...
+    @overload
+    def stride(self, _int) -> _int: ...
+    @overload
+    def sum(self, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def sum(self, dim: Union[_int, _size], keepdim: _bool=False, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def sum(self, dim: List[Union[str, None]], keepdim: _bool=False, *, dtype: Optional[_dtype]=None) -> Tensor: ...
+    @overload
+    def sum_to_size(self, size: _size) -> Tensor: ...
+    @overload
+    def sum_to_size(self, *size: _int) -> Tensor: ...
+    def svd(self, some: _bool=True, compute_uv: _bool=True) -> Tuple[Tensor, Tensor, Tensor]: ...
+    def symeig(self, eigenvectors: _bool=False, upper: _bool=True) -> Tuple[Tensor, Tensor]: ...
+    def t(self) -> Tensor: ...
+    def t_(self) -> Tensor: ...
+    def take(self, index: Tensor) -> Tensor: ...
+    def tan(self) -> Tensor: ...
+    def tan_(self) -> Tensor: ...
+    def tanh(self) -> Tensor: ...
+    def tanh_(self) -> Tensor: ...
+    @overload
+    def to(self, dtype: _dtype, non_blocking: _bool=False, copy: _bool=False) -> Tensor: ...
+    @overload
+    def to(self, device: Optional[Union[_device, str]]=None, dtype: Optional[_dtype]=None, non_blocking: _bool=False, copy: _bool=False) -> Tensor: ...
+    @overload
+    def to(self, other: Tensor, non_blocking: _bool=False, copy: _bool=False) -> Tensor: ...
+    def to_dense(self) -> Tensor: ...
+    def to_mkldnn(self) -> Tensor: ...
+    @overload
+    def to_sparse(self, sparse_dim: _int) -> Tensor: ...
+    @overload
+    def to_sparse(self) -> Tensor: ...
+    def tolist(self) -> List: ...
+    def topk(self, k: _int, dim: _int=-1, largest: _bool=True, sorted: _bool=True) -> Tuple[Tensor, Tensor]: ...
+    def trace(self) -> Tensor: ...
+    @overload
+    def transpose(self, dim0: _int, dim1: _int) -> Tensor: ...
+    @overload
+    def transpose(self, dim0: Union[str, None], dim1: Union[str, None]) -> Tensor: ...
+    def transpose_(self, dim0: _int, dim1: _int) -> Tensor: ...
+    def triangular_solve(self, A: Tensor, upper: _bool=True, transpose: _bool=False, unitriangular: _bool=False) -> Tuple[Tensor, Tensor]: ...
+    def tril(self, diagonal: _int=0) -> Tensor: ...
+    def tril_(self, diagonal: _int=0) -> Tensor: ...
+    def triu(self, diagonal: _int=0) -> Tensor: ...
+    def triu_(self, diagonal: _int=0) -> Tensor: ...
+    def trunc(self) -> Tensor: ...
+    def trunc_(self) -> Tensor: ...
+    def type(self, dtype: Union[None, str, _dtype]=None, non_blocking: _bool=False) -> Union[str, Tensor]: ...
+    def type_as(self, other: Tensor) -> Tensor: ...
+    @overload
+    def unbind(self, dim: _int=0) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+    @overload
+    def unbind(self, dim: Union[str, None]) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+    @overload
+    def unflatten(self, dim: Union[str, None], sizes: _size, names: List[Union[str, None]]) -> Tensor: ...
+    @overload
+    def unflatten(self, dim: _int, sizes: _size, names: List[Union[str, None]]) -> Tensor: ...
+    def unfold(self, dimension: _int, size: _int, step: _int) -> Tensor: ...
+    def uniform_(self, from_: _float=0, to: _float=1, *, generator: Generator=None) -> Tensor: ...
+    def unsqueeze(self, dim: _int) -> Tensor: ...
+    def unsqueeze_(self, dim: _int) -> Tensor: ...
+    def values(self) -> Tensor: ...
+    @overload
+    def var(self, unbiased: _bool=True) -> Tensor: ...
+    @overload
+    def var(self, dim: Union[_int, _size], unbiased: _bool=True, keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def var(self, dim: List[Union[str, None]], unbiased: _bool=True, keepdim: _bool=False) -> Tensor: ...
+    @overload
+    def view(self, size: _size) -> Tensor: ...
+    @overload
+    def view(self, *size: _int) -> Tensor: ...
+    def view_as(self, other: Tensor) -> Tensor: ...
+    def where(self, condition: Tensor, other: Tensor) -> Tensor: ...
+    def zero_(self) -> Tensor: ...
+    @overload
+    def zeros_like_(self, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like_(self, value: Number, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like_(self, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+    @overload
+    def zeros_like_(self, value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+    @overload
+    def zeros_like__(self, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like__(self, value: Number, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like__(self, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+    @overload
+    def zeros_like__(self, value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+    @overload
+    def zeros_like___(self, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like___(self, value: Number, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like___(self, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+    @overload
+    def zeros_like___(self, value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+    @overload
+    def zeros_like____(self, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like____(self, value: Number, other: Union[Tensor, Number]) -> Tensor: ...
+    @overload
+    def zeros_like____(self, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+    @overload
+    def zeros_like____(self, value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+
+    # Manually defined methods from torch/tensor.py
+    def __len__(self) -> _int: ...
+    def __iter__(self) -> Iterator[Tensor]: ...
+    def __contains__(self, item: Union[Tensor, Number]) -> _bool: ...
+    def register_hook(self, hook: Callable) -> Any: ...
+    def retain_grad(self) -> None: ...
+    def is_shared(self) -> _bool: ...
+    def share_memory_(self) -> None: ...
+    # TODO: fill in the types for these, or otherwise figure out some
+    # way to not have to write these out again...
+    def nonzero(self, *, as_tuple=True): ...
+    def norm(self, p="fro", dim=None, keepdim=False): ...
+    def stft(self, n_fft, hop_length=None, win_length=None, window=None,
+             center=True, pad_mode='reflect', normalized=False, onesided=True): ...
+    def split(self, split_size, dim=0): ...
+    def unique(self, sorted=True, return_inverse=False, dim=None): ...
+    def unique_consecutive(self, sorted=True, return_inverse=False, return_counts=False, dim=None): ...
+    def lu(self, pivot=True, get_infos=False): ...
+
+#MODIFIED BY TORCHGPIPE
+    from .cuda import Stream
+    def record_stream(self, stream: Optional[Stream]) -> None: ...
+#END
+
+@overload
+def __and__(self: Tensor, other: Number) -> Tensor: ...
+@overload
+def __and__(self: Tensor, other: Tensor) -> Tensor: ...
+@overload
+def __lshift__(self: Tensor, other: Number) -> Tensor: ...
+@overload
+def __lshift__(self: Tensor, other: Tensor) -> Tensor: ...
+@overload
+def __or__(self: Tensor, other: Number) -> Tensor: ...
+@overload
+def __or__(self: Tensor, other: Tensor) -> Tensor: ...
+@overload
+def __rshift__(self: Tensor, other: Number) -> Tensor: ...
+@overload
+def __rshift__(self: Tensor, other: Tensor) -> Tensor: ...
+@overload
+def __xor__(self: Tensor, other: Number) -> Tensor: ...
+@overload
+def __xor__(self: Tensor, other: Tensor) -> Tensor: ...
+def _adaptive_avg_pool2d(self: Tensor, output_size: Union[_int, _size]) -> Tensor: ...
+def _addr(self: Tensor, vec1: Tensor, vec2: Tensor, *, beta: Number=1, alpha: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+def _addr_(self: Tensor, vec1: Tensor, vec2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+def _baddbmm_mkl_(self: Tensor, batch1: Tensor, batch2: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+def _batch_norm_impl_index(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, momentum: _float, eps: _float, cudnn_enabled: _bool) -> Tuple[Tensor, Tensor, Tensor, Tensor, _int]: ...
+def _cast_Byte(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cast_Char(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cast_Double(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cast_Float(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cast_Half(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cast_Int(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cast_Long(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cast_Short(self: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int=0, *, out: Optional[Tensor]=None) -> Tensor: ...
+def _convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: _size, padding: _size, dilation: _size, transposed: _bool, output_padding: _size, groups: _int, benchmark: _bool, deterministic: _bool, cudnn_enabled: _bool) -> Tensor: ...
+def _convolution_nogroup(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: _size, padding: _size, dilation: _size, transposed: _bool, output_padding: _size) -> Tensor: ...
+def _copy_from(self: Tensor, dst: Tensor, non_blocking: _bool=False) -> Tensor: ...
+def _ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: _size, target_lengths: _size, blank: _int=0, zero_infinity: _bool=False) -> Tuple[Tensor, Tensor]: ...
+def _cudnn_ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: _size, target_lengths: _size, blank: _int, deterministic: _bool, zero_infinity: _bool) -> Tuple[Tensor, Tensor]: ...
+def _cudnn_init_dropout_state(dropout: _float, train: _bool, dropout_seed: _int, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def _cudnn_rnn(input: Tensor, weight: Union[Tuple[Tensor, ...], List[Tensor]], weight_stride0: _int, weight_buf: Optional[Tensor], hx: Tensor, cx: Optional[Tensor], mode: _int, hidden_size: _int, num_layers: _int, batch_first: _bool, dropout: _float, train: _bool, bidirectional: _bool, batch_sizes: _size, dropout_state: Optional[Tensor]) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]: ...
+def _cudnn_rnn_flatten_weight(weight_arr: Union[Tuple[Tensor, ...], List[Tensor]], weight_stride0: _int, input_size: _int, mode: _int, hidden_size: _int, num_layers: _int, batch_first: _bool, bidirectional: _bool) -> Tensor: ...
+def _cufft_clear_plan_cache(device_index: _int) -> None: ...
+def _cufft_get_plan_cache_max_size(device_index: _int) -> _int: ...
+def _cufft_get_plan_cache_size(device_index: _int) -> _int: ...
+def _cufft_set_plan_cache_max_size(device_index: _int, max_size: _int) -> None: ...
+def _debug_has_internal_overlap(self: Tensor) -> _int: ...
+def _dim_arange(like: Tensor, dim: _int) -> Tensor: ...
+def _dirichlet_grad(x: Tensor, alpha: Tensor, total: Tensor) -> Tensor: ...
+def _embedding_bag(weight: Tensor, indices: Tensor, offsets: Tensor, scale_grad_by_freq: _bool=False, mode: _int=0, sparse: _bool=False, per_sample_weights: Optional[Tensor]=None) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
+@overload
+def _empty_affine_quantized(size: _size, *, scale: _float=1, zero_point: _int=0, memory_format: Optional[memory_format]=contiguous_format, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def _empty_affine_quantized(*size: _int, scale: _float=1, zero_point: _int=0, memory_format: Optional[memory_format]=contiguous_format, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def _empty_per_channel_affine_quantized(size: _size, *, scales: Tensor, zero_points: Tensor, axis: _int, memory_format: Optional[memory_format]=contiguous_format, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def _empty_per_channel_affine_quantized(*size: _int, scales: Tensor, zero_points: Tensor, axis: _int, memory_format: Optional[memory_format]=contiguous_format, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def _fft_with_size(self: Tensor, signal_ndim: _int, complex_input: _bool, complex_output: _bool, inverse: _bool, checked_signal_sizes: _size, normalized: _bool, onesided: _bool, output_sizes: _size) -> Tensor: ...
+def _fused_dropout(self: Tensor, p: _float, generator: Generator=None) -> Tuple[Tensor, Tensor]: ...
+def _has_compatible_shallow_copy_type(self: Tensor, from_: Tensor) -> _bool: ...
+def _index_copy_(self: Tensor, dim: _int, index: Tensor, source: Tensor) -> Tensor: ...
+def _index_put_impl_(self: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool=False, unsafe: _bool=False) -> Tensor: ...
+def _log_softmax(self: Tensor, dim: _int, half_to_float: _bool) -> Tensor: ...
+def _log_softmax_backward_data(grad_output: Tensor, output: Tensor, dim: _int, self: Tensor) -> Tensor: ...
+def _lu_solve_helper(self: Tensor, LU_data: Tensor, LU_pivots: Tensor) -> Tensor: ...
+def _lu_with_info(self: Tensor, pivot: _bool=True, check_errors: _bool=True) -> Tuple[Tensor, Tensor, Tensor]: ...
+def _make_per_channel_quantized_tensor(self: Tensor, scale: Tensor, zero_point: Tensor, axis: _int) -> Tensor: ...
+def _make_per_tensor_quantized_tensor(self: Tensor, scale: _float, zero_point: _int) -> Tensor: ...
+def _masked_scale(self: Tensor, mask: Tensor, scale: _float) -> Tensor: ...
+def _max(self: Tensor, dim: _int, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def _min(self: Tensor, dim: _int, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def _mkldnn_reshape(self: Tensor, shape: _size) -> Tensor: ...
+def _mkldnn_transpose(self: Tensor, dim0: _int, dim1: _int) -> Tensor: ...
+def _mkldnn_transpose_(self: Tensor, dim0: _int, dim1: _int) -> Tensor: ...
+def _mode(self: Tensor, dim: _int=-1, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def _multinomial_alias_draw(J: Tensor, q: Tensor, num_samples: _int, *, generator: Generator=None) -> Tensor: ...
+def _multinomial_alias_setup(probs: Tensor) -> Tuple[Tensor, Tensor]: ...
+def _nnpack_available() -> _bool: ...
+def _nnpack_spatial_convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], padding: Union[_int, _size], stride: Union[_int, _size]=1) -> Tensor: ...
+def _pack_padded_sequence(input: Tensor, lengths: Tensor, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
+def _pad_packed_sequence(data: Tensor, batch_sizes: Tensor, batch_first: _bool, padding_value: Number, total_length: _int) -> Tuple[Tensor, Tensor]: ...
+def _reshape_from_tensor(self: Tensor, shape: Tensor) -> Tensor: ...
+def _s_where(condition: Tensor, self: Tensor, other: Tensor) -> Tensor: ...
+def _sample_dirichlet(self: Tensor, generator: Generator=None) -> Tensor: ...
+def _shape_as_tensor(self: Tensor) -> Tensor: ...
+def _sobol_engine_draw(quasi: Tensor, n: _int, sobolstate: Tensor, dimension: _int, num_generated: _int, dtype: Optional[_dtype]) -> Tuple[Tensor, Tensor]: ...
+def _sobol_engine_ff_(self: Tensor, n: _int, sobolstate: Tensor, dimension: _int, num_generated: _int) -> Tensor: ...
+def _sobol_engine_initialize_state_(self: Tensor, dimension: _int) -> Tensor: ...
+def _sobol_engine_scramble_(self: Tensor, ltm: Tensor, dimension: _int) -> Tensor: ...
+def _softmax(self: Tensor, dim: _int, half_to_float: _bool) -> Tensor: ...
+def _softmax_backward_data(grad_output: Tensor, output: Tensor, dim: _int, self: Tensor) -> Tensor: ...
+def _sparse_addmm(self: Tensor, sparse: Tensor, dense: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+def _sparse_mm(sparse: Tensor, dense: Tensor) -> Tensor: ...
+@overload
+def _sparse_sum(self: Tensor) -> Tensor: ...
+@overload
+def _sparse_sum(self: Tensor, *, dtype: _dtype) -> Tensor: ...
+@overload
+def _sparse_sum(self: Tensor, dim: Union[_int, _size]) -> Tensor: ...
+@overload
+def _sparse_sum(self: Tensor, dim: Union[_int, _size], *, dtype: _dtype) -> Tensor: ...
+def _standard_gamma(self: Tensor, generator: Generator=None) -> Tensor: ...
+def _standard_gamma_grad(self: Tensor, output: Tensor) -> Tensor: ...
+def _std(self: Tensor, unbiased: _bool=True) -> Tensor: ...
+def _test_optional_float(self: Tensor, *, scale: Optional[_float]=None) -> Tensor: ...
+def _trilinear(i1: Tensor, i2: Tensor, i3: Tensor, expand1: _size, expand2: _size, expand3: _size, sumdim: _size, unroll_dim: _int=1) -> Tensor: ...
+def _unique(self: Tensor, sorted: _bool=True, return_inverse: _bool=False) -> Tuple[Tensor, Tensor]: ...
+def _unique2(self: Tensor, sorted: _bool=True, return_inverse: _bool=False, return_counts: _bool=False) -> Tuple[Tensor, Tensor, Tensor]: ...
+def _use_cudnn_ctc_loss(log_probs: Tensor, targets: Tensor, input_lengths: _size, target_lengths: _size, blank: _int) -> _bool: ...
+def _var(self: Tensor, unbiased: _bool=True) -> Tensor: ...
+def _weight_norm(v: Tensor, g: Tensor, dim: _int=0) -> Tensor: ...
+def _weight_norm_cuda_interface(v: Tensor, g: Tensor, dim: _int=0) -> Tuple[Tensor, Tensor]: ...
+def abs(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def abs_(self: Tensor) -> Tensor: ...
+def acos(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def acos_(self: Tensor) -> Tensor: ...
+def adaptive_avg_pool1d(self: Tensor, output_size: Union[_int, _size]) -> Tensor: ...
+def adaptive_max_pool1d(self: Tensor, output_size: Union[_int, _size]) -> Tuple[Tensor, Tensor]: ...
+@overload
+def add(input: Union[Tensor, Number], other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def add(input: Union[Tensor, Number], value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def add(self: Tensor, alpha: Number, other: Tensor) -> Tensor: ...
+@overload
+def add(self: Tensor, alpha: Number, other: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addbmm(self: Tensor, batch1: Tensor, batch2: Tensor, *, beta: Number=1, alpha: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def addbmm(beta: Number, self: Tensor, alpha: Number, batch1: Tensor, batch2: Tensor) -> Tensor: ...
+@overload
+def addbmm(beta: Number, self: Tensor, alpha: Number, batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addbmm(beta: Number, self: Tensor, batch1: Tensor, batch2: Tensor) -> Tensor: ...
+@overload
+def addbmm(beta: Number, self: Tensor, batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addcdiv(self: Tensor, tensor1: Tensor, tensor2: Tensor, *, value: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def addcdiv(self: Tensor, value: Number, tensor1: Tensor, tensor2: Tensor) -> Tensor: ...
+@overload
+def addcdiv(self: Tensor, value: Number, tensor1: Tensor, tensor2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addcmul(self: Tensor, tensor1: Tensor, tensor2: Tensor, *, value: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def addcmul(self: Tensor, value: Number, tensor1: Tensor, tensor2: Tensor) -> Tensor: ...
+@overload
+def addcmul(self: Tensor, value: Number, tensor1: Tensor, tensor2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addmm(self: Tensor, mat1: Tensor, mat2: Tensor, *, beta: Number=1, alpha: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def addmm(beta: Number, self: Tensor, alpha: Number, mat1: Tensor, mat2: Tensor) -> Tensor: ...
+@overload
+def addmm(beta: Number, self: Tensor, alpha: Number, mat1: Tensor, mat2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addmm(beta: Number, self: Tensor, mat1: Tensor, mat2: Tensor) -> Tensor: ...
+@overload
+def addmm(beta: Number, self: Tensor, mat1: Tensor, mat2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addmv(self: Tensor, mat: Tensor, vec: Tensor, *, beta: Number=1, alpha: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def addmv(beta: Number, self: Tensor, alpha: Number, mat: Tensor, vec: Tensor) -> Tensor: ...
+@overload
+def addmv(beta: Number, self: Tensor, alpha: Number, mat: Tensor, vec: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addmv(beta: Number, self: Tensor, mat: Tensor, vec: Tensor) -> Tensor: ...
+@overload
+def addmv(beta: Number, self: Tensor, mat: Tensor, vec: Tensor, *, out: Tensor) -> Tensor: ...
+def addmv_(self: Tensor, mat: Tensor, vec: Tensor, *, beta: Number=1, alpha: Number=1) -> Tensor: ...
+@overload
+def addr(self: Tensor, vec1: Tensor, vec2: Tensor, *, beta: Number=1, alpha: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def addr(beta: Number, self: Tensor, alpha: Number, vec1: Tensor, vec2: Tensor) -> Tensor: ...
+@overload
+def addr(beta: Number, self: Tensor, alpha: Number, vec1: Tensor, vec2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def addr(beta: Number, self: Tensor, vec1: Tensor, vec2: Tensor) -> Tensor: ...
+@overload
+def addr(beta: Number, self: Tensor, vec1: Tensor, vec2: Tensor, *, out: Tensor) -> Tensor: ...
+def affine_grid_generator(theta: Tensor, size: _size, align_corners: _bool) -> Tensor: ...
+@overload
+def all(self: Tensor, dim: _int, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def all(self: Tensor, dim: Union[str, None], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def all(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def allclose(self: Tensor, other: Tensor, rtol: _float=1e-05, atol: _float=1e-08, equal_nan: _bool=False) -> _bool: ...
+def alpha_dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
+def alpha_dropout_(self: Tensor, p: _float, train: _bool) -> Tensor: ...
+def angle(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def any(self: Tensor, dim: _int, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def any(self: Tensor, dim: Union[str, None], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def any(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def arange(start: Number, end: Number, step: Number, *, out: Optional[Tensor]=None, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+@overload
+def arange(start: Number, end: Number, *, out: Optional[Tensor]=None, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+@overload
+def arange(end: Number, *, out: Optional[Tensor]=None, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+def argmax(self: Tensor, dim: Optional[_int]=None, keepdim: _bool=False) -> Tensor: ...
+def argmin(self: Tensor, dim: Optional[_int]=None, keepdim: _bool=False) -> Tensor: ...
+@overload
+def argsort(self: Tensor, dim: _int=-1, descending: _bool=False) -> Tensor: ...
+@overload
+def argsort(self: Tensor, dim: Union[str, None], descending: _bool=False) -> Tensor: ...
+def as_strided(self: Tensor, size: _size, stride: _size, storage_offset: Optional[_int]=None) -> Tensor: ...
+def as_strided_(self: Tensor, size: _size, stride: _size, storage_offset: Optional[_int]=None) -> Tensor: ...
+def as_tensor(data: Any, dtype: _dtype=None, device: Optional[_device]=None) -> Tensor: ...
+def asin(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def asin_(self: Tensor) -> Tensor: ...
+def atan(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def atan2(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def atan_(self: Tensor) -> Tensor: ...
+def avg_pool1d(self: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0, ceil_mode: _bool=False, count_include_pad: _bool=True) -> Tensor: ...
+@overload
+def baddbmm(self: Tensor, batch1: Tensor, batch2: Tensor, *, beta: Number=1, alpha: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def baddbmm(beta: Number, self: Tensor, alpha: Number, batch1: Tensor, batch2: Tensor) -> Tensor: ...
+@overload
+def baddbmm(beta: Number, self: Tensor, alpha: Number, batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def baddbmm(beta: Number, self: Tensor, batch1: Tensor, batch2: Tensor) -> Tensor: ...
+@overload
+def baddbmm(beta: Number, self: Tensor, batch1: Tensor, batch2: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def bartlett_window(window_length: _int, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def bartlett_window(window_length: _int, periodic: _bool, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def batch_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, momentum: _float, eps: _float, cudnn_enabled: _bool) -> Tensor: ...
+def batch_norm_backward_elemt(grad_out: Tensor, input: Tensor, mean: Tensor, invstd: Tensor, weight: Optional[Tensor], mean_dy: Tensor, mean_dy_xmu: Tensor) -> Tensor: ...
+def batch_norm_backward_reduce(grad_out: Tensor, input: Tensor, mean: Tensor, invstd: Tensor, weight: Optional[Tensor], input_g: _bool, weight_g: _bool, bias_g: _bool) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
+def batch_norm_elemt(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], mean: Tensor, invstd: Tensor, eps: _float, *, out: Optional[Tensor]=None) -> Tensor: ...
+def batch_norm_gather_stats(input: Tensor, mean: Tensor, invstd: Tensor, running_mean: Optional[Tensor], running_var: Optional[Tensor], momentum: _float, eps: _float, count: _int) -> Tuple[Tensor, Tensor]: ...
+def batch_norm_gather_stats_with_counts(input: Tensor, mean: Tensor, invstd: Tensor, running_mean: Optional[Tensor], running_var: Optional[Tensor], momentum: _float, eps: _float, counts: _size) -> Tuple[Tensor, Tensor]: ...
+def batch_norm_stats(input: Tensor, eps: _float) -> Tuple[Tensor, Tensor]: ...
+def batch_norm_update_stats(input: Tensor, running_mean: Optional[Tensor], running_var: Optional[Tensor], momentum: _float) -> Tuple[Tensor, Tensor]: ...
+@overload
+def bernoulli(self: Tensor, *, generator: Generator=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def bernoulli(self: Tensor, p: _float, *, generator: Generator=None, out: Optional[Tensor]=None) -> Tensor: ...
+def bilinear(input1: Tensor, input2: Tensor, weight: Tensor, bias: Optional[Tensor]) -> Tensor: ...
+def bincount(self: Tensor, weights: Optional[Tensor]=None, minlength: _int=0) -> Tensor: ...
+def bitwise_not(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def bitwise_xor(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def bitwise_xor(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def blackman_window(window_length: _int, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def blackman_window(window_length: _int, periodic: _bool, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def bmm(self: Tensor, mat2: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def can_cast(from_: _dtype, to: _dtype) -> _bool: ...
+@overload
+def cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int=0, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def cat(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: Union[str, None], *, out: Optional[Tensor]=None) -> Tensor: ...
+def ceil(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def ceil_(self: Tensor) -> Tensor: ...
+def celu(self: Tensor, alpha: Number=1.0) -> Tensor: ...
+def celu_(self: Tensor, alpha: Number=1.0) -> Tensor: ...
+def cholesky(self: Tensor, upper: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+def cholesky_inverse(self: Tensor, upper: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+def cholesky_solve(self: Tensor, input2: Tensor, upper: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+def chunk(self: Tensor, chunks: _int, dim: _int=0) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+def clamp(self, min: _float=-inf, max: _float=inf, *, out: Optional[Tensor]=None) -> Tensor: ...
+def clamp_max(self: Tensor, max: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+def clamp_max_(self: Tensor, max: Number) -> Tensor: ...
+def clamp_min(self: Tensor, min: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+def clamp_min_(self: Tensor, min: Number) -> Tensor: ...
+def clone(self: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+def combinations(self: Tensor, r: _int=2, with_replacement: _bool=False) -> Tensor: ...
+def conj(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def constant_pad_nd(self: Tensor, pad: _size, value: Number=0) -> Tensor: ...
+def conv1d(input: Tensor, weight: Tensor, bias: Optional[Tensor]=None, stride: Union[_int, _size]=1, padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, groups: _int=1) -> Tensor: ...
+def conv2d(input: Tensor, weight: Tensor, bias: Optional[Tensor]=None, stride: Union[_int, _size]=1, padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, groups: _int=1) -> Tensor: ...
+def conv3d(input: Tensor, weight: Tensor, bias: Optional[Tensor]=None, stride: Union[_int, _size]=1, padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, groups: _int=1) -> Tensor: ...
+def conv_tbc(self: Tensor, weight: Tensor, bias: Tensor, pad: _int=0) -> Tensor: ...
+def conv_transpose1d(input: Tensor, weight: Tensor, bias: Optional[Tensor]=None, stride: Union[_int, _size]=1, padding: Union[_int, _size]=0, output_padding: Union[_int, _size]=0, groups: _int=1, dilation: Union[_int, _size]=1) -> Tensor: ...
+def conv_transpose2d(input: Tensor, weight: Tensor, bias: Optional[Tensor]=None, stride: Union[_int, _size]=1, padding: Union[_int, _size]=0, output_padding: Union[_int, _size]=0, groups: _int=1, dilation: Union[_int, _size]=1) -> Tensor: ...
+def conv_transpose3d(input: Tensor, weight: Tensor, bias: Optional[Tensor]=None, stride: Union[_int, _size]=1, padding: Union[_int, _size]=0, output_padding: Union[_int, _size]=0, groups: _int=1, dilation: Union[_int, _size]=1) -> Tensor: ...
+def convolution(input: Tensor, weight: Tensor, bias: Optional[Tensor], stride: _size, padding: _size, dilation: _size, transposed: _bool, output_padding: _size, groups: _int) -> Tensor: ...
+def cos(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def cos_(self: Tensor) -> Tensor: ...
+def cosh(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def cosh_(self: Tensor) -> Tensor: ...
+def cosine_similarity(x1: Tensor, x2: Tensor, dim: _int=1, eps: _float=1e-08) -> Tensor: ...
+def cross(self: Tensor, other: Tensor, dim: Optional[_int]=None, *, out: Optional[Tensor]=None) -> Tensor: ...
+def cudnn_affine_grid_generator(theta: Tensor, N: _int, C: _int, H: _int, W: _int) -> Tensor: ...
+def cudnn_batch_norm(input: Tensor, weight: Tensor, bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, exponential_average_factor: _float, epsilon: _float) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
+def cudnn_convolution(self: Tensor, weight: Tensor, bias: Optional[Tensor], padding: _size, stride: _size, dilation: _size, groups: _int, benchmark: _bool, deterministic: _bool) -> Tensor: ...
+def cudnn_convolution_transpose(self: Tensor, weight: Tensor, bias: Optional[Tensor], padding: _size, output_padding: _size, stride: _size, dilation: _size, groups: _int, benchmark: _bool, deterministic: _bool) -> Tensor: ...
+def cudnn_grid_sampler(self: Tensor, grid: Tensor) -> Tensor: ...
+def cudnn_is_acceptable(self: Tensor) -> _bool: ...
+@overload
+def cumprod(self: Tensor, dim: _int, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def cumprod(self: Tensor, dim: Union[str, None], *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def cumsum(self: Tensor, dim: _int, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def cumsum(self: Tensor, dim: Union[str, None], *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+def dequantize(self: Tensor) -> Tensor: ...
+def det(self: Tensor) -> Tensor: ...
+def detach(self: Tensor) -> Tensor: ...
+def detach_(self: Tensor) -> Tensor: ...
+def diag(self: Tensor, diagonal: _int=0, *, out: Optional[Tensor]=None) -> Tensor: ...
+def diag_embed(self: Tensor, offset: _int=0, dim1: _int=-2, dim2: _int=-1) -> Tensor: ...
+def diagflat(self: Tensor, offset: _int=0) -> Tensor: ...
+def diagonal(self: Tensor, offset: _int=0, dim1: _int=0, dim2: _int=1) -> Tensor: ...
+def digamma(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def dist(self: Tensor, other: Tensor, p: Number=2) -> Tensor: ...
+@overload
+def div(input: Union[Tensor, Number], other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def div(input: Union[Tensor, Number], value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+def dot(self: Tensor, tensor: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
+def dropout_(self: Tensor, p: _float, train: _bool) -> Tensor: ...
+def eig(self: Tensor, eigenvectors: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def embedding(weight: Tensor, indices: Tensor, padding_idx: _int=-1, scale_grad_by_freq: _bool=False, sparse: _bool=False) -> Tensor: ...
+def embedding_bag(weight: Tensor, indices: Tensor, offsets: Tensor, scale_grad_by_freq: _bool=False, mode: _int=0, sparse: _bool=False, per_sample_weights: Optional[Tensor]=None) -> Tuple[Tensor, Tensor, Tensor, Tensor]: ...
+def embedding_renorm_(self: Tensor, indices: Tensor, max_norm: _float, norm_type: _float) -> Tensor: ...
+@overload
+def empty(size: _size, *, names: Optional[List[Union[str, None]]], memory_format: Optional[memory_format]=None, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def empty(*size: _int, names: Optional[List[Union[str, None]]], memory_format: Optional[memory_format]=None, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def empty(size: _size, *, memory_format: Optional[memory_format]=None, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def empty(*size: _int, memory_format: Optional[memory_format]=None, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def empty_like(self: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def empty_like(self: Tensor, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def empty_strided(size: _size, stride: _size, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def eq(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def eq(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def equal(self: Tensor, other: Tensor) -> _bool: ...
+def erf(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def erf_(self: Tensor) -> Tensor: ...
+def erfc(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def erfc_(self: Tensor) -> Tensor: ...
+def erfinv(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def exp(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def exp_(self: Tensor) -> Tensor: ...
+def expm1(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def expm1_(self: Tensor) -> Tensor: ...
+@overload
+def eye(n: _int, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def eye(n: _int, m: _int, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def fake_quantize_per_channel_affine(self: Tensor, scale: Tensor, zero_point: Tensor, axis: _int, quant_min: _int, quant_max: _int) -> Tensor: ...
+def fake_quantize_per_tensor_affine(self: Tensor, scale: _float, zero_point: _int, quant_min: _int, quant_max: _int) -> Tensor: ...
+def fbgemm_linear_fp16_weight(input: Tensor, packed_weight: Tensor, bias: Tensor) -> Tensor: ...
+def fbgemm_linear_fp16_weight_fp32_activation(input: Tensor, packed_weight: Tensor, bias: Tensor) -> Tensor: ...
+def fbgemm_linear_int8_weight(input: Tensor, weight: Tensor, packed: Tensor, col_offsets: Tensor, weight_scale: Number, weight_zero_point: Number, bias: Tensor) -> Tensor: ...
+def fbgemm_linear_int8_weight_fp32_activation(input: Tensor, weight: Tensor, packed: Tensor, col_offsets: Tensor, weight_scale: Number, weight_zero_point: Number, bias: Tensor) -> Tensor: ...
+def fbgemm_linear_quantize_weight(input: Tensor) -> Tuple[Tensor, Tensor, _float, _int]: ...
+def fbgemm_pack_gemm_matrix_fp16(input: Tensor) -> Tensor: ...
+@overload
+def fbgemm_pack_quantized_matrix(input: Tensor) -> Tensor: ...
+@overload
+def fbgemm_pack_quantized_matrix(input: Tensor, K: _int, N: _int) -> Tensor: ...
+def feature_alpha_dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
+def feature_alpha_dropout_(self: Tensor, p: _float, train: _bool) -> Tensor: ...
+def feature_dropout(input: Tensor, p: _float, train: _bool) -> Tensor: ...
+def feature_dropout_(self: Tensor, p: _float, train: _bool) -> Tensor: ...
+def fft(self: Tensor, signal_ndim: _int, normalized: _bool=False) -> Tensor: ...
+@overload
+def fill_(self: Tensor, value: Number) -> Tensor: ...
+@overload
+def fill_(self: Tensor, value: Tensor) -> Tensor: ...
+@overload
+def flatten(self: Tensor, start_dim: _int=0, end_dim: _int=-1) -> Tensor: ...
+@overload
+def flatten(self: Tensor, start_dim: _int, end_dim: _int, out_dim: Union[str, None]) -> Tensor: ...
+@overload
+def flatten(self: Tensor, start_dim: Union[str, None], end_dim: Union[str, None], out_dim: Union[str, None]) -> Tensor: ...
+@overload
+def flatten(self: Tensor, dims: List[Union[str, None]], out_dim: Union[str, None]) -> Tensor: ...
+def flip(self: Tensor, dims: _size) -> Tensor: ...
+def floor(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def floor_(self: Tensor) -> Tensor: ...
+@overload
+def fmod(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def fmod(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def frac(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def frac_(self: Tensor) -> Tensor: ...
+@overload
+def frobenius_norm(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def frobenius_norm(self: Tensor, dim: Union[_int, _size], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+def from_file(filename: str, shared: Optional[_bool]=None, size: Optional[_int]=0, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def from_numpy(ndarray) -> Tensor: ...
+@overload
+def full(size: _size, fill_value: Number, *, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def full(size: _size, fill_value: Number, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def full_like(self: Tensor, fill_value: Number, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def full_like(self: Tensor, fill_value: Number, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def gather(self: Tensor, dim: _int, index: Tensor, *, sparse_grad: _bool=False, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def gather(self: Tensor, dim: Union[str, None], index: Tensor, *, sparse_grad: _bool=False, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def ge(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def ge(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def geqrf(self: Tensor, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def ger(self: Tensor, vec2: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def get_default_dtype() -> _dtype: ...
+def get_num_interop_threads() -> _int: ...
+def get_num_threads() -> _int: ...
+def grid_sampler(input: Tensor, grid: Tensor, interpolation_mode: _int, padding_mode: _int, align_corners: _bool) -> Tensor: ...
+def grid_sampler_2d(input: Tensor, grid: Tensor, interpolation_mode: _int, padding_mode: _int, align_corners: _bool) -> Tensor: ...
+def grid_sampler_3d(input: Tensor, grid: Tensor, interpolation_mode: _int, padding_mode: _int, align_corners: _bool) -> Tensor: ...
+def group_norm(input: Tensor, num_groups: _int, weight: Optional[Tensor]=None, bias: Optional[Tensor]=None, eps: _float=1e-05, cudnn_enabled: _bool=True) -> Tensor: ...
+@overload
+def gru(input: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
+@overload
+def gru(data: Tensor, batch_sizes: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor]: ...
+def gru_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor]=None, b_hh: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def gt(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def gt(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def hamming_window(window_length: _int, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def hamming_window(window_length: _int, periodic: _bool, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def hamming_window(window_length: _int, periodic: _bool, alpha: _float, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def hamming_window(window_length: _int, periodic: _bool, alpha: _float, beta: _float, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def hann_window(window_length: _int, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def hann_window(window_length: _int, periodic: _bool, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def hardshrink(self: Tensor, lambd: Number=0.5) -> Tensor: ...
+def histc(self: Tensor, bins: _int=100, min: Number=0, max: Number=0, *, out: Optional[Tensor]=None) -> Tensor: ...
+def hspmm(mat1: Tensor, mat2: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def ifft(self: Tensor, signal_ndim: _int, normalized: _bool=False) -> Tensor: ...
+def imag(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def index_add(self: Tensor, dim: _int, index: Tensor, source: Tensor) -> Tensor: ...
+@overload
+def index_add(self: Tensor, dim: Union[str, None], index: Tensor, source: Tensor) -> Tensor: ...
+@overload
+def index_copy(self: Tensor, dim: _int, index: Tensor, source: Tensor) -> Tensor: ...
+@overload
+def index_copy(self: Tensor, dim: Union[str, None], index: Tensor, source: Tensor) -> Tensor: ...
+@overload
+def index_fill(self: Tensor, dim: _int, index: Tensor, value: Number) -> Tensor: ...
+@overload
+def index_fill(self: Tensor, dim: _int, index: Tensor, value: Tensor) -> Tensor: ...
+@overload
+def index_fill(self: Tensor, dim: Union[str, None], index: Tensor, value: Number) -> Tensor: ...
+@overload
+def index_fill(self: Tensor, dim: Union[str, None], index: Tensor, value: Tensor) -> Tensor: ...
+def index_put(self: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool=False) -> Tensor: ...
+def index_put_(self: Tensor, indices: Optional[Union[Tuple[Tensor, ...], List[Tensor]]], values: Tensor, accumulate: _bool=False) -> Tensor: ...
+@overload
+def index_select(self: Tensor, dim: _int, index: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def index_select(self: Tensor, dim: Union[str, None], index: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def instance_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], use_input_stats: _bool, momentum: _float, eps: _float, cudnn_enabled: _bool) -> Tensor: ...
+def int_repr(self: Tensor) -> Tensor: ...
+def inverse(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def irfft(self: Tensor, signal_ndim: _int, normalized: _bool=False, onesided: _bool=True, signal_sizes: _size=()) -> Tensor: ...
+def is_complex(self: Tensor) -> _bool: ...
+def is_distributed(self: Tensor) -> _bool: ...
+def is_floating_point(self: Tensor) -> _bool: ...
+def is_nonzero(self: Tensor) -> _bool: ...
+def is_same_size(self: Tensor, other: Tensor) -> _bool: ...
+def is_signed(self: Tensor) -> _bool: ...
+def isclose(self: Tensor, other: Tensor, rtol: _float=1e-05, atol: _float=1e-08, equal_nan: _bool=False) -> Tensor: ...
+def isfinite(self: Tensor) -> Tensor: ...
+def isnan(self: Tensor) -> Tensor: ...
+@overload
+def kthvalue(self: Tensor, k: _int, dim: _int=-1, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def kthvalue(self: Tensor, k: _int, dim: Union[str, None], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def layer_norm(input: Tensor, normalized_shape: _size, weight: Optional[Tensor]=None, bias: Optional[Tensor]=None, eps: _float=1e-05, cudnn_enable: _bool=True) -> Tensor: ...
+@overload
+def le(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def le(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def lerp(self: Tensor, end: Tensor, weight: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def lerp(self: Tensor, end: Tensor, weight: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def lgamma(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def linspace(start: Number, end: Number, steps: _int=100, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def log(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def log10(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def log10_(self: Tensor) -> Tensor: ...
+def log1p(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def log1p_(self: Tensor) -> Tensor: ...
+def log2(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def log2_(self: Tensor) -> Tensor: ...
+def log_(self: Tensor) -> Tensor: ...
+@overload
+def log_softmax(self: Tensor, dim: _int, dtype: Optional[_dtype]=None) -> Tensor: ...
+@overload
+def log_softmax(self: Tensor, dim: Union[str, None], *, dtype: Optional[_dtype]=None) -> Tensor: ...
+def logdet(self: Tensor) -> Tensor: ...
+def logical_not(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def logical_xor(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def logspace(start: Number, end: Number, steps: _int=100, base: _float=10.0, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def logsumexp(self: Tensor, dim: Union[_int, _size], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def logsumexp(self: Tensor, dim: List[Union[str, None]], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def lstm(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor, Tensor]: ...
+@overload
+def lstm(data: Tensor, batch_sizes: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor, Tensor]: ...
+def lstm_cell(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor]=None, b_hh: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def lstsq(self: Tensor, A: Tensor, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def lt(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def lt(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def lu_solve(self: Tensor, LU_data: Tensor, LU_pivots: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def masked_fill(self: Tensor, mask: Tensor, value: Number) -> Tensor: ...
+@overload
+def masked_fill(self: Tensor, mask: Tensor, value: Tensor) -> Tensor: ...
+def masked_scatter(self: Tensor, mask: Tensor, source: Tensor) -> Tensor: ...
+def masked_select(self: Tensor, mask: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def matmul(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def matrix_power(self: Tensor, n: _int) -> Tensor: ...
+@overload
+def matrix_rank(self: Tensor, tol: _float, symmetric: _bool=False) -> Tensor: ...
+@overload
+def matrix_rank(self: Tensor, symmetric: _bool=False) -> Tensor: ...
+@overload
+def max(self: Tensor, dim: _int, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def max(self: Tensor, dim: Union[str, None], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def max(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def max(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def max_pool1d(self: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, ceil_mode: _bool=False) -> Tensor: ...
+def max_pool1d_with_indices(self: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, ceil_mode: _bool=False) -> Tuple[Tensor, Tensor]: ...
+def max_pool2d(self: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, ceil_mode: _bool=False) -> Tensor: ...
+def max_pool3d(self: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, ceil_mode: _bool=False) -> Tensor: ...
+@overload
+def mean(self: Tensor, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def mean(self: Tensor, dim: Union[_int, _size], keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def mean(self: Tensor, dim: List[Union[str, None]], keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def median(self: Tensor, dim: _int, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def median(self: Tensor, dim: Union[str, None], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def median(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def min(self: Tensor, dim: _int, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def min(self: Tensor, dim: Union[str, None], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def min(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def min(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def miopen_batch_norm(input: Tensor, weight: Tensor, bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, exponential_average_factor: _float, epsilon: _float) -> Tuple[Tensor, Tensor, Tensor]: ...
+def miopen_convolution(self: Tensor, weight: Tensor, bias: Optional[Tensor], padding: _size, stride: _size, dilation: _size, groups: _int, benchmark: _bool, deterministic: _bool) -> Tensor: ...
+def miopen_convolution_transpose(self: Tensor, weight: Tensor, bias: Optional[Tensor], padding: _size, output_padding: _size, stride: _size, dilation: _size, groups: _int, benchmark: _bool, deterministic: _bool) -> Tensor: ...
+def miopen_depthwise_convolution(self: Tensor, weight: Tensor, bias: Optional[Tensor], padding: _size, stride: _size, dilation: _size, groups: _int, benchmark: _bool, deterministic: _bool) -> Tensor: ...
+def miopen_rnn(input: Tensor, weight: Union[Tuple[Tensor, ...], List[Tensor]], weight_stride0: _int, hx: Tensor, cx: Optional[Tensor], mode: _int, hidden_size: _int, num_layers: _int, batch_first: _bool, dropout: _float, train: _bool, bidirectional: _bool, batch_sizes: _size, dropout_state: Optional[Tensor]) -> Tuple[Tensor, Tensor, Tensor, Tensor, Tensor]: ...
+def mkldnn_adaptive_avg_pool2d(self: Tensor, output_size: Union[_int, _size]) -> Tensor: ...
+def mkldnn_convolution(self: Tensor, weight: Tensor, bias: Optional[Tensor], padding: _size, stride: _size, dilation: _size, groups: _int) -> Tensor: ...
+def mkldnn_convolution_backward_weights(weight_size: _size, grad_output: Tensor, self: Tensor, padding: _size, stride: _size, dilation: _size, groups: _int, bias_defined: _bool) -> Tuple[Tensor, Tensor]: ...
+def mkldnn_max_pool2d(self: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, ceil_mode: _bool=False) -> Tensor: ...
+def mm(self: Tensor, mat2: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def mode(self: Tensor, dim: _int=-1, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def mode(self: Tensor, dim: Union[str, None], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def mul(input: Union[Tensor, Number], other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def mul(input: Union[Tensor, Number], value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+def multinomial(self: Tensor, num_samples: _int, replacement: _bool=False, *, generator: Generator=None, out: Optional[Tensor]=None) -> Tensor: ...
+def mv(self: Tensor, vec: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def mvlgamma(self: Tensor, p: _int) -> Tensor: ...
+def narrow(self: Tensor, dim: _int, start: _int, length: _int) -> Tensor: ...
+def native_batch_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], running_mean: Optional[Tensor], running_var: Optional[Tensor], training: _bool, momentum: _float, eps: _float) -> Tuple[Tensor, Tensor, Tensor]: ...
+def native_layer_norm(input: Tensor, weight: Optional[Tensor], bias: Optional[Tensor], M: _int, N: _int, eps: _float) -> Tuple[Tensor, Tensor, Tensor]: ...
+def native_norm(self: Tensor, p: Number=2) -> Tensor: ...
+@overload
+def ne(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def ne(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def neg(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def neg_(self: Tensor) -> Tensor: ...
+def norm_except_dim(v: Tensor, pow: _int=2, dim: _int=0) -> Tensor: ...
+@overload
+def normal(mean: Tensor, std: _float=1, *, generator: Generator=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def normal(mean: _float, std: Tensor, *, generator: Generator=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def normal(mean: Tensor, std: Tensor, *, generator: Generator=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def normal(mean: _float, std: _float, size: _size, *, generator: Generator=None, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def nuclear_norm(self: Tensor, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def nuclear_norm(self: Tensor, dim: Union[_int, _size], keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+def numel(self: Tensor) -> _int: ...
+@overload
+def ones(size: _size, *, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def ones(*size: _int, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def ones(size: _size, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def ones(*size: _int, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def ones_like(self: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def ones_like(self: Tensor, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def orgqr(self: Tensor, input2: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def ormqr(self: Tensor, input2: Tensor, input3: Tensor, left: _bool=True, transpose: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+def pairwise_distance(x1: Tensor, x2: Tensor, p: _float=2, eps: _float=1e-06, keepdim: _bool=False) -> Tensor: ...
+def pdist(self: Tensor, p: _float=2) -> Tensor: ...
+def pinverse(self: Tensor, rcond: _float=1e-15) -> Tensor: ...
+def pixel_shuffle(self: Tensor, upscale_factor: _int) -> Tensor: ...
+def poisson(self: Tensor, generator: Generator=None) -> Tensor: ...
+def poisson_nll_loss(input: Tensor, target: Tensor, log_input: _bool, full: _bool, eps: _float, reduction: _int) -> Tensor: ...
+def polygamma(n: _int, self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def pow(self: Tensor, exponent: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def pow(self: Tensor, exponent: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def pow(self: Number, exponent: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def prelu(self: Tensor, weight: Tensor) -> Tensor: ...
+@overload
+def prod(self: Tensor, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def prod(self: Tensor, dim: _int, keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def prod(self: Tensor, dim: Union[str, None], keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+def promote_types(type1: _dtype, type2: _dtype) -> _dtype: ...
+def q_per_channel_axis(self: Tensor) -> _int: ...
+def q_per_channel_scales(self: Tensor) -> Tensor: ...
+def q_per_channel_zero_points(self: Tensor) -> Tensor: ...
+def q_scale(self: Tensor) -> _float: ...
+def q_zero_point(self: Tensor) -> _int: ...
+def qr(self: Tensor, some: _bool=True, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def quantize_per_channel(self: Tensor, scales: Tensor, zero_points: Tensor, axis: _int, dtype: _dtype) -> Tensor: ...
+def quantize_per_tensor(self: Tensor, scale: _float, zero_point: _int, dtype: _dtype) -> Tensor: ...
+@overload
+def quantized_gru(input: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
+@overload
+def quantized_gru(data: Tensor, batch_sizes: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor]: ...
+def quantized_gru_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Number, scale_hh: Number, zero_point_ih: Number, zero_point_hh: Number) -> Tensor: ...
+@overload
+def quantized_lstm(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool, *, dtype: Optional[_dtype]=None, use_dynamic: _bool=False) -> Tuple[Tensor, Tensor, Tensor]: ...
+@overload
+def quantized_lstm(data: Tensor, batch_sizes: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, *, dtype: Optional[_dtype]=None, use_dynamic: _bool=False) -> Tuple[Tensor, Tensor, Tensor]: ...
+def quantized_lstm_cell(input: Tensor, hx: Union[Tuple[Tensor, ...], List[Tensor]], w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Number, scale_hh: Number, zero_point_ih: Number, zero_point_hh: Number) -> Tuple[Tensor, Tensor]: ...
+def quantized_max_pool2d(self: Tensor, kernel_size: Union[_int, _size], stride: Union[_int, _size]=(), padding: Union[_int, _size]=0, dilation: Union[_int, _size]=1, ceil_mode: _bool=False) -> Tensor: ...
+def quantized_rnn_relu_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Number, scale_hh: Number, zero_point_ih: Number, zero_point_hh: Number) -> Tensor: ...
+def quantized_rnn_tanh_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Tensor, b_hh: Tensor, packed_ih: Tensor, packed_hh: Tensor, col_offsets_ih: Tensor, col_offsets_hh: Tensor, scale_ih: Number, scale_hh: Number, zero_point_ih: Number, zero_point_hh: Number) -> Tensor: ...
+@overload
+def rand(size: _size, *, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand(*size: _int, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand(size: _size, *, generator: Generator, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand(*size: _int, generator: Generator, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand(size: _size, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand(*size: _int, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand(size: _size, *, generator: Generator, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand(*size: _int, generator: Generator, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def rand_like(self: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def rand_like(self: Tensor, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randint(low: _int, high: _int, size: _size, *, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+@overload
+def randint(high: _int, size: _size, *, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+@overload
+def randint_like(self: Tensor, high: _int, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def randint_like(self: Tensor, low: _int, high: _int, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def randint_like(self: Tensor, high: _int, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randint_like(self: Tensor, low: _int, high: _int, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(size: _size, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(*size: _int, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(size: _size, *, generator: Generator, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(*size: _int, generator: Generator, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(size: _size, *, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(*size: _int, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(size: _size, *, generator: Generator, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn(*size: _int, generator: Generator, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randn_like(self: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def randn_like(self: Tensor, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randperm(n: _int, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def randperm(n: _int, *, generator: Generator, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def range(start: Number, end: Number, step: Number=1, *, out: Optional[Tensor]=None, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+def real(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def reciprocal(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def reciprocal_(self: Tensor) -> Tensor: ...
+def relu(self: Tensor) -> Tensor: ...
+def relu_(self: Tensor) -> Tensor: ...
+@overload
+def remainder(self: Tensor, other: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def remainder(self: Tensor, other: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def renorm(self: Tensor, p: Number, dim: _int, maxnorm: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def repeat_interleave(repeats: Tensor) -> Tensor: ...
+@overload
+def repeat_interleave(self: Tensor, repeats: Tensor, dim: Optional[_int]=None) -> Tensor: ...
+@overload
+def repeat_interleave(self: Tensor, repeats: _int, dim: Optional[_int]=None) -> Tensor: ...
+def reshape(self: Tensor, shape: _size) -> Tensor: ...
+def resize_as_(self: Tensor, the_template: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def result_type(tensor: Tensor, other: Tensor) -> _dtype: ...
+@overload
+def result_type(tensor: Tensor, other: Number) -> _dtype: ...
+@overload
+def result_type(scalar: Number, tensor: Tensor) -> _dtype: ...
+@overload
+def result_type(scalar1: Number, scalar2: Number) -> _dtype: ...
+def rfft(self: Tensor, signal_ndim: _int, normalized: _bool=False, onesided: _bool=True) -> Tensor: ...
+@overload
+def rnn_relu(input: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
+@overload
+def rnn_relu(data: Tensor, batch_sizes: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor]: ...
+def rnn_relu_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor]=None, b_hh: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def rnn_tanh(input: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool, batch_first: _bool) -> Tuple[Tensor, Tensor]: ...
+@overload
+def rnn_tanh(data: Tensor, batch_sizes: Tensor, hx: Tensor, params: Union[Tuple[Tensor, ...], List[Tensor]], has_biases: _bool, num_layers: _int, dropout: _float, train: _bool, bidirectional: _bool) -> Tuple[Tensor, Tensor]: ...
+def rnn_tanh_cell(input: Tensor, hx: Tensor, w_ih: Tensor, w_hh: Tensor, b_ih: Optional[Tensor]=None, b_hh: Optional[Tensor]=None) -> Tensor: ...
+def roll(self: Tensor, shifts: Union[_int, _size], dims: Union[_int, _size]=()) -> Tensor: ...
+def rot90(self: Tensor, k: _int=1, dims: _size=(0,1)) -> Tensor: ...
+def round(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def round_(self: Tensor) -> Tensor: ...
+def rrelu(self: Tensor, lower: Number=0.125, upper: Number=0.3333333333333333, training: _bool=False, generator: Generator=None) -> Tensor: ...
+def rrelu_(self: Tensor, lower: Number=0.125, upper: Number=0.3333333333333333, training: _bool=False, generator: Generator=None) -> Tensor: ...
+def rsqrt(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def rsqrt_(self: Tensor) -> Tensor: ...
+@overload
+def rsub(self: Tensor, other: Tensor, *, alpha: Number=1) -> Tensor: ...
+@overload
+def rsub(self: Tensor, other: Number, alpha: Number=1) -> Tensor: ...
+def scalar_tensor(s: Number, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def scatter(self: Tensor, dim: _int, index: Tensor, src: Tensor) -> Tensor: ...
+@overload
+def scatter(self: Tensor, dim: _int, index: Tensor, value: Number) -> Tensor: ...
+@overload
+def scatter(self: Tensor, dim: Union[str, None], index: Tensor, src: Tensor) -> Tensor: ...
+@overload
+def scatter(self: Tensor, dim: Union[str, None], index: Tensor, value: Number) -> Tensor: ...
+@overload
+def scatter_add(self: Tensor, dim: _int, index: Tensor, src: Tensor) -> Tensor: ...
+@overload
+def scatter_add(self: Tensor, dim: Union[str, None], index: Tensor, src: Tensor) -> Tensor: ...
+@overload
+def select(self: Tensor, dim: Union[str, None], index: _int) -> Tensor: ...
+@overload
+def select(self: Tensor, dim: _int, index: _int) -> Tensor: ...
+def selu(self: Tensor) -> Tensor: ...
+def selu_(self: Tensor) -> Tensor: ...
+def set_flush_denormal(mode: _bool) -> _bool: ...
+def set_num_interop_threads(num: _int) -> None: ...
+def set_num_threads(num: _int) -> None: ...
+def sigmoid(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def sigmoid_(self: Tensor) -> Tensor: ...
+def sign(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def sin(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def sin_(self: Tensor) -> Tensor: ...
+def sinh(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def sinh_(self: Tensor) -> Tensor: ...
+def slogdet(self: Tensor) -> Tuple[Tensor, Tensor]: ...
+def smm(self: Tensor, mat2: Tensor) -> Tensor: ...
+@overload
+def softmax(self: Tensor, dim: _int, dtype: Optional[_dtype]=None) -> Tensor: ...
+@overload
+def softmax(self: Tensor, dim: Union[str, None], *, dtype: Optional[_dtype]=None) -> Tensor: ...
+def solve(self: Tensor, A: Tensor, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def sort(self: Tensor, dim: _int=-1, descending: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+@overload
+def sort(self: Tensor, dim: Union[str, None], descending: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def sparse_coo_tensor(indices: Tensor, values: Union[Tensor,List], size: Optional[_size]=None, *, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def split_with_sizes(self: Tensor, split_sizes: _size, dim: _int=0) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+def sqrt(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def sqrt_(self: Tensor) -> Tensor: ...
+@overload
+def squeeze(self: Tensor) -> Tensor: ...
+@overload
+def squeeze(self: Tensor, dim: _int) -> Tensor: ...
+@overload
+def squeeze(self: Tensor, dim: Union[str, None]) -> Tensor: ...
+@overload
+def sspaddmm(self: Tensor, mat1: Tensor, mat2: Tensor, *, beta: Number=1, alpha: Number=1, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def sspaddmm(beta: Number, self: Tensor, alpha: Number, mat1: Tensor, mat2: Tensor) -> Tensor: ...
+@overload
+def sspaddmm(beta: Number, self: Tensor, mat1: Tensor, mat2: Tensor) -> Tensor: ...
+def stack(tensors: Union[Tuple[Tensor, ...], List[Tensor]], dim: _int=0, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def std(self: Tensor, unbiased: _bool=True, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def std(self: Tensor, dim: Union[_int, _size], unbiased: _bool=True, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def std(self: Tensor, dim: List[Union[str, None]], unbiased: _bool=True, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def std_mean(self: Tensor, unbiased: _bool=True) -> Tuple[Tensor, Tensor]: ...
+@overload
+def std_mean(self: Tensor, dim: Union[_int, _size], unbiased: _bool=True, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+@overload
+def std_mean(self: Tensor, dim: List[Union[str, None]], unbiased: _bool=True, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+@overload
+def sub(input: Union[Tensor, Number], other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def sub(input: Union[Tensor, Number], value: Number, other: Union[Tensor, Number], *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def sub(self: Tensor, alpha: Number, other: Tensor) -> Tensor: ...
+@overload
+def sub(self: Tensor, alpha: Number, other: Tensor, *, out: Tensor) -> Tensor: ...
+@overload
+def sum(self: Tensor, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def sum(self: Tensor, dim: Union[_int, _size], keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def sum(self: Tensor, dim: List[Union[str, None]], keepdim: _bool=False, *, dtype: Optional[_dtype]=None, out: Optional[Tensor]=None) -> Tensor: ...
+def svd(self: Tensor, some: _bool=True, compute_uv: _bool=True, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor, Tensor]: ...
+def symeig(self: Tensor, eigenvectors: _bool=False, upper: _bool=True, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def t(self: Tensor) -> Tensor: ...
+def take(self: Tensor, index: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def tan(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def tan_(self: Tensor) -> Tensor: ...
+def tanh(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def tanh_(self: Tensor) -> Tensor: ...
+def tensor(data: Any, dtype: Optional[_dtype]=None, device: Union[_device, str, None]=None, requires_grad: _bool=False) -> Tensor: ...
+def threshold(self: Tensor, threshold: Number, value: Number, *, out: Optional[Tensor]=None) -> Tensor: ...
+def threshold_(self: Tensor, threshold: Number, value: Number) -> Tensor: ...
+def topk(self: Tensor, k: _int, dim: _int=-1, largest: _bool=True, sorted: _bool=True, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def trace(self: Tensor) -> Tensor: ...
+@overload
+def transpose(self: Tensor, dim0: _int, dim1: _int) -> Tensor: ...
+@overload
+def transpose(self: Tensor, dim0: Union[str, None], dim1: Union[str, None]) -> Tensor: ...
+@overload
+def trapz(y: Tensor, x: Tensor, *, dim: _int=-1) -> Tensor: ...
+@overload
+def trapz(y: Tensor, *, dx: _float=1, dim: _int=-1) -> Tensor: ...
+def triangular_solve(self: Tensor, A: Tensor, upper: _bool=True, transpose: _bool=False, unitriangular: _bool=False, *, out: Optional[Tensor]=None) -> Tuple[Tensor, Tensor]: ...
+def tril(self: Tensor, diagonal: _int=0, *, out: Optional[Tensor]=None) -> Tensor: ...
+def tril_indices(row: _int, col: _int, offset: _int=0, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def triu(self: Tensor, diagonal: _int=0, *, out: Optional[Tensor]=None) -> Tensor: ...
+def triu_indices(row: _int, col: _int, offset: _int=0, *, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+def trunc(self: Tensor, *, out: Optional[Tensor]=None) -> Tensor: ...
+def trunc_(self: Tensor) -> Tensor: ...
+@overload
+def unbind(self: Tensor, dim: _int=0) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+@overload
+def unbind(self: Tensor, dim: Union[str, None]) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+def unique_dim(self: Tensor, dim: _int, sorted: _bool=True, return_inverse: _bool=False, return_counts: _bool=False) -> Tuple[Tensor, Tensor, Tensor]: ...
+def unsqueeze(self: Tensor, dim: _int) -> Tensor: ...
+@overload
+def var(self: Tensor, unbiased: _bool=True, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def var(self: Tensor, dim: Union[_int, _size], unbiased: _bool=True, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def var(self: Tensor, dim: List[Union[str, None]], unbiased: _bool=True, keepdim: _bool=False, *, out: Optional[Tensor]=None) -> Tensor: ...
+@overload
+def var_mean(self: Tensor, unbiased: _bool=True) -> Tuple[Tensor, Tensor]: ...
+@overload
+def var_mean(self: Tensor, dim: Union[_int, _size], unbiased: _bool=True, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+@overload
+def var_mean(self: Tensor, dim: List[Union[str, None]], unbiased: _bool=True, keepdim: _bool=False) -> Tuple[Tensor, Tensor]: ...
+@overload
+def where(condition: Tensor, self: Tensor, other: Tensor) -> Tensor: ...
+@overload
+def where(condition: Tensor) -> Union[Tuple[Tensor, ...], List[Tensor]]: ...
+def zero_(self: Tensor) -> Tensor: ...
+@overload
+def zeros(size: _size, *, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def zeros(*size: _int, names: Optional[List[Union[str, None]]], out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def zeros(size: _size, *, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def zeros(*size: _int, out: Optional[Tensor]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+@overload
+def zeros_like(self: Tensor, *, memory_format: Optional[memory_format]=None) -> Tensor: ...
+@overload
+def zeros_like(self: Tensor, *, memory_format: Optional[memory_format]=None, dtype: _dtype=None, layout: _layout=strided, device: Union[_device, str, None]=None, requires_grad:_bool=False) -> Tensor: ...
+
+class DoubleStorage(Storage): ...
+class FloatStorage(Storage): ...
+class LongStorage(Storage): ...
+class IntStorage(Storage): ...
+class ShortStorage(Storage): ...
+class CharStorage(Storage): ...
+class ByteStorage(Storage): ...
+class BoolStorage(Storage): ...
+class DoubleTensor(Tensor): ...
+class FloatTensor(Tensor): ...
+class LongTensor(Tensor): ...
+class IntTensor(Tensor): ...
+class ShortTensor(Tensor): ...
+class CharTensor(Tensor): ...
+class ByteTensor(Tensor): ...
+class BoolTensor(Tensor): ...
+
+float32: dtype = ...
+float: dtype = ...
+float64: dtype = ...
+double: dtype = ...
+float16: dtype = ...
+half: dtype = ...
+uint8: dtype = ...
+int8: dtype = ...
+int16: dtype = ...
+short: dtype = ...
+int32: dtype = ...
+int: dtype = ...
+int64: dtype = ...
+long: dtype = ...
+complex32: dtype = ...
+complex64: dtype = ...
+complex128: dtype = ...
+quint8: dtype = ...
+qint8: dtype = ...
+qint32: dtype = ...
+bool: dtype = ...
+
+# Pure Python functions defined in torch/__init__.py
+
+def typename(obj) -> str: ...
+def is_tensor(obj) -> _bool: ...
+def is_storage(obj) -> _bool: ...
+def set_default_tensor_type(type) -> None: ...  # ick, what a bad legacy API
+def set_default_dtype(d : _dtype) -> None: ...
+def manager_path() -> str: ...
+def compiled_with_cxx11_abi() -> _bool: ...
+
+# The return value of this function depends on the value of `as_tuple`,
+# (similar to `unique`, `lu`, etc.); as such, it is not
+# possible to type correctly
+def nonzero(input: Tensor, *, out: Optional[Tensor]=None, as_tuple: Optional[_bool]=None): ...
+
+#MODIFIED BY TORCHGPIPE
+def is_grad_enabled() -> _bool: ...
+__version__: str = ...
+#END

stubs/torch/autograd/__init__.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from typing import Any, Callable, Union, Tuple, Sequence, Optional
+from .. import Tensor
+from .grad_mode import no_grad as no_grad, enable_grad as enable_grad, \
+    set_grad_enabled as set_grad_enabled
+from .profiler import record_function
+
+# TODO make Variable and Function more precise
+class Variable:
+    ...
+
+class Function:
+    @staticmethod
+    def forward(ctx: Any, *args: Any, **kwargs: Any) -> Any: ...
+    @staticmethod
+    def backward(ctx: Any, *grad_outputs: Any) -> Any: ...
+
+#MODIFIED BY TORCHGPIPE
+    @staticmethod
+    def apply(*args: Any, **kwargs: Any) -> Any: ...
+#END
+
+class NestedIOFunction(Function):
+    # The 'type: ignore' statements are needed here because these functions are declared as '@staticmethod' in the
+    # superclass (Function) but are instance methods here, which mypy reports as incomptabile.
+    def backward(self, *gradients: Any) -> Any: ...  # type: ignore
+    def forward(self, *args: Any) -> tuple: ...  # type: ignore
+    def save_for_backward(self, *args: Any) -> None:...
+    def mark_dirty(self, *args: Any, **kwargs: Any) -> None:...
+    def mark_non_differentiable(self, *args: Any, **kwargs: Any) -> None: ...
+    def forward_extended(self, *input: Any) -> None:...
+    def backward_extended(self, *grad_output: Any) -> None: ...
+
+# 'func' accepts a vararg of tensors, which isn't expressable in the type system at the moment.
+# If https://mypy.readthedocs.io/en/latest/additional_features.html?highlight=callable#extended-callable-types is accepted,
+# the '...' first argument of Callabe can be replaced with VarArg(Tensor).
+# For now, we permit any input.
+def gradcheck(func: Callable[..., Union[Tensor, Tuple[Tensor, ...]]], inputs: Union[Tensor, Tuple[Tensor, ...]], eps: float=..., atol: float=..., rtol: float=..., raise_exception: bool=..., check_sparse_nnz: bool=...) -> bool: ...
+def gradgradcheck(func: Callable[..., Union[Tensor, Tuple[Tensor, ...]]], inputs: Union[Tensor, Tuple[Tensor, ...]], eps: float=..., atol: float=..., rtol: float=..., gen_non_contig_grad_outputs: bool=..., raise_exception: bool=...) -> bool: ...
+
+class detect_anomaly:
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Any) -> bool: ...
+
+class set_detect_anomaly:
+    def __init__(self, mode: bool) -> None: ...
+    def __enter__(self) -> None:...
+    def __exit__(self, *args: Any) -> bool: ...
+
+_TensorOrTensors = Union[Tensor, Sequence[Tensor]]
+def backward(tensors: _TensorOrTensors, grad_tensors: Optional[_TensorOrTensors]=..., retain_graph: Optional[bool]=..., create_graph: bool=...) -> None: ...
+def grad(outputs: _TensorOrTensors, inputs: _TensorOrTensors, grad_outputs: Optional[_TensorOrTensors]=..., retain_graph: Optional[bool]=..., create_graph: bool=..., only_inputs: bool=..., allow_unused: bool=...) -> Tuple[Tensor, ...]: ...
\ No newline at end of file

stubs/torch/autograd/grad_mode.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from typing import Any, Callable, Optional, TypeVar
+
+# Used for annotating the decorator usage of 'no_grad' and 'enable_grad'.
+# See https://mypy.readthedocs.io/en/latest/generics.html#declaring-decorators
+FuncType = Callable[..., Any]
+T = TypeVar('T', bound=FuncType)
+
+class no_grad:
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Any) -> Optional[bool]: ...
+    def __call__(self, func: T) -> T: ...
+
+class enable_grad:
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Any) -> Optional[bool]: ...
+    def __call__(self, func: T) -> T: ...
+
+class set_grad_enabled:
+    def __init__(self, mode: bool) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Any) -> Optional[bool]: ...

stubs/torch/autograd/profiler.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from typing import Any, ContextManager, Optional
+
+class record_function(ContextManager[None]):
+    def __init__(self, name: str) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Any) -> Optional[bool]: ...

stubs/torch/backends/__init__.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+#MODIFIED BY TORCHGPIPE
+from . import cudnn
+#END

stubs/torch/backends/cudnn.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+#MODIFIED BY TORCHGPIPE
+def version() -> int: ...
+#END

stubs/torch/cuda/__init__.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from typing import Optional, Tuple, Union
+import ctypes
+from .. import device as _device
+
+def is_available() -> bool: ...
+def init() -> None: ...
+
+class cudaStatus:
+    SUCCESS: int
+    ERROR_NOT_READY: int
+
+class CudaError:
+    def __init__(self, code: int) -> None: ...
+
+class _CudaDeviceProperties:
+    name: str
+    major: int
+    minor: int
+    multi_processor_count: int
+    total_memory: int
+    is_integrated: int
+    is_multi_gpu_board: int
+
+_device_t = Union[_device, int]
+
+def check_error(res: int) -> None: ...
+def device_count() -> int: ...
+def empty_cache() -> None: ...
+def synchronize(device: _device_t) -> None: ...
+def set_device(device: _device_t) -> None: ...
+def get_device_capability(device: Optional[_device_t]=...) -> Tuple[int, int]: ...
+def get_device_name(device: Optional[_device_t]=...) -> str: ...
+def get_device_properties(device: _device_t) -> _CudaDeviceProperties: ...
+def current_device() -> int: ...
+def memory_allocated(device: Optional[_device_t]=...) -> int: ...
+def max_memory_allocated(device: Optional[_device_t]=...) -> int: ...
+def reset_max_memory_allocated(device: Optional[_device_t]=...) -> None: ...
+def memory_cached(device: Optional[_device_t]=...) -> int: ...
+def max_memory_cached(device: Optional[_device_t]=...) -> int: ...
+def reset_max_memory_cached(device: Optional[_device_t]=...) -> None: ...
+def cudart() -> ctypes.CDLL: ...
+def find_cuda_windows_lib() -> Optional[ctypes.CDLL]: ...
+#MODIFIED BY TORCHGPIPE
+from .. import ByteTensor
+def set_rng_state(new_state: ByteTensor, device: _device_t = ...) -> None: ...
+def get_rng_state(device: _device_t = ...) -> ByteTensor: ...
+#END
+
+#MODIFIED BY TORCHGPIPE
+from typing import Any
+class device:
+    def __init__(self, device: _device_t = ...) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Any) -> None: ...
+
+class Stream:
+    device: _device
+    def __init__(self, device: _device_t = ..., priority: int = ...) -> None: ...
+    def synchronize(self) -> None: ...
+    def wait_stream(self, stream: Stream) -> None: ...
+
+class stream:
+    def __init__(self, stream: Optional[Stream] = ...) -> None: ...
+    def __enter__(self) -> None: ...
+    def __exit__(self, *args: Any) -> None: ...
+
+def current_stream(device: Optional[_device_t]) -> Stream: ...
+def default_stream(device: Optional[_device_t]) -> Stream: ...
+#END

stubs/torch/cuda/comm/__init__.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+#MODIFIED BY TORCHGPIPE
+from typing import Iterable, Optional, Tuple
+
+from torch import Tensor
+
+
+def scatter(tensor: Tensor,
+            devices: Iterable[int],
+            chunk_sizes: Optional[Iterable[int]] = None,
+            dim: int = 0,
+            ) -> Tuple[Tensor, ...]: ...
+
+
+def gather(tensors: Iterable[Tensor],
+           dim: int = 0,
+           destination: Optional[int] = None,
+           ) -> Tensor: ...
+
+#END

stubs/torch/distributed/__init__.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from typing import Any
+from torch import Tensor
+
+def get_rank(group: Any) -> int: ...
+
+def get_world_size(group: Any) -> int: ...
+
+def broadcast(tensor: Tensor, src: Any, group: Any, async_op: Any = False): ...
+
+class group(object):
+    WORLD: Any

stubs/torch/nn/__init__.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from .modules import * 
+from .parameter import Parameter as Parameter
+from .parallel import DataParallel as DataParallel
+from . import functional as functional

stubs/torch/nn/common_types.pyi

+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from typing import TypeVar, Union, Tuple
+from .. import Tensor
+
+# Create some useful type aliases
+
+# Template for arguments which can be supplied as a tuple, or which can be a scalar which PyTorch will internally
+# broadcast to a tuple.
+# Comes in several variants: A tuple of unknown size, and a fixed-size tuple for 1d, 2d, or 3d operations.
+T = TypeVar('T')
+_scalar_or_tuple_any_t = Union[T, Tuple[T, ...]]
+_scalar_or_tuple_1_t = Union[T, Tuple[T]]
+_scalar_or_tuple_2_t = Union[T, Tuple[T, T]]
+_scalar_or_tuple_3_t = Union[T, Tuple[T, T, T]]
+_scalar_or_tuple_4_t = Union[T, Tuple[T, T, T, T]]
+_scalar_or_tuple_5_t = Union[T, Tuple[T, T, T, T, T]]
+_scalar_or_tuple_6_t = Union[T, Tuple[T, T, T, T, T, T]]
+
+# For arguments which represent size parameters (eg, kernel size, padding)
+_size_any_t = _scalar_or_tuple_any_t[int]
+_size_1_t = _scalar_or_tuple_1_t[int]
+_size_2_t = _scalar_or_tuple_2_t[int]
+_size_3_t = _scalar_or_tuple_3_t[int]
+_size_4_t = _scalar_or_tuple_4_t[int]
+_size_5_t = _scalar_or_tuple_5_t[int]
+_size_6_t = _scalar_or_tuple_6_t[int]
+
+# For arguments that represent a ratio to adjust each dimension of an input with (eg, upsampling parameters)
+_ratio_2_t = _scalar_or_tuple_2_t[float]
+_ratio_3_t = _scalar_or_tuple_3_t[float]
+_ratio_any_t = _scalar_or_tuple_any_t[float]
+
+_tensor_list_t = _scalar_or_tuple_any_t[Tensor]
+
+# For the return value of max pooling operations that may or may not return indices.
+# With the proposed 'Literal' feature to Python typing, it might be possible to
+# eventually eliminate this.
+_maybe_indices_t = _scalar_or_tuple_2_t[Tensor]