diff --git a/docs/api/torch_npu_apis.md b/docs/api/torch_npu_apis.md new file mode 100644 index 0000000000000000000000000000000000000000..98560562ea52713b76564b9c9193174f80c9d30f --- /dev/null +++ b/docs/api/torch_npu_apis.md @@ -0,0 +1,22540 @@ +# API of PyTorch Ascend Adapter + +PyTorch Ascend Adapter named torch_npu is committed to maintaining compatibility with PyTorch's native API so that users can better use torch_npu. The current API comparison between torch_npu and PyTorch is as follows: + +- **[torch](#torch)** + +- **[torch.nn](#torchnn)** + +- **[torch.nn.functional](#torchnnfunctional)** + +- **[torch.Tensor](#torchtensor)** + +- **[Tensor Attributes](#tensor-attributes)** + +- **[torch.autograd](#torchautograd)** + +- **[torch.library](#torchlibrary)** + +- **[torch.cuda](#torchcuda)** + +- **[torch.cuda.amp](#torchcudaamp)** + +- **[torch.backends](#torchbackends)** + +- **[torch.distributed](#torchdistributed)** + +- **[torch.distributed.algorithms.join](#torchdistributedalgorithmsjoin)** + +- **[torch.distributed.elastic](#torchdistributedelastic)** + +- **[torch.distributed.fsdp](#torchdistributedfsdp)** + +- **[torch.distributed.optim](#torchdistributedoptim)** + +- **[torch.distributed.tensor.parallel](#torchdistributedtensorparallel)** + +- **[torch.distributed.checkpoint](#torchdistributedcheckpoint)** + +- **[torch.distributions](#torchdistributions)** + +- **[torch.fft](#torchfft)** + +- **[torch.func](#torchfunc)** + +- **[torch.futures](#torchfutures)** + +- **[torch.fx](#torchfx)** + +- **[torch.hub](#torchhub)** + +- **[torch.jit](#torchjit)** + +- **[torch.linalg](#torchlinalg)** + +- **[torch.monitor](#torchmonitor)** + +- **[torch.signal](#torchsignal)** + +- **[torch.special](#torchspecial)** + +- **[torch.overrides](#torchoverrides)** + +- **[torch.package](#torchpackage)** + +- **[torch.profiler](#torchprofiler)** + +- **[torch.nn.init](#torchnninit)** + +- **[torch.onnx](#torchonnx)** + +- **[torch.optim](#torchoptim)** + +- **[torch.cpu](#torchcpu)** + +- **[torch.\_logging](#torch_logging)** + +- **[torch.compiler](#torchcompiler)** + +- **[torch.export](#torchexport)** + +- **[DDP Communication Hooks](#ddp-communication-hooks)** + +- **[Pipeline Parallelism](#pipeline-parallelism)** + +- **[Quantization](#quantization)** + +- **[Distributed RPC Framework](#distributed-rpc-framework)** + +- **[torch.random](#torchrandom)** + +- **[torch.nested](#torchnested)** + +- **[torch.sparse](#torchsparse)** + +- **[torch.Storage](#torchstorage)** + +- **[torch.testing](#torchtesting)** + +- **[torch.utils](#torchutils)** + +- **[torch.utils.benchmark](#torchutilsbenchmark)** + +- **[torch.utils.checkpoint](#torchutilscheckpoint)** + +- **[torch.utils.cpp\_extension](#torchutilscpp_extension)** + +- **[torch.utils.data](#torchutilsdata)** + +- **[torch.utils.dlpack](#torchutilsdlpack)** + +- **[torch.utils.mobile\_optimizer](#torchutilsmobile_optimizer)** + +- **[torch.utils.model\_zoo](#torchutilsmodel_zoo)** + +- **[torch.utils.tensorboard](#torchutilstensorboard)** + +- **[Type Info](#type-info)** + +- **[Named Tensors](#named-tensors)** + +- **[torch.\_\_config\_\_](#torch__config__)** + +- **[Understanding CUDA Memory Usage](#understanding-cuda-memory-usage)** + +>![](../../figures/icon-note.gif) **NOTE:** +>1. Marked as compatible, please note if there are any limitations. +>2. Not indicating whether it is compatible means that the compatibility of this API has not been tested and will be improved in the future. + +## torch + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.default_generator

+		    

torch.SymInt

+

Y

+		  

torch.SymFloat

+

Y

+		  

torch.SymBool

+

Y

+		  

torch.Tag

+

Y

+		  

torch.Tag.name

+		    

torch.is_tensor

+

Y

+		  

torch.is_storage

+

Y

+		  

torch.is_complex

+

Y

+		  

torch.is_conj

+		    

torch.is_floating_point

+

Y

+		  

torch.is_nonzero

+

Y

+		  

torch.set_default_dtype

+

Y

+		  

torch.get_default_dtype

+

Y

+		  

torch.set_default_device

+		    

torch.set_default_tensor_type

+

Y

+		  

torch.numel

+

Y

+		  

torch.set_printoptions

+

Y

+		  

torch.set_flush_denormal

+

Y

+		  

torch.tensor

+

Y

+		  

torch.sparse_coo_tensor

+		    

torch.sparse_csr_tensor

+		    

torch.sparse_csc_tensor

+		    

torch.sparse_bsr_tensor

+		    

torch.sparse_bsc_tensor

+		    

torch.asarray

+

Y

+		  

torch.as_tensor

+

Y

+		  

torch.as_strided

+

Y

+		  

torch.from_numpy

+

Y

+		  

torch.from_dlpack

+		    

torch.frombuffer

+

Y

+		  

torch.zeros

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.zeros_like

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ones

+

Y

+

Only support fp16，fp32，int64

+

torch.ones_like

+

Y

+

Only support fp16，fp32，int64

+

torch.arange

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.range

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.linspace

+		    

torch.logspace

+		    

torch.eye

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.empty

+

Y

+		  

torch.empty_like

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.empty_strided

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.full

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.full_like

+		    

torch.quantize_per_tensor

+		    

torch.quantize_per_channel

+		    

torch.dequantize

+		    

torch.complex

+		    

torch.polar

+		    

torch.heaviside

+		    

torch.adjoint

+		    

torch.argwhere

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.cat

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.concat

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.concatenate

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.conj

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.chunk

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.dsplit

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.column_stack

+		    

torch.dstack

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.gather

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.hsplit

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.hstack

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.index_add

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.index_copy

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.index_reduce

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.index_select

+		    

torch.masked_select

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.movedim

+		    

torch.moveaxis

+

Y

+		  

torch.narrow

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.narrow_copy

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nonzero

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.permute

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.reshape

+		    

torch.row_stack

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.select

+		    

torch.scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.diagonal_scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.select_scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.slice_scatter

+		    

torch.scatter_add

+		    

torch.scatter_reduce

+		    

torch.split

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.squeeze

+

Y

+

Only support fp16，fp32，int64

+

torch.stack

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.swapaxes

+		    

torch.swapdims

+		    

torch.t

+

Y

+		  

torch.take

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.take_along_dim

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.tensor_split

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.tile

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.transpose

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.unbind

+		    

torch.unsqueeze

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.vsplit

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.vstack

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.where

+

Y

+

Only support fp16，fp32，int64，bool；Don`t support 8-dimensional shape

+

torch.Generator

+

Y

+		  

torch.Generator.device

+		    

torch.Generator.get_state

+

Y

+		  

torch.Generator.initial_seed

+

Y

+		  

torch.Generator.manual_seed

+

Y

+		  

torch.Generator.seed

+

Y

+		  

torch.Generator.set_state

+

Y

+		  

torch.seed

+

Y

+		  

torch.manual_seed

+

Y

+		  

torch.initial_seed

+

Y

+		  

torch.get_rng_state

+

Y

+		  

torch.set_rng_state

+

Y

+		  

torch.bernoulli

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.multinomial

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.normal

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.poisson

+		    

torch.rand

+		    

torch.rand_like

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.randint

+		    

torch.randint_like

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.randn

+		    

torch.randn_like

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.randperm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.quasirandom.SobolEngine

+		    

torch.quasirandom.SobolEngine.draw

+		    

torch.quasirandom.SobolEngine.draw_base2

+		    

torch.quasirandom.SobolEngine.fast_forward

+		    

torch.quasirandom.SobolEngine.reset

+		    

torch.save

+

Y

+		  

torch.load

+

Y

+		  

torch.get_num_threads

+

Y

+		  

torch.set_num_threads

+

Y

+		  

torch.get_num_interop_threads

+

Y

+		  

torch.set_num_interop_threads

+

Y

+		  

torch.no_grad

+

Y

+		  

torch.enable_grad

+

Y

+		  

torch.set_grad_enabled

+

Y

+		  

torch.is_grad_enabled

+

Y

+		  

torch.inference_mode

+

Y

+		  

torch.is_inference_mode_enabled

+

Y

+		  

torch.abs

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.absolute

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.acos

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.arccos

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.acosh

+

Y

+

Only support fp16，fp32

+

torch.arccosh

+

Y

+

Only support fp16，fp32

+

torch.add

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.addcdiv

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.addcmul

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.angle

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.asin

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.arcsin

+		    

torch.asinh

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.arcsinh

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.atan

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.arctan

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.atanh

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.arctanh

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.atan2

+		    

torch.arctan2

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.bitwise_not

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.bitwise_and

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.bitwise_or

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.bitwise_xor

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.bitwise_left_shift

+		    

torch.bitwise_right_shift

+		    

torch.ceil

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.clamp

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.clip

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.conj_physical

+		    

torch.copysign

+		    

torch.cos

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.cosh

+

Y

+

Only support fp16，fp32

+

torch.deg2rad

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.div

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.divide

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.digamma

+		    

torch.erf

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.erfc

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.erfinv

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.exp

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.exp2

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.expm1

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.fake_quantize_per_channel_affine

+		    

torch.fake_quantize_per_tensor_affine

+		    

torch.fix

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.float_power

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.floor

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.floor_divide

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.fmod

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.frac

+		    

torch.frexp

+		    

torch.gradient

+		    

torch.imag

+		    

torch.ldexp

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.lerp

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.lgamma

+		    

torch.log

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.log10

+		    

torch.log1p

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.log2

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.logaddexp

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.logaddexp2

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.logical_and

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.logical_not

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.logical_or

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.logical_xor

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.logit

+		    

torch.hypot

+		    

torch.i0

+		    

torch.igamma

+		    

torch.igammac

+		    

torch.mul

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.multiply

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.mvlgamma

+		    

torch.nan_to_num

+		    

torch.neg

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.negative

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nextafter

+		    

torch.polygamma

+		    

torch.positive

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.pow

+		    

torch.quantized_batch_norm

+		    

torch.quantized_max_pool1d

+		    

torch.quantized_max_pool2d

+		    

torch.rad2deg

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.real

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.reciprocal

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.remainder

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.round

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.rsqrt

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.sigmoid

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.sign

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.sgn

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.signbit

+		    

torch.sin

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.sinc

+		    

torch.sinh

+

Y

+

Only support fp16，fp32

+

torch.softmax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.sqrt

+

Y

+

Only support fp16，fp32

+

torch.square

+

Y

+

Only support fp16，fp32，int64

+

torch.sub

+

Y

+

Only support fp16，fp32，int64

+

torch.subtract

+		    

torch.tan

+

Y

+

Only support fp16，fp32，int64

+

torch.tanh

+

Y

+

Only support fp16，fp32，int64

+

torch.true_divide

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.trunc

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.xlogy

+

Y

+

Only support fp16，fp32

+

torch.argmax

+

Y

+

Only support fp16，fp32，int64

+

torch.argmin

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.amax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.amin

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.aminmax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.all

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.any

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.max

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.min

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.dist

+		    

torch.logsumexp

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.mean

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nanmean

+		    

torch.median

+

Y

+

Only support fp16，fp32，int64

+

torch.nanmedian

+		    

torch.mode

+		    

torch.norm

+		    

torch.nansum

+		    

torch.prod

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.quantile

+		    

torch.nanquantile

+		    

torch.std

+

Y

+

Only support fp16，fp32

+

torch.std_mean

+		    

torch.sum

+

Y

+

Only support fp16，fp32，int64，bool；Don`t support dtype parameter

+

torch.unique

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.unique_consecutive

+		    

torch.var

+

Y

+

Only support fp16，fp32

+

torch.var_mean

+		    

torch.count_nonzero

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.allclose

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.argsort

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.eq

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.equal

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ge

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.greater_equal

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.gt

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.greater

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.isclose

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.isfinite

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.isin

+		    

torch.isinf

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.isposinf

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.isneginf

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.isnan

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.isreal

+		    

torch.kthvalue

+

Y

+

Only support fp16，fp32

+

torch.le

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.less_equal

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.lt

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.less

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.maximum

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.minimum

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.fmax

+		    

torch.fmin

+		    

torch.ne

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.not_equal

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.sort

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.topk

+

Y

+

Only support fp16，fp32，int64，bool；Don`t support sorted=False

+

torch.msort

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.stft

+		    

torch.istft

+		    

torch.bartlett_window

+		    

torch.blackman_window

+		    

torch.hamming_window

+		    

torch.hann_window

+		    

torch.kaiser_window

+		    

torch.atleast_1d

+		    

torch.atleast_2d

+		    

torch.atleast_3d

+		    

torch.bincount

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.block_diag

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.broadcast_tensors

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.broadcast_to

+		    

torch.broadcast_shapes

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.bucketize

+		    

torch.cartesian_prod

+		    

torch.cdist

+		    

torch.clone

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.combinations

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.corrcoef

+		    

torch.cov

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.cross

+		    

torch.cummax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.cummin

+		    

torch.cumprod

+		    

torch.cumsum

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.diag

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.diag_embed

+		    

torch.diagflat

+		    

torch.diagonal

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.diff

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.einsum

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.flatten

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.flip

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.fliplr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.flipud

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.kron

+		    

torch.rot90

+		    

torch.gcd

+		    

torch.histc

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.histogram

+		    

torch.histogramdd

+		    

torch.meshgrid

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.lcm

+		    

torch.logcumsumexp

+		    

torch.ravel

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.renorm

+		    

torch.repeat_interleave

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.roll

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.searchsorted

+

Y

+

Only support fp16，fp32，int64

+

torch.tensordot

+		    

torch.trace

+		    

torch.tril

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.tril_indices

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.triu

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.triu_indices

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.unflatten

+

Y

+		  

torch.vander

+		    

torch.view_as_real

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.view_as_complex

+		    

torch.resolve_conj

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.resolve_neg

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.addbmm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.addmm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.addmv

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.addr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.baddbmm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.bmm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.chain_matmul

+		    

torch.cholesky

+		    

torch.cholesky_inverse

+		    

torch.cholesky_solve

+		    

torch.dot

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.geqrf

+		    

torch.ger

+		    

torch.inner

+		    

torch.inverse

+		    

torch.det

+		    

torch.logdet

+		    

torch.slogdet

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.lu

+		    

torch.lu_solve

+		    

torch.lu_unpack

+		    

torch.matmul

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.matrix_power

+		    

torch.matrix_exp

+		    

torch.mm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.mv

+		    

torch.orgqr

+		    

torch.ormqr

+		    

torch.outer

+		    

torch.pinverse

+		    

torch.qr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.svd

+		    

torch.svd_lowrank

+		    

torch.pca_lowrank

+		    

torch.lobpcg

+		    

torch.trapz

+		    

torch.trapezoid

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.cumulative_trapezoid

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.triangular_solve

+		    

torch.vdot

+		    

torch._foreach_abs

+		    

torch._foreach_abs_

+		    

torch._foreach_acos

+		    

torch._foreach_acos_

+		    

torch._foreach_asin

+		    

torch._foreach_asin_

+		    

torch._foreach_atan

+		    

torch._foreach_atan_

+		    

torch._foreach_ceil

+		    

torch._foreach_ceil_

+		    

torch._foreach_cos

+		    

torch._foreach_cos_

+		    

torch._foreach_cosh

+		    

torch._foreach_cosh_

+		    

torch._foreach_erf

+		    

torch._foreach_erf_

+		    

torch._foreach_erfc

+		    

torch._foreach_erfc_

+		    

torch._foreach_exp

+		    

torch._foreach_exp_

+		    

torch._foreach_expm1

+		    

torch._foreach_expm1_

+		    

torch._foreach_floor

+		    

torch._foreach_floor_

+		    

torch._foreach_log

+		    

torch._foreach_log_

+		    

torch._foreach_log10

+		    

torch._foreach_log10_

+		    

torch._foreach_log1p

+		    

torch._foreach_log1p_

+		    

torch._foreach_log2

+		    

torch._foreach_log2_

+		    

torch._foreach_neg

+		    

torch._foreach_neg_

+		    

torch._foreach_tan

+		    

torch._foreach_tan_

+		    

torch._foreach_sin

+		    

torch._foreach_sin_

+		    

torch._foreach_sinh

+		    

torch._foreach_sinh_

+		    

torch._foreach_round

+		    

torch._foreach_round_

+		    

torch._foreach_sqrt

+		    

torch._foreach_sqrt_

+		    

torch._foreach_lgamma

+		    

torch._foreach_lgamma_

+		    

torch._foreach_frac

+		    

torch._foreach_frac_

+		    

torch._foreach_reciprocal

+		    

torch._foreach_reciprocal_

+		    

torch._foreach_sigmoid

+		    

torch._foreach_sigmoid_

+		    

torch._foreach_trunc

+		    

torch._foreach_trunc_

+		    

torch._foreach_zero_

+		    

torch.compiled_with_cxx11_abi

+

Y

+		  

torch.result_type

+

Y

+		  

torch.can_cast

+

Y

+		  

torch.promote_types

+

Y

+		  

torch.use_deterministic_algorithms

+

Y

+		  

torch.are_deterministic_algorithms_enabled

+

Y

+		  

torch.is_deterministic_algorithms_warn_only_enabled

+		    

torch.set_deterministic_debug_mode

+

Y

+		  

torch.get_deterministic_debug_mode

+

Y

+		  

torch.set_float32_matmul_precision

+		    

torch.get_float32_matmul_precision

+		    

torch.set_warn_always

+

Y

+		  

torch.is_warn_always_enabled

+

Y

+		  

torch.vmap

+

Y

+		  

torch._assert

+

Y

+		  

torch.sym_float

+

Y

+		  

torch.sym_int

+

Y

+		  

torch.sym_max

+

Y

+		  

torch.sym_min

+

Y

+		  

torch.sym_not

+

Y

+		  

torch.compile

+

Y

+		  
+ +## torch.nn + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.nn.parameter.Parameter

+

Y

+		  

torch.nn.parameter.UninitializedParameter

+

Y

+		  

torch.nn.parameter.UninitializedParameter.cls_to_become

+		    

torch.nn.parameter.UninitializedBuffer

+

Y

+		  

torch.nn.Module

+

Y

+		  

torch.nn.Module.add_module

+

Y

+		  

torch.nn.Module.apply

+

Y

+		  

torch.nn.Module.bfloat16

+

Y

+		  

torch.nn.Module.buffers

+

Y

+		  

torch.nn.Module.children

+

Y

+		  

torch.nn.Module.compile

+		    

torch.nn.Module.cpu

+

Y

+		  

torch.nn.Module.cuda

+

Y

+		  

torch.nn.Module.double

+		    

torch.nn.Module.eval

+

Y

+		  

torch.nn.Module.extra_repr

+

Y

+		  

torch.nn.Module.float

+

Y

+		  

torch.nn.Module.forward

+

Y

+		  

torch.nn.Module.get_buffer

+

Y

+		  

torch.nn.Module.get_extra_state

+

Y

+		  

torch.nn.Module.get_parameter

+

Y

+		  

torch.nn.Module.get_submodule

+

Y

+		  

torch.nn.Module.half

+

Y

+		  

torch.nn.Module.ipu

+		    

torch.nn.Module.load_state_dict

+

Y

+		  

torch.nn.Module.modules

+

Y

+		  

torch.nn.Module.named_buffers

+

Y

+		  

torch.nn.Module.named_children

+

Y

+		  

torch.nn.Module.named_modules

+

Y

+		  

torch.nn.Module.named_parameters

+

Y

+		  

torch.nn.Module.parameters

+

Y

+		  

torch.nn.Module.register_backward_hook

+

Y

+		  

torch.nn.Module.register_buffer

+

Y

+		  

torch.nn.Module.register_forward_hook

+

Y

+		  

torch.nn.Module.register_forward_pre_hook

+

Y

+		  

torch.nn.Module.register_full_backward_hook

+

Y

+		  

torch.nn.Module.register_full_backward_pre_hook

+

Y

+		  

torch.nn.Module.register_load_state_dict_post_hook

+

Y

+		  

torch.nn.Module.register_module

+

Y

+		  

torch.nn.Module.register_parameter

+

Y

+		  

torch.nn.Module.register_state_dict_pre_hook

+

Y

+		  

torch.nn.Module.requires_grad_

+

Y

+		  

torch.nn.Module.set_extra_state

+

Y

+		  

torch.nn.Module.share_memory

+		    

torch.nn.Module.state_dict

+

Y

+		  

torch.nn.Module.to

+

Y

+		  

torch.nn.Module.to_empty

+

Y

+		  

torch.nn.Module.train

+

Y

+		  

torch.nn.Module.type

+

Y

+		  

torch.nn.Module.xpu

+		    

torch.nn.Module.zero_grad

+

Y

+		  

torch.nn.Sequential

+

Y

+		  

torch.nn.Sequential.append

+

Y

+		  

torch.nn.ModuleList

+

Y

+		  

torch.nn.ModuleList.append

+

Y

+		  

torch.nn.ModuleList.extend

+

Y

+		  

torch.nn.ModuleList.insert

+

Y

+		  

torch.nn.ModuleDict

+

Y

+		  

torch.nn.ModuleDict.clear

+

Y

+		  

torch.nn.ModuleDict.items

+

Y

+		  

torch.nn.ModuleDict.keys

+

Y

+		  

torch.nn.ModuleDict.pop

+

Y

+		  

torch.nn.ModuleDict.update

+

Y

+		  

torch.nn.ModuleDict.values

+

Y

+		  

torch.nn.ParameterList

+

Y

+		  

torch.nn.ParameterList.append

+

Y

+		  

torch.nn.ParameterList.extend

+

Y

+		  

torch.nn.ParameterDict

+

Y

+		  

torch.nn.ParameterDict.clear

+

Y

+		  

torch.nn.ParameterDict.copy

+

Y

+		  

torch.nn.ParameterDict.fromkeys

+

Y

+		  

torch.nn.ParameterDict.get

+

Y

+		  

torch.nn.ParameterDict.items

+

Y

+		  

torch.nn.ParameterDict.keys

+

Y

+		  

torch.nn.ParameterDict.pop

+

Y

+		  

torch.nn.ParameterDict.popitem

+

Y

+		  

torch.nn.ParameterDict.setdefault

+

Y

+		  

torch.nn.ParameterDict.update

+

Y

+		  

torch.nn.ParameterDict.values

+

Y

+		  

torch.nn.modules.module.register_module_forward_pre_hook

+

Y

+		  

torch.nn.modules.module.register_module_forward_hook

+

Y

+		  

torch.nn.modules.module.register_module_backward_hook

+

Y

+		  

torch.nn.modules.module.register_module_full_backward_pre_hook

+		    

torch.nn.modules.module.register_module_full_backward_hook

+

Y

+		  

torch.nn.modules.module.register_module_buffer_registration_hook

+		    

torch.nn.modules.module.register_module_module_registration_hook

+		    

torch.nn.modules.module.register_module_parameter_registration_hook

+		    

torch.nn.Conv1d

+		    

torch.nn.Conv2d

+		    

torch.nn.Conv3d

+		    

torch.nn.ConvTranspose1d

+		    

torch.nn.ConvTranspose2d

+		    

torch.nn.ConvTranspose3d

+		    

torch.nn.LazyConv1d

+		    

torch.nn.LazyConv1d.cls_to_become

+		    

torch.nn.LazyConv2d

+		    

torch.nn.LazyConv2d.cls_to_become

+		    

torch.nn.LazyConv3d

+		    

torch.nn.LazyConv3d.cls_to_become

+		    

torch.nn.LazyConvTranspose1d

+		    

torch.nn.LazyConvTranspose1d.cls_to_become

+		    

torch.nn.LazyConvTranspose2d

+		    

torch.nn.LazyConvTranspose2d.cls_to_become

+		    

torch.nn.LazyConvTranspose3d

+		    

torch.nn.LazyConvTranspose3d.cls_to_become

+		    

torch.nn.Unfold

+		    

torch.nn.Fold

+		    

torch.nn.MaxPool1d

+		    

torch.nn.MaxPool2d

+		    

torch.nn.MaxPool3d

+		    

torch.nn.MaxUnpool1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.MaxUnpool2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.MaxUnpool3d

+		    

torch.nn.AvgPool1d

+		    

torch.nn.AvgPool2d

+		    

torch.nn.AvgPool3d

+		    

torch.nn.FractionalMaxPool2d

+		    

torch.nn.FractionalMaxPool3d

+		    

torch.nn.LPPool1d

+		    

torch.nn.LPPool2d

+		    

torch.nn.AdaptiveMaxPool1d

+		    

torch.nn.AdaptiveMaxPool2d

+		    

torch.nn.AdaptiveMaxPool3d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.AdaptiveAvgPool1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.AdaptiveAvgPool2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.AdaptiveAvgPool3d

+		    

torch.nn.ReflectionPad1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ReflectionPad2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ReflectionPad3d

+		    

torch.nn.ReplicationPad1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ReplicationPad2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ReplicationPad3d

+		    

torch.nn.ZeroPad1d

+		    

torch.nn.ZeroPad2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ZeroPad3d

+		    

torch.nn.ConstantPad1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ConstantPad2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ConstantPad3d

+		    

torch.nn.ELU

+		    

torch.nn.Hardshrink

+		    

torch.nn.Hardsigmoid

+

Y

+

Only support fp16，fp32

+

torch.nn.Hardtanh

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Hardswish

+

Y

+

Only support fp16，fp32

+

torch.nn.LeakyReLU

+

Y

+

Only support fp16，fp32

+

torch.nn.LogSigmoid

+		    

torch.nn.MultiheadAttention

+		    

torch.nn.MultiheadAttention.forward

+		    

torch.nn.MultiheadAttention.merge_masks

+		    

torch.nn.PReLU

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.ReLU

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.ReLU6

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.RReLU

+		    

torch.nn.SELU

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.CELU

+		    

torch.nn.GELU

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Sigmoid

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.SiLU

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Mish

+		    

torch.nn.Softplus

+

Y

+

Only support fp16，fp32

+

torch.nn.Softshrink

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Softsign

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Tanh

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.Tanhshrink

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Threshold

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.GLU

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Softmin

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Softmax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Softmax2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.LogSoftmax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.AdaptiveLogSoftmaxWithLoss

+		    

torch.nn.AdaptiveLogSoftmaxWithLoss.log_prob

+		    

torch.nn.AdaptiveLogSoftmaxWithLoss.predict

+		    

torch.nn.BatchNorm1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.BatchNorm2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.BatchNorm3d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.LazyBatchNorm1d

+		    

torch.nn.LazyBatchNorm1d.cls_to_become

+		    

torch.nn.LazyBatchNorm2d

+		    

torch.nn.LazyBatchNorm2d.cls_to_become

+		    

torch.nn.LazyBatchNorm3d

+		    

torch.nn.LazyBatchNorm3d.cls_to_become

+		    

torch.nn.GroupNorm

+		    

torch.nn.SyncBatchNorm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.SyncBatchNorm.convert_sync_batchnorm

+

Y

+		  

torch.nn.InstanceNorm1d

+		    

torch.nn.InstanceNorm2d

+		    

torch.nn.InstanceNorm3d

+		    

torch.nn.LazyInstanceNorm1d

+		    

torch.nn.LazyInstanceNorm1d.cls_to_become

+		    

torch.nn.LazyInstanceNorm2d

+		    

torch.nn.LazyInstanceNorm2d.cls_to_become

+		    

torch.nn.LazyInstanceNorm3d

+		    

torch.nn.LazyInstanceNorm3d.cls_to_become

+		    

torch.nn.LayerNorm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.LocalResponseNorm

+		    

torch.nn.RNNBase

+		    

torch.nn.RNNBase.flatten_parameters

+		    

torch.nn.RNN

+		    

torch.nn.LSTM

+		    

torch.nn.GRU

+		    

torch.nn.RNNCell

+		    

torch.nn.LSTMCell

+		    

torch.nn.GRUCell

+		    

torch.nn.Transformer

+		    

torch.nn.Transformer.forward

+		    

torch.nn.Transformer.generate_square_subsequent_mask

+		    

torch.nn.TransformerEncoder

+		    

torch.nn.TransformerEncoder.forward

+		    

torch.nn.TransformerDecoder

+		    

torch.nn.TransformerDecoder.forward

+		    

torch.nn.TransformerEncoderLayer

+		    

torch.nn.TransformerEncoderLayer.forward

+		    

torch.nn.TransformerDecoderLayer

+		    

torch.nn.TransformerDecoderLayer.forward

+		    

torch.nn.Identity

+

Y

+		  

torch.nn.Linear

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Bilinear

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.LazyLinear

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.LazyLinear.cls_to_become

+		    

torch.nn.Dropout

+		    

torch.nn.Dropout1d

+		    

torch.nn.Dropout2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Dropout3d

+		    

torch.nn.AlphaDropout

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.FeatureAlphaDropout

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Embedding

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Embedding.from_pretrained

+

Y

+		  

torch.nn.EmbeddingBag

+		    

torch.nn.EmbeddingBag.forward

+

Y

+		  

torch.nn.EmbeddingBag.from_pretrained

+

Y

+		  

torch.nn.CosineSimilarity

+		    

torch.nn.PairwiseDistance

+		    

torch.nn.L1Loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.MSELoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.CrossEntropyLoss

+		    

torch.nn.CTCLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.NLLLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.PoissonNLLLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.GaussianNLLLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.KLDivLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.BCELoss

+		    

torch.nn.BCEWithLogitsLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.MarginRankingLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.HingeEmbeddingLoss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.MultiLabelMarginLoss

+		    

torch.nn.HuberLoss

+		    

torch.nn.SmoothL1Loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.SoftMarginLoss

+		    

torch.nn.MultiLabelSoftMarginLoss

+

Y

+

Only support fp16，fp32

+

torch.nn.CosineEmbeddingLoss

+		    

torch.nn.MultiMarginLoss

+		    

torch.nn.TripletMarginLoss

+		    

torch.nn.TripletMarginWithDistanceLoss

+		    

torch.nn.PixelShuffle

+		    

torch.nn.PixelUnshuffle

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Upsample

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.UpsamplingNearest2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.UpsamplingBilinear2d

+		    

torch.nn.ChannelShuffle

+		    

torch.nn.DataParallel

+		    

torch.nn.parallel.DistributedDataParallel

+

Y

+		  

torch.nn.parallel.DistributedDataParallel.join

+

Y

+		  

torch.nn.parallel.DistributedDataParallel.join_hook

+

Y

+		  

torch.nn.parallel.DistributedDataParallel.no_sync

+

Y

+		  

torch.nn.parallel.DistributedDataParallel.register_comm_hook

+

Y

+		  

torch.nn.utils.clip_grad_norm_

+		    

torch.nn.utils.clip_grad_value_

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.utils.parameters_to_vector

+		    

torch.nn.utils.vector_to_parameters

+		    

torch.nn.utils.prune.BasePruningMethod

+

Y

+		  

torch.nn.utils.prune.BasePruningMethod.apply

+

Y

+		  

torch.nn.utils.prune.BasePruningMethod.apply_mask

+

Y

+		  

torch.nn.utils.prune.BasePruningMethod.compute_mask

+		    

torch.nn.utils.prune.BasePruningMethod.prune

+

Y

+		  

torch.nn.utils.prune.BasePruningMethod.remove

+

Y

+		  

torch.nn.utils.prune.PruningContainer

+

Y

+		  

torch.nn.utils.prune.PruningContainer.add_pruning_method

+

Y

+		  

torch.nn.utils.prune.PruningContainer.apply

+

Y

+		  

torch.nn.utils.prune.PruningContainer.apply_mask

+

Y

+		  

torch.nn.utils.prune.PruningContainer.compute_mask

+

Y

+		  

torch.nn.utils.prune.PruningContainer.prune

+

Y

+		  

torch.nn.utils.prune.PruningContainer.remove

+

Y

+		  

torch.nn.utils.prune.Identity

+

Y

+		  

torch.nn.utils.prune.Identity.apply

+

Y

+		  

torch.nn.utils.prune.Identity.apply_mask

+

Y

+		  

torch.nn.utils.prune.Identity.prune

+

Y

+		  

torch.nn.utils.prune.Identity.remove

+

Y

+		  

torch.nn.utils.prune.RandomUnstructured

+

Y

+		  

torch.nn.utils.prune.RandomUnstructured.apply

+

Y

+		  

torch.nn.utils.prune.RandomUnstructured.apply_mask

+

Y

+		  

torch.nn.utils.prune.RandomUnstructured.prune

+

Y

+		  

torch.nn.utils.prune.RandomUnstructured.remove

+		    

torch.nn.utils.prune.L1Unstructured

+

Y

+		  

torch.nn.utils.prune.L1Unstructured.apply

+

Y

+		  

torch.nn.utils.prune.L1Unstructured.apply_mask

+

Y

+		  

torch.nn.utils.prune.L1Unstructured.prune

+

Y

+		  

torch.nn.utils.prune.L1Unstructured.remove

+

Y

+		  

torch.nn.utils.prune.RandomStructured

+

Y

+		  

torch.nn.utils.prune.RandomStructured.apply

+

Y

+		  

torch.nn.utils.prune.RandomStructured.apply_mask

+

Y

+		  

torch.nn.utils.prune.RandomStructured.compute_mask

+

Y

+		  

torch.nn.utils.prune.RandomStructured.prune

+

Y

+		  

torch.nn.utils.prune.RandomStructured.remove

+

Y

+		  

torch.nn.utils.prune.LnStructured

+

Y

+		  

torch.nn.utils.prune.LnStructured.apply

+

Y

+		  

torch.nn.utils.prune.LnStructured.apply_mask

+

Y

+		  

torch.nn.utils.prune.LnStructured.compute_mask

+

Y

+		  

torch.nn.utils.prune.LnStructured.prune

+

Y

+		  

torch.nn.utils.prune.LnStructured.remove

+

Y

+		  

torch.nn.utils.prune.CustomFromMask

+

Y

+		  

torch.nn.utils.prune.CustomFromMask.apply

+

Y

+		  

torch.nn.utils.prune.CustomFromMask.apply_mask

+

Y

+		  

torch.nn.utils.prune.CustomFromMask.prune

+

Y

+		  

torch.nn.utils.prune.CustomFromMask.remove

+

Y

+		  

torch.nn.utils.prune.identity

+

Y

+		  

torch.nn.utils.prune.random_unstructured

+

Y

+		  

torch.nn.utils.prune.l1_unstructured

+

Y

+		  

torch.nn.utils.prune.random_structured

+

Y

+		  

torch.nn.utils.prune.ln_structured

+

Y

+		  

torch.nn.utils.prune.global_unstructured

+

Y

+		  

torch.nn.utils.prune.custom_from_mask

+

Y

+		  

torch.nn.utils.prune.remove

+

Y

+		  

torch.nn.utils.prune.is_pruned

+

Y

+		  

torch.nn.utils.weight_norm

+		    

torch.nn.utils.remove_weight_norm

+		    

torch.nn.utils.spectral_norm

+		    

torch.nn.utils.remove_spectral_norm

+		    

torch.nn.utils.skip_init

+		    

torch.nn.utils.parametrizations.orthogonal

+		    

torch.nn.utils.parametrizations.spectral_norm

+		    

torch.nn.utils.parametrize.register_parametrization

+		    

torch.nn.utils.parametrize.remove_parametrizations

+		    

torch.nn.utils.parametrize.cached

+		    

torch.nn.utils.parametrize.is_parametrized

+		    

torch.nn.utils.parametrize.ParametrizationList

+

Y

+		  

torch.nn.utils.parametrize.ParametrizationList.right_inverse

+

Y

+		  

torch.nn.utils.stateless.functional_call

+		    

torch.nn.utils.rnn.PackedSequence

+

Y

+		  

torch.nn.utils.rnn.PackedSequence.batch_sizes

+		    

torch.nn.utils.rnn.PackedSequence.count

+

Y

+		  

torch.nn.utils.rnn.PackedSequence.data

+		    

torch.nn.utils.rnn.PackedSequence.index

+

Y

+		  

torch.nn.utils.rnn.PackedSequence.is_cuda

+		    

torch.nn.utils.rnn.PackedSequence.is_pinned

+

Y

+		  

torch.nn.utils.rnn.PackedSequence.sorted_indices

+		    

torch.nn.utils.rnn.PackedSequence.to

+

Y

+		  

torch.nn.utils.rnn.PackedSequence.unsorted_indices

+		    

torch.nn.utils.rnn.pack_padded_sequence

+		    

torch.nn.utils.rnn.pad_packed_sequence

+		    

torch.nn.utils.rnn.pad_sequence

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.utils.rnn.pack_sequence

+		    

torch.nn.utils.rnn.unpack_sequence

+		    

torch.nn.utils.rnn.unpad_sequence

+		    

torch.nn.Flatten

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.Unflatten

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.modules.lazy.LazyModuleMixin

+

Y

+		  

torch.nn.modules.lazy.LazyModuleMixin.has_uninitialized_params

+

Y

+		  

torch.nn.modules.lazy.LazyModuleMixin.initialize_parameters

+

Y

+		  
+ +## torch.nn.functional + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.nn.functional.conv1d

+		    

torch.nn.functional.conv2d

+		    

torch.nn.functional.conv3d

+		    

torch.nn.functional.conv_transpose1d

+		    

torch.nn.functional.conv_transpose2d

+		    

torch.nn.functional.conv_transpose3d

+		    

torch.nn.functional.unfold

+		    

torch.nn.functional.fold

+		    

torch.nn.functional.avg_pool1d

+		    

torch.nn.functional.avg_pool2d

+		    

torch.nn.functional.avg_pool3d

+		    

torch.nn.functional.max_pool1d

+		    

torch.nn.functional.max_pool2d

+		    

torch.nn.functional.max_pool3d

+		    

torch.nn.functional.max_unpool1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.max_unpool2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.max_unpool3d

+		    

torch.nn.functional.lp_pool1d

+		    

torch.nn.functional.lp_pool2d

+		    

torch.nn.functional.adaptive_max_pool1d

+		    

torch.nn.functional.adaptive_max_pool2d

+		    

torch.nn.functional.adaptive_max_pool3d

+		    

torch.nn.functional.adaptive_avg_pool1d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.adaptive_avg_pool2d

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.adaptive_avg_pool3d

+		    

torch.nn.functional.fractional_max_pool2d

+		    

torch.nn.functional.fractional_max_pool3d

+		    

torch.nn.functional.scaled_dot_product_attention

+		    

torch.nn.functional.threshold

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.functional.threshold_

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.functional.relu

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.functional.relu_

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.functional.hardtanh

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.hardtanh_

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.hardswish

+

Y

+

Only support fp16，fp32

+

torch.nn.functional.relu6

+		    

torch.nn.functional.elu

+		    

torch.nn.functional.elu_

+		    

torch.nn.functional.selu

+		    

torch.nn.functional.celu

+		    

torch.nn.functional.leaky_relu

+

Y

+

Only support fp16，fp32

+

torch.nn.functional.leaky_relu_

+

Y

+

Only support fp16，fp32

+

torch.nn.functional.prelu

+		    

torch.nn.functional.rrelu

+		    

torch.nn.functional.rrelu_

+		    

torch.nn.functional.glu

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.gelu

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.logsigmoid

+		    

torch.nn.functional.hardshrink

+		    

torch.nn.functional.tanhshrink

+		    

torch.nn.functional.softsign

+		    

torch.nn.functional.softplus

+

Y

+

Only support fp16，fp32

+

torch.nn.functional.softmin

+		    

torch.nn.functional.softmax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.softshrink

+		    

torch.nn.functional.gumbel_softmax

+		    

torch.nn.functional.log_softmax

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.tanh

+

Y

+

Only support fp16，fp32，int64

+

torch.nn.functional.sigmoid

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.hardsigmoid

+

Y

+

Only support fp16，fp32

+

torch.nn.functional.silu

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.mish

+		    

torch.nn.functional.batch_norm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.group_norm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.instance_norm

+		    

torch.nn.functional.layer_norm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.local_response_norm

+		    

torch.nn.functional.normalize

+		    

torch.nn.functional.linear

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.bilinear

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.dropout

+		    

torch.nn.functional.alpha_dropout

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.feature_alpha_dropout

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.dropout1d

+		    

torch.nn.functional.dropout2d

+		    

torch.nn.functional.dropout3d

+		    

torch.nn.functional.embedding

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.embedding_bag

+		    

torch.nn.functional.one_hot

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.pairwise_distance

+		    

torch.nn.functional.cosine_similarity

+		    

torch.nn.functional.pdist

+		    

torch.nn.functional.binary_cross_entropy

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.binary_cross_entropy_with_logits

+		    

torch.nn.functional.poisson_nll_loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.cosine_embedding_loss

+		    

torch.nn.functional.cross_entropy

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.ctc_loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.gaussian_nll_loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.hinge_embedding_loss

+		    

torch.nn.functional.kl_div

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.l1_loss

+		    

torch.nn.functional.mse_loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.margin_ranking_loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.multilabel_margin_loss

+		    

torch.nn.functional.multilabel_soft_margin_loss

+		    

torch.nn.functional.multi_margin_loss

+		    

torch.nn.functional.nll_loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.huber_loss

+		    

torch.nn.functional.smooth_l1_loss

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.soft_margin_loss

+		    

torch.nn.functional.triplet_margin_loss

+		    

torch.nn.functional.triplet_margin_with_distance_loss

+		    

torch.nn.functional.pixel_shuffle

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.pixel_unshuffle

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.pad

+		    

torch.nn.functional.interpolate

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.upsample

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.upsample_nearest

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.upsample_bilinear

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.nn.functional.grid_sample

+		    

torch.nn.functional.affine_grid

+		    

torch.nn.parallel.data_parallel

+		    
+ +## torch.Tensor + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.Tensor

+

Y

+		  

Tensor.T

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.H

+		    

Tensor.mT

+		    

Tensor.mH

+		    

Tensor.new_tensor

+		    

Tensor.new_full

+

Y

+		  

Tensor.new_empty

+

Y

+		  

Tensor.new_ones

+

Y

+		  

Tensor.new_zeros

+

Y

+		  

Tensor.is_cuda

+		    

Tensor.is_quantized

+		    

Tensor.is_meta

+		    

Tensor.device

+		    

Tensor.grad

+

Y

+		  

Tensor.ndim

+

Y

+		  

Tensor.real

+		    

Tensor.imag

+		    

Tensor.nbytes

+		    

Tensor.itemsize

+		    

Tensor.abs

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.abs_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.absolute

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.absolute_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.acos

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.acos_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arccos

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arccos_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.add

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.add_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addbmm

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addbmm_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addcdiv

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addcdiv_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addcmul

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addcmul_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addmm

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addmm_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sspaddmm

+		    

Tensor.addmv

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addmv_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addr

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.addr_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.adjoint

+		    

Tensor.allclose

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.amax

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.amin

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.aminmax

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.angle

+		    

Tensor.apply_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.argmax

+

Y

+

Only support fp16，fp32，int64

+

Tensor.argmin

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.argsort

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.argwhere

+		    

Tensor.asin

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.asin_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arcsin

+		    

Tensor.arcsin_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.as_strided

+		    

Tensor.atan

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.atan_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arctan

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arctan_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.atan2

+		    

Tensor.atan2_

+		    

Tensor.arctan2

+		    

Tensor.arctan2_

+		    

Tensor.all

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.any

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.backward

+

Y

+		  

Tensor.baddbmm

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.baddbmm_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bernoulli

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bernoulli_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bfloat16

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bincount

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_not

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_not_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_and

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_and_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_or

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_or_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_xor

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_xor_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bitwise_left_shift

+		    

Tensor.bitwise_left_shift_

+		    

Tensor.bitwise_right_shift

+		    

Tensor.bitwise_right_shift_

+		    

Tensor.bmm

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.bool

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.byte

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.broadcast_to

+		    

Tensor.cauchy_

+		    

Tensor.ceil

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.ceil_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.char

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.cholesky

+		    

Tensor.cholesky_inverse

+		    

Tensor.cholesky_solve

+		    

Tensor.chunk

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.clamp

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.clamp_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.clip

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.clip_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.clone

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.contiguous

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.copy_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.conj

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.conj_physical

+		    

Tensor.conj_physical_

+		    

Tensor.resolve_conj

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.resolve_neg

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.copysign

+		    

Tensor.copysign_

+		    

Tensor.cos

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.cos_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.cosh

+

Y

+

Only support fp16，fp32

+

Tensor.cosh_

+

Y

+

Only support fp16，fp32

+

Tensor.corrcoef

+		    

Tensor.count_nonzero

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.cov

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.acosh

+

Y

+

Only support fp16，fp32

+

Tensor.acosh_

+

Y

+

Only support fp16，fp32

+

Tensor.arccosh

+

Y

+

Only support fp16，fp32

+

Tensor.arccosh_

+

Y

+

Only support fp16，fp32

+

Tensor.cpu

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.cross

+		    

Tensor.cuda

+		    

Tensor.logcumsumexp

+		    

Tensor.cummax

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.cummin

+		    

Tensor.cumprod

+		    

Tensor.cumprod_

+		    

Tensor.cumsum

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.cumsum_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.chalf

+		    

Tensor.cfloat

+		    

Tensor.cdouble

+		    

Tensor.data_ptr

+

Y

+		  

Tensor.deg2rad

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.dequantize

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.det

+		    

Tensor.dense_dim

+		    

Tensor.detach

+

Y

+		  

Tensor.detach_

+

Y

+		  

Tensor.diag

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.diag_embed

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.diagflat

+		    

Tensor.diagonal

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.diagonal_scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.fill_diagonal_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.fmax

+		    

Tensor.fmin

+		    

Tensor.diff

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.digamma

+		    

Tensor.digamma_

+		    

Tensor.dim

+

Y

+		  

Tensor.dim_order

+		    

Tensor.dist

+		    

Tensor.div

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.div_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.divide

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.divide_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.dot

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.double

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.dsplit

+

Y

+		  

Tensor.element_size

+

Y

+		  

Tensor.eq

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.eq_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.equal

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.erf

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.erf_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.erfc

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.erfc_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.erfinv

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.erfinv_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.exp

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.exp_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.expm1

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.expm1_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.expand

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.expand_as

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.exponential_

+		    

Tensor.fix

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.fix_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.fill_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.flatten

+

Y

+		  

Tensor.flip

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.fliplr

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.flipud

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.float

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.float_power

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.float_power_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.floor

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.floor_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.floor_divide

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.floor_divide_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.fmod

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.fmod_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.frac

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.frac_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.frexp

+		    

Tensor.gather

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.gcd

+		    

Tensor.gcd_

+		    

Tensor.ge

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.ge_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.greater_equal

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.greater_equal_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.geometric_

+		    

Tensor.geqrf

+		    

Tensor.ger

+		    

Tensor.get_device

+		    

Tensor.gt

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.gt_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.greater

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.greater_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.half

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.hardshrink

+		    

Tensor.heaviside

+		    

Tensor.histc

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.histogram

+		    

Tensor.hsplit

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.hypot

+		    

Tensor.hypot_

+		    

Tensor.i0

+		    

Tensor.i0_

+		    

Tensor.igamma

+		    

Tensor.igamma_

+		    

Tensor.igammac

+		    

Tensor.igammac_

+		    

Tensor.index_add_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.index_add

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.index_copy_

+		    

Tensor.index_copy

+		    

Tensor.index_fill_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.index_fill

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.index_put_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.index_put

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.index_reduce_

+		    

Tensor.index_reduce

+		    

Tensor.index_select

+		    

Tensor.indices

+		    

Tensor.inner

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.int

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.int_repr

+		    

Tensor.inverse

+		    

Tensor.isclose

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.isfinite

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.isinf

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.isposinf

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.isneginf

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.isnan

+

Y

+		  

Tensor.is_contiguous

+

Y

+		  

Tensor.is_complex

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.is_conj

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.is_floating_point

+

Y

+		  

Tensor.is_inference

+

Y

+		  

Tensor.is_leaf

+		    

Tensor.is_pinned

+

Y

+		  

Tensor.is_set_to

+

Y

+		  

Tensor.is_shared

+		    

Tensor.is_signed

+

Y

+		  

Tensor.is_sparse

+

Y

+		  

Tensor.istft

+		    

Tensor.isreal

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.item

+

Y

+		  

Tensor.kthvalue

+

Y

+

Only support fp16，fp32

+

Tensor.lcm

+		    

Tensor.lcm_

+		    

Tensor.ldexp

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.ldexp_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.le

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.le_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.less_equal

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.less_equal_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.lerp

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.lerp_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.lgamma

+		    

Tensor.lgamma_

+		    

Tensor.log

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.log_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logdet

+		    

Tensor.log10

+		    

Tensor.log10_

+		    

Tensor.log1p

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.log1p_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.log2

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.log2_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.log_normal_

+		    

Tensor.logaddexp

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logaddexp2

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logsumexp

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_and

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_and_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_not

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_not_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_or

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_or_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_xor

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logical_xor_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.logit

+		    

Tensor.logit_

+		    

Tensor.long

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.lt

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.lt_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.less

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.less_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.lu

+		    

Tensor.lu_solve

+		    

Tensor.as_subclass

+		    

Tensor.map_

+

Y

+		  

Tensor.masked_scatter_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.masked_scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.masked_fill_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.masked_fill

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.masked_select

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.matmul

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.matrix_power

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.matrix_exp

+		    

Tensor.max

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.maximum

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.mean

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.nanmean

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.median

+

Y

+

Only support fp16，fp32，int64

+

Tensor.nanmedian

+		    

Tensor.min

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.minimum

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.mm

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.smm

+		    

Tensor.mode

+		    

Tensor.movedim

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.moveaxis

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.msort

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.mul

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.mul_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.multiply

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.multiply_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.multinomial

+		    

Tensor.mv

+		    

Tensor.mvlgamma

+		    

Tensor.mvlgamma_

+		    

Tensor.nansum

+		    

Tensor.narrow

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.narrow_copy

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.ndimension

+

Y

+		  

Tensor.nan_to_num

+		    

Tensor.nan_to_num_

+		    

Tensor.ne

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.ne_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.not_equal

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.not_equal_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.neg

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.neg_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.negative

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.negative_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.nelement

+

Y

+		  

Tensor.nextafter

+		    

Tensor.nextafter_

+		    

Tensor.nonzero

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.norm

+		    

Tensor.normal_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.numel

+

Y

+		  

Tensor.numpy

+

Y

+		  

Tensor.orgqr

+		    

Tensor.ormqr

+		    

Tensor.outer

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.permute

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.pin_memory

+		    

Tensor.pinverse

+		    

Tensor.polygamma

+		    

Tensor.polygamma_

+		    

Tensor.positive

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.pow

+		    

Tensor.pow_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.prod

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.put_

+		    

Tensor.qr

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.qscheme

+		    

Tensor.quantile

+		    

Tensor.nanquantile

+		    

Tensor.q_scale

+		    

Tensor.q_zero_point

+		    

Tensor.q_per_channel_scales

+		    

Tensor.q_per_channel_zero_points

+		    

Tensor.q_per_channel_axis

+		    

Tensor.rad2deg

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.random_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.ravel

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.reciprocal

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.reciprocal_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.record_stream

+		    

Tensor.register_hook

+

Y

+		  

Tensor.register_post_accumulate_grad_hook

+		    

Tensor.remainder

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.remainder_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.renorm

+		    

Tensor.renorm_

+		    

Tensor.repeat

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.repeat_interleave

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.requires_grad

+		    

Tensor.requires_grad_

+

Y

+		  

Tensor.reshape

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.reshape_as

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.resize_

+		    

Tensor.resize_as_

+		    

Tensor.retain_grad

+

Y

+		  

Tensor.retains_grad

+

Y

+		  

Tensor.roll

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.rot90

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.round

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.round_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.rsqrt

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.rsqrt_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.scatter_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.scatter_add_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.scatter_add

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.scatter_reduce_

+		    

Tensor.scatter_reduce

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.select

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.select_scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.set_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.share_memory_

+		    

Tensor.short

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sigmoid

+		    

Tensor.sigmoid_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sign

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sign_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.signbit

+		    

Tensor.sgn

+		    

Tensor.sgn_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sin

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sin_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sinc

+		    

Tensor.sinc_

+		    

Tensor.sinh

+

Y

+

Only support fp16，fp32

+

Tensor.sinh_

+

Y

+

Only support fp16，fp32

+

Tensor.asinh

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.asinh_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arcsinh

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arcsinh_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.shape

+		    

Tensor.size

+

Y

+		  

Tensor.slogdet

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.slice_scatter

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.softmax

+		    

Tensor.sort

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.split

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sparse_mask

+		    

Tensor.sparse_dim

+		    

Tensor.sqrt

+

Y

+

Only support fp16，fp32

+

Tensor.sqrt_

+

Y

+

Only support fp16，fp32

+

Tensor.square

+

Y

+

Only support fp16，fp32，int64

+

Tensor.square_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.squeeze

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.squeeze_

+

Y

+		  

Tensor.std

+

Y

+

Only support fp16，fp32

+

Tensor.stft

+		    

Tensor.storage

+

Y

+		  

Tensor.untyped_storage

+

Y

+		  

Tensor.storage_offset

+

Y

+		  

Tensor.storage_type

+

Y

+		  

Tensor.stride

+

Y

+		  

Tensor.sub

+

Y

+

Only support fp16，fp32，int64

+

Tensor.sub_

+

Y

+

Only support fp16，fp32，int64

+

Tensor.subtract

+		    

Tensor.subtract_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sum

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.sum_to_size

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.svd

+		    

Tensor.swapaxes

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.swapdims

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.t

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.t_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.tensor_split

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.tile

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.to

+

Y

+

Only support fp16，fp32，int64，bool

+

to

+		    

torch.to

+		    

Tensor.to_mkldnn

+		    

Tensor.take

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.take_along_dim

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.tan

+

Y

+

Only support fp16，fp32，int64

+

Tensor.tan_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.tanh

+

Y

+

Only support fp16，fp32，int64

+

Tensor.tanh_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.atanh

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.atanh_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.arctanh

+		    

Tensor.arctanh_

+		    

Tensor.tolist

+

Y

+		  

Tensor.topk

+

Y

+

Only support fp16，fp32，int64，bool；Don`t support sorted=False

+

Tensor.to_dense

+		    

Tensor.to_sparse

+		    

to_sparse

+		    

Tensor.to_sparse_csr

+		    

Tensor.to_sparse_csc

+		    

Tensor.to_sparse_bsr

+		    

Tensor.to_sparse_bsc

+		    

Tensor.trace

+		    

Tensor.transpose

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.transpose_

+		    

Tensor.triangular_solve

+		    

Tensor.tril

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.tril_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.triu

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.triu_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.true_divide

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.true_divide_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.trunc

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.trunc_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.type

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.type_as

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.unbind

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.unflatten

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.unfold

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.uniform_

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.unique

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.unique_consecutive

+		    

Tensor.unsqueeze

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.unsqueeze_

+

Y

+		  

Tensor.values

+		    

Tensor.var

+

Y

+

Only support fp16，fp32

+

Tensor.vdot

+		    

Tensor.view

+

Y

+

Only support fp16，fp32，int64，bool

+

view

+		    

Tensor.view_as

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.vsplit

+

Y

+

Only support fp16，fp32，int64，bool

+

Tensor.where

+

Y

+

Only support fp16，fp32，int64，bool；Don`t support 8-dimensional shape

+

Tensor.xlogy

+

Y

+

Only support fp16，fp32

+

Tensor.xlogy_

+

Y

+

Only support fp16，fp32

+

Tensor.zero_

+

Y

+

Only support fp16，fp32，int64

+
+ +## Tensor Attributes + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.dtype

+

Y

+		  

torch.device

+

Y

+		  

torch.layout

+

Y

+		  

torch.memory_format

+		    
+ +## torch.autograd + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.autograd.Function

+

Y

+		  

torch.autograd.profiler.profile

+

Y

+		  

torch.autograd.profiler.emit_nvtx

+		    

torch.autograd.profiler.emit_itt

+		    

torch.autograd.detect_anomaly

+

Y

+		  

torch.autograd.set_detect_anomaly

+

Y

+		  

torch.autograd.graph.saved_tensors_hooks

+

Y

+		  

torch.autograd.graph.save_on_cpu

+

Y

+		  

torch.autograd.graph.disable_saved_tensors_hooks

+

Y

+		  

torch.autograd.graph.register_multi_grad_hook

+

Y

+		  

torch.autograd.graph.allow_mutation_on_saved_tensors

+

Y

+		  

torch.autograd.backward

+		    

torch.autograd.grad

+

Y

+		  

torch.autograd.forward_ad.dual_level

+

Y

+		  

torch.autograd.forward_ad.make_dual

+

Y

+		  

torch.autograd.forward_ad.unpack_dual

+

Y

+		  

torch.autograd.functional.jacobian

+

Y

+		  

torch.autograd.functional.hessian

+

Y

+		  

torch.autograd.functional.vjp

+

Y

+		  

torch.autograd.functional.jvp

+

Y

+		  

torch.autograd.functional.vhp

+

Y

+		  

torch.autograd.functional.hvp

+

Y

+		  

Function.forward

+		    

Function.backward

+		    

Function.jvp

+		    

Function.vmap

+		    

FunctionCtx.mark_dirty

+

Y

+		  

FunctionCtx.mark_non_differentiable

+

Y

+		  

FunctionCtx.save_for_backward

+

Y

+		  

FunctionCtx.set_materialize_grads

+

Y

+		  

torch.autograd.gradcheck

+

Y

+		  

torch.autograd.gradgradcheck

+

Y

+		  

profile.export_chrome_trace

+

Y

+		  

profile.key_averages

+

Y

+		  

profile.self_cpu_time_total

+		    

profile.total_average

+

Y

+		  

torch.autograd.profiler.load_nvprof

+		    

Node.name

+		    

Node.metadata

+		    

Node.next_functions

+		    

Node.register_hook

+		    

Node.register_prehook

+		    
+ +## torch.library + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.library.Library

+

Y

+		  

torch.library.Library.define

+

Y

+		  

torch.library.Library.impl

+

Y

+		  

torch.library.fallthrough_kernel

+		    
+ +## torch.cuda + +The cuda-related interfaces prefixed with torch.cuda correspond to the npu-related interfaces prefixed with torch.npu. When using them, you only need to replace ``torch.cuda.xxx`` with ``torch.npu.xxx``. + +Take torch.cuda.set_device as an example. + +```Python +... + +torch.cuda.set_device("cuda:0") +# torch.npu.set_device("cuda:0") + +... +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Ascend NPU API

+

Compatibility

+

Limitations

+

torch.cuda.can_device_access_peer

+

torch.npu.can_device_access_peer

+

Y

+		  

torch.cuda.current_blas_handle

+

torch.npu.current_blas_handle

+

Y

+		  

torch.cuda.current_device

+

torch.npu.current_device

+

Y

+		  

torch.cuda.device_count

+

torch.npu.device_count

+

Y

+		  

torch.cuda.device_of

+

torch.npu.device_of

+

Y

+		  

torch.cuda.get_device_name

+

torch.npu.get_device_name

+

Y

+		  

torch.cuda.get_device_properties

+

torch.npu.get_device_properties

+

Y

+		  

torch.cuda.get_sync_debug_mode

+

torch.npu.get_sync_debug_mode

+

Y

+		  

torch.cuda.init

+

torch.npu.init

+

Y

+		  

torch.cuda.is_available

+

torch.npu.is_available

+

Y

+		  

torch.cuda.is_initialized

+

torch.npu.is_initialized

+

Y

+		  

torch.cuda.set_device

+

torch.npu.set_device

+

Y

+		  

torch.cuda.set_stream

+

torch.npu.set_stream

+

Y

+		  

torch.cuda.set_sync_debug_mode

+

torch.npu.set_sync_debug_mode

+

Y

+		  

torch.cuda.stream

+

torch.npu.stream

+

Y

+		  

torch.cuda.utilization

+

torch.npu.utilization

+

Y

+		  

torch.cuda.get_rng_state

+

torch.npu.get_rng_state

+

Y

+		  

torch.cuda.set_rng_state

+

torch.npu.set_rng_state

+

Y

+		  

torch.cuda.set_rng_state_all

+

torch.npu.set_rng_state_all

+

Y

+		  

torch.cuda.manual_seed

+

torch.npu.manual_seed

+

Y

+		  

torch.cuda.manual_seed_all

+

torch.npu.manual_seed_all

+

Y

+		  

torch.cuda.seed

+

torch.npu.seed

+

Y

+		  

torch.cuda.seed_all

+

torch.npu.seed_all

+

Y

+		  

torch.cuda.initial_seed

+

torch.npu.initial_seed

+

Y

+		  

torch.cuda.Stream

+

torch.npu.Stream

+

Y

+		  

torch.cuda.Stream.wait_stream

+

torch.npu.Stream.wait_stream

+

Y

+		  

torch.cuda.Event

+

torch.npu.Event

+

Y

+		  

torch.cuda.Event.elapsed_time

+

torch.npu.Event.elapsed_time

+

Y

+		  

torch.cuda.Event.query

+

torch.npu.Event.query

+

Y

+		  

torch.cuda.Event.wait

+

torch.npu.Event.wait

+

Y

+		  

torch.cuda.empty_cache

+

torch.npu.empty_cache

+

Y

+		  

torch.cuda.memory_stats

+

torch.npu.memory_stats

+

Y

+		  

torch.cuda.memory_summary

+

torch.npu.memory_summary

+

Y

+		  

torch.cuda.memory_allocated

+

torch.npu.memory_allocated

+

Y

+		  

torch.cuda.max_memory_allocated

+

torch.npu.max_memory_allocated

+

Y

+		  

torch.cuda.reset_max_memory_allocated

+

torch.npu.reset_max_memory_allocated

+

Y

+		  

torch.cuda.memory_reserved

+

torch.npu.memory_reserved

+

Y

+		  

torch.cuda.max_memory_reserved

+

torch.npu.max_memory_reserved

+

Y

+		  

torch.cuda.set_per_process_memory_fraction

+

torch.npu.set_per_process_memory_fraction

+

Y

+		  

torch.cuda.memory_cached

+

torch.npu.memory_cached

+

Y

+		  

torch.cuda.max_memory_cached

+

torch.npu.max_memory_cached

+

Y

+		  

torch.cuda.reset_max_memory_cached

+

torch.npu.reset_max_memory_cached

+

Y

+		  

torch.cuda.reset_peak_memory_stats

+

torch.npu.reset_peak_memory_stats

+

Y

+		  

torch.cuda.caching_allocator_alloc

+

torch.npu.caching_allocator_alloc

+

Y

+		  

torch.cuda.caching_allocator_delete

+

torch.npu.caching_allocator_delete

+

Y

+		  

torch.cuda.StreamContext

+		      

torch.cuda.current_stream

+		      

torch.cuda.default_stream

+		      

torch.cuda.device

+		      

torch.cuda.get_arch_list

+		      

torch.cuda.get_device_capability

+		      

torch.cuda.get_gencode_flags

+		      

torch.cuda.ipc_collect

+		      

torch.cuda.memory_usage

+		      

torch.cuda.synchronize

+		      

torch.cuda.temperature

+		      

torch.cuda.power_draw

+		      

torch.cuda.clock_rate

+		      

torch.cuda.get_rng_state_all

+		      

torch.cuda.comm.broadcast

+		      

torch.cuda.comm.broadcast_coalesced

+		      

torch.cuda.comm.reduce_add

+		      

torch.cuda.comm.scatter

+		      

torch.cuda.comm.gather

+		      

torch.cuda.Stream.query

+		      

torch.cuda.Stream.record_event

+		      

torch.cuda.Stream.synchronize

+		      

torch.cuda.Stream.wait_event

+		      

torch.cuda.ExternalStream

+		      

torch.cuda.ExternalStream.query

+		      

torch.cuda.ExternalStream.record_event

+		      

torch.cuda.ExternalStream.synchronize

+		      

torch.cuda.ExternalStream.wait_event

+		      

torch.cuda.ExternalStream.wait_stream

+		      

torch.cuda.Event.from_ipc_handle

+		      

torch.cuda.Event.ipc_handle

+		      

torch.cuda.Event.record

+		      

torch.cuda.Event.synchronize

+		      

torch.cuda.is_current_stream_capturing

+		      

torch.cuda.graph_pool_handle

+		      

torch.cuda.CUDAGraph

+		      

torch.cuda.CUDAGraph.capture_begin

+		      

torch.cuda.CUDAGraph.capture_end

+		      

torch.cuda.CUDAGraph.debug_dump

+		      

torch.cuda.CUDAGraph.enable_debug_mode

+		      

torch.cuda.CUDAGraph.pool

+		      

torch.cuda.CUDAGraph.replay

+		      

torch.cuda.CUDAGraph.reset

+		      

torch.cuda.graph

+		      

torch.cuda.make_graphed_callables

+		      

torch.cuda.list_gpu_processes

+		      

torch.cuda.mem_get_info

+		      

torch.cuda.memory_snapshot

+		      

torch.cuda.get_allocator_backend

+		      

torch.cuda.CUDAPluggableAllocator

+		      

torch.cuda.change_current_allocator

+		      

torch.cuda.nvtx.mark

+		      

torch.cuda.nvtx.range_push

+		      

torch.cuda.nvtx.range_pop

+		      

torch.cuda.jiterator._create_jit_fn

+		      

torch.cuda.jiterator._create_multi_output_jit_fn

+		      

torch.cuda._sanitizer.enable_cuda_sanitizer

+		      
+ +## torch.cuda.amp + +Just like torch.cuda above, you only need to replace ``torch.cuda.amp.xxx`` with ``torch.npu.amp.xxx``. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Ascend NPU API

+

Compatibility

+

Limitations

+

torch.autocast

+

-

+

Y

+		  

torch.cuda.amp.autocast

+

torch.npu.amp.autocast

+

Y

+		  

torch.cuda.amp.custom_fwd

+		      

torch.cuda.amp.custom_bwd

+

torch.npu.amp.custom_bwd

+

Y

+		  

torch.cpu.amp.autocast

+

torch.cpu.amp.autocast

+

Y

+		  

torch.cuda.amp.GradScaler

+

torch.npu.amp.GradScaler

+

Y

+		  

torch.cuda.amp.GradScaler.get_backoff_factor

+

torch.npu.amp.GradScaler.get_backoff_factor

+

Y

+		  

torch.cuda.amp.GradScaler.get_growth_factor

+

torch.npu.amp.GradScaler.get_growth_factor

+

Y

+		  

torch.cuda.amp.GradScaler.get_growth_interval

+

torch.npu.amp.GradScaler.get_growth_interval

+

Y

+		  

torch.cuda.amp.GradScaler.get_scale

+

torch.npu.amp.GradScaler.get_scale

+

Y

+		  

torch.cuda.amp.GradScaler.is_enabled

+

torch.npu.amp.GradScaler.is_enabled

+

Y

+		  

torch.cuda.amp.GradScaler.load_state_dict

+

torch.npu.amp.GradScaler.load_state_dict

+

Y

+		  

torch.cuda.amp.GradScaler.scale

+

torch.npu.amp.GradScaler.scale

+

Y

+		  

torch.cuda.amp.GradScaler.set_backoff_factor

+

torch.npu.amp.GradScaler.set_backoff_factor

+

Y

+		  

torch.cuda.amp.GradScaler.set_growth_factor

+

torch.npu.amp.GradScaler.set_growth_factor

+

Y

+		  

torch.cuda.amp.GradScaler.set_growth_interval

+

torch.npu.amp.GradScaler.set_growth_interval

+

Y

+		  

torch.cuda.amp.GradScaler.state_dict

+

torch.npu.amp.GradScaler.state_dict

+

Y

+		  

torch.cuda.amp.GradScaler.step

+

torch.npu.amp.GradScaler.step

+

Y

+		  

torch.cuda.amp.GradScaler.unscale_

+

torch.npu.amp.GradScaler.unscale_

+

Y

+		  

torch.cuda.amp.GradScaler.update

+

torch.npu.amp.GradScaler.update

+

Y

+		  
+ +## torch.backends + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.backends.cpu.get_cpu_capability

+		    

torch.backends.cuda.is_built

+

Y

+		  

torch.backends.cuda.matmul.allow_tf32

+

Y

+		  

torch.backends.cuda.matmul.allow_fp16_reduced_precision_reduction

+		    

torch.backends.cuda.matmul.allow_bf16_reduced_precision_reduction

+		    

torch.backends.cuda.cufft_plan_cache

+		    

torch.backends.cuda.cufft_plan_cache.size

+		    

torch.backends.cuda.cufft_plan_cache.max_size

+		    

torch.backends.cuda.cufft_plan_cache.clear

+		    

torch.backends.cuda.preferred_linalg_library

+

Y

+		  

torch.backends.cuda.SDPBackend

+

Y

+		  

torch.backends.cuda.flash_sdp_enabled

+

Y

+		  

torch.backends.cuda.enable_mem_efficient_sdp

+

Y

+		  

torch.backends.cuda.mem_efficient_sdp_enabled

+

Y

+		  

torch.backends.cuda.enable_flash_sdp

+

Y

+		  

torch.backends.cuda.math_sdp_enabled

+

Y

+		  

torch.backends.cuda.enable_math_sdp

+

Y

+		  

torch.backends.cuda.sdp_kernel

+

Y

+		  

torch.backends.cudnn.version

+		    

torch.backends.cudnn.is_available

+

Y

+		  

torch.backends.cudnn.enabled

+

Y

+		  

torch.backends.cudnn.allow_tf32

+

Y

+		  

torch.backends.cudnn.deterministic

+

Y

+		  

torch.backends.cudnn.benchmark

+

Y

+		  

torch.backends.cudnn.benchmark_limit

+		    

torch.backends.mps.is_available

+

Y

+		  

torch.backends.mps.is_built

+

Y

+		  

torch.backends.mkl.is_available

+

Y

+		  

torch.backends.mkl.verbose

+

Y

+		  

torch.backends.mkldnn.is_available

+

Y

+		  

torch.backends.mkldnn.verbose

+

Y

+		  

torch.backends.openmp.is_available

+

Y

+		  

torch.backends.opt_einsum.is_available

+

Y

+		  

torch.backends.opt_einsum.get_opt_einsum

+

Y

+		  

torch.backends.opt_einsum.enabled

+		    

torch.backends.opt_einsum.strategy

+		    
+ +## torch.distributed + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.is_available

+

Y

+		  

torch.distributed.init_process_group

+

Y

+		  

torch.distributed.is_initialized

+

Y

+		  

torch.distributed.is_mpi_available

+

Y

+		  

torch.distributed.is_nccl_available

+

Y

+		  

torch.distributed.is_gloo_available

+

Y

+		  

torch.distributed.is_torchelastic_launched

+

Y

+		  

torch.distributed.Backend

+

Y

+		  

torch.distributed.Backend.register_backend

+		    

torch.distributed.get_backend

+

Y

+		  

torch.distributed.get_rank

+

Y

+		  

torch.distributed.get_world_size

+

Y

+		  

torch.distributed.Store

+

Y

+		  

torch.distributed.TCPStore

+

Y

+		  

torch.distributed.HashStore

+

Y

+		  

torch.distributed.FileStore

+

Y

+		  

torch.distributed.PrefixStore

+

Y

+		  

torch.distributed.Store.set

+

Y

+		  

torch.distributed.Store.get

+

Y

+		  

torch.distributed.Store.add

+

Y

+		  

torch.distributed.Store.compare_set

+

Y

+		  

torch.distributed.Store.wait

+

Y

+		  

torch.distributed.Store.num_keys

+

Y

+		  

torch.distributed.Store.delete_key

+

Y

+		  

torch.distributed.Store.set_timeout

+

Y

+		  

torch.distributed.new_group

+

Y

+		  

torch.distributed.get_group_rank

+

Y

+		  

torch.distributed.get_global_rank

+

Y

+		  

torch.distributed.get_process_group_ranks

+

Y

+		  

torch.distributed.send

+

Y

+		  

torch.distributed.recv

+

Y

+		  

torch.distributed.isend

+		    

torch.distributed.irecv

+		    

torch.distributed.batch_isend_irecv

+		    

torch.distributed.P2POp

+

Y

+		  

torch.distributed.broadcast

+

Y

+		  

torch.distributed.broadcast_object_list

+

Y

+		  

torch.distributed.all_reduce

+

Y

+		  

torch.distributed.reduce

+		    

torch.distributed.all_gather

+

Y

+		  

torch.distributed.all_gather_into_tensor

+

Y

+		  

torch.distributed.all_gather_object

+

Y

+		  

torch.distributed.gather

+		    

torch.distributed.gather_object

+		    

torch.distributed.scatter

+		    

torch.distributed.scatter_object_list

+		    

torch.distributed.reduce_scatter

+

Y

+		  

torch.distributed.reduce_scatter_tensor

+

Y

+		  

torch.distributed.all_to_all_single

+

Y

+		  

torch.distributed.all_to_all

+

Y

+		  

torch.distributed.barrier

+

Y

+		  

torch.distributed.monitored_barrier

+		    

torch.distributed.ReduceOp

+

Y

+		  

torch.distributed.reduce_op

+

Y

+		  

torch.distributed.broadcast_multigpu

+		    

torch.distributed.all_reduce_multigpu

+		    

torch.distributed.reduce_multigpu

+		    

torch.distributed.all_gather_multigpu

+		    

torch.distributed.reduce_scatter_multigpu

+		    

torch.distributed.DistBackendError

+

Y

+		  
+ +## torch.distributed.algorithms.join + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.algorithms.Join

+

Y

+		  

torch.distributed.algorithms.Join.notify_join_context

+		    

torch.distributed.algorithms.Joinable

+

Y

+		  

torch.distributed.algorithms.Joinable.join_device

+		    

torch.distributed.algorithms.Joinable.join_hook

+		    

torch.distributed.algorithms.Joinable.join_process_group

+		    

torch.distributed.algorithms.JoinHook

+

Y

+		  

torch.distributed.algorithms.JoinHook.main_hook

+

Y

+		  

torch.distributed.algorithms.JoinHook.post_hook

+

Y

+		  
+ +## torch.distributed.elastic + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.elastic.agent.server.ElasticAgent

+		    

torch.distributed.elastic.agent.server.ElasticAgent.get_worker_group

+		    

torch.distributed.elastic.agent.server.ElasticAgent.run

+		    

torch.distributed.elastic.agent.server.WorkerSpec

+		    

torch.distributed.elastic.agent.server.WorkerSpec.get_entrypoint_name

+		    

torch.distributed.elastic.agent.server.WorkerState

+		    

torch.distributed.elastic.agent.server.WorkerState.is_running

+		    

torch.distributed.elastic.agent.server.Worker

+		    

torch.distributed.elastic.agent.server.WorkerGroup

+		    

torch.distributed.elastic.agent.server.local_elastic_agent.LocalElasticAgent

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._assign_worker_ranks

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._exit_barrier

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._initialize_workers

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._monitor_workers

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._rendezvous

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._restart_workers

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._shutdown

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._start_workers

+		    

torch.distributed.elastic.agent.server.SimpleElasticAgent._stop_workers

+		    

torch.distributed.elastic.agent.server.api.RunResult

+		    

torch.distributed.elastic.multiprocessing.start_processes

+		    

torch.distributed.elastic.multiprocessing.api.PContext

+		    

torch.distributed.elastic.multiprocessing.api.MultiprocessContext

+		    

torch.distributed.elastic.multiprocessing.api.SubprocessContext

+		    

torch.distributed.elastic.multiprocessing.api.RunProcsResult

+		    

torch.distributed.elastic.multiprocessing.errors.record

+		    

torch.distributed.elastic.multiprocessing.errors.ChildFailedError

+		    

torch.distributed.elastic.multiprocessing.errors.ErrorHandler

+		    

torch.distributed.elastic.multiprocessing.errors.ProcessFailure

+		    

torch.distributed.elastic.rendezvous.RendezvousParameters

+		    

torch.distributed.elastic.rendezvous.RendezvousParameters.get

+		    

torch.distributed.elastic.rendezvous.RendezvousParameters.get_as_bool

+		    

torch.distributed.elastic.rendezvous.RendezvousParameters.get_as_int

+		    

torch.distributed.elastic.rendezvous.RendezvousHandlerRegistry

+		    

torch.distributed.elastic.rendezvous.RendezvousHandlerRegistry.create_handler

+		    

torch.distributed.elastic.rendezvous.RendezvousHandlerRegistry.register

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler.get_backend

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler.get_run_id

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler.is_closed

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler.next_rendezvous

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler.num_nodes_waiting

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler.set_closed

+		    

torch.distributed.elastic.rendezvous.RendezvousHandler.shutdown

+		    

torch.distributed.elastic.rendezvous.RendezvousError

+		    

torch.distributed.elastic.rendezvous.RendezvousClosedError

+		    

torch.distributed.elastic.rendezvous.RendezvousTimeoutError

+		    

torch.distributed.elastic.rendezvous.RendezvousConnectionError

+		    

torch.distributed.elastic.rendezvous.RendezvousStateError

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.create_handler

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.DynamicRendezvousHandler

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.DynamicRendezvousHandler.from_backend

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousBackend

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousBackend.get_state

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousBackend.name

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousBackend.set_state

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousTimeout

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousTimeout.close

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousTimeout.heartbeat

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousTimeout.join

+		    

torch.distributed.elastic.rendezvous.dynamic_rendezvous.RendezvousTimeout.last_call

+		    

torch.distributed.elastic.rendezvous.c10d_rendezvous_backend.create_backend

+		    

torch.distributed.elastic.rendezvous.c10d_rendezvous_backend.C10dRendezvousBackend

+		    

torch.distributed.elastic.rendezvous.c10d_rendezvous_backend.C10dRendezvousBackend.get_state

+		    

torch.distributed.elastic.rendezvous.c10d_rendezvous_backend.C10dRendezvousBackend.name

+		    

torch.distributed.elastic.rendezvous.c10d_rendezvous_backend.C10dRendezvousBackend.set_state

+		    

torch.distributed.elastic.rendezvous.etcd_rendezvous_backend.create_backend

+		    

torch.distributed.elastic.rendezvous.etcd_rendezvous_backend.EtcdRendezvousBackend

+		    

torch.distributed.elastic.rendezvous.etcd_rendezvous_backend.EtcdRendezvousBackend.get_state

+		    

torch.distributed.elastic.rendezvous.etcd_rendezvous_backend.EtcdRendezvousBackend.name

+		    

torch.distributed.elastic.rendezvous.etcd_rendezvous_backend.EtcdRendezvousBackend.set_state

+		    

torch.distributed.elastic.rendezvous.etcd_rendezvous.EtcdRendezvousHandler

+		    

torch.distributed.elastic.rendezvous.etcd_store.EtcdStore

+		    

torch.distributed.elastic.rendezvous.etcd_store.EtcdStore.add

+		    

torch.distributed.elastic.rendezvous.etcd_store.EtcdStore.check

+		    

torch.distributed.elastic.rendezvous.etcd_store.EtcdStore.get

+		    

torch.distributed.elastic.rendezvous.etcd_store.EtcdStore.set

+		    

torch.distributed.elastic.rendezvous.etcd_store.EtcdStore.wait

+		    

torch.distributed.elastic.rendezvous.etcd_server.EtcdServer

+		    

torch.distributed.elastic.timer.configure

+		    

torch.distributed.elastic.timer.expires

+		    

torch.distributed.elastic.timer.LocalTimerServer

+		    

torch.distributed.elastic.timer.LocalTimerClient

+		    

torch.distributed.elastic.timer.FileTimerServer

+		    

torch.distributed.elastic.timer.FileTimerClient

+		    

torch.distributed.elastic.timer.TimerRequest

+		    

torch.distributed.elastic.timer.TimerServer

+		    

torch.distributed.elastic.timer.TimerServer.clear_timers

+		    

torch.distributed.elastic.timer.TimerServer.get_expired_timers

+		    

torch.distributed.elastic.timer.TimerServer.register_timers

+		    

torch.distributed.elastic.timer.TimerClient

+		    

torch.distributed.elastic.timer.TimerClient.acquire

+		    

torch.distributed.elastic.timer.TimerClient.release

+		    

torch.distributed.elastic.metrics.api.MetricHandler

+		    

torch.distributed.elastic.metrics.api.ConsoleMetricHandler

+		    

torch.distributed.elastic.metrics.api.NullMetricHandler

+		    

torch.distributed.elastic.metrics.configure

+		    

torch.distributed.elastic.metrics.prof

+		    

torch.distributed.elastic.metrics.put_metric

+		    

torch.distributed.elastic.events.record

+		    

torch.distributed.elastic.events.get_logging_handler

+		    

torch.distributed.elastic.events.api.Event

+		    

torch.distributed.elastic.events.api.EventSource

+		    

torch.distributed.elastic.events.api.EventMetadataValue

+		    
+ +## torch.distributed.fsdp + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.fsdp.FullyShardedDataParallel

+		    

torch.distributed.fsdp.FullyShardedDataParallel.apply

+

Y

+		  

torch.distributed.fsdp.FullyShardedDataParallel.clip_grad_norm_

+

Y

+		  

torch.distributed.fsdp.FullyShardedDataParallel.flatten_sharded_optim_state_dict

+		    

torch.distributed.fsdp.FullyShardedDataParallel.forward

+

Y

+		  

torch.distributed.fsdp.FullyShardedDataParallel.fsdp_modules

+		    

torch.distributed.fsdp.FullyShardedDataParallel.full_optim_state_dict

+		    

torch.distributed.fsdp.FullyShardedDataParallel.get_state_dict_type

+		    

torch.distributed.fsdp.FullyShardedDataParallel.module

+		    

torch.distributed.fsdp.FullyShardedDataParallel.named_buffers

+

Y

+		  

torch.distributed.fsdp.FullyShardedDataParallel.named_parameters

+

Y

+		  

torch.distributed.fsdp.FullyShardedDataParallel.no_sync

+		    

torch.distributed.fsdp.FullyShardedDataParallel.optim_state_dict

+		    

torch.distributed.fsdp.FullyShardedDataParallel.optim_state_dict_to_load

+		    

torch.distributed.fsdp.FullyShardedDataParallel.register_comm_hook

+

Y

+		  

torch.distributed.fsdp.FullyShardedDataParallel.rekey_optim_state_dict

+		    

torch.distributed.fsdp.FullyShardedDataParallel.scatter_full_optim_state_dict

+		    

torch.distributed.fsdp.FullyShardedDataParallel.set_state_dict_type

+		    

torch.distributed.fsdp.FullyShardedDataParallel.shard_full_optim_state_dict

+		    

torch.distributed.fsdp.FullyShardedDataParallel.sharded_optim_state_dict

+		    

torch.distributed.fsdp.FullyShardedDataParallel.state_dict_type

+		    

torch.distributed.fsdp.FullyShardedDataParallel.summon_full_params

+		    

torch.distributed.fsdp.BackwardPrefetch

+

Y

+		  

torch.distributed.fsdp.ShardingStrategy

+

Y

+		  

torch.distributed.fsdp.MixedPrecision

+		    

torch.distributed.fsdp.CPUOffload

+

Y

+		  

torch.distributed.fsdp.StateDictConfig

+		    

torch.distributed.fsdp.FullStateDictConfig

+		    

torch.distributed.fsdp.ShardedStateDictConfig

+		    

torch.distributed.fsdp.LocalStateDictConfig

+		    

torch.distributed.fsdp.OptimStateDictConfig

+		    

torch.distributed.fsdp.FullOptimStateDictConfig

+		    

torch.distributed.fsdp.ShardedOptimStateDictConfig

+		    

torch.distributed.fsdp.LocalOptimStateDictConfig

+		    

torch.distributed.fsdp.StateDictSettings

+		    
+ +## torch.distributed.optim + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.optim.DistributedOptimizer

+		    

torch.distributed.optim.DistributedOptimizer.step

+		    

torch.distributed.optim.PostLocalSGDOptimizer

+

Y

+		  

torch.distributed.optim.PostLocalSGDOptimizer.load_state_dict

+

Y

+		  

torch.distributed.optim.PostLocalSGDOptimizer.state_dict

+

Y

+		  

torch.distributed.optim.PostLocalSGDOptimizer.step

+

Y

+		  

torch.distributed.optim.ZeroRedundancyOptimizer

+

Y

+		  

torch.distributed.optim.ZeroRedundancyOptimizer.add_param_group

+

Y

+		  

torch.distributed.optim.ZeroRedundancyOptimizer.consolidate_state_dict

+		    

torch.distributed.optim.ZeroRedundancyOptimizer.join_hook

+		    

torch.distributed.optim.ZeroRedundancyOptimizer.load_state_dict

+		    

torch.distributed.optim.ZeroRedundancyOptimizer.state_dict

+

Y

+		  

torch.distributed.optim.ZeroRedundancyOptimizer.step

+		    
+ +## torch.distributed.tensor.parallel + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.tensor.parallel.parallelize_module

+		    

torch.distributed.tensor.parallel.style.RowwiseParallel

+		    

torch.distributed.tensor.parallel.style.ColwiseParallel

+		    

torch.distributed.tensor.parallel.style.PairwiseParallel

+		    

torch.distributed.tensor.parallel.style.SequenceParallel

+		    

torch.distributed.tensor.parallel.style.make_input_replicate_1d

+		    

torch.distributed.tensor.parallel.style.make_input_reshard_replicate

+		    

torch.distributed.tensor.parallel.style.make_input_shard_1d

+		    

torch.distributed.tensor.parallel.style.make_input_shard_1d_last_dim

+		    

torch.distributed.tensor.parallel.style.make_output_replicate_1d

+		    

torch.distributed.tensor.parallel.style.make_output_reshard_tensor

+		    

torch.distributed.tensor.parallel.style.make_output_shard_1d

+		    

torch.distributed.tensor.parallel.style.make_output_tensor

+		    

torch.distributed.tensor.parallel.fsdp.enable_2d_with_fsdp

+		    

torch.distributed.tensor.parallel.ddp.pre_dp_module_transform

+		    
+ +## torch.distributed.checkpoint + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.checkpoint.load_state_dict

+		    

torch.distributed.checkpoint.save_state_dict

+		    

torch.distributed.checkpoint.StorageReader

+		    

torch.distributed.checkpoint.StorageReader.prepare_global_plan

+		    

torch.distributed.checkpoint.StorageReader.prepare_local_plan

+		    

torch.distributed.checkpoint.StorageReader.read_data

+		    

torch.distributed.checkpoint.StorageReader.read_metadata

+		    

torch.distributed.checkpoint.StorageReader.set_up_storage_reader

+		    

torch.distributed.checkpoint.StorageWriter

+		    

torch.distributed.checkpoint.StorageWriter.finish

+		    

torch.distributed.checkpoint.StorageWriter.prepare_global_plan

+		    

torch.distributed.checkpoint.StorageWriter.prepare_local_plan

+		    

torch.distributed.checkpoint.StorageWriter.set_up_storage_writer

+		    

torch.distributed.checkpoint.StorageWriter.write_data

+		    

torch.distributed.checkpoint.LoadPlanner

+		    

torch.distributed.checkpoint.LoadPlanner.commit_tensor

+		    

torch.distributed.checkpoint.LoadPlanner.create_global_plan

+		    

torch.distributed.checkpoint.LoadPlanner.create_local_plan

+		    

torch.distributed.checkpoint.LoadPlanner.finish_plan

+		    

torch.distributed.checkpoint.LoadPlanner.load_bytes

+		    

torch.distributed.checkpoint.LoadPlanner.resolve_tensor

+		    

torch.distributed.checkpoint.LoadPlanner.set_up_planner

+		    

torch.distributed.checkpoint.LoadPlan

+		    

torch.distributed.checkpoint.ReadItem

+		    

torch.distributed.checkpoint.SavePlanner

+		    

torch.distributed.checkpoint.SavePlanner.create_global_plan

+		    

torch.distributed.checkpoint.SavePlanner.create_local_plan

+		    

torch.distributed.checkpoint.SavePlanner.finish_plan

+		    

torch.distributed.checkpoint.SavePlanner.resolve_data

+		    

torch.distributed.checkpoint.SavePlanner.set_up_planner

+		    

torch.distributed.checkpoint.SavePlan

+		    

torch.distributed.checkpoint.WriteItem

+		    

torch.distributed.checkpoint.FileSystemReader

+		    

torch.distributed.checkpoint.FileSystemWriter

+		    

torch.distributed.checkpoint.DefaultSavePlanner

+		    

torch.distributed.checkpoint.DefaultSavePlanner.lookup_object

+		    

torch.distributed.checkpoint.DefaultSavePlanner.transform_object

+		    

torch.distributed.checkpoint.DefaultLoadPlanner

+		    

torch.distributed.checkpoint.DefaultLoadPlanner.lookup_tensor

+		    

torch.distributed.checkpoint.DefaultLoadPlanner.transform_tensor

+		    
+ +## torch.distributions + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributions.distribution.Distribution

+		    

torch.distributions.distribution.Distribution.arg_constraints

+		    

torch.distributions.distribution.Distribution.batch_shape

+		    

torch.distributions.distribution.Distribution.cdf

+		    

torch.distributions.distribution.Distribution.entropy

+		    

torch.distributions.distribution.Distribution.enumerate_support

+		    

torch.distributions.distribution.Distribution.event_shape

+		    

torch.distributions.distribution.Distribution.expand

+		    

torch.distributions.distribution.Distribution.icdf

+		    

torch.distributions.distribution.Distribution.log_prob

+		    

torch.distributions.distribution.Distribution.mean

+		    

torch.distributions.distribution.Distribution.mode

+		    

torch.distributions.distribution.Distribution.perplexity

+		    

torch.distributions.distribution.Distribution.rsample

+		    

torch.distributions.distribution.Distribution.sample

+		    

torch.distributions.distribution.Distribution.sample_n

+		    

torch.distributions.distribution.Distribution.set_default_validate_args

+		    

torch.distributions.distribution.Distribution.stddev

+		    

torch.distributions.distribution.Distribution.support

+		    

torch.distributions.distribution.Distribution.variance

+		    

torch.distributions.exp_family.ExponentialFamily

+		    

torch.distributions.exp_family.ExponentialFamily.entropy

+		    

torch.distributions.bernoulli.Bernoulli

+		    

torch.distributions.bernoulli.Bernoulli.arg_constraints

+		    

torch.distributions.bernoulli.Bernoulli.entropy

+		    

torch.distributions.bernoulli.Bernoulli.enumerate_support

+		    

torch.distributions.bernoulli.Bernoulli.expand

+		    

torch.distributions.bernoulli.Bernoulli.has_enumerate_support

+		    

torch.distributions.bernoulli.Bernoulli.log_prob

+		    

torch.distributions.bernoulli.Bernoulli.logits

+		    

torch.distributions.bernoulli.Bernoulli.mean

+		    

torch.distributions.bernoulli.Bernoulli.mode

+		    

torch.distributions.bernoulli.Bernoulli.param_shape

+		    

torch.distributions.bernoulli.Bernoulli.probs

+		    

torch.distributions.bernoulli.Bernoulli.sample

+		    

torch.distributions.bernoulli.Bernoulli.support

+		    

torch.distributions.bernoulli.Bernoulli.variance

+		    

torch.distributions.beta.Beta

+		    

torch.distributions.beta.Beta.arg_constraints

+		    

torch.distributions.beta.Beta.concentration0

+		    

torch.distributions.beta.Beta.concentration1

+		    

torch.distributions.beta.Beta.entropy

+		    

torch.distributions.beta.Beta.expand

+		    

torch.distributions.beta.Beta.has_rsample

+		    

torch.distributions.beta.Beta.log_prob

+		    

torch.distributions.beta.Beta.mean

+		    

torch.distributions.beta.Beta.mode

+		    

torch.distributions.beta.Beta.rsample

+		    

torch.distributions.beta.Beta.support

+		    

torch.distributions.beta.Beta.variance

+		    

torch.distributions.binomial.Binomial

+		    

torch.distributions.binomial.Binomial.arg_constraints

+		    

torch.distributions.binomial.Binomial.entropy

+		    

torch.distributions.binomial.Binomial.enumerate_support

+		    

torch.distributions.binomial.Binomial.expand

+		    

torch.distributions.binomial.Binomial.has_enumerate_support

+		    

torch.distributions.binomial.Binomial.log_prob

+		    

torch.distributions.binomial.Binomial.logits

+		    

torch.distributions.binomial.Binomial.mean

+		    

torch.distributions.binomial.Binomial.mode

+		    

torch.distributions.binomial.Binomial.param_shape

+		    

torch.distributions.binomial.Binomial.probs

+		    

torch.distributions.binomial.Binomial.sample

+		    

torch.distributions.binomial.Binomial.support

+		    

torch.distributions.binomial.Binomial.variance

+		    

torch.distributions.categorical.Categorical

+		    

torch.distributions.categorical.Categorical.arg_constraints

+		    

torch.distributions.categorical.Categorical.entropy

+		    

torch.distributions.categorical.Categorical.enumerate_support

+		    

torch.distributions.categorical.Categorical.expand

+		    

torch.distributions.categorical.Categorical.has_enumerate_support

+		    

torch.distributions.categorical.Categorical.log_prob

+		    

torch.distributions.categorical.Categorical.logits

+		    

torch.distributions.categorical.Categorical.mean

+		    

torch.distributions.categorical.Categorical.mode

+		    

torch.distributions.categorical.Categorical.param_shape

+		    

torch.distributions.categorical.Categorical.probs

+		    

torch.distributions.categorical.Categorical.sample

+		    

torch.distributions.categorical.Categorical.support

+		    

torch.distributions.categorical.Categorical.variance

+		    

torch.distributions.cauchy.Cauchy

+		    

torch.distributions.cauchy.Cauchy.arg_constraints

+		    

torch.distributions.cauchy.Cauchy.cdf

+		    

torch.distributions.cauchy.Cauchy.entropy

+		    

torch.distributions.cauchy.Cauchy.expand

+		    

torch.distributions.cauchy.Cauchy.has_rsample

+		    

torch.distributions.cauchy.Cauchy.icdf

+		    

torch.distributions.cauchy.Cauchy.log_prob

+		    

torch.distributions.cauchy.Cauchy.mean

+		    

torch.distributions.cauchy.Cauchy.mode

+		    

torch.distributions.cauchy.Cauchy.rsample

+		    

torch.distributions.cauchy.Cauchy.support

+		    

torch.distributions.cauchy.Cauchy.variance

+		    

torch.distributions.chi2.Chi2

+		    

torch.distributions.chi2.Chi2.arg_constraints

+		    

torch.distributions.chi2.Chi2.df

+		    

torch.distributions.chi2.Chi2.expand

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.arg_constraints

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.cdf

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.entropy

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.expand

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.has_rsample

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.icdf

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.log_prob

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.logits

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.mean

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.param_shape

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.probs

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.rsample

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.sample

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.stddev

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.support

+		    

torch.distributions.continuous_bernoulli.ContinuousBernoulli.variance

+		    

torch.distributions.dirichlet.Dirichlet

+		    

torch.distributions.dirichlet.Dirichlet.arg_constraints

+		    

torch.distributions.dirichlet.Dirichlet.entropy

+		    

torch.distributions.dirichlet.Dirichlet.expand

+		    

torch.distributions.dirichlet.Dirichlet.has_rsample

+		    

torch.distributions.dirichlet.Dirichlet.log_prob

+		    

torch.distributions.dirichlet.Dirichlet.mean

+		    

torch.distributions.dirichlet.Dirichlet.mode

+		    

torch.distributions.dirichlet.Dirichlet.rsample

+		    

torch.distributions.dirichlet.Dirichlet.support

+		    

torch.distributions.dirichlet.Dirichlet.variance

+		    

torch.distributions.exponential.Exponential

+		    

torch.distributions.exponential.Exponential.arg_constraints

+		    

torch.distributions.exponential.Exponential.cdf

+		    

torch.distributions.exponential.Exponential.entropy

+		    

torch.distributions.exponential.Exponential.expand

+		    

torch.distributions.exponential.Exponential.has_rsample

+		    

torch.distributions.exponential.Exponential.icdf

+		    

torch.distributions.exponential.Exponential.log_prob

+		    

torch.distributions.exponential.Exponential.mean

+		    

torch.distributions.exponential.Exponential.mode

+		    

torch.distributions.exponential.Exponential.rsample

+		    

torch.distributions.exponential.Exponential.stddev

+		    

torch.distributions.exponential.Exponential.support

+		    

torch.distributions.exponential.Exponential.variance

+		    

torch.distributions.fishersnedecor.FisherSnedecor

+		    

torch.distributions.fishersnedecor.FisherSnedecor.arg_constraints

+		    

torch.distributions.fishersnedecor.FisherSnedecor.expand

+		    

torch.distributions.fishersnedecor.FisherSnedecor.has_rsample

+		    

torch.distributions.fishersnedecor.FisherSnedecor.log_prob

+		    

torch.distributions.fishersnedecor.FisherSnedecor.mean

+		    

torch.distributions.fishersnedecor.FisherSnedecor.mode

+		    

torch.distributions.fishersnedecor.FisherSnedecor.rsample

+		    

torch.distributions.fishersnedecor.FisherSnedecor.support

+		    

torch.distributions.fishersnedecor.FisherSnedecor.variance

+		    

torch.distributions.gamma.Gamma

+		    

torch.distributions.gamma.Gamma.arg_constraints

+		    

torch.distributions.gamma.Gamma.cdf

+		    

torch.distributions.gamma.Gamma.entropy

+		    

torch.distributions.gamma.Gamma.expand

+		    

torch.distributions.gamma.Gamma.has_rsample

+		    

torch.distributions.gamma.Gamma.log_prob

+		    

torch.distributions.gamma.Gamma.mean

+		    

torch.distributions.gamma.Gamma.mode

+		    

torch.distributions.gamma.Gamma.rsample

+		    

torch.distributions.gamma.Gamma.support

+		    

torch.distributions.gamma.Gamma.variance

+		    

torch.distributions.geometric.Geometric

+		    

torch.distributions.geometric.Geometric.arg_constraints

+		    

torch.distributions.geometric.Geometric.entropy

+		    

torch.distributions.geometric.Geometric.expand

+		    

torch.distributions.geometric.Geometric.log_prob

+		    

torch.distributions.geometric.Geometric.logits

+		    

torch.distributions.geometric.Geometric.mean

+		    

torch.distributions.geometric.Geometric.mode

+		    

torch.distributions.geometric.Geometric.probs

+		    

torch.distributions.geometric.Geometric.sample

+		    

torch.distributions.geometric.Geometric.support

+		    

torch.distributions.geometric.Geometric.variance

+		    

torch.distributions.gumbel.Gumbel

+		    

torch.distributions.gumbel.Gumbel.arg_constraints

+		    

torch.distributions.gumbel.Gumbel.entropy

+		    

torch.distributions.gumbel.Gumbel.expand

+		    

torch.distributions.gumbel.Gumbel.log_prob

+		    

torch.distributions.gumbel.Gumbel.mean

+		    

torch.distributions.gumbel.Gumbel.mode

+		    

torch.distributions.gumbel.Gumbel.stddev

+		    

torch.distributions.gumbel.Gumbel.support

+		    

torch.distributions.gumbel.Gumbel.variance

+		    

torch.distributions.half_cauchy.HalfCauchy

+		    

torch.distributions.half_cauchy.HalfCauchy.arg_constraints

+		    

torch.distributions.half_cauchy.HalfCauchy.cdf

+		    

torch.distributions.half_cauchy.HalfCauchy.entropy

+		    

torch.distributions.half_cauchy.HalfCauchy.expand

+		    

torch.distributions.half_cauchy.HalfCauchy.has_rsample

+		    

torch.distributions.half_cauchy.HalfCauchy.icdf

+		    

torch.distributions.half_cauchy.HalfCauchy.log_prob

+		    

torch.distributions.half_cauchy.HalfCauchy.mean

+		    

torch.distributions.half_cauchy.HalfCauchy.mode

+		    

torch.distributions.half_cauchy.HalfCauchy.scale

+		    

torch.distributions.half_cauchy.HalfCauchy.support

+		    

torch.distributions.half_cauchy.HalfCauchy.variance

+		    

torch.distributions.half_normal.HalfNormal

+		    

torch.distributions.half_normal.HalfNormal.arg_constraints

+		    

torch.distributions.half_normal.HalfNormal.cdf

+		    

torch.distributions.half_normal.HalfNormal.entropy

+		    

torch.distributions.half_normal.HalfNormal.expand

+		    

torch.distributions.half_normal.HalfNormal.has_rsample

+		    

torch.distributions.half_normal.HalfNormal.icdf

+		    

torch.distributions.half_normal.HalfNormal.log_prob

+		    

torch.distributions.half_normal.HalfNormal.mean

+		    

torch.distributions.half_normal.HalfNormal.mode

+		    

torch.distributions.half_normal.HalfNormal.scale

+		    

torch.distributions.half_normal.HalfNormal.support

+		    

torch.distributions.half_normal.HalfNormal.variance

+		    

torch.distributions.independent.Independent

+		    

torch.distributions.independent.Independent.arg_constraints

+		    

torch.distributions.independent.Independent.entropy

+		    

torch.distributions.independent.Independent.enumerate_support

+		    

torch.distributions.independent.Independent.expand

+		    

torch.distributions.independent.Independent.has_enumerate_support

+		    

torch.distributions.independent.Independent.has_rsample

+		    

torch.distributions.independent.Independent.log_prob

+		    

torch.distributions.independent.Independent.mean

+		    

torch.distributions.independent.Independent.mode

+		    

torch.distributions.independent.Independent.rsample

+		    

torch.distributions.independent.Independent.sample

+		    

torch.distributions.independent.Independent.support

+		    

torch.distributions.independent.Independent.variance

+		    

torch.distributions.kumaraswamy.Kumaraswamy

+		    

torch.distributions.kumaraswamy.Kumaraswamy.arg_constraints

+		    

torch.distributions.kumaraswamy.Kumaraswamy.entropy

+		    

torch.distributions.kumaraswamy.Kumaraswamy.expand

+		    

torch.distributions.kumaraswamy.Kumaraswamy.has_rsample

+		    

torch.distributions.kumaraswamy.Kumaraswamy.mean

+		    

torch.distributions.kumaraswamy.Kumaraswamy.mode

+		    

torch.distributions.kumaraswamy.Kumaraswamy.support

+		    

torch.distributions.kumaraswamy.Kumaraswamy.variance

+		    

torch.distributions.lkj_cholesky.LKJCholesky

+		    

torch.distributions.lkj_cholesky.LKJCholesky.arg_constraints

+		    

torch.distributions.lkj_cholesky.LKJCholesky.expand

+		    

torch.distributions.lkj_cholesky.LKJCholesky.log_prob

+		    

torch.distributions.lkj_cholesky.LKJCholesky.sample

+		    

torch.distributions.lkj_cholesky.LKJCholesky.support

+		    

torch.distributions.laplace.Laplace

+		    

torch.distributions.laplace.Laplace.arg_constraints

+		    

torch.distributions.laplace.Laplace.cdf

+		    

torch.distributions.laplace.Laplace.entropy

+		    

torch.distributions.laplace.Laplace.expand

+		    

torch.distributions.laplace.Laplace.has_rsample

+		    

torch.distributions.laplace.Laplace.icdf

+		    

torch.distributions.laplace.Laplace.log_prob

+		    

torch.distributions.laplace.Laplace.mean

+		    

torch.distributions.laplace.Laplace.mode

+		    

torch.distributions.laplace.Laplace.rsample

+		    

torch.distributions.laplace.Laplace.stddev

+		    

torch.distributions.laplace.Laplace.support

+		    

torch.distributions.laplace.Laplace.variance

+		    

torch.distributions.log_normal.LogNormal

+		    

torch.distributions.log_normal.LogNormal.arg_constraints

+		    

torch.distributions.log_normal.LogNormal.entropy

+		    

torch.distributions.log_normal.LogNormal.expand

+		    

torch.distributions.log_normal.LogNormal.has_rsample

+		    

torch.distributions.log_normal.LogNormal.loc

+		    

torch.distributions.log_normal.LogNormal.mean

+		    

torch.distributions.log_normal.LogNormal.mode

+		    

torch.distributions.log_normal.LogNormal.scale

+		    

torch.distributions.log_normal.LogNormal.support

+		    

torch.distributions.log_normal.LogNormal.variance

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.arg_constraints

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.covariance_matrix

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.entropy

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.expand

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.has_rsample

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.log_prob

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.mean

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.mode

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.precision_matrix

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.rsample

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.scale_tril

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.support

+		    

torch.distributions.lowrank_multivariate_normal.LowRankMultivariateNormal.variance

+		    

torch.distributions.mixture_same_family.MixtureSameFamily

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.arg_constraints

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.cdf

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.component_distribution

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.expand

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.has_rsample

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.log_prob

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.mean

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.mixture_distribution

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.sample

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.support

+		    

torch.distributions.mixture_same_family.MixtureSameFamily.variance

+		    

torch.distributions.multinomial.Multinomial

+		    

torch.distributions.multinomial.Multinomial.arg_constraints

+		    

torch.distributions.multinomial.Multinomial.entropy

+		    

torch.distributions.multinomial.Multinomial.expand

+		    

torch.distributions.multinomial.Multinomial.log_prob

+		    

torch.distributions.multinomial.Multinomial.logits

+		    

torch.distributions.multinomial.Multinomial.mean

+		    

torch.distributions.multinomial.Multinomial.param_shape

+		    

torch.distributions.multinomial.Multinomial.probs

+		    

torch.distributions.multinomial.Multinomial.sample

+		    

torch.distributions.multinomial.Multinomial.support

+		    

torch.distributions.multinomial.Multinomial.total_count

+		    

torch.distributions.multinomial.Multinomial.variance

+		    

torch.distributions.multivariate_normal.MultivariateNormal

+		    

torch.distributions.multivariate_normal.MultivariateNormal.arg_constraints

+		    

torch.distributions.multivariate_normal.MultivariateNormal.covariance_matrix

+		    

torch.distributions.multivariate_normal.MultivariateNormal.entropy

+		    

torch.distributions.multivariate_normal.MultivariateNormal.expand

+		    

torch.distributions.multivariate_normal.MultivariateNormal.has_rsample

+		    

torch.distributions.multivariate_normal.MultivariateNormal.log_prob

+		    

torch.distributions.multivariate_normal.MultivariateNormal.mean

+		    

torch.distributions.multivariate_normal.MultivariateNormal.mode

+		    

torch.distributions.multivariate_normal.MultivariateNormal.precision_matrix

+		    

torch.distributions.multivariate_normal.MultivariateNormal.rsample

+		    

torch.distributions.multivariate_normal.MultivariateNormal.scale_tril

+		    

torch.distributions.multivariate_normal.MultivariateNormal.support

+		    

torch.distributions.multivariate_normal.MultivariateNormal.variance

+		    

torch.distributions.negative_binomial.NegativeBinomial

+		    

torch.distributions.negative_binomial.NegativeBinomial.arg_constraints

+		    

torch.distributions.negative_binomial.NegativeBinomial.expand

+		    

torch.distributions.negative_binomial.NegativeBinomial.log_prob

+		    

torch.distributions.negative_binomial.NegativeBinomial.logits

+		    

torch.distributions.negative_binomial.NegativeBinomial.mean

+		    

torch.distributions.negative_binomial.NegativeBinomial.mode

+		    

torch.distributions.negative_binomial.NegativeBinomial.param_shape

+		    

torch.distributions.negative_binomial.NegativeBinomial.probs

+		    

torch.distributions.negative_binomial.NegativeBinomial.sample

+		    

torch.distributions.negative_binomial.NegativeBinomial.support

+		    

torch.distributions.negative_binomial.NegativeBinomial.variance

+		    

torch.distributions.normal.Normal

+		    

torch.distributions.normal.Normal.arg_constraints

+		    

torch.distributions.normal.Normal.cdf

+		    

torch.distributions.normal.Normal.entropy

+		    

torch.distributions.normal.Normal.expand

+		    

torch.distributions.normal.Normal.has_rsample

+		    

torch.distributions.normal.Normal.icdf

+		    

torch.distributions.normal.Normal.log_prob

+		    

torch.distributions.normal.Normal.mean

+		    

torch.distributions.normal.Normal.mode

+		    

torch.distributions.normal.Normal.rsample

+		    

torch.distributions.normal.Normal.sample

+		    

torch.distributions.normal.Normal.stddev

+		    

torch.distributions.normal.Normal.support

+		    

torch.distributions.normal.Normal.variance

+		    

torch.distributions.one_hot_categorical.OneHotCategorical

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.arg_constraints

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.entropy

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.enumerate_support

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.expand

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.has_enumerate_support

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.log_prob

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.logits

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.mean

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.mode

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.param_shape

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.probs

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.sample

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.support

+		    

torch.distributions.one_hot_categorical.OneHotCategorical.variance

+		    

torch.distributions.pareto.Pareto

+		    

torch.distributions.pareto.Pareto.arg_constraints

+		    

torch.distributions.pareto.Pareto.entropy

+		    

torch.distributions.pareto.Pareto.expand

+		    

torch.distributions.pareto.Pareto.mean

+		    

torch.distributions.pareto.Pareto.mode

+		    

torch.distributions.pareto.Pareto.support

+		    

torch.distributions.pareto.Pareto.variance

+		    

torch.distributions.poisson.Poisson

+		    

torch.distributions.poisson.Poisson.arg_constraints

+		    

torch.distributions.poisson.Poisson.expand

+		    

torch.distributions.poisson.Poisson.log_prob

+		    

torch.distributions.poisson.Poisson.mean

+		    

torch.distributions.poisson.Poisson.mode

+		    

torch.distributions.poisson.Poisson.sample

+		    

torch.distributions.poisson.Poisson.support

+		    

torch.distributions.poisson.Poisson.variance

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli.arg_constraints

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli.expand

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli.has_rsample

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli.logits

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli.probs

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli.support

+		    

torch.distributions.relaxed_bernoulli.RelaxedBernoulli.temperature

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.arg_constraints

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.expand

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.log_prob

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.logits

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.param_shape

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.probs

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.rsample

+		    

torch.distributions.relaxed_bernoulli.LogitRelaxedBernoulli.support

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.arg_constraints

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.expand

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.has_rsample

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.logits

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.probs

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.support

+		    

torch.distributions.relaxed_categorical.RelaxedOneHotCategorical.temperature

+		    

torch.distributions.studentT.StudentT

+		    

torch.distributions.studentT.StudentT.arg_constraints

+		    

torch.distributions.studentT.StudentT.entropy

+		    

torch.distributions.studentT.StudentT.expand

+		    

torch.distributions.studentT.StudentT.has_rsample

+		    

torch.distributions.studentT.StudentT.log_prob

+		    

torch.distributions.studentT.StudentT.mean

+		    

torch.distributions.studentT.StudentT.mode

+		    

torch.distributions.studentT.StudentT.rsample

+		    

torch.distributions.studentT.StudentT.support

+		    

torch.distributions.studentT.StudentT.variance

+		    

torch.distributions.transformed_distribution.TransformedDistribution

+		    

torch.distributions.transformed_distribution.TransformedDistribution.arg_constraints

+		    

torch.distributions.transformed_distribution.TransformedDistribution.cdf

+		    

torch.distributions.transformed_distribution.TransformedDistribution.expand

+		    

torch.distributions.transformed_distribution.TransformedDistribution.has_rsample

+		    

torch.distributions.transformed_distribution.TransformedDistribution.icdf

+		    

torch.distributions.transformed_distribution.TransformedDistribution.log_prob

+		    

torch.distributions.transformed_distribution.TransformedDistribution.rsample

+		    

torch.distributions.transformed_distribution.TransformedDistribution.sample

+		    

torch.distributions.transformed_distribution.TransformedDistribution.support

+		    

torch.distributions.uniform.Uniform

+		    

torch.distributions.uniform.Uniform.arg_constraints

+		    

torch.distributions.uniform.Uniform.cdf

+		    

torch.distributions.uniform.Uniform.entropy

+		    

torch.distributions.uniform.Uniform.expand

+		    

torch.distributions.uniform.Uniform.has_rsample

+		    

torch.distributions.uniform.Uniform.icdf

+		    

torch.distributions.uniform.Uniform.log_prob

+		    

torch.distributions.uniform.Uniform.mean

+		    

torch.distributions.uniform.Uniform.mode

+		    

torch.distributions.uniform.Uniform.rsample

+		    

torch.distributions.uniform.Uniform.stddev

+		    

torch.distributions.uniform.Uniform.support

+		    

torch.distributions.uniform.Uniform.variance

+		    

torch.distributions.von_mises.VonMises

+		    

torch.distributions.von_mises.VonMises.arg_constraints

+		    

torch.distributions.von_mises.VonMises.expand

+		    

torch.distributions.von_mises.VonMises.has_rsample

+		    

torch.distributions.von_mises.VonMises.log_prob

+		    

torch.distributions.von_mises.VonMises.mean

+		    

torch.distributions.von_mises.VonMises.mode

+		    

torch.distributions.von_mises.VonMises.sample

+		    

torch.distributions.von_mises.VonMises.support

+		    

torch.distributions.von_mises.VonMises.variance

+		    

torch.distributions.weibull.Weibull

+		    

torch.distributions.weibull.Weibull.arg_constraints

+		    

torch.distributions.weibull.Weibull.entropy

+		    

torch.distributions.weibull.Weibull.expand

+		    

torch.distributions.weibull.Weibull.mean

+		    

torch.distributions.weibull.Weibull.mode

+		    

torch.distributions.weibull.Weibull.support

+		    

torch.distributions.weibull.Weibull.variance

+		    

torch.distributions.wishart.Wishart

+		    

torch.distributions.wishart.Wishart.arg_constraints

+		    

torch.distributions.wishart.Wishart.covariance_matrix

+		    

torch.distributions.wishart.Wishart.entropy

+		    

torch.distributions.wishart.Wishart.expand

+		    

torch.distributions.wishart.Wishart.has_rsample

+		    

torch.distributions.wishart.Wishart.log_prob

+		    

torch.distributions.wishart.Wishart.mean

+		    

torch.distributions.wishart.Wishart.mode

+		    

torch.distributions.wishart.Wishart.precision_matrix

+		    

torch.distributions.wishart.Wishart.rsample

+		    

torch.distributions.wishart.Wishart.scale_tril

+		    

torch.distributions.wishart.Wishart.support

+		    

torch.distributions.wishart.Wishart.variance

+		    

torch.distributions.kl.kl_divergence

+		    

torch.distributions.kl.register_kl

+		    

torch.distributions.transforms.AbsTransform

+		    

torch.distributions.transforms.AffineTransform

+		    

torch.distributions.transforms.CatTransform

+		    

torch.distributions.transforms.ComposeTransform

+		    

torch.distributions.transforms.CorrCholeskyTransform

+		    

torch.distributions.transforms.CumulativeDistributionTransform

+		    

torch.distributions.transforms.ExpTransform

+		    

torch.distributions.transforms.IndependentTransform

+		    

torch.distributions.transforms.LowerCholeskyTransform

+		    

torch.distributions.transforms.PositiveDefiniteTransform

+		    

torch.distributions.transforms.PowerTransform

+		    

torch.distributions.transforms.ReshapeTransform

+		    

torch.distributions.transforms.SigmoidTransform

+		    

torch.distributions.transforms.SoftplusTransform

+		    

torch.distributions.transforms.TanhTransform

+		    

torch.distributions.transforms.SoftmaxTransform

+		    

torch.distributions.transforms.StackTransform

+		    

torch.distributions.transforms.StickBreakingTransform

+		    

torch.distributions.transforms.Transform

+		    

torch.distributions.transforms.Transform.inv

+		    

torch.distributions.transforms.Transform.sign

+		    

torch.distributions.transforms.Transform.log_abs_det_jacobian

+		    

torch.distributions.transforms.Transform.forward_shape

+		    

torch.distributions.transforms.Transform.inverse_shape

+		    

torch.distributions.constraints.Constraint

+		    

torch.distributions.constraints.Constraint.check

+		    

torch.distributions.constraints.cat

+		    

torch.distributions.constraints.dependent_property

+		    

torch.distributions.constraints.greater_than

+		    

torch.distributions.constraints.greater_than_eq

+		    

torch.distributions.constraints.independent

+		    

torch.distributions.constraints.integer_interval

+		    

torch.distributions.constraints.interval

+		    

torch.distributions.constraints.half_open_interval

+		    

torch.distributions.constraints.less_than

+		    

torch.distributions.constraints.multinomial

+		    

torch.distributions.constraints.stack

+		    

torch.distributions.constraint_registry.ConstraintRegistry

+		    

torch.distributions.constraint_registry.ConstraintRegistry.register

+		    
+ +## torch.fft + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.fft.fft

+		    

torch.fft.ifft

+		    

torch.fft.fft2

+		    

torch.fft.ifft2

+		    

torch.fft.fftn

+		    

torch.fft.ifftn

+		    

torch.fft.rfft

+		    

torch.fft.irfft

+		    

torch.fft.rfft2

+		    

torch.fft.irfft2

+		    

torch.fft.rfftn

+		    

torch.fft.irfftn

+		    

torch.fft.hfft

+		    

torch.fft.ihfft

+		    

torch.fft.hfft2

+		    

torch.fft.ihfft2

+		    

torch.fft.hfftn

+		    

torch.fft.ihfftn

+		    

torch.fft.fftfreq

+		    

torch.fft.rfftfreq

+		    

torch.fft.fftshift

+		    

torch.fft.ifftshift

+		    
+ +## torch.func + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.func.vmap

+		    

torch.func.grad

+		    

torch.func.grad_and_value

+		    

torch.func.vjp

+		    

torch.func.jvp

+		    

torch.func.linearize

+		    

torch.func.jacrev

+		    

torch.func.jacfwd

+		    

torch.func.hessian

+		    

torch.func.functionalize

+		    

torch.func.functional_call

+		    

torch.func.stack_module_state

+		    

torch.func.replace_all_batch_norm_modules_

+		    
+ +## torch.futures + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.futures.Future

+

Y

+		  

torch.futures.Future.add_done_callback

+

Y

+		  

torch.futures.Future.done

+

Y

+		  

torch.futures.Future.set_exception

+

Y

+		  

torch.futures.Future.set_result

+

Y

+		  

torch.futures.Future.then

+

Y

+		  

torch.futures.Future.value

+

Y

+		  

torch.futures.Future.wait

+

Y

+		  

torch.futures.collect_all

+

Y

+		  

torch.futures.wait_all

+

Y

+		  
+ +## torch.fx + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.fx.symbolic_trace

+

Y

+		  

torch.fx.wrap

+

Y

+		  

torch.fx.GraphModule

+

Y

+		  

torch.fx.GraphModule.__init__

+

Y

+		  

torch.fx.GraphModule.add_submodule

+

Y

+		  

torch.fx.GraphModule.code

+		    

torch.fx.GraphModule.delete_all_unused_submodules

+

Y

+		  

torch.fx.GraphModule.delete_submodule

+

Y

+		  

torch.fx.GraphModule.graph

+		    

torch.fx.GraphModule.print_readable

+

Y

+		  

torch.fx.GraphModule.recompile

+

Y

+		  

torch.fx.GraphModule.to_folder

+

Y

+		  

torch.fx.Graph

+

Y

+		  

torch.fx.Graph.__init__

+

Y

+		  

torch.fx.Graph.call_function

+

Y

+		  

torch.fx.Graph.call_method

+

Y

+		  

torch.fx.Graph.call_module

+

Y

+		  

torch.fx.Graph.create_node

+

Y

+		  

torch.fx.Graph.eliminate_dead_code

+

Y

+		  

torch.fx.Graph.erase_node

+

Y

+		  

torch.fx.Graph.get_attr

+

Y

+		  

torch.fx.Graph.graph_copy

+

Y

+		  

torch.fx.Graph.inserting_after

+

Y

+		  

torch.fx.Graph.inserting_before

+

Y

+		  

torch.fx.Graph.lint

+

Y

+		  

torch.fx.Graph.node_copy

+

Y

+		  

torch.fx.Graph.nodes

+		    

torch.fx.Graph.on_generate_code

+

Y

+		  

torch.fx.Graph.output

+

Y

+		  

torch.fx.Graph.placeholder

+

Y

+		  

torch.fx.Graph.print_tabular

+

Y

+		  

torch.fx.Graph.process_inputs

+

Y

+		  

torch.fx.Graph.process_outputs

+

Y

+		  

torch.fx.Graph.python_code

+

Y

+		  

torch.fx.Graph.set_codegen

+

Y

+		  

torch.fx.Node

+

Y

+		  

torch.fx.Node.all_input_nodes

+		    

torch.fx.Node.append

+

Y

+		  

torch.fx.Node.args

+		    

torch.fx.Node.format_node

+

Y

+		  

torch.fx.Node.is_impure

+

Y

+		  

torch.fx.Node.kwargs

+		    

torch.fx.Node.next

+		    

torch.fx.Node.normalized_arguments

+

Y

+		  

torch.fx.Node.prepend

+

Y

+		  

torch.fx.Node.prev

+		    

torch.fx.Node.replace_all_uses_with

+

Y

+		  

torch.fx.Node.replace_input_with

+

Y

+		  

torch.fx.Node.stack_trace

+		    

torch.fx.Node.update_arg

+

Y

+		  

torch.fx.Node.update_kwarg

+

Y

+		  

torch.fx.Tracer

+

Y

+		  

torch.fx.Tracer.call_module

+

Y

+		  

torch.fx.Tracer.create_arg

+

Y

+		  

torch.fx.Tracer.create_args_for_root

+

Y

+		  

torch.fx.Tracer.create_node

+

Y

+		  

torch.fx.Tracer.create_proxy

+

Y

+		  

torch.fx.Tracer.getattr

+

Y

+		  

torch.fx.Tracer.is_leaf_module

+

Y

+		  

torch.fx.Tracer.iter

+

Y

+		  

torch.fx.Tracer.keys

+

Y

+		  

torch.fx.Tracer.path_of_module

+

Y

+		  

torch.fx.Tracer.proxy

+

Y

+		  

torch.fx.Tracer.to_bool

+

Y

+		  

torch.fx.Tracer.trace

+

Y

+		  

torch.fx.Proxy

+

Y

+		  

torch.fx.Interpreter

+

Y

+		  

torch.fx.Interpreter.boxed_run

+		    

torch.fx.Interpreter.call_function

+

Y

+		  

torch.fx.Interpreter.call_method

+

Y

+		  

torch.fx.Interpreter.call_module

+

Y

+		  

torch.fx.Interpreter.fetch_args_kwargs_from_env

+

Y

+		  

torch.fx.Interpreter.fetch_attr

+

Y

+		  

torch.fx.Interpreter.get_attr

+

Y

+		  

torch.fx.Interpreter.map_nodes_to_values

+

Y

+		  

torch.fx.Interpreter.output

+

Y

+		  

torch.fx.Interpreter.placeholder

+

Y

+		  

torch.fx.Interpreter.run

+

Y

+		  

torch.fx.Interpreter.run_node

+

Y

+		  

torch.fx.Transformer

+

Y

+		  

torch.fx.Transformer.call_function

+

Y

+		  

torch.fx.Transformer.call_module

+

Y

+		  

torch.fx.Transformer.get_attr

+

Y

+		  

torch.fx.Transformer.placeholder

+

Y

+		  

torch.fx.Transformer.transform

+

Y

+		  

torch.fx.replace_pattern

+

Y

+		  
+ +## torch.hub + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.hub.list

+

Y

+		  

torch.hub.help

+

Y

+		  

torch.hub.load

+

Y

+		  

torch.hub.download_url_to_file

+

Y

+		  

torch.hub.load_state_dict_from_url

+

Y

+		  

torch.hub.get_dir

+

Y

+		  

torch.hub.set_dir

+

Y

+		  
+ +## torch.jit + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.jit.export

+

Y

+		  

torch.jit.is_scripting

+

Y

+		  

torch.jit.is_tracing

+

Y

+		  

torch.jit.script

+		    

torch.jit.trace

+

Y

+		  

torch.jit.script_if_tracing

+

Y

+		  

torch.jit.trace_module

+

Y

+		  

torch.jit.fork

+		    

torch.jit.wait

+		    

torch.jit.ScriptModule

+

Y

+		  

torch.jit.ScriptModule.add_module

+		    

torch.jit.ScriptModule.apply

+

Y

+		  

torch.jit.ScriptModule.bfloat16

+		    

torch.jit.ScriptModule.buffers

+

Y

+		  

torch.jit.ScriptModule.children

+

Y

+		  

torch.jit.ScriptModule.code

+		    

torch.jit.ScriptModule.code_with_constants

+		    

torch.jit.ScriptModule.compile

+		    

torch.jit.ScriptModule.cpu

+

Y

+		  

torch.jit.ScriptModule.cuda

+

Y

+		  

torch.jit.ScriptModule.double

+

Y

+		  

torch.jit.ScriptModule.eval

+

Y

+		  

torch.jit.ScriptModule.extra_repr

+

Y

+		  

torch.jit.ScriptModule.float

+

Y

+		  

torch.jit.ScriptModule.get_buffer

+

Y

+		  

torch.jit.ScriptModule.get_extra_state

+		    

torch.jit.ScriptModule.get_parameter

+

Y

+		  

torch.jit.ScriptModule.get_submodule

+

Y

+		  

torch.jit.ScriptModule.graph

+		    

torch.jit.ScriptModule.half

+

Y

+		  

torch.jit.ScriptModule.inlined_graph

+		    

torch.jit.ScriptModule.ipu

+

Y

+		  

torch.jit.ScriptModule.load_state_dict

+

Y

+		  

torch.jit.ScriptModule.modules

+

Y

+		  

torch.jit.ScriptModule.named_buffers

+

Y

+		  

torch.jit.ScriptModule.named_children

+

Y

+		  

torch.jit.ScriptModule.named_modules

+

Y

+		  

torch.jit.ScriptModule.named_parameters

+

Y

+		  

torch.jit.ScriptModule.parameters

+

Y

+		  

torch.jit.ScriptModule.register_backward_hook

+

Y

+		  

torch.jit.ScriptModule.register_buffer

+		    

torch.jit.ScriptModule.register_forward_hook

+

Y

+		  

torch.jit.ScriptModule.register_forward_pre_hook

+

Y

+		  

torch.jit.ScriptModule.register_full_backward_hook

+

Y

+		  

torch.jit.ScriptModule.register_full_backward_pre_hook

+

Y

+		  

torch.jit.ScriptModule.register_load_state_dict_post_hook

+

Y

+		  

torch.jit.ScriptModule.register_module

+		    

torch.jit.ScriptModule.register_parameter

+		    

torch.jit.ScriptModule.register_state_dict_pre_hook

+

Y

+		  

torch.jit.ScriptModule.requires_grad_

+

Y

+		  

torch.jit.ScriptModule.save

+

Y

+		  

torch.jit.ScriptModule.set_extra_state

+		    

torch.jit.ScriptModule.share_memory

+		    

torch.jit.ScriptModule.state_dict

+

Y

+		  

torch.jit.ScriptModule.to

+

Y

+		  

torch.jit.ScriptModule.to_empty

+

Y

+		  

torch.jit.ScriptModule.train

+

Y

+		  

torch.jit.ScriptModule.type

+

Y

+		  

torch.jit.ScriptModule.xpu

+

Y

+		  

torch.jit.ScriptModule.zero_grad

+

Y

+		  

torch.jit.ScriptFunction

+

Y

+		  

torch.jit.ScriptFunction.get_debug_state

+

Y

+		  

torch.jit.ScriptFunction.save

+

Y

+		  

torch.jit.ScriptFunction.save_to_buffer

+

Y

+		  

torch.jit.freeze

+

Y

+		  

torch.jit.optimize_for_inference

+

Y

+		  

torch.jit.enable_onednn_fusion

+

Y

+		  

torch.jit.onednn_fusion_enabled

+

Y

+		  

torch.jit.set_fusion_strategy

+		    

torch.jit.strict_fusion

+		    

torch.jit.save

+

Y

+		  

torch.jit.load

+

Y

+		  

torch.jit.ignore

+

Y

+		  

torch.jit.unused

+

Y

+		  

torch.jit.isinstance

+

Y

+		  

torch.jit.Attribute

+

Y

+		  

torch.jit.Attribute.count

+

Y

+		  

torch.jit.Attribute.index

+

Y

+		  

torch.jit.Attribute.type

+		    

torch.jit.Attribute.value

+		    

torch.jit.annotate

+

Y

+		  
+ +## torch.linalg + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.linalg.norm

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.linalg.vector_norm

+		    

torch.linalg.matrix_norm

+		    

torch.linalg.diagonal

+		    

torch.linalg.det

+		    

torch.linalg.slogdet

+		    

torch.linalg.cond

+		    

torch.linalg.matrix_rank

+		    

torch.linalg.cholesky

+		    

torch.linalg.qr

+		    

torch.linalg.lu

+		    

torch.linalg.lu_factor

+		    

torch.linalg.eig

+		    

torch.linalg.eigvals

+		    

torch.linalg.eigh

+		    

torch.linalg.eigvalsh

+		    

torch.linalg.svd

+		    

torch.linalg.svdvals

+		    

torch.linalg.solve

+		    

torch.linalg.solve_triangular

+		    

torch.linalg.lu_solve

+		    

torch.linalg.lstsq

+		    

torch.linalg.inv

+		    

torch.linalg.pinv

+		    

torch.linalg.matrix_exp

+		    

torch.linalg.matrix_power

+		    

torch.linalg.cross

+		    

torch.linalg.matmul

+		    

torch.linalg.vecdot

+		    

torch.linalg.multi_dot

+		    

torch.linalg.householder_product

+		    

torch.linalg.tensorinv

+		    

torch.linalg.tensorsolve

+		    

torch.linalg.vander

+		    

torch.linalg.cholesky_ex

+		    

torch.linalg.inv_ex

+		    

torch.linalg.solve_ex

+		    

torch.linalg.lu_factor_ex

+		    

torch.linalg.ldl_factor

+		    

torch.linalg.ldl_factor_ex

+		    

torch.linalg.ldl_solve

+		    
+ +## torch.monitor + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.monitor.Aggregation

+

Y

+		  

torch.monitor.Aggregation.name

+		    

torch.monitor.Stat

+

Y

+		  

torch.monitor.Stat.__init__

+

Y

+		  

torch.monitor.Stat.add

+

Y

+		  

torch.monitor.Stat.count

+		    

torch.monitor.Stat.get

+

Y

+		  

torch.monitor.Stat.name

+		    

torch.monitor.data_value_t

+

Y

+		  

torch.monitor.Event

+

Y

+		  

torch.monitor.Event.__init__

+

Y

+		  

torch.monitor.Event.data

+		    

torch.monitor.Event.name

+		    

torch.monitor.Event.timestamp

+		    

torch.monitor.EventHandlerHandle

+

Y

+		  

torch.monitor.log_event

+

Y

+		  

torch.monitor.register_event_handler

+

Y

+		  

torch.monitor.unregister_event_handler

+

Y

+		  

torch.monitor.TensorboardEventHandler

+

Y

+		  

torch.monitor.TensorboardEventHandler.__init__

+

Y

+		  
+ +## torch.signal + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.signal.windows.bartlett

+		    

torch.signal.windows.blackman

+		    

torch.signal.windows.cosine

+		    

torch.signal.windows.exponential

+		    

torch.signal.windows.gaussian

+		    

torch.signal.windows.general_cosine

+		    

torch.signal.windows.general_hamming

+		    

torch.signal.windows.hamming

+		    

torch.signal.windows.hann

+		    

torch.signal.windows.kaiser

+		    

torch.signal.windows.nuttall

+		    
+ +## torch.special + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.special.airy_ai

+		    

torch.special.bessel_j0

+		    

torch.special.bessel_j1

+		    

torch.special.digamma

+		    

torch.special.entr

+		    

torch.special.erf

+		    

torch.special.erfc

+		    

torch.special.erfcx

+		    

torch.special.erfinv

+		    

torch.special.exp2

+		    

torch.special.expit

+		    

torch.special.expm1

+		    

torch.special.gammainc

+		    

torch.special.gammaincc

+		    

torch.special.gammaln

+		    

torch.special.i0

+		    

torch.special.i0e

+		    

torch.special.i1

+		    

torch.special.i1e

+		    

torch.special.log1p

+		    

torch.special.log_ndtr

+		    

torch.special.log_softmax

+		    

torch.special.logit

+		    

torch.special.logsumexp

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.special.multigammaln

+		    

torch.special.ndtr

+		    

torch.special.ndtri

+		    

torch.special.polygamma

+		    

torch.special.psi

+		    

torch.special.round

+		    

torch.special.scaled_modified_bessel_k0

+		    

torch.special.scaled_modified_bessel_k1

+		    

torch.special.sinc

+		    

torch.special.softmax

+		    

torch.special.spherical_bessel_j0

+		    

torch.special.xlog1py

+		    

torch.special.xlogy

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.special.zeta

+		    
+ +## torch.overrides + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.overrides.get_ignored_functions

+

Y

+		  

torch.overrides.get_overridable_functions

+

Y

+		  

torch.overrides.resolve_name

+

Y

+		  

torch.overrides.get_testing_overrides

+

Y

+		  

torch.overrides.handle_torch_function

+

Y

+		  

torch.overrides.has_torch_function

+

Y

+		  

torch.overrides.is_tensor_like

+

Y

+		  

torch.overrides.is_tensor_method_or_property

+

Y

+		  

torch.overrides.wrap_torch_function

+

Y

+		  
+ +## torch.package + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.package.PackagingError

+

Y

+		  

torch.package.EmptyMatchError

+

Y

+		  

torch.package.PackageExporter

+

Y

+		  

torch.package.PackageExporter.__init__

+

Y

+		  

torch.package.PackageExporter.add_dependency

+

Y

+		  

torch.package.PackageExporter.all_paths

+

Y

+		  

torch.package.PackageExporter.close

+

Y

+		  

torch.package.PackageExporter.denied_modules

+

Y

+		  

torch.package.PackageExporter.deny

+

Y

+		  

torch.package.PackageExporter.dependency_graph_string

+

Y

+		  

torch.package.PackageExporter.extern

+

Y

+		  

torch.package.PackageExporter.externed_modules

+

Y

+		  

torch.package.PackageExporter.get_rdeps

+

Y

+		  

torch.package.PackageExporter.get_unique_id

+

Y

+		  

torch.package.PackageExporter.intern

+

Y

+		  

torch.package.PackageExporter.interned_modules

+

Y

+		  

torch.package.PackageExporter.mock

+

Y

+		  

torch.package.PackageExporter.mocked_modules

+

Y

+		  

torch.package.PackageExporter.register_extern_hook

+

Y

+		  

torch.package.PackageExporter.register_intern_hook

+

Y

+		  

torch.package.PackageExporter.register_mock_hook

+

Y

+		  

torch.package.PackageExporter.save_binary

+

Y

+		  

torch.package.PackageExporter.save_module

+

Y

+		  

torch.package.PackageExporter.save_pickle

+

Y

+		  

torch.package.PackageExporter.save_source_file

+

Y

+		  

torch.package.PackageExporter.save_source_string

+

Y

+		  

torch.package.PackageExporter.save_text

+

Y

+		  

torch.package.PackageImporter

+

Y

+		  

torch.package.PackageImporter.__init__

+

Y

+		  

torch.package.PackageImporter.file_structure

+

Y

+		  

torch.package.PackageImporter.id

+

Y

+		  

torch.package.PackageImporter.import_module

+

Y

+		  

torch.package.PackageImporter.load_binary

+

Y

+		  

torch.package.PackageImporter.load_pickle

+

Y

+		  

torch.package.PackageImporter.load_text

+

Y

+		  

torch.package.PackageImporter.python_version

+

Y

+		  

torch.package.Directory

+

Y

+		  

torch.package.Directory.has_file

+

Y

+		  
+ +## torch.profiler + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.profiler._KinetoProfile

+		    

torch.profiler._KinetoProfile.add_metadata

+		    

torch.profiler._KinetoProfile.add_metadata_json

+		    

torch.profiler._KinetoProfile.events

+		    

torch.profiler._KinetoProfile.export_chrome_trace

+		    

torch.profiler._KinetoProfile.export_memory_timeline

+		    

torch.profiler._KinetoProfile.export_stacks

+		    

torch.profiler._KinetoProfile.key_averages

+		    

torch.profiler.profile

+

Y

+		  

torch.profiler.profile.step

+

Y

+		  

torch.profiler.ProfilerAction

+

Y

+		  

torch.profiler.ProfilerActivity

+

Y

+		  

torch.profiler.ProfilerActivity.name

+		    

torch.profiler.schedule

+

Y

+		  

torch.profiler.tensorboard_trace_handler

+

Y

+		  

torch.profiler.itt.is_available

+		    

torch.profiler.itt.mark

+		    

torch.profiler.itt.range_push

+		    

torch.profiler.itt.range_pop

+		    
+ +## torch.nn.init + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.nn.init.calculate_gain

+

Y

+		  

torch.nn.init.uniform_

+

Y

+		  

torch.nn.init.normal_

+

Y

+		  

torch.nn.init.constant_

+

Y

+		  

torch.nn.init.ones_

+

Y

+		  

torch.nn.init.zeros_

+

Y

+		  

torch.nn.init.eye_

+

Y

+		  

torch.nn.init.dirac_

+

Y

+		  

torch.nn.init.xavier_uniform_

+

Y

+		  

torch.nn.init.xavier_normal_

+

Y

+		  

torch.nn.init.kaiming_uniform_

+

Y

+		  

torch.nn.init.kaiming_normal_

+

Y

+		  

torch.nn.init.trunc_normal_

+		    

torch.nn.init.orthogonal_

+

Y

+		  

torch.nn.init.sparse_

+

Y

+		  
+ +## torch.onnx + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.onnx.dynamo_export

+

Y

+		  

torch.onnx.ExportOptions

+

Y

+		  

torch.onnx.enable_fake_mode

+		    

torch.onnx.ExportOutput

+

Y

+		  

torch.onnx.ExportOutput.adapt_torch_inputs_to_onnx

+

Y

+		  

torch.onnx.ExportOutput.adapt_torch_outputs_to_onnx

+

Y

+		  

torch.onnx.ExportOutput.diagnostic_context

+		    

torch.onnx.ExportOutput.fake_context

+		    

torch.onnx.ExportOutput.model_proto

+		    

torch.onnx.ExportOutput.save

+

Y

+		  

torch.onnx.ExportOutput.save_diagnostics

+		    

torch.onnx.ExportOutputSerializer

+

Y

+		  

torch.onnx.ExportOutputSerializer.serialize

+

Y

+		  

torch.onnx.OnnxExporterError

+		    

torch.onnx.OnnxRegistry

+		    

torch.onnx.OnnxRegistry.get_op_functions

+		    

torch.onnx.OnnxRegistry.is_registered_op

+		    

torch.onnx.OnnxRegistry.opset_version

+		    

torch.onnx.OnnxRegistry.register_op

+		    

torch.onnx.DiagnosticOptions

+		    

torch.onnx.is_onnxrt_backend_supported

+		    

torch.onnx.export

+

Y

+		  

torch.onnx.export_to_pretty_string

+

Y

+		  

torch.onnx.register_custom_op_symbolic

+

Y

+		  

torch.onnx.unregister_custom_op_symbolic

+

Y

+		  

torch.onnx.select_model_mode_for_export

+

Y

+		  

torch.onnx.is_in_onnx_export

+

Y

+		  

torch.onnx.enable_log

+

Y

+		  

torch.onnx.disable_log

+

Y

+		  

torch.onnx.verification.find_mismatch

+

Y

+		  

torch.onnx.JitScalarType

+

Y

+		  

torch.onnx.JitScalarType.dtype

+

Y

+		  

torch.onnx.JitScalarType.from_dtype

+

Y

+		  

torch.onnx.JitScalarType.from_value

+

Y

+		  

torch.onnx.JitScalarType.onnx_compatible

+

Y

+		  

torch.onnx.JitScalarType.onnx_type

+

Y

+		  

torch.onnx.JitScalarType.scalar_name

+

Y

+		  

torch.onnx.JitScalarType.torch_name

+

Y

+		  

torch.onnx.verification.GraphInfo

+

Y

+		  

torch.onnx.verification.GraphInfo.all_mismatch_leaf_graph_info

+

Y

+		  

torch.onnx.verification.GraphInfo.clear

+

Y

+		  

torch.onnx.verification.GraphInfo.essential_node_count

+

Y

+		  

torch.onnx.verification.GraphInfo.essential_node_kinds

+

Y

+		  

torch.onnx.verification.GraphInfo.export_repro

+

Y

+		  

torch.onnx.verification.GraphInfo.find_mismatch

+

Y

+		  

torch.onnx.verification.GraphInfo.find_partition

+

Y

+		  

torch.onnx.verification.GraphInfo.has_mismatch

+

Y

+		  

torch.onnx.verification.GraphInfo.pretty_print_mismatch

+

Y

+		  

torch.onnx.verification.GraphInfo.pretty_print_tree

+

Y

+		  

torch.onnx.verification.GraphInfo.verify_export

+

Y

+		  

torch.onnx.verification.VerificationOptions

+

Y

+		  
+ +## torch.optim + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.optim.Optimizer

+		    

Optimizer.add_param_group

+

Y

+		  

Optimizer.load_state_dict

+

Y

+		  

Optimizer.state_dict

+

Y

+		  

Optimizer.step

+

Y

+		  

Optimizer.zero_grad

+

Y

+		  

torch.optim.Adadelta

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.Adadelta.add_param_group

+

Y

+		  

torch.optim.Adadelta.load_state_dict

+

Y

+		  

torch.optim.Adadelta.register_load_state_dict_post_hook

+		    

torch.optim.Adadelta.register_load_state_dict_pre_hook

+		    

torch.optim.Adadelta.register_state_dict_post_hook

+		    

torch.optim.Adadelta.register_state_dict_pre_hook

+		    

torch.optim.Adadelta.register_step_post_hook

+		    

torch.optim.Adadelta.register_step_pre_hook

+		    

torch.optim.Adadelta.state_dict

+

Y

+		  

torch.optim.Adadelta.step

+		    

torch.optim.Adadelta.zero_grad

+

Y

+		  

torch.optim.Adagrad

+		    

torch.optim.Adagrad.add_param_group

+

Y

+		  

torch.optim.Adagrad.load_state_dict

+

Y

+		  

torch.optim.Adagrad.register_load_state_dict_post_hook

+		    

torch.optim.Adagrad.register_load_state_dict_pre_hook

+		    

torch.optim.Adagrad.register_state_dict_post_hook

+		    

torch.optim.Adagrad.register_state_dict_pre_hook

+		    

torch.optim.Adagrad.register_step_post_hook

+		    

torch.optim.Adagrad.register_step_pre_hook

+		    

torch.optim.Adagrad.state_dict

+

Y

+		  

torch.optim.Adagrad.step

+		    

torch.optim.Adagrad.zero_grad

+

Y

+		  

torch.optim.Adam

+		    

torch.optim.Adam.add_param_group

+

Y

+		  

torch.optim.Adam.load_state_dict

+

Y

+		  

torch.optim.Adam.register_load_state_dict_post_hook

+		    

torch.optim.Adam.register_load_state_dict_pre_hook

+		    

torch.optim.Adam.register_state_dict_post_hook

+		    

torch.optim.Adam.register_state_dict_pre_hook

+		    

torch.optim.Adam.register_step_post_hook

+		    

torch.optim.Adam.register_step_pre_hook

+		    

torch.optim.Adam.state_dict

+

Y

+		  

torch.optim.Adam.step

+		    

torch.optim.Adam.zero_grad

+

Y

+		  

torch.optim.AdamW

+		    

torch.optim.AdamW.add_param_group

+		    

torch.optim.AdamW.load_state_dict

+		    

torch.optim.AdamW.register_load_state_dict_post_hook

+		    

torch.optim.AdamW.register_load_state_dict_pre_hook

+		    

torch.optim.AdamW.register_state_dict_post_hook

+		    

torch.optim.AdamW.register_state_dict_pre_hook

+		    

torch.optim.AdamW.register_step_post_hook

+		    

torch.optim.AdamW.register_step_pre_hook

+		    

torch.optim.AdamW.state_dict

+		    

torch.optim.AdamW.step

+		    

torch.optim.AdamW.zero_grad

+		    

torch.optim.SparseAdam

+		    

torch.optim.SparseAdam.add_param_group

+		    

torch.optim.SparseAdam.load_state_dict

+		    

torch.optim.SparseAdam.register_load_state_dict_post_hook

+		    

torch.optim.SparseAdam.register_load_state_dict_pre_hook

+		    

torch.optim.SparseAdam.register_state_dict_post_hook

+		    

torch.optim.SparseAdam.register_state_dict_pre_hook

+		    

torch.optim.SparseAdam.register_step_post_hook

+		    

torch.optim.SparseAdam.register_step_pre_hook

+		    

torch.optim.SparseAdam.state_dict

+		    

torch.optim.SparseAdam.step

+		    

torch.optim.SparseAdam.zero_grad

+		    

torch.optim.Adamax

+		    

torch.optim.Adamax.add_param_group

+		    

torch.optim.Adamax.load_state_dict

+		    

torch.optim.Adamax.register_load_state_dict_post_hook

+		    

torch.optim.Adamax.register_load_state_dict_pre_hook

+		    

torch.optim.Adamax.register_state_dict_post_hook

+		    

torch.optim.Adamax.register_state_dict_pre_hook

+		    

torch.optim.Adamax.register_step_post_hook

+		    

torch.optim.Adamax.register_step_pre_hook

+		    

torch.optim.Adamax.state_dict

+		    

torch.optim.Adamax.step

+		    

torch.optim.Adamax.zero_grad

+		    

torch.optim.ASGD

+		    

torch.optim.ASGD.add_param_group

+		    

torch.optim.ASGD.load_state_dict

+		    

torch.optim.ASGD.register_load_state_dict_post_hook

+		    

torch.optim.ASGD.register_load_state_dict_pre_hook

+		    

torch.optim.ASGD.register_state_dict_post_hook

+		    

torch.optim.ASGD.register_state_dict_pre_hook

+		    

torch.optim.ASGD.register_step_post_hook

+		    

torch.optim.ASGD.register_step_pre_hook

+		    

torch.optim.ASGD.state_dict

+		    

torch.optim.ASGD.step

+		    

torch.optim.ASGD.zero_grad

+		    

torch.optim.LBFGS

+		    

torch.optim.LBFGS.add_param_group

+		    

torch.optim.LBFGS.load_state_dict

+		    

torch.optim.LBFGS.register_load_state_dict_post_hook

+		    

torch.optim.LBFGS.register_load_state_dict_pre_hook

+		    

torch.optim.LBFGS.register_state_dict_post_hook

+		    

torch.optim.LBFGS.register_state_dict_pre_hook

+		    

torch.optim.LBFGS.register_step_post_hook

+		    

torch.optim.LBFGS.register_step_pre_hook

+		    

torch.optim.LBFGS.state_dict

+		    

torch.optim.LBFGS.step

+		    

torch.optim.LBFGS.zero_grad

+		    

torch.optim.NAdam

+		    

torch.optim.NAdam.add_param_group

+		    

torch.optim.NAdam.load_state_dict

+		    

torch.optim.NAdam.register_load_state_dict_post_hook

+		    

torch.optim.NAdam.register_load_state_dict_pre_hook

+		    

torch.optim.NAdam.register_state_dict_post_hook

+		    

torch.optim.NAdam.register_state_dict_pre_hook

+		    

torch.optim.NAdam.register_step_post_hook

+		    

torch.optim.NAdam.register_step_pre_hook

+		    

torch.optim.NAdam.state_dict

+		    

torch.optim.NAdam.step

+		    

torch.optim.NAdam.zero_grad

+		    

torch.optim.RAdam

+		    

torch.optim.RAdam.add_param_group

+		    

torch.optim.RAdam.load_state_dict

+		    

torch.optim.RAdam.register_load_state_dict_post_hook

+		    

torch.optim.RAdam.register_load_state_dict_pre_hook

+		    

torch.optim.RAdam.register_state_dict_post_hook

+		    

torch.optim.RAdam.register_state_dict_pre_hook

+		    

torch.optim.RAdam.register_step_post_hook

+		    

torch.optim.RAdam.register_step_pre_hook

+		    

torch.optim.RAdam.state_dict

+		    

torch.optim.RAdam.step

+		    

torch.optim.RAdam.zero_grad

+		    

torch.optim.RMSprop

+		    

torch.optim.RMSprop.add_param_group

+		    

torch.optim.RMSprop.load_state_dict

+		    

torch.optim.RMSprop.register_load_state_dict_post_hook

+		    

torch.optim.RMSprop.register_load_state_dict_pre_hook

+		    

torch.optim.RMSprop.register_state_dict_post_hook

+		    

torch.optim.RMSprop.register_state_dict_pre_hook

+		    

torch.optim.RMSprop.register_step_post_hook

+		    

torch.optim.RMSprop.register_step_pre_hook

+		    

torch.optim.RMSprop.state_dict

+		    

torch.optim.RMSprop.step

+		    

torch.optim.RMSprop.zero_grad

+		    

torch.optim.Rprop

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.Rprop.add_param_group

+		    

torch.optim.Rprop.load_state_dict

+		    

torch.optim.Rprop.register_load_state_dict_post_hook

+		    

torch.optim.Rprop.register_load_state_dict_pre_hook

+		    

torch.optim.Rprop.register_state_dict_post_hook

+		    

torch.optim.Rprop.register_state_dict_pre_hook

+		    

torch.optim.Rprop.register_step_post_hook

+		    

torch.optim.Rprop.register_step_pre_hook

+		    

torch.optim.Rprop.state_dict

+		    

torch.optim.Rprop.step

+		    

torch.optim.Rprop.zero_grad

+		    

torch.optim.SGD

+		    

torch.optim.SGD.add_param_group

+		    

torch.optim.SGD.load_state_dict

+		    

torch.optim.SGD.register_load_state_dict_post_hook

+		    

torch.optim.SGD.register_load_state_dict_pre_hook

+		    

torch.optim.SGD.register_state_dict_post_hook

+		    

torch.optim.SGD.register_state_dict_pre_hook

+		    

torch.optim.SGD.register_step_post_hook

+		    

torch.optim.SGD.register_step_pre_hook

+		    

torch.optim.SGD.state_dict

+		    

torch.optim.SGD.step

+		    

torch.optim.SGD.zero_grad

+		    

torch.optim.lr_scheduler.LambdaLR

+

Y

+		  

torch.optim.lr_scheduler.LambdaLR.get_last_lr

+		    

torch.optim.lr_scheduler.LambdaLR.load_state_dict

+		    

torch.optim.lr_scheduler.LambdaLR.print_lr

+		    

torch.optim.lr_scheduler.LambdaLR.state_dict

+		    

torch.optim.lr_scheduler.MultiplicativeLR

+		    

torch.optim.lr_scheduler.MultiplicativeLR.get_last_lr

+		    

torch.optim.lr_scheduler.MultiplicativeLR.load_state_dict

+		    

torch.optim.lr_scheduler.MultiplicativeLR.print_lr

+		    

torch.optim.lr_scheduler.MultiplicativeLR.state_dict

+		    

torch.optim.lr_scheduler.StepLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.StepLR.get_last_lr

+		    

torch.optim.lr_scheduler.StepLR.load_state_dict

+		    

torch.optim.lr_scheduler.StepLR.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.StepLR.state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.MultiStepLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.MultiStepLR.get_last_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.MultiStepLR.load_state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.MultiStepLR.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.MultiStepLR.state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ConstantLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ConstantLR.get_last_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ConstantLR.load_state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ConstantLR.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ConstantLR.state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.LinearLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.LinearLR.get_last_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.LinearLR.load_state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.LinearLR.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.LinearLR.state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ExponentialLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ExponentialLR.get_last_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ExponentialLR.load_state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ExponentialLR.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ExponentialLR.state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.PolynomialLR

+		    

torch.optim.lr_scheduler.PolynomialLR.get_last_lr

+		    

torch.optim.lr_scheduler.PolynomialLR.load_state_dict

+		    

torch.optim.lr_scheduler.PolynomialLR.print_lr

+		    

torch.optim.lr_scheduler.PolynomialLR.state_dict

+		    

torch.optim.lr_scheduler.CosineAnnealingLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingLR.get_last_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingLR.load_state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingLR.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingLR.state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.ChainedScheduler

+		    

torch.optim.lr_scheduler.ChainedScheduler.get_last_lr

+		    

torch.optim.lr_scheduler.ChainedScheduler.load_state_dict

+		    

torch.optim.lr_scheduler.ChainedScheduler.print_lr

+		    

torch.optim.lr_scheduler.ChainedScheduler.state_dict

+		    

torch.optim.lr_scheduler.SequentialLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.SequentialLR.get_last_lr

+		    

torch.optim.lr_scheduler.SequentialLR.load_state_dict

+		    

torch.optim.lr_scheduler.SequentialLR.print_lr

+		    

torch.optim.lr_scheduler.SequentialLR.state_dict

+		    

torch.optim.lr_scheduler.ReduceLROnPlateau

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CyclicLR

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CyclicLR.get_last_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CyclicLR.get_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CyclicLR.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.OneCycleLR

+

Y

+		  

torch.optim.lr_scheduler.OneCycleLR.get_last_lr

+		    

torch.optim.lr_scheduler.OneCycleLR.load_state_dict

+		    

torch.optim.lr_scheduler.OneCycleLR.print_lr

+		    

torch.optim.lr_scheduler.OneCycleLR.state_dict

+		    

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.get_last_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.load_state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.print_lr

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.state_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.optim.lr_scheduler.CosineAnnealingWarmRestarts.step

+

Y

+

Only support fp16，fp32，int64，bool

+
+ +## torch.cpu + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.cpu.current_stream

+		    

torch.cpu.is_available

+		    

torch.cpu.synchronize

+		    

torch.cpu.stream

+		    

torch.cpu.device_count

+		    

torch.cpu.StreamContext

+		    
+ +## torch.\_logging + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch._logging.set_logs

+		    
+ +## torch.compiler + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.compiler.compile

+		    

torch.compiler.reset

+		    

torch.compiler.allow_in_graph

+		    

torch.compiler.assume_constant_result

+		    

torch.compiler.list_backends

+		    

torch.compiler.disable

+		    
+ +## torch.export + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.export.export

+		    

torch.export.dynamic_dim

+		    

torch.export.constrain_as_size

+		    

torch.export.constrain_as_value

+		    

torch.export.save

+		    

torch.export.load

+		    

torch.export.Constraint

+		    

torch.export.ExportedProgram

+		    

torch.export.ExportedProgram.module

+		    

torch.export.ExportBackwardSignature

+		    

torch.export.ExportGraphSignature

+		    

torch.export.ArgumentKind

+		    

torch.export.ArgumentSpec

+		    

torch.export.ModuleCallSignature

+		    

torch.export.ModuleCallEntry

+		    
+ +## DDP Communication Hooks + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.GradBucket

+

Y

+		  

torch.distributed.GradBucket.index

+

Y

+		  

torch.distributed.GradBucket.buffer

+

Y

+		  

torch.distributed.GradBucket.gradients

+

Y

+		  

torch.distributed.GradBucket.is_last

+

Y

+		  

torch.distributed.GradBucket.set_buffer

+

Y

+		  

torch.distributed.GradBucket.parameters

+

Y

+		  

torch.distributed.algorithms.ddp_comm_hooks.default_hooks.allreduce_hook

+

Y

+		  

torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_hook

+

Y

+		  

torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_hook

+		    

torch.distributed.algorithms.ddp_comm_hooks.default_hooks.fp16_compress_wrapper

+

Y

+		  

torch.distributed.algorithms.ddp_comm_hooks.default_hooks.bf16_compress_wrapper

+		    

torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.PowerSGDState

+

Y

+		  

torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.powerSGD_hook

+

Y

+		  

torch.distributed.algorithms.ddp_comm_hooks.powerSGD_hook.batched_powerSGD_hook

+

Y

+		  

torch.distributed.algorithms.ddp_comm_hooks.debugging_hooks.noop_hook

+

Y

+		  

__getstate__

+		    

__setstate__

+		    
+ +## Pipeline Parallelism + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.pipeline.sync.Pipe

+		    

torch.distributed.pipeline.sync.Pipe.forward

+		    

torch.distributed.pipeline.sync.skip.skippable.skippable

+		    

torch.distributed.pipeline.sync.skip.skippable.stash

+		    

torch.distributed.pipeline.sync.skip.skippable.pop

+		    

torch.distributed.pipeline.sync.skip.skippable.verify_skippables

+		    
+ +## Quantization + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.ao.quantization.quantize

+		    

torch.ao.quantization.quantize_dynamic

+		    

torch.ao.quantization.quantize_qat

+		    

torch.ao.quantization.prepare

+		    

torch.ao.quantization.prepare_qat

+		    

torch.ao.quantization.convert

+		    

torch.ao.quantization.fuse_modules

+		    

torch.ao.quantization.QuantStub

+		    

torch.ao.quantization.DeQuantStub

+		    

torch.ao.quantization.QuantWrapper

+		    

torch.ao.quantization.add_quant_dequant

+		    

torch.ao.quantization.swap_module

+		    

torch.ao.quantization.propagate_qconfig_

+		    

torch.ao.quantization.default_eval_fn

+		    

torch.ao.quantization.quantize_fx.prepare_fx

+		    

torch.ao.quantization.quantize_fx.prepare_qat_fx

+		    

torch.ao.quantization.quantize_fx.convert_fx

+		    

torch.ao.quantization.quantize_fx.fuse_fx

+		    

torch.ao.quantization.qconfig_mapping.QConfigMapping

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.QConfigMapping.from_dict

+		    

torch.ao.quantization.qconfig_mapping.QConfigMapping.set_global

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.QConfigMapping.set_module_name

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.QConfigMapping.set_module_name_object_type_order

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.QConfigMapping.set_module_name_regex

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.QConfigMapping.set_object_type

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.QConfigMapping.to_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.get_default_qconfig_mapping

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.qconfig_mapping.get_default_qat_qconfig_mapping

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendConfig

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendConfig.configs

+		    

torch.ao.quantization.backend_config.BackendConfig.from_dict

+		    

torch.ao.quantization.backend_config.BackendConfig.set_backend_pattern_config

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendConfig.set_backend_pattern_configs

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendConfig.set_name

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendConfig.to_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.add_dtype_config

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.from_dict

+		    

torch.ao.quantization.backend_config.BackendPatternConfig.set_dtype_configs

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.set_fused_module

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.set_fuser_method

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.set_observation_type

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.set_pattern

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.set_qat_module

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.set_reference_quantized_module

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.set_root_module

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.BackendPatternConfig.to_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.DTypeConfig

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.DTypeConfig.from_dict

+		    

torch.ao.quantization.backend_config.DTypeConfig.to_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.DTypeWithConstraints

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.ObservationType

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.backend_config.ObservationType.INPUT_OUTPUT_NOT_OBSERVED

+		    

torch.ao.quantization.backend_config.ObservationType.OUTPUT_SHARE_OBSERVER_WITH_INPUT

+		    

torch.ao.quantization.backend_config.ObservationType.OUTPUT_USE_DIFFERENT_OBSERVER_AS_INPUT

+		    

torch.ao.quantization.fx.custom_config.FuseCustomConfig

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.FuseCustomConfig.from_dict

+		    

torch.ao.quantization.fx.custom_config.FuseCustomConfig.set_preserved_attributes

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.FuseCustomConfig.to_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.from_dict

+		    

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_float_to_observed_mapping

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_input_quantized_indexes

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_non_traceable_module_classes

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_non_traceable_module_names

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_output_quantized_indexes

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_preserved_attributes

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_standalone_module_class

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.set_standalone_module_name

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.PrepareCustomConfig.to_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.ConvertCustomConfig

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.ConvertCustomConfig.from_dict

+		    

torch.ao.quantization.fx.custom_config.ConvertCustomConfig.set_observed_to_quantized_mapping

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.ConvertCustomConfig.set_preserved_attributes

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.ConvertCustomConfig.to_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.fx.custom_config.StandaloneModuleConfigEntry

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.ObserverBase

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.ObserverBase.with_args

+		    

torch.ao.quantization.observer.ObserverBase.with_callable_args

+		    

torch.ao.quantization.observer.MinMaxObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.MinMaxObserver.calculate_qparams

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.MinMaxObserver.forward

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.MinMaxObserver.reset_min_max_vals

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.MovingAverageMinMaxObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.PerChannelMinMaxObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.PerChannelMinMaxObserver.reset_min_max_vals

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.MovingAveragePerChannelMinMaxObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.HistogramObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.PlaceholderObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.RecordingObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.NoopObserver

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.quantization.observer.get_observer_state_dict

+		    

torch.ao.quantization.observer.load_observer_state_dict

+		    

torch.ao.quantization.observer.default_observer

+		    

torch.ao.quantization.observer.default_placeholder_observer

+		    

torch.ao.quantization.observer.default_debug_observer

+		    

torch.ao.quantization.observer.default_weight_observer

+		    

torch.ao.quantization.observer.default_histogram_observer

+		    

torch.ao.quantization.observer.default_per_channel_weight_observer

+		    

torch.ao.quantization.observer.default_dynamic_quant_observer

+		    

torch.ao.quantization.observer.default_float_qparams_observer

+		    

torch.ao.quantization.fake_quantize.FakeQuantizeBase

+		    

torch.ao.quantization.fake_quantize.FakeQuantize

+		    

torch.ao.quantization.fake_quantize.FixedQParamsFakeQuantize

+		    

torch.ao.quantization.fake_quantize.FusedMovingAvgObsFakeQuantize

+		    

torch.ao.quantization.fake_quantize.default_fake_quant

+		    

torch.ao.quantization.fake_quantize.default_weight_fake_quant

+		    

torch.ao.quantization.fake_quantize.default_per_channel_weight_fake_quant

+		    

torch.ao.quantization.fake_quantize.default_histogram_fake_quant

+		    

torch.ao.quantization.fake_quantize.default_fused_act_fake_quant

+		    

torch.ao.quantization.fake_quantize.default_fused_wt_fake_quant

+		    

torch.ao.quantization.fake_quantize.default_fused_per_channel_wt_fake_quant

+		    

torch.ao.quantization.fake_quantize.disable_fake_quant

+		    

torch.ao.quantization.fake_quantize.enable_fake_quant

+		    

torch.ao.quantization.fake_quantize.disable_observer

+		    

torch.ao.quantization.fake_quantize.enable_observer

+		    

torch.ao.quantization.qconfig.QConfig

+		    

torch.ao.quantization.qconfig.default_qconfig

+		    

torch.ao.quantization.qconfig.default_debug_qconfig

+		    

torch.ao.quantization.qconfig.default_per_channel_qconfig

+		    

torch.ao.quantization.qconfig.default_dynamic_qconfig

+		    

torch.ao.quantization.qconfig.float16_dynamic_qconfig

+		    

torch.ao.quantization.qconfig.float16_static_qconfig

+		    

torch.ao.quantization.qconfig.per_channel_dynamic_qconfig

+		    

torch.ao.quantization.qconfig.float_qparams_weight_only_qconfig

+		    

torch.ao.quantization.qconfig.default_qat_qconfig

+		    

torch.ao.quantization.qconfig.default_weight_only_qconfig

+		    

torch.ao.quantization.qconfig.default_activation_only_qconfig

+		    

torch.ao.quantization.qconfig.default_qat_qconfig_v2

+		    

torch.ao.nn.intrinsic.ConvReLU1d

+		    

torch.ao.nn.intrinsic.ConvReLU2d

+		    

torch.ao.nn.intrinsic.ConvReLU3d

+		    

torch.ao.nn.intrinsic.LinearReLU

+		    

torch.ao.nn.intrinsic.ConvBn1d

+		    

torch.ao.nn.intrinsic.ConvBn2d

+		    

torch.ao.nn.intrinsic.ConvBn3d

+		    

torch.ao.nn.intrinsic.ConvBnReLU1d

+		    

torch.ao.nn.intrinsic.ConvBnReLU2d

+		    

torch.ao.nn.intrinsic.ConvBnReLU3d

+		    

torch.ao.nn.intrinsic.BNReLU2d

+		    

torch.ao.nn.intrinsic.BNReLU3d

+		    

torch.ao.nn.intrinsic.qat.LinearReLU

+		    

torch.ao.nn.intrinsic.qat.ConvBn1d

+		    

torch.ao.nn.intrinsic.qat.ConvBnReLU1d

+		    

torch.ao.nn.intrinsic.qat.ConvBn2d

+		    

torch.ao.nn.intrinsic.qat.ConvBnReLU2d

+		    

torch.ao.nn.intrinsic.qat.ConvReLU2d

+		    

torch.ao.nn.intrinsic.qat.ConvBn3d

+		    

torch.ao.nn.intrinsic.qat.ConvBnReLU3d

+		    

torch.ao.nn.intrinsic.qat.ConvReLU3d

+		    

torch.ao.nn.intrinsic.qat.update_bn_stats

+		    

torch.ao.nn.intrinsic.qat.freeze_bn_stats

+		    

torch.ao.nn.intrinsic.quantized.BNReLU2d

+		    

torch.ao.nn.intrinsic.quantized.BNReLU3d

+		    

torch.ao.nn.intrinsic.quantized.ConvReLU1d

+		    

torch.ao.nn.intrinsic.quantized.ConvReLU2d

+		    

torch.ao.nn.intrinsic.quantized.ConvReLU3d

+		    

torch.ao.nn.intrinsic.quantized.LinearReLU

+		    

torch.ao.nn.intrinsic.quantized.dynamic.LinearReLU

+		    

torch.ao.nn.qat.Conv2d

+		    

torch.ao.nn.qat.Conv3d

+		    

torch.ao.nn.qat.Linear

+		    

torch.ao.nn.qat.Linear.from_float

+		    

torch.ao.nn.qat.dynamic.Linear

+		    

torch.ao.nn.quantized.ReLU6

+		    

torch.ao.nn.quantized.Hardswish

+		    

torch.ao.nn.quantized.ELU

+		    

torch.ao.nn.quantized.LeakyReLU

+		    

torch.ao.nn.quantized.Sigmoid

+		    

torch.ao.nn.quantized.BatchNorm2d

+		    

torch.ao.nn.quantized.BatchNorm3d

+		    

torch.ao.nn.quantized.Conv1d

+		    

torch.ao.nn.quantized.Conv1d.from_float

+		    

torch.ao.nn.quantized.Conv2d

+		    

torch.ao.nn.quantized.Conv2d.from_float

+		    

torch.ao.nn.quantized.Conv3d

+		    

torch.ao.nn.quantized.Conv3d.from_float

+		    

torch.ao.nn.quantized.ConvTranspose1d

+		    

torch.ao.nn.quantized.ConvTranspose2d

+		    

torch.ao.nn.quantized.ConvTranspose3d

+		    

torch.ao.nn.quantized.Embedding

+		    

torch.ao.nn.quantized.Embedding.from_float

+		    

torch.ao.nn.quantized.EmbeddingBag

+		    

torch.ao.nn.quantized.EmbeddingBag.from_float

+		    

torch.ao.nn.quantized.FloatFunctional

+		    

torch.ao.nn.quantized.FXFloatFunctional

+		    

torch.ao.nn.quantized.QFunctional

+		    

torch.ao.nn.quantized.Linear

+		    

torch.ao.nn.quantized.Linear.from_float

+		    

torch.ao.nn.quantized.Linear.from_reference

+		    

torch.ao.nn.quantized.LayerNorm

+		    

torch.ao.nn.quantized.GroupNorm

+		    

torch.ao.nn.quantized.InstanceNorm1d

+		    

torch.ao.nn.quantized.InstanceNorm2d

+		    

torch.ao.nn.quantized.InstanceNorm3d

+		    

torch.ao.nn.quantized.functional.avg_pool2d

+		    

torch.ao.nn.quantized.functional.avg_pool3d

+		    

torch.ao.nn.quantized.functional.adaptive_avg_pool2d

+		    

torch.ao.nn.quantized.functional.adaptive_avg_pool3d

+		    

torch.ao.nn.quantized.functional.conv1d

+		    

torch.ao.nn.quantized.functional.conv2d

+		    

torch.ao.nn.quantized.functional.conv3d

+		    

torch.ao.nn.quantized.functional.interpolate

+		    

torch.ao.nn.quantized.functional.linear

+		    

torch.ao.nn.quantized.functional.max_pool1d

+		    

torch.ao.nn.quantized.functional.max_pool2d

+		    

torch.ao.nn.quantized.functional.celu

+		    

torch.ao.nn.quantized.functional.leaky_relu

+		    

torch.ao.nn.quantized.functional.hardtanh

+		    

torch.ao.nn.quantized.functional.hardswish

+		    

torch.ao.nn.quantized.functional.threshold

+		    

torch.ao.nn.quantized.functional.elu

+		    

torch.ao.nn.quantized.functional.hardsigmoid

+		    

torch.ao.nn.quantized.functional.clamp

+		    

torch.ao.nn.quantized.functional.upsample

+		    

torch.ao.nn.quantized.functional.upsample_bilinear

+		    

torch.ao.nn.quantized.functional.upsample_nearest

+		    

torch.ao.nn.quantizable.LSTM

+		    

torch.ao.nn.quantizable.MultiheadAttention

+		    

torch.ao.nn.quantizable.MultiheadAttention.dequantize

+		    

torch.ao.nn.quantizable.MultiheadAttention.forward

+		    

torch.ao.nn.quantized.dynamic.Linear

+		    

torch.ao.nn.quantized.dynamic.Linear.from_float

+		    

torch.ao.nn.quantized.dynamic.Linear.from_reference

+		    

torch.ao.nn.quantized.dynamic.LSTM

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.nn.quantized.dynamic.GRU

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.nn.quantized.dynamic.RNNCell

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.nn.quantized.dynamic.LSTMCell

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.nn.quantized.dynamic.GRUCell

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.compare_weights

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.get_logger_dict

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Logger

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Logger.forward

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.ShadowLogger

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.ShadowLogger.forward

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.OutputLogger

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.OutputLogger.forward

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow.forward

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow.add

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow.add_scalar

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow.mul

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow.mul_scalar

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow.cat

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.Shadow.add_relu

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.prepare_model_with_stubs

+		    

torch.ao.ns._numeric_suite.compare_model_stub

+		    

torch.ao.ns._numeric_suite.get_matching_activations

+

Y

+

Only support fp16，fp32，int64，bool

+

torch.ao.ns._numeric_suite.prepare_model_outputs

+		    

torch.ao.ns._numeric_suite.compare_model_outputs

+		    

torch.ao.ns._numeric_suite_fx.OutputLogger

+		    

torch.ao.ns._numeric_suite_fx.OutputLogger.forward

+		    

torch.ao.ns._numeric_suite_fx.OutputComparisonLogger

+		    

torch.ao.ns._numeric_suite_fx.OutputComparisonLogger.forward

+		    

torch.ao.ns._numeric_suite_fx.NSTracer

+		    

torch.ao.ns._numeric_suite_fx.NSTracer.is_leaf_module

+		    

torch.ao.ns._numeric_suite_fx.extract_weights

+		    

torch.ao.ns._numeric_suite_fx.add_loggers

+		    

torch.ao.ns._numeric_suite_fx.extract_logger_info

+		    

torch.ao.ns._numeric_suite_fx.add_shadow_loggers

+		    

torch.ao.ns._numeric_suite_fx.extract_shadow_logger_info

+		    

torch.ao.ns._numeric_suite_fx.extend_logger_results_with_comparison

+		    

torch.ao.ns._numeric_suite_fx.prepare_n_shadows_model

+		    

torch.ao.ns._numeric_suite_fx.loggers_set_enabled

+		    

torch.ao.ns._numeric_suite_fx.loggers_set_save_activations

+		    

torch.ao.ns._numeric_suite_fx.convert_n_shadows_model

+		    

torch.ao.ns._numeric_suite_fx.extract_results_n_shadows_model

+		    

torch.ao.ns._numeric_suite_fx.print_comparisons_n_shadows_model

+		    

torch.ao.ns.fx.utils.compute_sqnr

+		    

torch.ao.ns.fx.utils.compute_normalized_l2_error

+		    

torch.ao.ns.fx.utils.compute_cosine_similarity

+		    
+ +## Distributed RPC Framework + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.distributed.rpc.init_rpc

+		    

torch.distributed.rpc.rpc_sync

+		    

torch.distributed.rpc.rpc_async

+		    

torch.distributed.rpc.remote

+		    

torch.distributed.rpc.get_worker_info

+		    

torch.distributed.rpc.shutdown

+		    

torch.distributed.rpc.WorkerInfo

+		    

torch.distributed.rpc.WorkerInfo.id

+		    

torch.distributed.rpc.WorkerInfo.name

+		    

torch.distributed.rpc.functions.async_execution

+		    

torch.distributed.rpc.BackendType

+		    

torch.distributed.rpc.RpcBackendOptions

+		    

torch.distributed.rpc.RpcBackendOptions.init_method

+		    

torch.distributed.rpc.RpcBackendOptions.rpc_timeout

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions.device_maps

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions.devices

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions.init_method

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions.num_worker_threads

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions.rpc_timeout

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions.set_device_map

+		    

torch.distributed.rpc.TensorPipeRpcBackendOptions.set_devices

+		    

torch.distributed.rpc.PyRRef

+		    

torch.distributed.rpc.PyRRef.backward

+		    

torch.distributed.rpc.PyRRef.confirmed_by_owner

+		    

torch.distributed.rpc.PyRRef.is_owner

+		    

torch.distributed.rpc.PyRRef.local_value

+		    

torch.distributed.rpc.PyRRef.owner

+		    

torch.distributed.rpc.PyRRef.owner_name

+		    

torch.distributed.rpc.PyRRef.remote

+		    

torch.distributed.rpc.PyRRef.rpc_async

+		    

torch.distributed.rpc.PyRRef.rpc_sync

+		    

torch.distributed.rpc.PyRRef.to_here

+		    

torch.distributed.nn.api.remote_module.RemoteModule

+		    

torch.distributed.nn.api.remote_module.RemoteModule.get_module_rref

+		    

torch.distributed.nn.api.remote_module.RemoteModule.remote_parameters

+		    

torch.distributed.autograd.backward

+		    

torch.distributed.autograd.context

+		    

torch.distributed.autograd.get_gradients

+		    
+ +## torch.random + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.random.fork_rng

+

Y

+		  

torch.random.get_rng_state

+

Y

+		  

torch.random.initial_seed

+

Y

+		  

torch.random.manual_seed

+

Y

+		  

torch.random.seed

+

Y

+		  

torch.random.set_rng_state

+

Y

+		  
+ +## torch.nested + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.nested.nested_tensor

+		    

torch.nested.as_nested_tensor

+		    

torch.nested.to_padded_tensor

+		    
+ +## torch.sparse + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

Tensor.is_sparse_csr

+		    

Tensor.to_sparse_coo

+		    

Tensor.coalesce

+		    

Tensor.sparse_resize_

+		    

Tensor.sparse_resize_and_clear_

+		    

Tensor.is_coalesced

+		    

Tensor.crow_indices

+		    

Tensor.col_indices

+		    

Tensor.row_indices

+		    

Tensor.ccol_indices

+		    

torch.sparse_compressed_tensor

+		    

torch.sparse.sum

+		    

torch.sparse.addmm

+		    

torch.sparse.sampled_addmm

+		    

torch.sparse.mm

+		    

torch.sspaddmm

+		    

torch.hspmm

+		    

torch.smm

+		    

torch.sparse.softmax

+		    

torch.sparse.log_softmax

+		    

torch.sparse.spdiags

+		    

torch.sparse.check_sparse_tensor_invariants

+		    

torch.sparse.check_sparse_tensor_invariants.disable

+		    

torch.sparse.check_sparse_tensor_invariants.enable

+		    

torch.sparse.check_sparse_tensor_invariants.is_enabled

+		    

torch.sparse.as_sparse_gradcheck

+		    
+ +## torch.Storage + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.TypedStorage

+

Y

+		  

torch.TypedStorage.bfloat16

+		    

torch.TypedStorage.bool

+

Y

+		  

torch.TypedStorage.byte

+

Y

+		  

torch.TypedStorage.char

+

Y

+		  

torch.TypedStorage.clone

+

Y

+		  

torch.TypedStorage.complex_double

+		    

torch.TypedStorage.complex_float

+		    

torch.TypedStorage.copy_

+

Y

+		  

torch.TypedStorage.cpu

+

Y

+		  

torch.TypedStorage.cuda

+

Y

+		  

torch.TypedStorage.data_ptr

+

Y

+		  

torch.TypedStorage.device

+		    

torch.TypedStorage.double

+

Y

+		  

torch.TypedStorage.dtype

+		    

torch.TypedStorage.element_size

+

Y

+		  

torch.TypedStorage.fill_

+

Y

+		  

torch.TypedStorage.float

+

Y

+		  

torch.TypedStorage.from_buffer

+

Y

+		  

torch.TypedStorage.from_file

+

Y

+		  

torch.TypedStorage.get_device

+

Y

+		  

torch.TypedStorage.half

+

Y

+		  

torch.TypedStorage.hpu

+		    

torch.TypedStorage.int

+

Y

+		  

torch.TypedStorage.is_cuda

+		    

torch.TypedStorage.is_hpu

+		    

torch.TypedStorage.is_pinned

+

Y

+		  

torch.TypedStorage.is_shared

+

Y

+		  

torch.TypedStorage.is_sparse

+		    

torch.TypedStorage.long

+

Y

+		  

torch.TypedStorage.nbytes

+

Y

+		  

torch.TypedStorage.pickle_storage_type

+

Y

+		  

torch.TypedStorage.pin_memory

+

Y

+		  

torch.TypedStorage.resize_

+

Y

+		  

torch.TypedStorage.share_memory_

+		    

torch.TypedStorage.short

+

Y

+		  

torch.TypedStorage.size

+

Y

+		  

torch.TypedStorage.tolist

+

Y

+		  

torch.TypedStorage.type

+

Y

+		  

torch.TypedStorage.untyped

+

Y

+		  

torch.UntypedStorage

+

Y

+		  

torch.UntypedStorage.bfloat16

+		    

torch.UntypedStorage.bool

+

Y

+		  

torch.UntypedStorage.byte

+

Y

+		  

torch.UntypedStorage.byteswap

+		    

torch.UntypedStorage.char

+

Y

+		  

torch.UntypedStorage.clone

+

Y

+		  

torch.UntypedStorage.complex_double

+		    

torch.UntypedStorage.complex_float

+		    

torch.UntypedStorage.copy_

+

Y

+		  

torch.UntypedStorage.cpu

+

Y

+		  

torch.UntypedStorage.cuda

+

Y

+		  

torch.UntypedStorage.data_ptr

+

Y

+		  

torch.UntypedStorage.device

+		    

torch.UntypedStorage.double

+

Y

+		  

torch.UntypedStorage.element_size

+

Y

+		  

torch.UntypedStorage.fill_

+

Y

+		  

torch.UntypedStorage.float

+

Y

+		  

torch.UntypedStorage.from_buffer

+		    

torch.UntypedStorage.from_file

+		    

torch.UntypedStorage.get_device

+

Y

+		  

torch.UntypedStorage.half

+

Y

+		  

torch.UntypedStorage.hpu

+		    

torch.UntypedStorage.int

+

Y

+		  

torch.UntypedStorage.is_cuda

+		    

torch.UntypedStorage.is_hpu

+		    

torch.UntypedStorage.is_pinned

+

Y

+		  

torch.UntypedStorage.is_shared

+

Y

+		  

torch.UntypedStorage.is_sparse

+		    

torch.UntypedStorage.is_sparse_csr

+		    

torch.UntypedStorage.long

+

Y

+		  

torch.UntypedStorage.mps

+		    

torch.UntypedStorage.nbytes

+

Y

+		  

torch.UntypedStorage.new

+

Y

+		  

torch.UntypedStorage.pin_memory

+

Y

+		  

torch.UntypedStorage.resize_

+

Y

+		  

torch.UntypedStorage.share_memory_

+		    

torch.UntypedStorage.short

+

Y

+		  

torch.UntypedStorage.size

+

Y

+		  

torch.UntypedStorage.tolist

+

Y

+		  

torch.UntypedStorage.type

+

Y

+		  

torch.UntypedStorage.untyped

+

Y

+		  

torch.DoubleStorage

+

Y

+		  

torch.DoubleStorage.dtype

+		    

torch.FloatStorage

+

Y

+		  

torch.FloatStorage.dtype

+		    

torch.HalfStorage

+

Y

+		  

torch.HalfStorage.dtype

+		    

torch.LongStorage

+

Y

+		  

torch.LongStorage.dtype

+		    

torch.IntStorage

+

Y

+		  

torch.IntStorage.dtype

+		    

torch.ShortStorage

+

Y

+		  

torch.ShortStorage.dtype

+		    

torch.CharStorage

+

Y

+		  

torch.CharStorage.dtype

+		    

torch.ByteStorage

+

Y

+		  

torch.ByteStorage.dtype

+		    

torch.BoolStorage

+

Y

+		  

torch.BoolStorage.dtype

+		    

torch.BFloat16Storage

+		    

torch.BFloat16Storage.dtype

+		    

torch.ComplexDoubleStorage

+		    

torch.ComplexDoubleStorage.dtype

+		    

torch.ComplexFloatStorage

+		    

torch.ComplexFloatStorage.dtype

+		    

torch.QUInt8Storage

+		    

torch.QUInt8Storage.dtype

+		    

torch.QInt8Storage

+		    

torch.QInt8Storage.dtype

+		    

torch.QInt32Storage

+		    

torch.QInt32Storage.dtype

+		    

torch.QUInt4x2Storage

+		    

torch.QUInt4x2Storage.dtype

+		    

torch.QUInt2x4Storage

+		    

torch.QUInt2x4Storage.dtype

+		    
+ +## torch.testing + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.testing.assert_close

+

Y

+		  

torch.testing.make_tensor

+

Y

+		  

torch.testing.assert_allclose

+

Y

+		  
+ +## torch.utils + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.rename_privateuse1_backend

+		    

torch.utils.generate_methods_for_privateuse1_backend

+		    

torch.utils.get_cpp_backtrace

+		    

torch.utils.set_module

+		    
+ +## torch.utils.benchmark + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.benchmark.Timer

+		    

torch.utils.benchmark.Timer.blocked_autorange

+		    

torch.utils.benchmark.Timer.collect_callgrind

+

Y

+		  

torch.utils.benchmark.Timer.timeit

+		    

torch.utils.benchmark.Measurement

+

Y

+		  

torch.utils.benchmark.Measurement.merge

+		    

torch.utils.benchmark.Measurement.significant_figures

+		    

torch.utils.benchmark.CallgrindStats

+

Y

+		  

torch.utils.benchmark.CallgrindStats.as_standardized

+

Y

+		  

torch.utils.benchmark.CallgrindStats.counts

+

Y

+		  

torch.utils.benchmark.CallgrindStats.delta

+

Y

+		  

torch.utils.benchmark.CallgrindStats.stats

+

Y

+		  

torch.utils.benchmark.FunctionCounts

+

Y

+		  

torch.utils.benchmark.FunctionCounts.denoise

+

Y

+		  

torch.utils.benchmark.FunctionCounts.filter

+

Y

+		  

torch.utils.benchmark.FunctionCounts.transform

+

Y

+		  
+ +## torch.utils.checkpoint + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.checkpoint.checkpoint

+

Y

+		  

torch.utils.checkpoint.checkpoint_sequential

+

Y

+		  
+ +## torch.utils.cpp\_extension + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.cpp_extension.CppExtension

+

Y

+		  

torch.utils.cpp_extension.CUDAExtension

+

Y

+		  

torch.utils.cpp_extension.BuildExtension

+

Y

+		  

torch.utils.cpp_extension.load

+		    

torch.utils.cpp_extension.load_inline

+

Y

+		  

torch.utils.cpp_extension.include_paths

+

Y

+		  

torch.utils.cpp_extension.get_compiler_abi_compatibility_and_version

+

Y

+		  

torch.utils.cpp_extension.verify_ninja_availability

+

Y

+		  

torch.utils.cpp_extension.is_ninja_available

+

Y

+		  
+ +## torch.utils.data + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.data.DataLoader

+

Y

+		  

torch.utils.data.Dataset

+

Y

+		  

torch.utils.data.IterableDataset

+

Y

+		  

torch.utils.data.TensorDataset

+

Y

+		  

torch.utils.data.StackDataset

+		    

torch.utils.data.ConcatDataset

+

Y

+		  

torch.utils.data.ChainDataset

+

Y

+		  

torch.utils.data.Subset

+

Y

+		  

torch.utils.data._utils.collate.collate

+

Y

+		  

torch.utils.data.default_collate

+

Y

+		  

torch.utils.data.default_convert

+

Y

+		  

torch.utils.data.get_worker_info

+

Y

+		  

torch.utils.data.random_split

+

Y

+		  

torch.utils.data.Sampler

+

Y

+		  

torch.utils.data.SequentialSampler

+

Y

+		  

torch.utils.data.RandomSampler

+

Y

+		  

torch.utils.data.SubsetRandomSampler

+

Y

+		  

torch.utils.data.WeightedRandomSampler

+

Y

+		  

torch.utils.data.BatchSampler

+

Y

+		  

torch.utils.data.distributed.DistributedSampler

+

Y

+		  
+ +## torch.utils.dlpack + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.dlpack.from_dlpack

+		    

torch.utils.dlpack.to_dlpack

+		    
+ +## torch.utils.mobile\_optimizer + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.mobile_optimizer.optimize_for_mobile

+		    
+ +## torch.utils.model\_zoo + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.model_zoo.load_url

+

Y

+		  
+ +## torch.utils.tensorboard + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.utils.tensorboard.writer.SummaryWriter

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.__init__

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_scalar

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_scalars

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_histogram

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_image

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_images

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_figure

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_video

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_audio

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_text

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_graph

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_embedding

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_pr_curve

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_custom_scalars

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_mesh

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.add_hparams

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.flush

+

Y

+		  

torch.utils.tensorboard.writer.SummaryWriter.close

+

Y

+		  
+ +## Type Info + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.finfo

+

Y

+		  

torch.iinfo

+

Y

+		  
+ +## Named Tensors + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.Tensor

+

Y

+		  

names

+

Y

+		  

rename

+

Y

+		  

rename_

+

Y

+		  

refine_names

+

Y

+		  

align_as

+

Y

+		  

align_to

+

Y

+		  

flatten

+

Y

+		  
+ +## torch.\_\_config\_\_ + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.__config__.show

+

Y

+		  

torch.__config__.parallel_info

+

Y

+		  
+ +## Understanding CUDA Memory Usage + + + + + + + + + + + + + + + + + + + + +

PyTorch API

+

Compatibility

+

Limitations

+

torch.cuda.memory._record_memory_history

+		    

torch.cuda.memory._snapshot

+		    

torch.cuda.memory._dump_snapshot

+