torch_npu_apis.md

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

• torch.nn.functional

• torch.Tensor

• Tensor Attributes

• torch.autograd

• torch.library

• torch.cuda

• torch.cuda.amp

• torch.backends

• torch.distributed

• torch.distributed.algorithms.join

• torch.distributed.elastic

• torch.distributed.fsdp

• torch.distributed.optim

• torch.distributed.tensor.parallel

• torch.distributed.checkpoint

• torch.distributions

• torch.fft

• torch.func

• torch.futures

• torch.fx

• torch.hub

• torch.jit

• torch.linalg

• torch.monitor

• torch.signal

• torch.special

• torch.overrides

• torch.package

• torch.profiler

• torch.nn.init

• torch.onnx

• torch.optim

• torch.cpu

• torch._logging

• torch.compiler

• torch.export

• DDP Communication Hooks

• Pipeline Parallelism

• Quantization

• Distributed RPC Framework

• torch.random

• torch.nested

• torch.sparse

• torch.Storage

• torch.testing

• torch.utils

• torch.utils.benchmark

• torch.utils.checkpoint

• torch.utils.cpp_extension

• torch.utils.data

• torch.utils.dlpack

• torch.utils.mobile_optimizer

• torch.utils.model_zoo

• torch.utils.tensorboard

• Type Info

• Named Tensors

• torch.__config__

• Understanding CUDA Memory Usage

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.

...

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